avelin

type APIError struct {
	// StatusCode is the HTTP status. For errors reported inside a stream it
	// is the status of the stream response, usually 200.
	StatusCode int
	// Type is error.type, such as "rate_limit_error". It may be empty.
	Type string
	// Code is error.code as text. AVELIN documents numeric codes that repeat
	// the HTTP status. It may be empty.
	Code string
	// Message is error.message, or a fallback built from the body or status.
	Message string
	// RequestID comes from the X-Avelin-Request-Id header (see
	// Meta.RequestID). AVELIN omits it on some errors, such as 401 and 403.
	RequestID string
	// Header holds the response headers.
	Header http.Header
	// Body is the raw response body (at most 1 MiB), or the stream event data.
	Body []byte
}

type Catalog struct {
	Object string         `json:"object"`
	Data   []CatalogModel `json:"data"`
	// Meta is the HTTP status and headers of the response.
	Meta Meta `json:"-"`
	// Raw is the full response body, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type CatalogModel struct {
	ID               string         `json:"id"`
	Name             string         `json:"name"`
	Created          int64          `json:"created"`
	InputModalities  []string       `json:"input_modalities"`
	OutputModalities []string       `json:"output_modalities"`
	Pricing          CatalogPricing `json:"pricing"`
	// SupportedSamplingParameters lists request fields such as
	// "reasoning_effort" and "temperature".
	SupportedSamplingParameters []string `json:"supported_sampling_parameters"`
	ContextLength               int      `json:"context_length"`
	MaxOutputLength             int      `json:"max_output_length"`
}

type CatalogPricing struct {
	Prompt     string `json:"prompt"`
	Completion string `json:"completion"`
}

type ChatChoice struct {
	Index   int         `json:"index"`
	Message ChatMessage `json:"message"`
	// FinishReason is "stop", "length", "tool_calls" or "content_filter".
	// A forced tool call reports "stop", so check Message.ToolCalls rather
	// than this field.
	FinishReason string `json:"finish_reason"`
}

type ChatChunkChoice struct {
	Index        int         `json:"index"`
	Delta        ChatMessage `json:"delta"`
	FinishReason string      `json:"finish_reason"`
}

type ChatCompletion struct {
	ID      string       `json:"id"`
	Object  string       `json:"object"`
	Created int64        `json:"created"`
	Model   string       `json:"model"`
	Choices []ChatChoice `json:"choices"`
	Usage   Usage        `json:"usage"`
	// Meta is the HTTP status and headers of the response.
	Meta Meta `json:"-"`
	// Raw is the full response body, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type ChatCompletionChunk struct {
	ID      string            `json:"id"`
	Object  string            `json:"object"`
	Created int64             `json:"created"`
	Model   string            `json:"model"`
	Choices []ChatChunkChoice `json:"choices"`
	// Usage is set on the final chunk when StreamOptions.IncludeUsage is
	// true.
	Usage *Usage `json:"usage,omitempty"`
	// Raw is the event's JSON data, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type ChatCompletionRequest struct {
	Model    ModelID       `json:"model"`
	Messages []ChatMessage `json:"messages"`
	// MaxTokens caps the generated tokens. Zero leaves it to the server.
	MaxTokens int `json:"max_tokens,omitempty"`
	// Temperature is between 0 and 2. Use Ptr to set it.
	Temperature *float64 `json:"temperature,omitempty"`
	// TopP is between 0 and 1. Use Ptr to set it.
	TopP *float64 `json:"top_p,omitempty"`
	// N is the number of choices to generate. Zero means the default, 1.
	N int `json:"n,omitempty"`
	// Stop holds up to 4 stop sequences.
	Stop             []string `json:"stop,omitempty"`
	PresencePenalty  *float64 `json:"presence_penalty,omitempty"`
	FrequencyPenalty *float64 `json:"frequency_penalty,omitempty"`
	Tools            []Tool   `json:"tools,omitempty"`
	// ToolChoice controls tool use: "auto", "none", "required" (call at
	// least one tool), or a ToolChoiceFunction to force one function; nil or
	// "" leaves it to the server. A bare function name, which AVELIN's
	// reference shows, is accepted but ignored.
	ToolChoice any `json:"tool_choice,omitempty"`
	// ReasoningEffort is "low", "medium" or "high" on models that reason.
	// AVELIN documents only "high", but all three are accepted. Reasoning
	// tokens count toward MaxTokens.
	ReasoningEffort string `json:"reasoning_effort,omitempty"`
	// StreamOptions applies to CreateChatCompletionStream only;
	// CreateChatCompletion leaves it out of the request.
	StreamOptions *StreamOptions `json:"stream_options,omitempty"`
}

