gillmprovider

type APIKeyAuth struct {
	Name    string
	Login   func(ctx context.Context, interaction AuthInteraction) (Credential, error)
	Check   func(ctx context.Context, input APIKeyCheckInput) (*AuthCheck, error)
	Resolve func(ctx context.Context, input APIKeyResolveInput) (*AuthResult, error)
}

type APIKeyCheckInput struct {
	Context    AuthContext
	Credential *Credential
}

type APIKeyResolveInput struct {
	Context    AuthContext
	Credential *Credential
}

type APIProvider interface {
	Stream(model Model, llmContext Context, options StreamOptions) (*AssistantMessageEventStream, error)
	StreamSimple(model Model, llmContext Context, options SimpleStreamOptions) (*AssistantMessageEventStream, error)
}

type APIProviderFuncs struct {
	StreamFunc       func(Model, Context, StreamOptions) (*AssistantMessageEventStream, error)
	StreamSimpleFunc func(Model, Context, SimpleStreamOptions) (*AssistantMessageEventStream, error)
}

type APIProviderRegistration struct {
	API      string
	Provider APIProvider
	SourceID string
}

type AbortUsageExpectation string

type AnthropicCacheCreationUsage struct {
	Ephemeral5mInputTokens int `json:"ephemeral_5m_input_tokens"`
	Ephemeral1hInputTokens int `json:"ephemeral_1h_input_tokens"`
}

type AnthropicCompat struct {
	SupportsEagerToolInputStreaming bool
	SupportsCacheControlOnTools     bool
	SupportsLongCacheRetention      bool
	SupportsStrictTools             bool
	SupportsToolReferences          bool
	SupportsTemperature             bool
	SendSessionAffinityHeaders      bool
	AllowEmptySignature             bool
}

type AnthropicContentBlock struct {
	Type         string                    `json:"type"`
	Text         string                    `json:"text,omitempty"`
	Source       *AnthropicImageSource     `json:"source,omitempty"`
	ID           string                    `json:"id,omitempty"`
	Name         string                    `json:"name,omitempty"`
	Input        map[string]any            `json:"input,omitempty"`
	ToolUseID    string                    `json:"tool_use_id,omitempty"`
	ToolName     string                    `json:"tool_name,omitempty"`
	Content      any                       `json:"content,omitempty"`
	IsError      bool                      `json:"is_error,omitempty"`
	Thinking     string                    `json:"thinking,omitempty"`
	Signature    *string                   `json:"signature,omitempty"`
	Data         string                    `json:"data,omitempty"`
	CacheControl *OpenAICompatCacheControl `json:"cache_control,omitempty"`
}

type AnthropicImageSource struct {
	Type      string `json:"type"`
	MediaType string `json:"media_type"`
	Data      string `json:"data"`
}

type AnthropicMessage struct {
	Role    string `json:"role"`
	Content any    `json:"content"`
}

type AnthropicMessagesProvider struct {
	Client HTTPDoer
}

type AnthropicOAuthOptions struct {
	Client         HTTPDoer
	AuthContext    AuthContext
	CallbackHost   string
	RequestTimeout time.Duration
}

type AnthropicOutputTokensDetails struct {
	ThinkingTokens *int `json:"thinking_tokens"`
}

type AnthropicPayload struct {
	Model        string                  `json:"model"`
	Messages     []AnthropicMessage      `json:"messages"`
	System       []AnthropicContentBlock `json:"system,omitempty"`
	MaxTokens    int                     `json:"max_tokens"`
	Stream       bool                    `json:"stream"`
	Temperature  *float64                `json:"temperature,omitempty"`
	Tools        []AnthropicTool         `json:"tools,omitempty"`
	Thinking     map[string]any          `json:"thinking,omitempty"`
	OutputConfig map[string]any          `json:"output_config,omitempty"`
	Metadata     map[string]any          `json:"metadata,omitempty"`
}

type AnthropicPayloadOptions struct {
	MaxTokens        int
	Temperature      *float64
	CacheRetention   string
	SessionID        string
	Reasoning        string
	ThinkingBudgets  map[string]int
	ThinkingDisplay  string
	Metadata         map[string]any
	Headers          map[string]string
	IsOAuthToken     bool
	InterleavedThink *bool
	// contains filtered or unexported fields
}

