provider

type AttemptAttribution struct {
	CredentialID     string
	CredentialSource string
}

type CandidateIdentity struct {
	ProviderID    string
	ProviderType  string
	UpstreamModel string
}

type CapabilityOption string

type ChatCompletionsFieldPolicy struct {
	ReasoningStyle ReasoningFieldStyle
	AllowThinking  bool
	AllowedEfforts []string
	EffortAliases  map[string]string
	// ThinkingBudgetField maps Anthropic thinking.budget_tokens into a field
	// on a structured reasoning object. It is ignored for effort-style dialects.
	ThinkingBudgetField string
}

type ChatExecution struct {
	Response *ChatResponse
	Resolved ResolvedExecution
}

type ChatExtraFields struct {
	ResponseFormat    any
	Reasoning         map[string]any
	Thinking          map[string]any
	ReasoningEffort   string
	ToolStream        *bool
	StreamOptions     map[string]any
	User              string
	Metadata          map[string]any
	ParallelToolCalls *bool
	Store             *bool
}

type ChatOptions struct {
	TopK          int
	Responses     *ResponsesRequestContext
	ChatExtra     *ChatExtraFields
	ProtocolState *ProtocolState
}

type ChatRequest struct {
	Model         string
	Messages      []*schema.Message
	Options       []einomodel.Option
	ProtocolState *ProtocolState
}

type ChatRequestState struct {
	ModelName     string
	Messages      []*schema.Message
	Options       []einomodel.Option
	CommonOptions *einomodel.Options
	ProtocolState *ProtocolState
}

type ChatResponse struct {
	Message *schema.Message
}

type CompactMode string

type DialectCodec interface {
	Capture(NativeCaptureInput) (NativeEnvelope, error)
	Overlay(NativeOverlayInput) (json.RawMessage, error)
	FoldResponse([]NativeEnvelope) ([]NativeEnvelope, error)
	FoldStreamEvents([]NativeEnvelope) ([]NativeEnvelope, error)
	ValidateFragments(NativeStateKind, []NativeEnvelope) error
	ValidateOrder([]NativeEnvelope) error
}

type EmbeddingProvider interface {
	Provider
	Embedding(ctx context.Context, req *EmbeddingRequest) (*EmbeddingResponse, error)
}

type EmbeddingRequest struct {
	// Model is the embedding model to use. Leave empty to use provider default.
	Model string
	// Texts are the strings to embed.
	Texts []string
}

type EmbeddingResponse struct {
	Embeddings [][]float64
	Model      string
	Usage      Usage
}

type LLMApiRequestType string

type MessageProtocolState ProtocolState

type ModelCapabilities struct {
	Streaming       bool `json:"streaming,omitempty"`
	Tools           bool `json:"tools,omitempty"`
	Vision          bool `json:"vision,omitempty"`
	Embeddings      bool `json:"embeddings,omitempty"`
	ContextWindow   int  `json:"context_window,omitempty"`
	MaxOutputTokens int  `json:"max_output_tokens,omitempty"`
}

type ModelInfo struct {
	ID           string
	Name         string
	DisplayName  string
	Description  string
	Capabilities ModelCapabilities
}

type ModeledFieldBaseline struct {
	Path    string   `json:"path"`
	Present bool     `json:"present"`
	Digest  [32]byte `json:"digest"`
}

type ModeledProjection any

type NativeCaptureInput struct {
	Scope    NativeStateScope
	Kind     NativeStateKind
	Location NativeLocation
	Raw      json.RawMessage
	Modeled  ModeledProjection
}

type NativeEnvelope struct {
	Dialect   ProtocolDialect        `json:"dialect"`
	Scope     NativeStateScope       `json:"scope"`
	Kind      NativeStateKind        `json:"kind"`
	Location  NativeLocation         `json:"location"`
	Raw       json.RawMessage        `json:"raw"`
	Baselines []ModeledFieldBaseline `json:"baselines,omitempty"`
}

type NativeLocation struct {
	MessageIndex int    `json:"message_index,omitempty"`
	ContentIndex int    `json:"content_index,omitempty"`
	ToolIndex    int    `json:"tool_index,omitempty"`
	SourceIndex  int    `json:"source_index,omitempty"`
	Event        string `json:"event,omitempty"`
}

type NativeOverlayInput struct {
	Envelope NativeEnvelope
	Current  ModeledProjection
}

type NativeStateKind string

type NativeStateScope string

type NetworkConfig = httpclient.NetworkConfig

type ProtocolDialect string

type ProtocolFeature string

