llm

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

type AgentCallbacks struct {
	// OnReasoning is called when reasoning/thinking content is streamed
	OnReasoning func(content string)

	// OnContent is called when regular content is streamed
	OnContent func(content string)

	// BeforeToolExecute is called before each tool executes.
	// Returns a (possibly modified) context to pass to the tool.
	// Use this to inject context values that tools need (e.g., IRC context).
	// If nil, context passes through unchanged.
	BeforeToolExecute func(ctx context.Context, call messages.ChatMessageToolCall, args map[string]any) context.Context

	// OnToolStart is called once before parallel tool execution begins with all tool calls
	OnToolStart func(calls []messages.ChatMessageToolCall)

	// OnToolEnd is called after each tool executes
	OnToolEnd func(call messages.ChatMessageToolCall, result string, duration time.Duration, err error)

	// OnComplete is called when the final response is ready (no more tool calls)
	OnComplete func(response *messages.ChatMessage)

	// OnError is called when an error occurs
	OnError func(err error)
}

type AgentConfig struct {
	MaxIterations    int           // Maximum LLM calls before giving up (default: 10)
	ToolTimeout      time.Duration // Per-tool execution timeout (0 = no timeout)
	MaxParallelTools int           // Maximum parallel tool executions (0 = unlimited)
}

type AgentResponse struct {
	Message        *messages.ChatMessage  // Final assistant message (no tool calls)
	AllMessages    []messages.ChatMessage // All messages generated (assistant + tool results)
	IterationCount int                    // Number of LLM calls made
}

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

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

type CompletionRequest struct {
	APIKey         string
	BaseURL        string
	Timeout        time.Duration
	Temperature    float32
	Model          string
	MaxTokens      int
	Messages       []messages.ChatMessage // Message history
	Tools          []tools.Tool           // Available tools
	ResponseSchema *Schema                // Optional schema for structured output
	ThinkingEffort ThinkingEffort         // Reasoning effort level: ThinkingOff, ThinkingLow, ThinkingMedium, ThinkingHigh
	Stream         *bool                  // nil = streaming (default), false = non-streaming
}

type EventStreamProcessor interface {
	ProcessMessagesToEvents(<-chan messages.ChatMessage) <-chan *messages.StreamEvent
}

type ExecutionHooks struct {
	// BeforeExecute is called before each tool executes.
	// Returns a (possibly modified) context to pass to the tool.
	// If nil, context passes through unchanged.
	BeforeExecute func(ctx context.Context, toolCall messages.ChatMessageToolCall, args map[string]any) context.Context

	// AfterExecute is called after each tool executes with timing info.
	// Receives the result string and any error that occurred.
	AfterExecute func(toolCall messages.ChatMessageToolCall, result string, duration time.Duration, err error)

	// OnParseError is called when tool arguments fail to parse.
	// Returns the error message to use. If nil, uses default message.
	OnParseError func(toolCall messages.ChatMessageToolCall, err error) string

	// OnToolNotFound is called when a tool isn't in the registry.
	// Returns the error message to use. If nil, uses default message.
	OnToolNotFound func(toolCall messages.ChatMessageToolCall) string
}

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

type LLM interface {
	// Event-based streaming method
	ChatCompletionStream(context.Context, *CompletionRequest, EventStreamProcessor) <-chan *messages.StreamEvent
}

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

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

type OpenAIClient struct {
	ClientConfig ai.ClientConfig
	Client       *ai.Client
}

type Schema struct {
	Raw    map[string]any // Raw JSON schema
	Strict bool           // Whether to enforce strict validation
}

type SimpleProcessor struct{}

type ThinkingEffort string

type ToolExecutor struct {
	Registry *tools.ToolRegistry
	Hooks    *ExecutionHooks
	Timeout  time.Duration // Default timeout for tool execution
}