type ChatMessage struct {
	// Role is "system", "user", "assistant" or "tool".
	Role    string `json:"role"`
	Content string `json:"content"`
	// ReasoningContent is the model's reasoning, returned separately from
	// Content by reasoning-capable models.
	ReasoningContent string     `json:"reasoning_content,omitempty"`
	ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
	// ToolCallID identifies the call a "tool" message answers.
	ToolCallID string `json:"tool_call_id,omitempty"`
}

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

type CompletionTokensDetails struct {
	ReasoningTokens int `json:"reasoning_tokens"`
	TextTokens      int `json:"text_tokens"`
}

type ContentBlock struct {
	Type      string          `json:"type"`
	Text      string          `json:"text,omitempty"`
	Thinking  string          `json:"thinking,omitempty"`
	Signature string          `json:"signature,omitempty"`
	ID        string          `json:"id,omitempty"`
	Name      string          `json:"name,omitempty"`
	Input     json.RawMessage `json:"input,omitempty"`
	ToolUseID string          `json:"tool_use_id,omitempty"`
	// Content is a tool result: a string, or any value that marshals to an
	// array of content blocks.
	Content any  `json:"content,omitempty"`
	IsError bool `json:"is_error,omitempty"`
}

type Embedding struct {
	Object    string    `json:"object"`
	Index     int       `json:"index"`
	Embedding []float64 `json:"embedding"`
}

type EmbeddingList struct {
	Object string      `json:"object"`
	Data   []Embedding `json:"data"`
	Model  string      `json:"model"`
	// Usage has PromptTokens and TotalTokens set.
	Usage Usage `json:"usage"`
	// Meta is the HTTP status and headers of the response.
	Meta Meta `json:"-"`
	// Raw is the full response body, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type EmbeddingRequest struct {
	Model ModelID `json:"model"`
	// Input holds the texts to embed, one embedding per text.
	Input []string `json:"input"`
}

type FunctionCall struct {
	Name      string `json:"name,omitempty"`
	Arguments string `json:"arguments"`
}

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

type Message struct {
	ID    string `json:"id"`
	Type  string `json:"type"`
	Role  string `json:"role"`
	Model string `json:"model"`
	// Content holds the blocks in order. With thinking on, a "thinking"
	// block comes before the "text" block, so use Text for the answer.
	Content []ContentBlock `json:"content"`
	// StopReason is, for example, "end_turn" or "tool_use". A forced tool
	// call reports "end_turn", so look for "tool_use" blocks rather than
	// relying on this field.
	StopReason string       `json:"stop_reason"`
	Usage      MessageUsage `json:"usage"`
	// Meta is the HTTP status and headers of the response.
	Meta Meta `json:"-"`
	// Raw is the full response body, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type MessageParam struct {
	// Role is "user" or "assistant".
	Role    string
	Content string
	Blocks  []ContentBlock
}

type MessageRequest struct {
	Model ModelID `json:"model"`
	// MaxTokens is required and must be positive; CreateMessage and
	// CreateMessageStream return an error before sending otherwise.
	MaxTokens int            `json:"max_tokens"`
	Messages  []MessageParam `json:"messages"`
	System    string         `json:"system,omitempty"`
	// Thinking controls extended thinking. AVELIN documents it as on by
	// default, but live responses carry an empty thinking block unless it is
	// set to &Thinking{Type: "enabled", BudgetTokens: n}. Use
	// &Thinking{Type: "disabled"} to drop the block.
	Thinking *Thinking     `json:"thinking,omitempty"`
	Tools    []MessageTool `json:"tools,omitempty"`
	// ToolChoice controls tool use; nil leaves it to the model.
	ToolChoice *MessageToolChoice `json:"tool_choice,omitempty"`
	// Temperature and TopP are optional. Use Ptr to set them.
	Temperature   *float64 `json:"temperature,omitempty"`
	TopP          *float64 `json:"top_p,omitempty"`
	TopK          int      `json:"top_k,omitempty"`
	StopSequences []string `json:"stop_sequences,omitempty"`
}

