injection

type AdvancedInjector struct {
	// contains filtered or unexported fields
}

type AttackConfig struct {
	// Target configuration
	Target   TargetConfig
	Provider string
	Model    string

	// Attack parameters
	Technique   string
	Payload     string
	MaxAttempts int
	Timeout     time.Duration

	// Advanced options
	UseMutation         bool
	MutationRate        float64
	UseObfuscation      bool
	AggressivenessLevel int

	// Context for the attack
	Context  map[string]interface{}
	Metadata map[string]string
}

type AttackResult struct {
	// Identification
	ID        string
	Timestamp time.Time

	// Attack details
	Technique string
	Payload   string

	// Results
	Success    bool
	Confidence float64
	Response   string

	// Metrics
	AttemptCount int
	Duration     time.Duration
	TokensUsed   int

	// Analysis
	SuccessFactors []string
	FailureReasons []string

	// Evidence
	Evidence []Evidence

	// Metadata
	Metadata map[string]interface{}
}

type BasicSuccessDetector struct {
	// contains filtered or unexported fields
}

type ChainStep struct {
	Order     int
	Technique string
	Payload   string
	WaitTime  time.Duration
	Condition StepCondition
}

type ConditionType string

type EncodingFunc func(text string) string

type Engine struct {
	// contains filtered or unexported fields
}

type EngineConfig struct {
	MaxConcurrent  int
	DefaultTimeout time.Duration
	RetryAttempts  int
	RetryDelay     time.Duration
	CollectMetrics bool
	DebugMode      bool
}

type EnhancedSuccessDetector struct {
	// contains filtered or unexported fields
}

type ErrorType string

type Evidence struct {
	Type        EvidenceType
	Content     string
	Confidence  float64
	Explanation string
}

type EvidenceType string

type InMemoryMetricsCollector struct {
	// contains filtered or unexported fields
}

type InjectionChain struct {
	ID          string
	Name        string
	Description string
	Steps       []ChainStep
}

type InjectionEngine interface {
	// Execute runs an injection attack
	Execute(ctx context.Context, config AttackConfig) (*AttackResult, error)

	// ExecuteBatch runs multiple injection attempts
	ExecuteBatch(ctx context.Context, configs []AttackConfig) ([]*AttackResult, error)

	// GetTechniques returns available injection techniques
	GetTechniques() []TechniqueInfo

	// ValidatePayload checks if a payload is valid
	ValidatePayload(payload string) error
}

type InjectionError struct {
	Type    ErrorType
	Message string
	Details map[string]interface{}
}

type InjectionTechnique struct {
	ID          string
	Name        string
	Description string
	Category    TechniqueCategory
	Risk        RiskLevel
	Generator   PayloadGeneratorFunc
	Validator   PayloadValidator
	Examples    []string
}

type InjectorConfig struct {
	AggressivenessLevel int                  // 1-10, higher = more aggressive
	TargetModel         string               // Model-specific optimizations
	MaxAttempts         int                  // Max injection attempts
	MutationRate        float64              // Payload mutation probability
	SuccessPatterns     []string             // Patterns indicating success
	CustomTechniques    []InjectionTechnique // User-defined techniques
}

type Logger interface {
	Debug(msg string, keysAndValues ...interface{})
	Info(msg string, keysAndValues ...interface{})
	Warn(msg string, keysAndValues ...interface{})
	Error(msg string, keysAndValues ...interface{})
}

type Message struct {
	Role    string
	Content string
}

type MetricsCollector interface {
	// RecordAttempt logs an injection attempt
	RecordAttempt(result *AttackResult)

	// GetSuccessRate returns success rate for a technique
	GetSuccessRate(technique string) float64

	// GetAverageTime returns average execution time
	GetAverageTime(technique string) time.Duration

	// GetTechniqueStats returns detailed statistics
	GetTechniqueStats(technique string) *TechniqueStats
}

type ModelBehavior struct {
	TypicalRefusalPhrases []string
	SafetyDisclaimer      []string
	HelpfulnessIndicators []string
	ComplianceIndicators  []string
}

type MutationFunc func(string) string

type ObfuscationFunc func(string) string

type Obfuscator struct {
	// contains filtered or unexported fields
}

type PayloadGenerator interface {
	// Generate creates a new payload
	Generate(technique string, target string, context map[string]interface{}) (string, error)

	// GenerateVariants creates multiple payload variants
	GenerateVariants(technique string, target string, count int) ([]string, error)

	// Mutate modifies an existing payload
	Mutate(payload string) string

	// Obfuscate applies obfuscation to a payload
	Obfuscate(payload string) string
}

type PayloadGeneratorFunc func(target string, context map[string]interface{}) string

type PayloadMutator struct {
	// contains filtered or unexported fields
}

type PayloadValidator func(payload string) bool

type Provider interface {
	Query(ctx context.Context, messages []Message, options map[string]interface{}) (string, error)
	GetModel() string
	GetTokenCount(text string) int
}

type ProviderManager interface {
	GetProvider(name string) (Provider, error)
	ListProviders() []string
}

type ResponseAnalyzer struct {
	// contains filtered or unexported fields
}

type RiskLevel int

type StepCondition struct {
	Type            ConditionType
	PreviousResult  string // e.g., "success", "failure", "partial"
	ResponsePattern string // regex pattern
	MinConfidence   float64
}

type SuccessDetector interface {
	// Detect checks if an injection was successful
	Detect(response string, expectedBehavior string) (bool, float64)

	// AnalyzeEvidence extracts evidence from response
	AnalyzeEvidence(response string) []Evidence

	// CompareResponses checks behavior change
	CompareResponses(baseline, injected string) (changed bool, confidence float64)
}

type TargetConfig struct {
	// What we want the model to do
	Objective string

	// Expected behavior if successful
	SuccessIndicators []string

	// Context to work with
	SystemPrompt string
	History      []Message
}

type TechniqueCategory string

type TechniqueInfo struct {
	ID          string
	Name        string
	Description string
	Category    string
	Risk        string
	SuccessRate float64
	Examples    []string
}

type TechniqueStats struct {
	TotalAttempts      int
	SuccessfulAttempts int
	SuccessRate        float64
	AverageTime        time.Duration
	AverageTokens      int
	LastSuccess        time.Time
	LastFailure        time.Time
	CommonFailures     map[string]int
}