modelrepo

type BackendSpec struct {
	Type    string
	BaseURL string
	APIKey  string
}

type CapabilityConfig struct {
	ContextLength int
	// MaxOutputTokens is the provider's hard ceiling on output tokens.
	// Leave as 0 when unknown; the client will not clamp.
	MaxOutputTokens int
	CanChat         bool
	CanEmbed        bool
	CanStream       bool
	CanPrompt       bool
	CanThink        bool
}

type CatalogFactory interface {
	NewCatalogProvider(spec BackendSpec, opts ...CatalogOption) (CatalogProvider, error)
}

type CatalogOption func(*CatalogOptions)

type CatalogOptions struct {
	HTTPClient *http.Client
	Tracker    libtracker.ActivityTracker
}

type CatalogProvider interface {
	Type() string
	ListModels(ctx context.Context) ([]ObservedModel, error)
	ProviderFor(model ObservedModel) Provider
}

type CatalogProviderConstructor func(spec BackendSpec, opts CatalogOptions) (CatalogProvider, error)

type ChatArgument interface {
	Apply(config *ChatConfig)
}

type ChatConfig struct {
	Temperature *float64 `json:"temperature,omitempty"`
	MaxTokens   *int     `json:"max_tokens,omitempty"`
	TopP        *float64 `json:"top_p,omitempty"`
	Seed        *int     `json:"seed,omitempty"`
	Tools       []Tool   `json:"tools,omitempty"`
	// Think controls reasoning-model behaviour. nil = use provider default.
	// Normalized values are auto, off, minimal, low, medium, high, and xhigh.
	Think *string `json:"think,omitempty"`
	// Shift instructs the provider to slide the context window on overflow
	// instead of returning a token-limit error.
	Shift *bool `json:"shift,omitempty"`
	// Truncate instructs the provider to truncate history on overflow.
	Truncate *bool `json:"truncate,omitempty"`
}

type ChatResult struct {
	Message   Message
	ToolCalls []ToolCall
}

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

type FunctionTool struct {
	Name        string      `json:"name"`
	Description string      `json:"description,omitempty"`
	Parameters  interface{} `json:"parameters,omitempty"`
}

type LLMChatClient interface {
	Chat(ctx context.Context, messages []Message, args ...ChatArgument) (ChatResult, error)
}

type LLMEmbedClient interface {
	Embed(ctx context.Context, prompt string) ([]float64, error)
}

type LLMPromptExecClient interface {
	Prompt(ctx context.Context, systemInstruction string, temperature float32, prompt string) (string, error)
}

type LLMStreamClient interface {
	Stream(ctx context.Context, messages []Message, args ...ChatArgument) (<-chan *StreamParcel, error)
}

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

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
	// Thinking contains the model's internal reasoning trace (thinking tokens).
	// Only populated when thinking is enabled. Never sent back to the model.
	Thinking string `json:"thinking,omitempty"`

	// For tool calling (OpenAI / vLLM compatible).
	ToolCalls  []ToolCall `json:"tool_calls,omitempty"`
	ToolCallID string     `json:"tool_call_id,omitempty"`
}

type MockChatClient struct{}

type MockEmbedClient struct{}

type MockPromptClient struct{}

type MockProvider struct {
	ID              string
	Name            string
	ContextLength   int
	MaxOutputTokens int
	CanChatFlag     bool
	CanEmbedFlag    bool
	CanStreamFlag   bool
	CanPromptFlag   bool
	Backends        []string
}

type MockStreamClient struct{}

type ObservedModel struct {
	Name          string
	ContextLength int
	ModifiedAt    time.Time
	Size          int64
	Digest        string
	CapabilityConfig
	Meta map[string]string
}

type Provider interface {
	GetBackendIDs() []string
	ModelName() string
	GetID() string
	GetType() string
	GetContextLength() int
	// GetMaxOutputTokens returns the provider's hard ceiling on output tokens
	// (maxOutputTokens / max_tokens / max_completion_tokens in the wire format).
	// Returns 0 when the ceiling is unknown or effectively unlimited.
	GetMaxOutputTokens() int
	CanChat() bool
	CanEmbed() bool
	CanStream() bool
	CanPrompt() bool
	CanThink() bool
	GetChatConnection(ctx context.Context, backendID string) (LLMChatClient, error)
	GetPromptConnection(ctx context.Context, backendID string) (LLMPromptExecClient, error)
	GetEmbedConnection(ctx context.Context, backendID string) (LLMEmbedClient, error)
	GetStreamConnection(ctx context.Context, backendID string) (LLMStreamClient, error)
}

type SnapshotStore interface {
	// Save persists blob under key, replacing any previous blob for that key.
	Save(key string, blob []byte)
	// Load returns the blob previously saved under key, or ok=false on a miss.
	Load(key string) (blob []byte, ok bool)
	// Delete removes any blob stored under key. It is a no-op on a miss.
	Delete(key string)
}

type StreamParcel struct {
	Data string
	// Thinking carries a streamed reasoning/thinking delta separate from the
	// visible output text. Like Message.Thinking, it is provider-facing output
	// and must never be sent back as conversation history.
	Thinking string
	// ToolCalls carries final structured tool-call output for providers that can
	// assemble tool calls from a stream. It is normally emitted on a terminal
	// parcel, not token-by-token.
	ToolCalls []ToolCall
	Error     error
}

type Tool struct {
	Type     string        `json:"type"`
	Function *FunctionTool `json:"function,omitempty"`
}

type ToolCall struct {
	ID       string `json:"id,omitempty"`
	Type     string `json:"type"` // only "function" for now
	Function struct {
		Name      string `json:"name"`
		Arguments string `json:"arguments"`
	} `json:"function"`
	// ProviderMeta carries opaque provider-specific data that must be
	// round-tripped back on the next turn (e.g. Gemini thought_signature).
	ProviderMeta map[string]string `json:"provider_meta,omitempty"`
}

type WarmCache[S WarmSession] struct {
	// contains filtered or unexported fields
}

type WarmEntry[S WarmSession] struct {
	Sess S
	Turn sync.Mutex
	// contains filtered or unexported fields
}

type WarmSession interface{ Close() error }

type WithShift struct{}

type WithThink string