type MessageStreamDelta struct {
	Type        string `json:"type"`
	Text        string `json:"text"`
	Thinking    string `json:"thinking"`
	PartialJSON string `json:"partial_json"`
	Signature   string `json:"signature"`
	StopReason  string `json:"stop_reason"`
}

type MessageStreamEvent struct {
	Type         string              `json:"type"`
	Message      *Message            `json:"message,omitempty"`
	Index        int                 `json:"index"`
	ContentBlock *ContentBlock       `json:"content_block,omitempty"`
	Delta        *MessageStreamDelta `json:"delta,omitempty"`
	Usage        *MessageUsage       `json:"usage,omitempty"`
	// Raw is the event's JSON data, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type MessageTool struct {
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
	InputSchema any    `json:"input_schema"`
}

type MessageToolChoice struct {
	// Type is "auto", "any" (call at least one tool), "tool" (call Name) or
	// "none".
	Type string `json:"type"`
	// Name is the tool to call when Type is "tool".
	Name string `json:"name,omitempty"`
}

type MessageUsage struct {
	InputTokens  int `json:"input_tokens"`
	OutputTokens int `json:"output_tokens"`
	// TotalTokens is in AVELIN's docs but missing from live responses, so it
	// is usually zero; add InputTokens and OutputTokens instead.
	TotalTokens              int `json:"total_tokens"`
	CacheCreationInputTokens int `json:"cache_creation_input_tokens"`
	CacheReadInputTokens     int `json:"cache_read_input_tokens"`
}

type Meta struct {
	StatusCode int
	Header     http.Header
}

type Model struct {
	ID      string `json:"id"`
	Object  string `json:"object"`
	Created int64  `json:"created"`
	OwnedBy string `json:"owned_by"`
}

type ModelID string

type ModelList struct {
	Object string  `json:"object"`
	Data   []Model `json:"data"`
	// Meta is the HTTP status and headers of the response.
	Meta Meta `json:"-"`
	// Raw is the full response body, for fields this package does not model.
	Raw json.RawMessage `json:"-"`
}

type Option func(*Client)

type PromptTokensDetails struct {
	CachedTokens int `json:"cached_tokens"`
	TextTokens   int `json:"text_tokens"`
}

type Stream[T any] struct {
	// contains filtered or unexported fields
}

type StreamOptions struct {
	// IncludeUsage asks for a final chunk that carries Usage. It is not in
	// AVELIN's docs but works on the live API.
	IncludeUsage bool `json:"include_usage"`
}

type Thinking struct {
	// Type is "enabled" or "disabled". AVELIN documents only "disabled".
	Type string `json:"type"`
	// BudgetTokens caps thinking tokens for Type "enabled". It comes from the
	// Anthropic format and works on the live API, though AVELIN's reference
	// does not document it.
	BudgetTokens int `json:"budget_tokens,omitempty"`
}

type Tool struct {
	// Type is "function".
	Type     string             `json:"type"`
	Function FunctionDefinition `json:"function"`
}

type ToolCall struct {
	// Index is the call's position in the response; in streams it ties
	// fragments of one call together. AVELIN sends it in plain responses too.
	Index    *int         `json:"index,omitempty"`
	ID       string       `json:"id,omitempty"`
	Type     string       `json:"type,omitempty"`
	Function FunctionCall `json:"function"`
}

type ToolChoiceFunction struct {
	Name string
}

type Usage struct {
	PromptTokens     int `json:"prompt_tokens"`
	CompletionTokens int `json:"completion_tokens"`
	TotalTokens      int `json:"total_tokens"`
	// CompletionTokensDetails splits CompletionTokens into reasoning and
	// text.
	CompletionTokensDetails CompletionTokensDetails `json:"completion_tokens_details"`
	// PromptTokensDetails reports how many prompt tokens came from the
	// prompt cache.
	PromptTokensDetails      PromptTokensDetails `json:"prompt_tokens_details"`
	CacheCreationInputTokens int                 `json:"cache_creation_input_tokens"`
	CacheReadInputTokens     int                 `json:"cache_read_input_tokens"`
}