orchestration

type Action interface {
	Execute(context *FlowContext) error
}

type AlwaysTrue struct{}

type AttackAnalysis struct {
	AttackID           string
	Duration           time.Duration
	ConversationCount  int
	VulnerabilityCount int
	SuccessRate        float64
	Insights           []string
	VulnerabilityTypes map[string]int
}

type AttackState struct {
	ID              string
	TargetModel     string
	AttackType      string
	StartTime       time.Time
	EndTime         *time.Time
	Status          AttackStatus
	SuccessMetrics  map[string]float64
	Conversations   []*ConversationState
	Vulnerabilities []Vulnerability
	// contains filtered or unexported fields
}

type AttackStatus string

type AttackStrategy interface {
	Name() string
	NextTurn(state *ConversationState) (string, error)
	ShouldContinue(state *ConversationState) bool
	ExtractInfo(response string, state *ConversationState) error
}

type ComplianceAchieved struct {
	Level float64
}

type ComplianceLevelAbove struct {
	Threshold float64
}

type Condition interface {
	Evaluate(context *FlowContext) bool
}

type ConversationFlow struct {
	ID              string
	Name            string
	StartNode       *FlowNode
	Nodes           map[string]*FlowNode
	Variables       map[string]interface{}
	SuccessCriteria []SuccessCriterion
}

type ConversationState struct {
	ID              string
	TurnCount       int
	Context         []Message
	ExtractedInfo   map[string]interface{}
	CurrentStrategy string
	SuccessMetrics  map[string]float64
	// contains filtered or unexported fields
}

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

type DecisionRule interface {
	Evaluate(context *FlowContext) (string, bool)
}

type DeepenRecursion struct {
	MaxDepth int
}

type Evidence struct {
	ConversationID string
	TurnNumber     int
	Prompt         string
	Response       string
	Timestamp      time.Time
}

type ExecutionStatus string

type ExtractComplianceLevel struct{}

type FlowContext struct {
	FlowID        string
	CurrentNodeID string
	Variables     map[string]interface{}
	History       []FlowEvent
	Responses     []string
	StartTime     time.Time
	// contains filtered or unexported fields
}

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

type FlowEvent struct {
	NodeID    string
	EventType string
	Data      interface{}
	Timestamp time.Time
}

type FlowExecution struct {
	Flow    *ConversationFlow
	Context *FlowContext
	Status  ExecutionStatus
}

type FlowNode struct {
	ID          string
	Type        NodeType
	Content     string
	Transitions []Transition
	Actions     []Action
	Metadata    map[string]interface{}
}

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

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

type InformationExtracted struct {
	MinItems int
}

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

type Message struct {
	Role      string // "user" or "assistant"
	Content   string
	Timestamp time.Time
	Metadata  map[string]interface{}
}

type MonitorContextWindow struct{}

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

type NodeType string

type OrchestratorConfig struct {
	MaxTurns           int
	TurnTimeout        time.Duration
	ParallelSessions   int
	AdaptiveStrategies bool
	MemoryRetention    bool
}

type RecursionDepthReached struct {
	Depth int
}

type ResponseContains struct {
	Keywords []string
}

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

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

type StateCheckpoint struct {
	ID        string
	StateID   string
	Timestamp time.Time
	TurnCount int
	Data      []byte
	Metadata  map[string]interface{}
}

type StateConfig struct {
	CheckpointInterval time.Duration
	MaxCheckpoints     int
	PersistenceEnabled bool
	CompressionEnabled bool
	EncryptionEnabled  bool
}

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

type StateStore interface {
	Save(id string, state []byte) error
	Load(id string) ([]byte, error)
	Delete(id string) error
	List() ([]string, error)
}

type SuccessCriterion interface {
	IsMet(context *FlowContext) bool
	Description() string
}

type Transition struct {
	TargetNodeID string
	Condition    Condition
	Priority     int
}

type UpdateVariable struct {
	Name  string
	Value interface{}
}

type VariableEquals struct {
	Name  string
	Value interface{}
}

type Vulnerability struct {
	ID          string
	Type        string
	Severity    string
	Description string
	Evidence    []Evidence
	Discovered  time.Time
}