type AnthropicRawUsage struct {
	InputTokens              int                          `json:"input_tokens"`
	OutputTokens             int                          `json:"output_tokens"`
	CacheReadInputTokens     int                          `json:"cache_read_input_tokens"`
	CacheCreationInputTokens int                          `json:"cache_creation_input_tokens"`
	CacheCreation            AnthropicCacheCreationUsage  `json:"cache_creation"`
	OutputTokensDetails      AnthropicOutputTokensDetails `json:"output_tokens_details"`
}

type AnthropicRequestState struct {
	Compat            AnthropicCompat
	ToolPlacement     DeferredToolSet
	DeferredToolNames map[string]struct{}
	NormalizeToolName ToolNameNormalizer
}

type AnthropicSSEEvent struct {
	Event string
	Data  string
}

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

type AnthropicTool struct {
	Name                string                    `json:"name"`
	Description         string                    `json:"description,omitempty"`
	EagerInputStreaming *bool                     `json:"eager_input_streaming,omitempty"`
	Strict              *bool                     `json:"strict,omitempty"`
	InputSchema         map[string]any            `json:"input_schema"`
	DeferLoading        bool                      `json:"defer_loading,omitempty"`
	CacheControl        *OpenAICompatCacheControl `json:"cache_control,omitempty"`
}

type AnthropicToolOptions struct {
	IsOAuthToken                    bool
	SupportsEagerToolInputStreaming bool
	SupportsStrictTools             bool
	CacheControl                    *OpenAICompatCacheControl
	DeferLoading                    bool
}

type AssistantImages struct {
	API          string
	Provider     string
	Model        string
	Output       []ImagesContent
	ResponseID   string
	Usage        Usage
	StopReason   string
	ErrorMessage string
	Timestamp    int64
}

type AssistantMessageDiagnostic struct {
	Type      string               `json:"type"`
	Timestamp int64                `json:"timestamp"`
	Error     *DiagnosticErrorInfo `json:"error,omitempty"`
	Details   map[string]any       `json:"details,omitempty"`
}

type AssistantMessageEvent struct {
	Type             string      `json:"type"`
	Partial          Message     `json:"partial,omitempty"`
	Message          Message     `json:"message,omitempty"`
	Error            Message     `json:"error,omitempty"`
	Reason           string      `json:"reason,omitempty"`
	ContentIndex     int         `json:"contentIndex,omitempty"`
	Delta            string      `json:"delta,omitempty"`
	Content          string      `json:"content,omitempty"`
	ContentSignature string      `json:"contentSignature,omitempty"`
	Redacted         *bool       `json:"redacted,omitempty"`
	ID               string      `json:"id,omitempty"`
	ToolName         string      `json:"toolName,omitempty"`
	ToolCall         ContentPart `json:"toolCall,omitempty"`
}

type AssistantMessageEventStream = EventStream[AssistantMessageEvent, Message]

type AuthCheck struct {
	Source string
	Type   CredentialType
}

type AuthContext interface {
	Env(ctx context.Context, name string) (value string, ok bool, err error)
	FileExists(ctx context.Context, path string) (bool, error)
}

type AuthContextFuncs struct {
	EnvFunc        func(ctx context.Context, name string) (value string, ok bool, err error)
	FileExistsFunc func(ctx context.Context, path string) (bool, error)
}

type AuthEvent struct {
	Type             AuthEventType
	Message          string
	Links            []AuthInfoLink
	URL              string
	Instructions     string
	UserCode         string
	VerificationURI  string
	IntervalSeconds  int
	ExpiresInSeconds int
}

type AuthEventType string

type AuthInfoLink struct {
	URL   string
	Label string
}

type AuthInteraction interface {
	Prompt(ctx context.Context, prompt AuthPrompt) (string, error)
	Notify(event AuthEvent)
}

type AuthPrompt struct {
	Type        AuthPromptType
	Message     string
	Placeholder string
	Options     []AuthPromptOption
}

type AuthPromptOption struct {
	ID          string
	Label       string
	Description string
}

type AuthPromptType string

type AuthResolutionOverrides struct {
	// APIKey is a pointer so callers can distinguish no override from an
	// explicit empty key.
	APIKey *string
	Env    ProviderEnv
}

type AuthResult struct {
	Auth   ModelAuth
	Env    ProviderEnv
	Source string
}

type AzureOpenAIConfig struct {
	BaseURL    string
	APIVersion string
}

type AzureOpenAIResponsesOptions struct {
	AzureAPIVersion     string
	AzureResourceName   string
	AzureBaseURL        string
	AzureDeploymentName string
	Env                 ProviderEnv
}

