model

type CacheController interface {
	// FlushCache flushes the KV cache for the backend
	FlushCache(ctx context.Context) error
	// GetCacheState returns the current cache state
	GetCacheState() CacheState
	// GetMemoryPressure returns the current memory pressure (0.0-1.0)
	// Returns 0.0 if memory pressure cannot be determined
	GetMemoryPressure(ctx context.Context) (float64, error)
}

type CacheState struct {
	// IsFlushed indicates whether the cache has been flushed
	IsFlushed bool
	// LastFlushTime is the timestamp of the last flush
	LastFlushTime int64
}

type ContentEvent struct {
	Content string
}

type Message struct {
	Role       MessageRole `json:"role"`                   // "user", "assistant", "system", or "tool"
	Content    string      `json:"content"`                // Message content
	ToolName   string      `json:"tool_name,omitempty"`    // Tool name, this is required when role is "tool" for Ollama)
	ToolCallID string      `json:"tool_call_id,omitempty"` // Tool call ID, this is required when role is "tool" for OpenAI API
}

type MessageRole string

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

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

type Provider interface {
	// Name returns the provider name (e.g., "ollama", "openai", "anthropic")
	Name() string

	// Chat sends a chat request to the model and returns the response
	// messages: conversation history
	// tools: available tools (for tool calling) - uses mcp.Tool for MCP compatibility
	// stream: if true, stream responses via the returned channel
	// maxTokens: maximum number of tokens to generate; 0 means no limit (use provider default)
	Chat(ctx context.Context, messages []Message, tools []*mcp.Tool, stream bool, maxTokens int) (*Response, <-chan StreamEvent, error)

	// EnsureReady ensures the model provider is ready (e.g., starts Ollama if needed)
	// Returns an error if the provider cannot be made ready
	EnsureReady(ctx context.Context) error
}

type Response struct {
	Content     string             `json:"content"`      // Text content from the model
	Thinking    string             `json:"thinking"`     // Thinking trace from the model (if supported)
	ToolCalls   []ToolCallWithID   `json:"tool_calls"`   // Tool calls requested by the model
	ToolResults []ToolResultWithID `json:"tool_results"` // Tool results returned by the model
	Metrics     *ResponseMetrics   `json:"metrics"`      // Response metrics
}

type ResponseMetrics struct {
	// TTFTMs is time to first token in milliseconds. Only set when task was executed with streaming.
	TTFTMs int64 `json:"ttft_ms,omitempty"`
	// TPOTMs is time per output token in milliseconds. Only set when task was executed with streaming.
	TPOTMs int64 `json:"tpot_ms,omitempty"`
}

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

type StreamEvent interface {
	// Type returns the type of stream event
	Type() StreamEventType
}

type StreamEventType string

type StreamWriter interface {
	io.Writer
	Flush() error
}

type ThinkingEvent struct {
	Content string
}

type ToolCallEvent struct {
	Name      string
	Arguments map[string]any
}

type ToolCallWithID struct {
	ID                string `json:"id"` // Unique identifier for this tool call
	McpCallToolParams mcp.CallToolParams
}

type ToolResultWithID struct {
	ID                string `json:"id"` // Tool call ID this result corresponds to
	McpCallToolResult mcp.CallToolResult
}