ai

type AdapterConfig struct {
	ProviderID string
	BaseURL    string
	APIKey     string
	HTTP       *http.Client
}

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

type AssistantSettings struct {
	Configured bool
	Active     *store.AIModelRef
	Fallback   []store.AIModelRef
}

type Attempt struct {
	Provider   string
	Model      string
	Usage      Usage
	Latency    time.Duration
	ErrorClass ErrorClass
}

type AttributedSink interface {
	ToolResultAttributed(toolUseID, toolName string, result json.RawMessage, isError bool, attr ToolAttribution)
}

type Backend interface {
	Provider
	ListModels(ctx context.Context) ([]ModelInfo, error)
	// Validate makes one cheap authenticated call and returns a *ProviderError on failure.
	Validate(ctx context.Context) error
}

type BackendFactory func(info ProviderInfo, cfg AdapterConfig) Backend

type BaseURLCheck struct {
	URL     string
	Private bool
}

type ChainEntry struct {
	Provider      string
	Model         string
	Backend       Provider
	ContextWindow int
}

type ChainProvider struct {
	Entries        []ChainEntry
	DefaultContext int
	Logger         *slog.Logger
	Now            func() time.Time
}

type ChatRequest struct {
	System   string
	Messages []Message
	Tools    []ToolSpec
	Model    string
}

type ContentBlock struct {
	Type string

	// Text is set when Type is ContentBlockText.
	Text string

	// ToolUseID, ToolName, ToolInput are set when Type is
	// ContentBlockToolUse: a tool the model wants to invoke.
	ToolUseID string
	ToolName  string
	ToolInput json.RawMessage

	// ToolResultForID, ToolResultContent, ToolResultIsError are set when
	// Type is ContentBlockToolResult: an already-executed tool's outcome,
	// keyed back to the ContentBlockToolUse.ToolUseID it answers.
	ToolResultForID   string
	ToolResultContent string
	ToolResultIsError bool
}

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

type ErrorClass string

type ErrorSink interface {
	TurnError(info TurnErrorInfo)
}

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

type GuardReport struct {
	DroppedToolResults int
	DroppedMessages    int
}

type HostResolver func(ctx context.Context, host string) ([]netip.Addr, error)

type Kind string

type Limits struct {
	StepTimeout        time.Duration
	MaxSteps           int
	ToolOutputMaxBytes int
	DefaultContext     int
	MonthlyTokenBudget int64
}

type Message struct {
	Role    string
	Content []ContentBlock
}

type ModelInfo struct {
	ID            string `json:"id"`
	Label         string `json:"label"`
	ContextWindow int    `json:"context_window,omitempty"`
	SupportsTools *bool  `json:"supports_tools,omitempty"`
}

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

type Provider interface {
	Complete(ctx context.Context, req ChatRequest, onText TextDeltaFunc) (TurnResult, error)
}

type ProviderError struct {
	Provider   string
	Class      ErrorClass
	Status     int
	RetryAfter time.Duration
	Detail     string
}

type ProviderInfo struct {
	ID              string
	Label           string
	Kind            Kind
	DefaultBaseURL  string
	BaseURLEditable bool
	KeyURL          string
	DefaultModel    string
	Brand           string
	// KeyRequired is false for self-hosted servers that run without auth.
	KeyRequired bool
}

type ProviderResolver interface {
	Configured(ctx context.Context) (bool, error)
	Chain(ctx context.Context) (Provider, error)
}

type ProviderView struct {
	ID              string `json:"id"`
	Label           string `json:"label"`
	Kind            Kind   `json:"kind"`
	DefaultBaseURL  string `json:"default_base_url"`
	BaseURLEditable bool   `json:"base_url_editable"`
	KeyURL          string `json:"key_url"`
	DefaultModel    string `json:"default_model"`
	Brand           string `json:"brand"`
	HasKey          bool   `json:"has_key"`
	BaseURL         string `json:"base_url,omitempty"`
	Status          string `json:"status"`
	StatusDetail    string `json:"status_detail,omitempty"`
	LastCheckedAt   string `json:"last_checked_at,omitempty"`
}

type RetryPolicy struct {
	MaxAttempts int
	BaseDelay   time.Duration
	MaxDelay    time.Duration
	// Jitter returns a value in [0,1); nil uses math/rand.
	Jitter func() float64
	// Sleep waits d or until ctx ends; nil uses a real timer.
	Sleep func(ctx context.Context, d time.Duration) error
}