type AzureOpenAIResponsesPayload struct {
	Model           string                     `json:"model"`
	Input           []OpenAIResponsesInputItem `json:"input"`
	Stream          bool                       `json:"stream"`
	Store           bool                       `json:"store"`
	PromptCacheKey  string                     `json:"prompt_cache_key,omitempty"`
	MaxOutputTokens int                        `json:"max_output_tokens,omitempty"`
	Temperature     *float64                   `json:"temperature,omitempty"`
	Tools           []OpenAIResponsesTool      `json:"tools,omitempty"`
	Reasoning       map[string]string          `json:"reasoning,omitempty"`
	Include         []string                   `json:"include,omitempty"`
}

type AzureOpenAIResponsesPayloadOptions struct {
	DeploymentName   string
	MaxTokens        int
	Temperature      *float64
	SessionID        string
	ReasoningEffort  string
	ReasoningSummary string
}

type AzureOpenAIResponsesProvider struct {
	Client HTTPDoer
}

type BedrockCachePoint struct {
	Type string
	TTL  string
}

type BedrockClientConfig struct {
	Endpoint    string
	Region      string
	Profile     string
	Credentials *BedrockCredentials
	BearerToken string
	SkipAuth    bool
	ProxyURL    string
	ForceHTTP1  bool
}

type BedrockClientOptions struct {
	Region      string
	Profile     string
	APIKey      string
	BearerToken string
	Env         ProviderEnv
}

type BedrockContentBlock struct {
	Text             string
	Image            *BedrockImageBlock
	ToolUse          *BedrockToolUseBlock
	ToolResult       *BedrockToolResultBlock
	ReasoningContent *BedrockReasoningContent
	CachePoint       *BedrockCachePoint
}

type BedrockContentBlockDeltaEvent struct {
	ContentBlockIndex int
	Text              string
	ToolUseInput      string
	ReasoningContent  *BedrockReasoningContent
}

type BedrockContentBlockStartEvent struct {
	ContentBlockIndex int
	ToolUse           *BedrockToolUseBlock
}

type BedrockContentBlockStopEvent struct {
	ContentBlockIndex int
}

type BedrockConverseStreamEvent struct {
	MessageStart      *BedrockMessageStartEvent
	ContentBlockStart *BedrockContentBlockStartEvent
	ContentBlockDelta *BedrockContentBlockDeltaEvent
	ContentBlockStop  *BedrockContentBlockStopEvent
	MessageStop       *BedrockMessageStopEvent
	Metadata          *BedrockMetadataEvent
	Error             error
}

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

type BedrockConverseStreamProvider struct {
	Transport BedrockConverseStreamTransport
}

type BedrockConverseStreamRequest struct {
	Model           Model
	Payload         BedrockPayload
	ClientConfig    BedrockClientConfig
	MaxTokens       int
	Temperature     *float64
	CacheRetention  string
	RequestMetadata map[string]string
	Headers         map[string]string
	OnResponse      func(status int, headers map[string]string) error
}

type BedrockConverseStreamTransport func(context.Context, BedrockConverseStreamRequest) (<-chan BedrockConverseStreamEvent, error)

type BedrockCredentials struct {
	AccessKeyID     string
	SecretAccessKey string
	SessionToken    string
}

type BedrockImageBlock struct {
	Format string
	Data   string
}

type BedrockMessage struct {
	Role    string
	Content []BedrockContentBlock
}

type BedrockMessageStartEvent struct {
	Role string
}

type BedrockMessageStopEvent struct {
	StopReason string
}

type BedrockMetadataEvent struct {
	Usage BedrockUsage
}

type BedrockNamedToolChoice struct {
	Type string
	Name string
}

type BedrockPayload struct {
	System                       []BedrockContentBlock
	Messages                     []BedrockMessage
	ToolConfig                   *BedrockToolConfig
	AdditionalModelRequestFields map[string]any
}

type BedrockPayloadOptions struct {
	Reasoning           string
	Region              string
	ThinkingBudgets     map[string]int
	ThinkingDisplay     string
	InterleavedThinking *bool
	CacheRetention      string
	ForcePromptCache    bool
	ToolChoice          any
}

type BedrockReasoningContent struct {
	Text      string
	Signature string
}

type BedrockTool struct {
	ToolSpec BedrockToolSpec
}

type BedrockToolConfig struct {
	Tools      []BedrockTool
	ToolChoice any
}

