llm

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

type BackendType string

type CacheablePrompt struct {
	StaticPrefix  string // persona + tool schemas + grimoire (cacheable)
	DynamicSuffix string // git status + date + memories (not cached)
}

type ChatCompletionResult struct {
	Content      string
	ToolCalls    []ToolCallResult
	FinishReason string
	Error        error
	Usage        *TokenUsage // Token usage from the API response (if available)
}

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

type Config struct {
	APIKey            string
	BaseURL           string
	Model             string
	Timeout           time.Duration
	SkipPersonaPrompt bool
	SimulateTyping    bool
	TypingSpeed       int // chars per second

	// Google Cloud authentication (for Gemini/Vertex AI)
	GoogleCredentialsFile string // Path to service account JSON file
	GoogleUseADC          bool   // Use Application Default Credentials

	// Collections (xAI only)
	Collections *config.CollectionsConfig
	XAIFeatures *config.XAIFeaturesConfig
}

type ExecutionResult struct {
	Success  bool           `json:"success"`
	Result   interface{}    `json:"result,omitempty"`
	Error    string         `json:"error,omitempty"`
	Metadata map[string]any `json:"metadata,omitempty"` // e.g. image base64 from read_file
}

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

type LLMBackend interface {
	// SendMessageStream sends a message with streaming callback.
	// The callback receives chunks as they arrive from the LLM.
	// Returns error if the request fails.
	SendMessageStream(ctx context.Context, messages []tui.ChatMessage,
		tools []tui.SkillDefinition, callback StreamCallback) error

	// SendMessageStreamEvents sends a message with granular streaming events.
	// Unlike SendMessageStream which batches tool calls into the final chunk,
	// this method delivers tool call information incrementally as it arrives.
	SendMessageStreamEvents(ctx context.Context, messages []tui.ChatMessage,
		tools []tui.SkillDefinition, callback StreamEventCallback) error

	// SendMessageSync sends a message and returns the complete result.
	// This is useful for non-streaming use cases or testing.
	// Returns the full chat completion result or error.
	SendMessageSync(ctx context.Context, messages []tui.ChatMessage,
		tools []tui.SkillDefinition) (*ChatCompletionResult, error)

	// SetSystemPrompt sets the system prompt (Celeste persona).
	// This configures the LLM's behavior and character.
	SetSystemPrompt(prompt string)

	// SetThinkingConfig configures extended thinking / reasoning effort.
	// Backends that don't support thinking silently ignore the config.
	SetThinkingConfig(config ThinkingConfig)

	// Close cleans up resources (e.g., network connections).
	// Should be called when the backend is no longer needed.
	Close() error
}

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

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

type SimulatedStreamConfig struct {
	TypingSpeed  int     // Characters per second
	GlitchChance float64 // Chance of corruption effect (0-1)
	MinDelay     time.Duration
	MaxDelay     time.Duration
}

type StreamCallback func(chunk StreamChunk)

type StreamChunk struct {
	Content      string
	IsFirst      bool
	IsFinal      bool
	FinishReason string
	ToolCalls    []ToolCallResult
	Usage        *TokenUsage // Only populated on final chunk with stream_options
}

type StreamEvent struct {
	// Type identifies which kind of event this is.
	Type StreamEventType

	// ContentDelta contains the text delta (only for EventContentDelta).
	ContentDelta string

	// ToolUseID is the unique identifier for the tool call
	// (set for EventToolUseStart, EventToolUseInputDelta, EventToolUseDone).
	ToolUseID string

	// ToolName is the function name being called
	// (set for EventToolUseStart, EventToolUseDone).
	ToolName string

	// InputDelta contains partial argument JSON
	// (only for EventToolUseInputDelta).
	InputDelta string

	// CompleteInput contains the fully accumulated argument JSON
	// (only for EventToolUseDone).
	CompleteInput string

	// Usage contains token usage statistics (only for EventMessageDone).
	Usage *TokenUsage

	// FinishReason indicates why the response ended (only for EventMessageDone).
	FinishReason string
}

type StreamEventCallback func(event StreamEvent)

type StreamEventType int

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

type ThinkingConfig struct {
	Enabled      bool
	BudgetTokens int    // 0 = provider default
	Level        string // "off", "low", "medium", "high", "max"
}

type TokenUsage struct {
	PromptTokens     int
	CompletionTokens int
	TotalTokens      int
}

type ToolCallResult struct {
	ID        string
	Name      string
	Arguments string
	// ArgsError is non-empty when the streamed Arguments could not be assembled
	// into valid JSON (e.g. a dropped stream delta). Empty means no detected
	// corruption — consumers still validate required fields themselves.
	ArgsError string
}

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

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