model

type ContentEvent struct {
	Content string
}

type InferenceOptions struct {
	// Stream is whether to stream the response. A nil value means no streaming.
	Stream bool `json:"stream,omitempty"`
	// MaxTokens is the maximum number of tokens to generate. A nil value means use the backend default.
	MaxTokens *int `json:"max_tokens,omitempty"`
	// Temperature is the temperature parameter for sampling. A nil value means use the backend default.
	Temperature *float64 `json:"temperature,omitempty"`
	// TopP is the nucleus sampling top_p parameter. A nil value means use the backend default.
	TopP *float64 `json:"top_p,omitempty"`
	// ResponseFormat is the structured output options. A nil value means no structured output.
	ResponseFormat *StructuredOutputOptions `json:"response_format,omitempty"`
	// ChatTemplateKwargs are extra kwargs passed to the chat template renderer
	ChatTemplateKwargs map[string]any `json:"chat_template_kwargs,omitempty"`
	// SchedulingPolicy selects stage-level backend queue scheduling behavior.
	SchedulingPolicy SchedulingPolicy `json:"scheduling_policy,omitempty"`
	// RequestSchedulingPolicy selects request-level ordering within a stage queue.
	RequestSchedulingPolicy RequestSchedulingPolicy `json:"request_scheduling_policy,omitempty"`
	// SchedulingHints are optional policy hints for backend queueing.
	SchedulingHints *SchedulingHints `json:"scheduling_hints,omitempty"`
	// ReasoningEffort controls thinking for reasoning-capable models ("high", "medium", "low", "none").
	ReasoningEffort string `json:"reasoning_effort,omitempty"`
}

type Message struct {
	// Role of the message
	Role MessageRole `json:"role"`
	// Content of the message
	Content string `json:"content"`
	// ToolName is used by the Ollama API
	ToolName string `json:"tool_name,omitempty"`
	// ToolCallID is used by the OpenAI API and vLLM
	ToolCallID string `json:"tool_call_id,omitempty"`
	// ToolCalls carries the tool calls from an assistant message so they can be
	// replayed in the conversation history on the next turn.
	ToolCalls []ToolCallWithID `json:"tool_calls,omitempty"`
}

type MessageRole string

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

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

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

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

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

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

	// Chat sends a chat request to the model with the given inference options and returns the response.
	Chat(ctx context.Context, messages []Message, tools []*mcp.Tool, opts InferenceOptions) (*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 ProviderFactory func(modelName string, backend *core.LLMBackend, cfg *config.OrlaConfig) (Provider, error)

type RequestSchedulingPolicy string

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
	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"`
	// PromptTokens is the number of tokens in the prompt (input). Reported by the backend.
	PromptTokens int `json:"prompt_tokens,omitempty"`
	// CompletionTokens is the number of tokens generated (output). Reported by the backend.
	CompletionTokens int `json:"completion_tokens,omitempty"`
	// QueueWaitMs is the time spent waiting in Orla's backend scheduler queue.
	QueueWaitMs int64 `json:"queue_wait_ms,omitempty"`
	// SchedulerDecisionMs is the time spent selecting the next request in the scheduler.
	SchedulerDecisionMs int64 `json:"scheduler_decision_ms,omitempty"`
	// DispatchMs is the request dispatch/setup time between scheduler dequeue and provider return.
	DispatchMs int64 `json:"dispatch_ms,omitempty"`
	// BackendLatencyMs is end-to-end backend latency for non-streaming calls.
	BackendLatencyMs int64 `json:"backend_latency_ms,omitempty"`
}

type SchedulingHints struct {
	// Priority is optional and used by priority-based scheduling policies.
	Priority *int `json:"priority,omitempty"`
}

type SchedulingPolicy string

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

type StreamEventType string

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

type StructuredOutputOptions struct {
	Name   string          `json:"name"`             // Required by OpenAI for json_schema response_format
	Strict bool            `json:"strict,omitempty"` // If true, response is guaranteed to conform to schema (default true when used)
	Schema json.RawMessage `json:"schema"`           // JSON Schema object. The schema must be valid when set
}

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
}