type BedrockToolInputSchema struct {
	JSON map[string]any
}

type BedrockToolResultBlock struct {
	ToolUseID string
	Content   []BedrockContentBlock
	Status    string
}

type BedrockToolSpec struct {
	Name        string
	Description string
	InputSchema BedrockToolInputSchema
	Strict      *bool
}

type BedrockToolUseBlock struct {
	ToolUseID string
	Name      string
	Input     map[string]any
}

type BedrockUsage struct {
	InputTokens          int
	OutputTokens         int
	CacheReadInputTokens int
	CacheWriteTokens     int
	TotalTokens          int
}

type ConstrainedSamplingConfig struct {
	Type     ConstrainedSamplingType       `json:"type"`
	Strict   ConstrainedSamplingStrictness `json:"strict,omitempty"`
	Variants GrammarVariants               `json:"variants,omitempty"`
}

type ConstrainedSamplingStrictness string

type ConstrainedSamplingType string

type ContentPart struct {
	Type              string         `json:"type"`
	Text              string         `json:"text,omitempty"`
	TextSignature     string         `json:"textSignature,omitempty"`
	Thinking          string         `json:"thinking,omitempty"`
	ThinkingSignature string         `json:"thinkingSignature,omitempty"`
	Redacted          bool           `json:"redacted,omitempty"`
	Data              string         `json:"data,omitempty"`
	MIMEType          string         `json:"mimeType,omitempty"`
	ID                string         `json:"id,omitempty"`
	Name              string         `json:"name,omitempty"`
	Arguments         map[string]any `json:"arguments,omitempty"`
	ThoughtSignature  string         `json:"thoughtSignature,omitempty"`
}

type Context struct {
	SystemPrompt string    `json:"systemPrompt,omitempty"`
	Messages     []Message `json:"messages,omitempty"`
	Tools        []Tool    `json:"tools,omitempty"`
}

type ContextUsageEstimate struct {
	Tokens         int  `json:"tokens"`
	UsageTokens    int  `json:"usageTokens"`
	TrailingTokens int  `json:"trailingTokens"`
	LastUsageIndex *int `json:"lastUsageIndex"`
}

type ConvertOpenAIResponsesOptions struct {
	AllowedToolCallProviders   map[string]bool
	IncludeSystemPrompt        *bool
	SupportsDeveloperRole      *bool
	GrammarToolInputProperties map[string]string
	DeferredTools              map[string]Tool
	ToolOptions                OpenAIResponsesToolOptions
}

type CreateImagesProviderOptions struct {
	ID     string
	Name   string
	Auth   ProviderAuth
	Models []ImagesModel

	FetchModels func(ctx context.Context) ([]ImagesModel, error)
	API         ImagesAPIProvider
}

type CreateProviderOptions struct {
	ID      string
	Name    string
	BaseURL string
	Headers map[string]string
	Auth    ProviderAuth
	Models  []Model

	FetchModels  func(ctx context.Context, input RefreshModelsContext) ([]Model, error)
	FilterModels func(models []Model, credential *Credential) []Model
	API          APIProvider
	APIs         map[string]APIProvider
}

type Credential struct {
	Type          CredentialType `json:"type"`
	Key           string         `json:"key,omitempty"`
	Access        string         `json:"access,omitempty"`
	Refresh       string         `json:"refresh,omitempty"`
	Expires       int64          `json:"expires,omitempty"`
	Env           ProviderEnv    `json:"env,omitempty"`
	EnterpriseURL string         `json:"enterpriseUrl,omitempty"`
	Metadata      map[string]any `json:"-"`
}

type CredentialInfo struct {
	ProviderID string         `json:"providerId"`
	Type       CredentialType `json:"type"`
}

type CredentialModifier func(ctx context.Context, current Credential, exists bool) (next Credential, write bool, err error)

type CredentialStore interface {
	ReadCredential(ctx context.Context, providerID string) (Credential, bool, error)
	ListCredentials(ctx context.Context) ([]CredentialInfo, error)
	ModifyCredential(ctx context.Context, providerID string, modify CredentialModifier) (Credential, bool, error)
	DeleteCredential(ctx context.Context, providerID string) error
}

type CredentialType string

type DeferredToolSet struct {
	Immediate     []Tool
	Deferred      map[string]Tool
	DeferredTools []Tool
}

type DiagnosticErrorInfo struct {
	Name    string `json:"name,omitempty"`
	Message string `json:"message"`
	Stack   string `json:"stack,omitempty"`
	Code    any    `json:"code,omitempty"`
}