type ProtocolFeatureClass string

type ProtocolFeatureDefinition struct {
	ID        ProtocolFeature
	Dialect   ProtocolDialect
	Class     ProtocolFeatureClass
	DependsOn []ProtocolFeature
}

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

type ProtocolState struct {
	Envelopes    []NativeEnvelope       `json:"envelopes,omitempty"`
	Requirements ProtocolRequirementSet `json:"requirements,omitempty"`
}

type Provider interface {
	// Chat performs a non-streaming chat completion and returns the full response.
	Chat(ctx context.Context, req *ChatRequest) (*ChatResponse, error)

	// StreamChat performs a streaming chat completion and returns an Eino message stream.
	StreamChat(ctx context.Context, req *ChatRequest) (*schema.StreamReader[*schema.Message], error)

	// ListModels returns the list of models available from this provider.
	ListModels(ctx context.Context) ([]ModelInfo, error)

	// Capabilities returns what this provider instance supports.
	Capabilities() ProviderCapabilities

	// Config returns the provider instance configuration view used at runtime.
	Config() ProviderConfig
}

type ProviderCapabilities struct {
	Streaming       bool
	Tools           bool
	Vision          bool
	Embeddings      bool
	ContextWindow   int
	MaxOutputTokens int
}

type ProviderConfig struct {
	// Id is the unique provider config ID.
	Id string `json:"id"`
	// ProviderType is the registered provider type (e.g. "openai", "anthropic").
	ProviderType string `json:"provider_type"`
	// Disabled prevents the provider from being selected at runtime.
	Disabled bool `json:"disabled"`
	// APIKey is the provider API key. May be empty for local providers (Ollama).
	APIKey string `json:"api_key,omitempty"`
	// BaseURL overrides the provider's default API base URL.
	BaseURL string `json:"base_url,omitempty"`
	// DefaultModel is used when the request does not specify a model.
	DefaultModel string `json:"default_model,omitempty"`
	// Network contains HTTP client configuration (timeout, retry, proxy).
	Network NetworkConfig `json:"network"`
	// Options holds provider-specific extra configuration.
	Options map[string]any `json:"options,omitempty"`
	// CreatedAt is set when the dynamic provider config is first persisted.
	CreatedAt time.Time `json:"created_at"`
	// UpdatedAt is bumped on every persisted create/update. It is used as the
	// runtime resolver's cache fingerprint so a config change rebuilds the
	// provider instance even if explicit invalidation was missed.
	UpdatedAt time.Time `json:"updated_at"`
}

type ProviderFactory func(config ProviderConfig) (Provider, error)

type ProviderTypeCapabilities struct {
	Dialect          ProtocolDialect
	ProtocolFeatures map[ProtocolFeature]struct{}
}

type ProviderTypeSetting struct {
	ProviderType string `json:"provider_type"`
	Enabled      bool   `json:"enabled"`
}

type ReasoningFieldStyle int

type ReasoningParts []schema.MessageOutputPart

type RequirementGap struct {
	Candidate CandidateIdentity
	Missing   []ProtocolFeature
}

type RequirementGapsError struct {
	Target string
	Gaps   []RequirementGap
}

type RequirementReason string

type ResolvedExecution struct {
	Candidate   ServedCandidate
	Attribution AttemptAttribution
}

type ResponsesInputTokensUsage struct {
	CachedTokens int `json:"cached_tokens,omitempty"`
}

type ResponsesOutputTokensUsage struct {
	ReasoningTokens int `json:"reasoning_tokens,omitempty"`
}

type ResponsesProvider interface {
	Provider
	CreateResponses(ctx context.Context, req *ResponsesRequest) (*ResponsesResponse, error)
	StreamResponses(ctx context.Context, req *ResponsesRequest) (*schema.StreamReader[*ResponsesStreamEvent], error)
}

type ResponsesReasoningSummaryPart struct {
	Type string `json:"type"`
	Text string `json:"text"`
}

type ResponsesRequest struct {
	Model              string                    `json:"model"`
	Input              any                       `json:"input"`
	Tools              []ResponsesToolDefinition `json:"tools,omitempty"`
	ToolChoice         json.RawMessage           `json:"tool_choice,omitempty"`
	MaxOutputTokens    int                       `json:"max_output_tokens,omitempty"`
	Temperature        float64                   `json:"temperature,omitempty"`
	TopP               float64                   `json:"top_p,omitempty"`
	Stream             bool                      `json:"stream,omitempty"`
	Instructions       string                    `json:"instructions,omitempty"`
	PreviousResponseID string                    `json:"previous_response_id,omitempty"`
	Store              *bool                     `json:"store,omitempty"`
	Text               map[string]any            `json:"text,omitempty"`
	Metadata           map[string]any            `json:"metadata,omitempty"`
	User               string                    `json:"user,omitempty"`
	Reasoning          map[string]any            `json:"reasoning,omitempty"`
	ParallelToolCalls  *bool                     `json:"parallel_tool_calls,omitempty"`
	Truncation         any                       `json:"truncation,omitempty"`
}

