assertions

type AssertionConfig struct {
	Type    string                 `json:"type" yaml:"type"`
	Params  map[string]interface{} `json:"params" yaml:"params"`
	Message string                 `json:"message,omitempty" yaml:"message,omitempty"` // Human-readable description of what this assertion checks
}

type AssertionResult struct {
	Passed  bool        `json:"passed"`
	Details interface{} `json:"details,omitempty"`
	Message string      `json:"message,omitempty"` // Human-readable description from config
}

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

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

type ContentIncludesAnyConversationValidator struct{}

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

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

type ContentNotIncludesConversationValidator struct{}

type ConversationAssertion struct {
	Type    string                 `json:"type" yaml:"type"`       // Validator type (e.g., "tools_not_called_with_args")
	Params  map[string]interface{} `json:"params" yaml:"params"`   // Validator-specific parameters
	Message string                 `json:"message" yaml:"message"` // Human-readable description shown on failure
}

type ConversationAssertionFactory func() ConversationValidator

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

type ConversationContext struct {
	// AllTurns contains the complete conversation history in chronological order.
	// Includes all messages from all roles (system, user, assistant, tool).
	AllTurns []types.Message

	// ToolCalls contains all tool invocations with their results.
	// Ordered chronologically to allow sequential analysis.
	ToolCalls []ToolCallRecord

	// Metadata provides scenario/execution context for the conversation.
	Metadata ConversationMetadata
}

type ConversationMetadata struct {
	ScenarioID     string                 `json:"scenario_id"`      // The scenario being tested
	PersonaID      string                 `json:"persona_id"`       // Persona used for self-play (if any)
	Variables      map[string]interface{} `json:"variables"`        // Variables passed to prompts
	PromptConfigID string                 `json:"prompt_config_id"` // Which prompt configuration was used
	ProviderID     string                 `json:"provider_id"`      // Which LLM provider was used
	TotalCost      float64                `json:"total_cost"`       // Total cost in USD across all turns
	TotalTokens    int                    `json:"total_tokens"`     // Total tokens used (input + output)
	Extras         map[string]interface{} `json:"extras,omitempty"` // Additional metadata (e.g., judge targets/defaults)
}

type ConversationValidationResult struct {
	Type    string                 `json:"type,omitempty"`    // Validator type (e.g., tools_not_called_with_args)
	Passed  bool                   `json:"passed"`            // Whether the assertion passed
	Message string                 `json:"message"`           // Human-readable result explanation
	Details map[string]interface{} `json:"details,omitempty"` // Structured details for debugging

	// For aggregated assertions (e.g., checking all turns), evidence of individual violations.
	// Helps users understand exactly which turns or actions failed the assertion.
	Violations []ConversationViolation `json:"violations,omitempty"`
}

type ConversationValidator interface {
	// Type returns the validator name (e.g., "tools_not_called_with_args").
	// Must match the type specified in ConversationAssertion configs.
	Type() string

	// ValidateConversation evaluates the assertion against the full conversation.
	// Returns a result indicating success/failure with detailed evidence.
	ValidateConversation(
		ctx context.Context,
		convCtx *ConversationContext,
		params map[string]interface{},
	) ConversationValidationResult
}

type ConversationViolation struct {
	TurnIndex   int                    `json:"turn_index"`          // Which turn (index in AllTurns) had the violation
	Description string                 `json:"description"`         // What was violated (human-readable)
	Evidence    map[string]interface{} `json:"evidence,omitempty"`  // Data supporting the violation (e.g., actual values)
	Timestamp   time.Time              `json:"timestamp,omitempty"` // When the violation occurred (if available)
}

type GuardrailTriggeredValidator struct{}

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

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

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

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

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

type LengthCapValidator struct{}

type QuestionCapValidator struct{}

type RoleIntegrityValidator struct{}

type ToolCallRecord struct {
	TurnIndex int                    `json:"turn_index"` // Which turn (index in AllTurns) this call occurred in
	ToolName  string                 `json:"tool_name"`  // Name of the tool called
	Arguments map[string]interface{} `json:"arguments"`  // Arguments passed to the tool
	Result    interface{}            `json:"result"`     // Tool's return value (nil if tool failed)
	Error     string                 `json:"error"`      // Error message if tool failed (empty on success)
	Duration  time.Duration          `json:"duration"`   // How long the tool took to execute
}

type ToolCallsWithArgsConversationValidator struct{}

type ToolsCalledConversationValidator struct{}

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

type ToolsNotCalledConversationValidator struct{}

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

type ToolsNotCalledWithArgsConversationValidator struct{}

type ValidationResult = validators.ValidationResult

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

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