type EventStream[T any, R any] struct {
	*eventstream.EventStream[T, R]
}

type FauxModelDefinition struct {
	ID            string
	Name          string
	Reasoning     bool
	Input         []string
	Cost          ModelCost
	ContextWindow int
	MaxTokens     int
}

type FauxOption func(*FauxOptions)

type FauxOptions struct {
	API             string
	Provider        string
	Models          []FauxModelDefinition
	TokensPerSecond float64
	TokenSize       FauxTokenSize
}

type FauxProviderHandle struct {
	Provider *Provider
	// contains filtered or unexported fields
}

type FauxProviderRegistration struct {
	API      string
	Provider string
	Models   []Model
	State    FauxState
	// contains filtered or unexported fields
}

type FauxResponseFactory func(context Context, options StreamOptions, state FauxState, model Model) (Message, error)

type FauxResponseStep struct {
	Message Message
	Factory FauxResponseFactory
}

type FauxState struct {
	CallCount int
}

type FauxTokenSize struct {
	Min int
	Max int
}

type GitHubCopilotDevicePollResponse struct {
	AccessToken string
	Error       string
	Interval    int
}

type GitHubCopilotOAuthOptions struct {
	Client              HTTPDoer
	RequestTimeout      time.Duration
	ModelCatalogTimeout time.Duration
}

type GoogleAuthOptions struct {
	KeyFilename string
}

type GoogleCandidate struct {
	Content      GoogleContent `json:"content"`
	FinishReason string        `json:"finishReason"`
}

type GoogleContent struct {
	Role  string       `json:"role"`
	Parts []GooglePart `json:"parts"`
}

type GoogleFunctionCall struct {
	Name string         `json:"name"`
	Args map[string]any `json:"args"`
	ID   string         `json:"id,omitempty"`
}

type GoogleFunctionCallingConfig struct {
	Mode GoogleFunctionCallingMode `json:"mode"`
}

type GoogleFunctionCallingMode string

type GoogleFunctionDeclaration struct {
	Name                 string `json:"name"`
	Description          string `json:"description,omitempty"`
	Parameters           any    `json:"parameters,omitempty"`
	ParametersJSONSchema any    `json:"parametersJsonSchema,omitempty"`
}

type GoogleFunctionResponse struct {
	Name     string         `json:"name"`
	Response map[string]any `json:"response"`
	Parts    []GooglePart   `json:"parts,omitempty"`
	ID       string         `json:"id,omitempty"`
}

type GoogleGenerateConfig struct {
	Temperature     *float64              `json:"temperature,omitempty"`
	MaxOutputTokens int                   `json:"maxOutputTokens,omitempty"`
	ThinkingConfig  *GoogleThinkingConfig `json:"thinkingConfig,omitempty"`
}

type GoogleInlineData struct {
	MIMEType string `json:"mimeType"`
	Data     string `json:"data"`
}

type GooglePart struct {
	Text             string                  `json:"text,omitempty"`
	Thought          bool                    `json:"thought,omitempty"`
	ThoughtSignature string                  `json:"thoughtSignature,omitempty"`
	InlineData       *GoogleInlineData       `json:"inlineData,omitempty"`
	FunctionCall     *GoogleFunctionCall     `json:"functionCall,omitempty"`
	FunctionResponse *GoogleFunctionResponse `json:"functionResponse,omitempty"`
}

type GooglePayload struct {
	Model             string               `json:"-"`
	Contents          []GoogleContent      `json:"contents"`
	Tools             []GoogleToolGroup    `json:"tools,omitempty"`
	ToolConfig        *GoogleToolConfig    `json:"toolConfig,omitempty"`
	SystemInstruction *GoogleSystemContent `json:"systemInstruction,omitempty"`
	Config            GoogleGenerateConfig `json:"generationConfig,omitempty"`
}

type GooglePayloadOptions struct {
	MaxTokens       int
	Temperature     *float64
	Reasoning       string
	ThinkingBudgets map[string]int
	ToolChoice      any
}

type GoogleProvider struct {
	Client HTTPDoer
}

type GoogleStreamChunk struct {
	ResponseID    string               `json:"responseId"`
	Candidates    []GoogleCandidate    `json:"candidates"`
	UsageMetadata *GoogleUsageMetadata `json:"usageMetadata,omitempty"`
}