type RetryProvider struct {
	Inner  Provider
	Policy RetryPolicy
}

type SaveError struct {
	Code    string
	Message string
	Fix     string
}

type SetInput struct {
	APIKey       string
	BaseURL      string
	DefaultModel string
}

type SetResult struct {
	PrivateBaseURL bool
}

type Sink interface {
	TextDelta(text string)
	ToolCallProposed(confirmationID, toolUseID, toolName string, arguments json.RawMessage)
	ToolResult(toolUseID, toolName string, result json.RawMessage, isError bool)
}

type Store interface {
	ListAIChatMessages(ctx context.Context, sessionID string) ([]store.AIChatMessage, error)
	SaveAIChatMessage(ctx context.Context, m store.AIChatMessage) error
	UpdateAIChatMessageToolCalls(ctx context.Context, messageID string, toolCalls []store.AIChatToolCall) error
	GetAIChatMessage(ctx context.Context, id string) (store.AIChatMessage, error)
	SaveAIChatConfirmation(ctx context.Context, c store.AIChatConfirmation) error
	GetAIChatConfirmation(ctx context.Context, id string) (store.AIChatConfirmation, error)
	ResolveAIChatConfirmation(ctx context.Context, id, status string, result json.RawMessage, resolvedAt time.Time) error
	ListPendingAIChatConfirmations(ctx context.Context, messageID string) ([]store.AIChatConfirmation, error)
}

type TestResult struct {
	OK           bool   `json:"ok"`
	Status       string `json:"status"`
	StatusDetail string `json:"status_detail,omitempty"`
	LatencyMS    int64  `json:"latency_ms"`
}

type TextDeltaFunc func(delta string)

type ToolAttribution struct {
	ConfirmationID string
	ActingAs       string
	Abilities      []string
}

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

type ToolExecutor interface {
	ListTools(ctx context.Context) ([]ToolSpec, error)
	Call(ctx context.Context, name string, args json.RawMessage) (result string, isError bool, err error)
}

type ToolFactory func(ctx context.Context, token string) (ToolExecutor, error)

type ToolSpec struct {
	Name        string
	Description string
	InputSchema json.RawMessage
	Traits      ToolTraits
}

type ToolTraits struct {
	Known           bool
	ReadOnly        bool
	Destructive     bool
	OpenWorld       bool
	Sensitive       bool
	UntrustedOutput bool
}

type ToolUseCall struct {
	ID    string
	Name  string
	Input json.RawMessage
}

type TurnCredential struct {
	// Token is a short-lived bearer minted for this turn only, capped to the sender.
	Token string
	// ActingAs names the human principal the token stands in for.
	ActingAs string
	// AbilitiesUsed drains the abilities the API checked since its last call; nil is allowed.
	AbilitiesUsed func() []string
}

type TurnErrorInfo struct {
	Code      string
	Message   string
	Fix       string
	Provider  string
	Retryable bool
}

type TurnResult struct {
	Text       string
	ToolCalls  []ToolUseCall
	StopReason string
	Usage      Usage
}

type Usage struct {
	PromptTokens     int
	CompletionTokens int
}

type UsageStore interface {
	RecordAIUsage(ctx context.Context, r store.AIUsageRecord) error
	SumAITokensSince(ctx context.Context, since time.Time) (int64, error)
}

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

type VaultOption func(*Vault)

type VaultSecrets interface {
	SetValue(ctx context.Context, serviceName, envKey, plaintext string) error
	Resolve(ctx context.Context, serviceName, envKey string) (string, error)
	Exists(ctx context.Context, serviceName, envKey string) (bool, error)
	DeleteAll(ctx context.Context, serviceName string) error
}

type VaultStore interface {
	GetAIAssistantSettings(ctx context.Context) (store.AIAssistantSettings, error)
	UpdateAIAssistantSettings(ctx context.Context, s store.AIAssistantSettings) error
	GetAIProviderConfig(ctx context.Context, id string) (store.AIProviderConfig, error)
	UpsertAIProviderConfig(ctx context.Context, c store.AIProviderConfig) error
	ListAIProviderConfigs(ctx context.Context) ([]store.AIProviderConfig, error)
	DeleteAIProviderConfig(ctx context.Context, id string) error
	SetAIProviderStatus(ctx context.Context, id, status, detail string, at time.Time) error
}