registry

type AntigravityModelConfig struct {
	Thinking            *ThinkingSupport
	MaxCompletionTokens int
	Name                string
}

type ModelCapabilities struct {
	// Attachment reports whether the model accepts file attachments
	// (typically image/pdf passed as content-block image_url with a data:
	// URI). Required for Vercel AI SDK to forward image bytes.
	Attachment bool `json:"attachment"`
	// ToolCall reports whether the model can emit OpenAI-style function
	// calls (tools[] with type=function, returning tool_calls).
	ToolCall bool `json:"tool_call"`
	// Reasoning reports whether the model emits reasoning/thinking chunks
	// distinct from final-answer content (DeepSeek-R1-style or Gemini
	// thinking budget). Clients that render a chain-of-thought UI key off
	// this flag.
	Reasoning bool `json:"reasoning"`
	// Modalities enumerates supported input + output media types. Each
	// entry is one of: text, image, audio, video, pdf. Output is usually
	// just ["text"] but TTS / image-gen / music-gen models output audio
	// or image. A model that omits an entry is assumed not to support it.
	Modalities ModelModalities `json:"modalities"`
}

type ModelInfo struct {
	// ID is the unique identifier for the model
	ID string `json:"id"`
	// Object type for the model (typically "model")
	Object string `json:"object"`
	// Created timestamp when the model was created
	Created int64 `json:"created"`
	// OwnedBy indicates the organization that owns the model
	OwnedBy string `json:"owned_by"`
	// Type indicates the model type (e.g., "claude", "gemini", "openai")
	Type string `json:"type"`
	// DisplayName is the human-readable name for the model
	DisplayName string `json:"display_name,omitempty"`
	// Name is used for Gemini-style model names
	Name string `json:"name,omitempty"`
	// Version is the model version
	Version string `json:"version,omitempty"`
	// Description provides detailed information about the model
	Description string `json:"description,omitempty"`
	// Visibility controls normal public catalog exposure. "private" models
	// remain routable internally but are omitted from GetAvailableModels.
	Visibility string `json:"visibility,omitempty"`
	// InputTokenLimit is the maximum input token limit
	InputTokenLimit int `json:"inputTokenLimit,omitempty"`
	// OutputTokenLimit is the maximum output token limit
	OutputTokenLimit int `json:"outputTokenLimit,omitempty"`
	// SupportedGenerationMethods lists supported generation methods
	SupportedGenerationMethods []string `json:"supportedGenerationMethods,omitempty"`
	// ContextLength is the context window size
	ContextLength int `json:"context_length,omitempty"`
	// MaxCompletionTokens is the maximum completion tokens
	MaxCompletionTokens int `json:"max_completion_tokens,omitempty"`
	// SupportedParameters lists supported parameters
	SupportedParameters []string `json:"supported_parameters,omitempty"`

	// Thinking holds provider-specific reasoning/thinking budget capabilities.
	// This is optional and currently used for Gemini thinking budget normalization.
	Thinking *ThinkingSupport `json:"thinking,omitempty"`

	// Capabilities describes what the model supports — vision, audio, tool
	// calling, reasoning, etc. Surfaced in /v1/models so OpenAI-compatible
	// clients (Vercel AI SDK / OpenCode / Cursor / Continue.dev) can
	// auto-detect feature support without per-model client-side config. If
	// nil, capabilities are inferred from the model ID at marshal time.
	Capabilities *ModelCapabilities `json:"capabilities,omitempty"`

	// NativeTools declares provider-native tools the upstream model
	// supports without caller-side implementation (e.g. MiniMax M2.7's
	// autonomous `{"type":"web_search"}`). Agent runtimes that discover
	// `/v1/models` can merge these entries into their caller-declared
	// `tools` array so the model picks them on recent-events / browsing
	// queries without relying on server-side autoinject hacks. Empty /
	// absent means the model exposes no provider-native tools.
	NativeTools []NativeTool `json:"native_tools,omitempty"`
}

type ModelModalities struct {
	Input  []string `json:"input"`
	Output []string `json:"output"`
}

type ModelRegistration struct {
	// Info contains the model metadata
	Info *ModelInfo
	// Count is the number of active clients that can provide this model
	Count int
	// LastUpdated tracks when this registration was last modified
	LastUpdated time.Time
	// QuotaExceededClients tracks which clients have exceeded quota for this model
	QuotaExceededClients map[string]*time.Time
	// Providers tracks available clients grouped by provider identifier
	Providers map[string]int
	// SuspendedClients tracks temporarily disabled clients keyed by client ID
	SuspendedClients map[string]string
}

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

type NativeTool struct {
	// Type is the tool type the upstream model recognises (e.g.
	// "web_search"). Matches the "type" key of an OpenAI tools[] entry.
	Type string `json:"type" yaml:"type"`
	// Description is a short human-readable sentence for the operator /
	// client UI. Not forwarded to the model.
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
	// Params documents the per-tool knobs (e.g. force_search,
	// max_keyword). Shape is intentionally loose (map[string]any) since
	// each provider defines its own parameter surface. Callers that want
	// to set a param append it alongside "type" on their tools[] entry.
	Params map[string]any `json:"params,omitempty" yaml:"params,omitempty"`
}

type ProviderInfo struct {
	// ID is the unique identifier for the provider (e.g., "gemini", "claude", "ollama")
	ID string `json:"id"`
	// Name is the human-readable name
	Name string `json:"name"`
	// Type indicates the provider type ("api" or "cli")
	Type string `json:"type"`
	// Mode indicates the operational mode ("local" or "online")
	Mode string `json:"mode"`
	// Status indicates provider availability ("active", "degraded", "unavailable")
	Status string `json:"status"`
	// ModelCount is the number of models available from this provider
	ModelCount int `json:"model_count"`
	// Models lists the model IDs available from this provider
	Models []string `json:"models,omitempty"`
}

type ThinkingSupport struct {
	// Min is the minimum allowed thinking budget (inclusive).
	Min int `json:"min,omitempty"`
	// Max is the maximum allowed thinking budget (inclusive).
	Max int `json:"max,omitempty"`
	// ZeroAllowed indicates whether 0 is a valid value (to disable thinking).
	ZeroAllowed bool `json:"zero_allowed,omitempty"`
	// DynamicAllowed indicates whether -1 is a valid value (dynamic thinking budget).
	DynamicAllowed bool `json:"dynamic_allowed,omitempty"`
	// Levels defines discrete reasoning effort levels (e.g., "low", "medium", "high").
	// When set, the model uses level-based reasoning instead of token budgets.
	Levels []string `json:"levels,omitempty"`
}