type ResponsesRequestContext struct {
	PreviousResponseID string
	Store              *bool
	Text               map[string]any
	Metadata           map[string]any
	User               string
	Reasoning          map[string]any
	ParallelToolCalls  *bool
	Truncation         any
}

type ResponsesResponse struct {
	ID        string                    `json:"id"`
	Object    string                    `json:"object"`
	CreatedAt int64                     `json:"created_at"`
	Model     string                    `json:"model"`
	Output    []ResponsesResponseOutput `json:"output"`
	Usage     *ResponsesResponseUsage   `json:"usage,omitempty"`
	RawJSON   json.RawMessage           `json:"-"`
}

type ResponsesResponseContentPart struct {
	Type        string          `json:"type"`
	Text        string          `json:"text,omitempty"`
	Annotations []any           `json:"annotations,omitempty"`
	Refusal     string          `json:"refusal,omitempty"`
	Summary     []any           `json:"summary,omitempty"`
	RawJSON     json.RawMessage `json:"-"`
}

type ResponsesResponseOutput struct {
	ID        string                          `json:"id,omitempty"`
	Type      string                          `json:"type"`
	Role      string                          `json:"role,omitempty"`
	Status    string                          `json:"status,omitempty"`
	Content   []ResponsesResponseContentPart  `json:"content,omitempty"`
	CallID    string                          `json:"call_id,omitempty"`
	Name      string                          `json:"name,omitempty"`
	Arguments string                          `json:"arguments,omitempty"`
	Summary   []ResponsesReasoningSummaryPart `json:"summary,omitempty"`
}

type ResponsesResponseUsage struct {
	InputTokens         int                        `json:"input_tokens"`
	OutputTokens        int                        `json:"output_tokens"`
	TotalTokens         int                        `json:"total_tokens"`
	InputTokensDetails  ResponsesInputTokensUsage  `json:"input_tokens_details,omitzero"`
	OutputTokensDetails ResponsesOutputTokensUsage `json:"output_tokens_details,omitzero"`
}

type ResponsesStreamEvent struct {
	Type         string                         `json:"type"`
	Response     *ResponsesResponse             `json:"response,omitempty"`
	Item         *ResponsesResponseOutput       `json:"item,omitempty"`
	Delta        string                         `json:"delta,omitempty"`
	ItemID       string                         `json:"item_id,omitempty"`
	OutputIndex  int                            `json:"output_index,omitempty"`
	ContentIndex int                            `json:"content_index,omitempty"`
	SummaryIndex int                            `json:"summary_index,omitempty"`
	Part         *ResponsesReasoningSummaryPart `json:"part,omitempty"`
	RawJSON      json.RawMessage                `json:"-"`
}

type ResponsesToolDefinition struct {
	Type        string                 `json:"type"`
	Name        string                 `json:"name,omitempty"`
	Description string                 `json:"description,omitempty"`
	Parameters  json.RawMessage        `json:"parameters,omitempty"`
	Function    *ResponsesToolFunction `json:"function,omitempty"`
}

type ResponsesToolFunction struct {
	Name        string          `json:"name"`
	Description string          `json:"description,omitempty"`
	Parameters  json.RawMessage `json:"parameters,omitempty"`
}

type RoutedChatExecutor interface {
	ExecuteChat(context.Context, *ChatRequest) (*ChatExecution, error)
	ExecuteStreamChat(context.Context, *ChatRequest) (*StreamExecution, error)
}

type ServedCandidate struct {
	Dialect       ProtocolDialect
	ProviderType  string
	ProviderID    string
	LogicalModel  string
	ClientModel   string
	UpstreamModel string
	Features      map[ProtocolFeature]struct{}
}

type StreamExecution struct {
	Stream   *schema.StreamReader[*schema.Message]
	Resolved ResolvedExecution
}

type UpstreamError struct {
	Status     int
	StatusText string
	Body       string
}

type Usage struct {
	InputTokens     int
	OutputTokens    int
	TotalTokens     int
	CachedTokens    int
	ReasoningTokens int
}