type GoogleSystemContent struct {
	Parts []GooglePart `json:"parts"`
}

type GoogleThinkingConfig struct {
	IncludeThoughts *bool  `json:"includeThoughts,omitempty"`
	ThinkingLevel   string `json:"thinkingLevel,omitempty"`
	ThinkingBudget  *int   `json:"thinkingBudget,omitempty"`
}

type GoogleThinkingOptions struct {
	Enabled       *bool
	Level         string
	BudgetTokens  *int
	Reasoning     string
	CustomBudgets map[string]int
}

type GoogleToolConfig struct {
	FunctionCallingConfig GoogleFunctionCallingConfig `json:"functionCallingConfig"`
}

type GoogleToolGroup struct {
	FunctionDeclarations []GoogleFunctionDeclaration `json:"functionDeclarations"`
}

type GoogleUsageMetadata struct {
	PromptTokenCount        int `json:"promptTokenCount"`
	CandidatesTokenCount    int `json:"candidatesTokenCount"`
	ThoughtsTokenCount      int `json:"thoughtsTokenCount"`
	CachedContentTokenCount int `json:"cachedContentTokenCount"`
	TotalTokenCount         int `json:"totalTokenCount"`
}

type GoogleVertexAPIProvider struct {
	Client        HTTPDoer
	TokenProvider GoogleVertexTokenProvider
}

type GoogleVertexClientConfig struct {
	VertexAI          bool
	APIKey            string
	Project           string
	Location          string
	APIVersion        string
	GoogleAuthOptions *GoogleAuthOptions
	HTTPOptions       *GoogleVertexHTTPOptions
}

type GoogleVertexHTTPOptions struct {
	BaseURL              string
	BaseURLResourceScope string
	APIVersion           string
}

type GoogleVertexOptions struct {
	APIKey   string
	Project  string
	Location string
	Env      ProviderEnv
}

type GoogleVertexTokenProvider interface {
	AccessToken(context.Context, GoogleVertexTokenRequest) (string, error)
}

type GoogleVertexTokenProviderFunc func(context.Context, GoogleVertexTokenRequest) (string, error)

type GoogleVertexTokenRequest struct {
	Project     string
	Location    string
	AuthOptions *GoogleAuthOptions
}

type GrammarConstrainedSampling struct {
	Format        GrammarFormat
	Definition    string
	InputProperty string
}

type GrammarFormat string

type GrammarToolInputJSONBuffer struct {
	Input   string
	Started bool
	Closed  bool
}

type GrammarVariants struct {
	OpenAILark  string `json:"openai_lark,omitempty"`
	OpenAIRegex string `json:"openai_regex,omitempty"`
}

type HTTPDoer interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPRuntimeConfig struct {
	IdleTimeout time.Duration
	ProxyURL    string
}

type ImagesAPIProvider interface {
	GenerateImages(model ImagesModel, imagesContext ImagesContext, options ImagesOptions) (AssistantImages, error)
}

type ImagesAPIProviderFuncs struct {
	GenerateImagesFunc func(ImagesModel, ImagesContext, ImagesOptions) (AssistantImages, error)
}

type ImagesContent struct {
	Type     string
	Text     string
	Data     string
	MIMEType string
}

type ImagesContext struct {
	Input []ImagesContent
}

type ImagesModel struct {
	ID       string
	Name     string
	API      string
	Provider string
	BaseURL  string
	Input    []string
	Output   []string
	Cost     ModelCost
	Headers  map[string]string
}

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

type ImagesModelsOptions = ModelsOptions

type ImagesOptions struct {
	Context context.Context
	APIKey  string
	// APIKeyOverride distinguishes an explicit empty key from no override.
	APIKeyOverride  *string
	Headers         map[string]string
	HeaderRemovals  []string
	Env             ProviderEnv
	TimeoutMillis   int
	MaxRetries      int
	MaxRetryDelayMs int
	Metadata        map[string]any
	OnPayload       func(payload any, model ImagesModel) (any, bool, error)
	OnResponse      func(status int, headers map[string]string, model ImagesModel) error
}

type ImagesProvider struct {
	ID   string
	Name string
	Auth ProviderAuth

	ModelSource        func() ([]ImagesModel, error)
	RefreshModelsFunc  func(ctx context.Context) error
	GenerateImagesFunc func(
		model ImagesModel,
		imagesContext ImagesContext,
		options ImagesOptions,
	) (AssistantImages, error)
	// contains filtered or unexported fields
}

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