llmtests

type AudioValidationResult struct {
	Valid           bool
	Format          string
	MagicBytesValid bool
	DecodeValid     bool
	FileSize        int64
	Errors          []string
}

type BatchCancelRetryCondition interface {
	ShouldRetry(response *schemas.BifrostBatchCancelResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type BatchCancelRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []BatchCancelRetryCondition                      // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type BatchCreateRetryCondition interface {
	ShouldRetry(response *schemas.BifrostBatchCreateResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type BatchCreateRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []BatchCreateRetryCondition                      // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type BatchListRetryCondition interface {
	ShouldRetry(response *schemas.BifrostBatchListResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type BatchListRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []BatchListRetryCondition                        // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type BatchResultsRetryCondition interface {
	ShouldRetry(response *schemas.BifrostBatchResultsResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type BatchResultsRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []BatchResultsRetryCondition                     // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type BatchRetrieveRetryCondition interface {
	ShouldRetry(response *schemas.BifrostBatchRetrieveResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type BatchRetrieveRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []BatchRetrieveRetryCondition                    // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type ChatRetryCondition interface {
	ShouldRetry(response *schemas.BifrostChatResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type ChatRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []ChatRetryCondition                             // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type ChatStreamValidationResult struct {
	Passed           bool
	Errors           []string
	ReceivedData     bool
	StreamErrors     []string
	ToolCallDetected bool
	ResponseCount    int
}

type ComprehensiveTestAccount struct{}

type ComprehensiveTestConfig struct {
	Provider                 schemas.ModelProvider
	TextModel                string
	ChatModel                string
	PromptCachingModel       string
	VisionModel              string
	ReasoningModel           string
	EmbeddingModel           string
	RerankModel              string
	TranscriptionModel       string
	SpeechSynthesisModel     string
	ChatAudioModel           string
	Scenarios                TestScenarios
	Fallbacks                []schemas.Fallback     // for chat, responses, image and reasoning tests
	TextCompletionFallbacks  []schemas.Fallback     // for text completion tests
	TranscriptionFallbacks   []schemas.Fallback     // for transcription tests
	SpeechSynthesisFallbacks []schemas.Fallback     // for speech synthesis tests
	EmbeddingFallbacks       []schemas.Fallback     // for embedding tests
	RerankFallbacks          []schemas.Fallback     // for rerank tests
	SkipReason               string                 // Reason to skip certain tests
	ImageGenerationModel     string                 // Model for image generation
	ImageGenerationFallbacks []schemas.Fallback     // Fallbacks for image generation
	ImageEditModel           string                 // Model for image editing
	ImageEditFallbacks       []schemas.Fallback     // Fallbacks for image editing
	ImageVariationModel      string                 // Model for image variation
	ImageVariationFallbacks  []schemas.Fallback     // Fallbacks for image variation
	VideoGenerationModel     string                 // Model for video generation
	ExternalTTSProvider      schemas.ModelProvider  // External TTS provider to use for testing
	ExternalTTSModel         string                 // External TTS model to use for testing
	BatchExtraParams         map[string]interface{} // Extra params for batch operations (e.g., role_arn, output_s3_uri for Bedrock)
	FileExtraParams          map[string]interface{} // Extra params for file operations (e.g., s3_bucket for Bedrock)
	DisableParallelFor       []string               // Test scenarios to disable parallel execution for (e.g., "Transcription" for rate-limited APIs)
	ExpectRawRequestResponse bool                   // When true, validate rawRequest/rawResponse in ExtraFields
	PassthroughModel         string                 // Model for passthrough API tests; defaults to ChatModel when empty
	CompactionModel          string                 // Model for compaction tests; defaults to claude-sonnet-4-6
	InterleavedThinkingModel string                 // Model for interleaved thinking tests; defaults to claude-opus-4-5
	FastModeModel            string                 // Model for fast mode tests; defaults to claude-opus-4-6
	RealtimeModel            string                 // Model for Realtime API (e.g., "gpt-4o-realtime-preview")
}

type ConsistencyResult struct {
	Provider       schemas.ModelProvider
	Response       string
	SentenceCount  int
	WordCount      int
	ContainsAI     bool
	ContainsFuture bool
}

type ContentValidationCondition struct{}

type ConversationSettings struct {
	MaxMessages                int
	ConversationGeneratorModel string
	RequiredMessageTypes       []MessageModality
}

type CountTokensRetryCondition interface {
	ShouldRetry(response *schemas.BifrostCountTokensResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type CountTokensRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []CountTokensRetryCondition                      // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type CrossProviderScenario struct {
	Name               string
	Description        string
	InitialMessage     string
	ExpectedFlow       []ScenarioStep
	MaxMessages        int
	RequiredModalities []MessageModality
	SuccessCriteria    ScenarioSuccess
}

type CrossProviderTestConfig struct {
	Providers            []ProviderConfig
	ConversationSettings ConversationSettings
	TestSettings         TestSettings
}

type DualAPITestResult struct {
	ChatCompletionsResponse *schemas.BifrostChatResponse
	ChatCompletionsError    *schemas.BifrostError
	ResponsesAPIResponse    *schemas.BifrostResponsesResponse
	ResponsesAPIError       *schemas.BifrostError
	BothSucceeded           bool
}

type EmbeddingRetryCondition interface {
	ShouldRetry(response *schemas.BifrostEmbeddingResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type EmbeddingRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []EmbeddingRetryCondition                        // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type EmptyCountTokensCondition struct{}

type EmptyEmbeddingCondition struct{}

type EmptyImageGenerationCondition struct{}

type EmptyResponseCondition struct{}

type EmptySpeechCondition struct{}

type EmptyTranscriptionCondition struct{}

type ErrorCategory struct {
	Name        string
	Description string
	Color       string // For potential colored output
}

type EvaluationRequest struct {
	ScenarioContext string
	UserMessage     string
	LLMResponse     string
	Provider        schemas.ModelProvider
	Criteria        StepSuccess
	APIType         string // "chat" or "responses"
}

type EvaluationResult struct {
	Passed            bool     `json:"passed"`
	Score             float64  `json:"score"`
	KeywordCheck      string   `json:"keyword_check"`
	ForbiddenCheck    string   `json:"forbidden_check"`
	ToolCheck         string   `json:"tool_check"`
	QualityAssessment string   `json:"quality_assessment"`
	Suggestions       string   `json:"suggestions"`
	FatalIssues       []string `json:"fatal_issues"`
}

type FileContentRetryCondition interface {
	ShouldRetry(response *schemas.BifrostFileContentResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type FileContentRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []FileContentRetryCondition                      // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type FileDeleteRetryCondition interface {
	ShouldRetry(response *schemas.BifrostFileDeleteResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type FileDeleteRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []FileDeleteRetryCondition                       // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type FileListRetryCondition interface {
	ShouldRetry(response *schemas.BifrostFileListResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type FileListRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []FileListRetryCondition                         // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type FileNotProcessedCondition struct{}

type FileRetrieveRetryCondition interface {
	ShouldRetry(response *schemas.BifrostFileRetrieveResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type FileRetrieveRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []FileRetrieveRetryCondition                     // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type FileUploadRetryCondition interface {
	ShouldRetry(response *schemas.BifrostFileUploadResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type FileUploadRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []FileUploadRetryCondition                       // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type GeneratedFollowup struct {
	UserMessage      string `json:"user_message"`
	ModalityContext  string `json:"modality_context"`
	ExpectedBehavior string `json:"expected_behavior"`
	TestFocus        string `json:"test_focus"`
}

type GenericResponseCondition struct{}

type ImageGenerationRetryCondition interface {
	ShouldRetry(response *schemas.BifrostImageGenerationResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type ImageGenerationRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []ImageGenerationRetryCondition                  // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type ImageGenerationStreamValidationResult struct {
	Passed       bool
	Errors       []string
	ReceivedData bool
	StreamErrors []string
	LastLatency  int64
}

type ImageNotProcessedCondition struct{}

type IncompleteStreamCondition struct{}

type InvalidCountTokensCondition struct{}

type InvalidEmbeddingDimensionCondition struct {
	ExpectedDimension int // Expected vector dimension (0 means any)
}

type ListModelsRetryCondition interface {
	ShouldRetry(response *schemas.BifrostListModelsResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type ListModelsRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []ListModelsRetryCondition                       // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type MalformedToolArgsCondition struct{}

type MessageModality string

type MissingToolCallCondition struct {
	ExpectedToolName string // Name of the tool that should have been called
}

type NextMessageRequest struct {
	Scenario            CrossProviderScenario
	ConversationHistory []schemas.ChatMessage
	CurrentStepNumber   int
	NextStep            ScenarioStep
	PreviousEvaluation  *EvaluationResult
	APIType             string // "chat" or "responses"
}

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

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

type OpusReasoningTestConfig struct {
	Provider    schemas.ModelProvider
	Opus45Model string // Opus 4.5 model identifier
	Opus46Model string // Opus 4.6 model identifier
	Fallbacks   []schemas.Fallback
	SkipOpus45  bool   // Skip Opus 4.5 tests
	SkipOpus46  bool   // Skip Opus 4.6 tests
	SkipReason  string // Reason for skipping
}

type ParsedError struct {
	Category    string                 // Error category (HTTP, Auth, RateLimit, etc.)
	Title       string                 // Short, readable title
	Message     string                 // Main error message
	Details     []string               // Additional details
	Suggestions []string               // Potential solutions
	Technical   map[string]interface{} // Technical details for debugging
}

type PartialToolCallCondition struct {
	ExpectedCount int // Expected number of tool calls
}

type ProviderConfig struct {
	Provider        schemas.ModelProvider
	ChatModel       string
	VisionModel     string
	ToolsSupported  bool
	VisionSupported bool
	StreamSupported bool
	Available       bool
}

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

type ResponseExpectations struct {
	// Basic structure expectations
	ShouldHaveContent    bool    // Response should have non-empty content
	ExpectedChoiceCount  int     // Expected number of choices (0 = any)
	ExpectedFinishReason *string // Expected finish reason

	// Content expectations
	ShouldContainKeywords []string       // Content should contain ALL these keywords (AND logic)
	ShouldContainAnyOf    []string       // Content should contain AT LEAST ONE of these keywords (OR logic)
	ShouldNotContainWords []string       // Content should NOT contain these words
	ContentPattern        *regexp.Regexp // Content should match this pattern
	IsRelevantToPrompt    bool           // Content should be relevant to the original prompt

	// Tool calling expectations
	ExpectedToolCalls          []ToolCallExpectation // Expected tool calls
	ShouldNotHaveFunctionCalls bool                  // Should not have any function calls

	// Technical expectations
	ShouldHaveUsageStats bool // Should have token usage information
	ShouldHaveTimestamps bool // Should have created timestamp
	ShouldHaveModel      bool // Should have model field
	ShouldHaveLatency    bool // Should have latency information in ExtraFields

	// Raw request/response expectations
	ShouldHaveRawRequest  bool // Should have non-nil, compact JSON rawRequest in ExtraFields
	ShouldHaveRawResponse bool // Should have non-nil, compact JSON rawResponse in ExtraFields

	// Provider-specific expectations
	ProviderSpecific map[string]interface{} // Provider-specific validation data
}

type ResponsesContentValidationCondition struct{}

type ResponsesEmptyCondition struct{}

type ResponsesFileNotProcessedCondition struct{}

type ResponsesGenericResponseCondition struct{}

type ResponsesRetryCondition interface {
	ShouldRetry(response *schemas.BifrostResponsesResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type ResponsesRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []ResponsesRetryCondition                        // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type ResponsesStreamValidationResult struct {
	Passed       bool
	Errors       []string
	ReceivedData bool
	StreamErrors []string
	LastLatency  int64
}

type ResponsesToolCallInfo struct {
	ID        string
	Name      string
	Arguments string
}

type SampleToolType string

type ScenarioStep struct {
	StepNumber       int
	ExpectedAction   string
	RequiredModality MessageModality
	SuccessCriteria  StepSuccess
}

type ScenarioSuccess struct {
	MinStepsCompleted   int
	RequiredModalities  []MessageModality
	OverallQualityScore float64
	MustCompleteGoal    bool
}

type SpeechRetryCondition interface {
	ShouldRetry(response *schemas.BifrostSpeechResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type SpeechRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []SpeechRetryCondition                           // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type SpeechStreamValidationResult struct {
	Passed       bool
	Errors       []string
	ReceivedData bool
	StreamErrors []string
	LastLatency  int64
}

type StepSuccess struct {
	MustContainKeywords    []string
	MustNotContainWords    []string
	ExpectedToolCalls      []string
	RequiresDataExtraction bool
	QualityThreshold       float64
}

type StreamErrorCondition struct{}

type StreamingToolCallAccumulator struct {
	// For Chat Completions: map of tool call index -> accumulated tool call
	ChatToolCalls map[int]*schemas.ChatAssistantMessageToolCall
	// For Responses API: map of call ID or item ID -> accumulated tool call info
	ResponsesToolCalls map[string]*ResponsesToolCallInfo
	// Map itemID to the key used in ResponsesToolCalls for quick lookup
	ItemIDToKey map[string]string
}

type StreamingValidationResult struct {
	Passed bool
	Errors []string
}

type TestRetryCondition interface {
	ShouldRetry(response *schemas.BifrostResponse, err *schemas.BifrostError, context TestRetryContext) (bool, string)
	GetConditionName() string
}

type TestRetryConfig struct {
	MaxAttempts int                                              // Maximum retry attempts (including initial attempt)
	BaseDelay   time.Duration                                    // Base delay between retries
	MaxDelay    time.Duration                                    // Maximum delay between retries
	Conditions  []TestRetryCondition                             // Conditions that trigger retries
	OnRetry     func(attempt int, reason string, t *testing.T)   // Called before each retry
	OnFinalFail func(attempts int, finalErr error, t *testing.T) // Called on final failure
}

type TestRetryContext struct {
	ScenarioName     string                 // Name of the test scenario
	AttemptNumber    int                    // Current attempt number (1-based)
	ExpectedBehavior map[string]interface{} // What we expected to happen
	TestMetadata     map[string]interface{} // Additional context for retry decisions
}

type TestScenarioFunc func(*testing.T, *bifrost.Bifrost, context.Context, ComprehensiveTestConfig)

type TestScenarios struct {
	TextCompletion               bool
	TextCompletionStream         bool
	SimpleChat                   bool
	CompletionStream             bool
	MultiTurnConversation        bool
	ToolCalls                    bool
	ToolCallsStreaming           bool // Streaming tool calls functionality
	MultipleToolCalls            bool
	MultipleToolCallsStreaming   bool // Streaming multiple tool calls (some providers only return 1 tool call in streaming)
	End2EndToolCalling           bool
	AutomaticFunctionCall        bool
	ImageURL                     bool
	ImageBase64                  bool
	MultipleImages               bool
	FileBase64                   bool
	FileURL                      bool
	CompleteEnd2End              bool
	SpeechSynthesis              bool // Text-to-speech functionality
	SpeechSynthesisStream        bool // Streaming text-to-speech functionality
	Transcription                bool // Speech-to-text functionality
	TranscriptionStream          bool // Streaming speech-to-text functionality
	Embedding                    bool // Embedding functionality
	Reasoning                    bool // Reasoning/thinking functionality via Responses API
	PromptCaching                bool // Prompt caching functionality
	ListModels                   bool // List available models functionality
	ImageGeneration              bool // Image generation functionality
	ImageGenerationStream        bool // Streaming image generation functionality
	ImageEdit                    bool // Image edit functionality
	ImageEditStream              bool // Streaming image edit functionality
	ImageVariation               bool // Image variation functionality
	ImageVariationStream         bool // Streaming image variation functionality (if supported)
	VideoGeneration              bool // Video generation functionality
	VideoRetrieve                bool // Video retrieve functionality
	VideoRemix                   bool // Video remix functionality (OpenAI only)
	VideoDownload                bool // Video download functionality
	VideoList                    bool // Video list functionality
	VideoDelete                  bool // Video delete functionality
	BatchCreate                  bool // Batch API create functionality
	BatchList                    bool // Batch API list functionality
	BatchRetrieve                bool // Batch API retrieve functionality
	BatchCancel                  bool // Batch API cancel functionality
	BatchResults                 bool // Batch API results functionality
	FileUpload                   bool // File API upload functionality
	FileList                     bool // File API list functionality
	FileRetrieve                 bool // File API retrieve functionality
	FileDelete                   bool // File API delete functionality
	FileContent                  bool // File API content download functionality
	FileBatchInput               bool // Whether batch create supports file-based input (InputFileID)
	CountTokens                  bool // Count tokens functionality
	ChatAudio                    bool // Chat completion with audio input/output functionality
	StructuredOutputs            bool // Structured outputs (JSON schema) functionality
	WebSearchTool                bool // Web search tool functionality
	ContainerCreate              bool // Container API create functionality
	ContainerList                bool // Container API list functionality
	ContainerRetrieve            bool // Container API retrieve functionality
	ContainerDelete              bool // Container API delete functionality
	ContainerFileCreate          bool // Container File API create functionality
	ContainerFileList            bool // Container File API list functionality
	ContainerFileRetrieve        bool // Container File API retrieve functionality
	ContainerFileContent         bool // Container File API content functionality
	ContainerFileDelete          bool // Container File API delete functionality
	PassThroughExtraParams       bool // Pass through extra params functionality
	Rerank                       bool // Rerank functionality
	PassthroughAPI               bool // Raw HTTP passthrough API (Passthrough + PassthroughStream)
	WebSocketResponses           bool // WebSocket Responses API mode
	Realtime                     bool // Realtime API (bidirectional audio/text)
	Compaction                   bool // Server-side compaction (context management)
	InterleavedThinking          bool // Interleaved thinking between tool calls (beta)
	FastMode                     bool // Fast mode for Opus 4.6 (beta: research preview)
	EagerInputStreaming          bool // Anthropic fine-grained tool streaming coverage
	ServerToolsViaOpenAIEndpoint bool // Anthropic-style server tools through OpenAI-compatible endpoint
}