republic

type Answer struct {
	Type          string             `json:"type"`
	Noul          float64            `json:"noul,omitempty"`
	Choice        string             `json:"choice,omitempty"`
	Score         float64            `json:"score,omitempty"`
	Probabilities map[string]float64 `json:"probabilities,omitempty"`
	Confidence    float64            `json:"confidence,omitempty"`
	Legend        map[string]string  `json:"legend,omitempty"`
}

type Auth interface {
	Apply(context.Context, *http.Request) error
}

type AuthFunc func(context.Context, *http.Request) error

type BuiltinTool struct {
	Kind           string         `json:"kind"`
	MaxUses        *int           `json:"max_uses"`
	AllowedDomains []string       `json:"allowed_domains"`
	BlockedDomains []string       `json:"blocked_domains"`
	UserLocation   *UserLocation  `json:"user_location"`
	APIFormat      string         `json:"api_format"`
	Definition     map[string]any `json:"definition"`
}

type BuiltinToolCall struct {
	Name   string         `json:"name"`
	Input  map[string]any `json:"input"`
	Output any            `json:"output"`
	ID     string         `json:"id,omitempty"`
}

type ChatFormat interface {
	Name() string
	Headers() http.Header
	Build(ChatRequest, bool) (HTTPRequest, error)
	Parse([]byte) ([]Delta, error)
	NewParser() StreamParser
}

type ChatModel struct {
	Provider *Provider
	Name     string
	Format   ChatFormat
	History  History
}

type ChatRequest struct {
	Model        string
	Messages     []Message
	Options      Options
	OutputSchema *OutputSchema
}

type Citation struct {
	URL       string `json:"url"`
	Title     string `json:"title,omitempty"`
	CitedText string `json:"cited_text,omitempty"`
}

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

type DecisionAPIFormat interface {
	Name() string
	Headers() http.Header
	Build(model string, state any, questions map[string]Question) (HTTPRequest, error)
	Parse(map[string]any) (DecisionResponse, error)
}

type DecisionModel struct {
	Provider     *Provider
	Name, Format string
	APIFormat    DecisionAPIFormat
}

type DecisionResponse struct {
	Answers          map[string]Answer
	TokenUsage       TokenUsage
	Model, RequestID string
	Headers          http.Header
}

type Delta struct {
	Event        *Event
	ProviderData *Part
	Fragment     *ToolCallFragment
	Usage        map[string]int
	ID           string
	Model        string
	FinishReason string
}

type DeviceAuthorize func(context.Context, string, string) error

type EmbeddingAPIFormat interface {
	Name() string
	Headers() http.Header
	Build(model string, texts []string, dimensions *int) (HTTPRequest, error)
	Parse(map[string]any) (EmbeddingResponse, error)
}

type EmbeddingModel struct {
	Provider     *Provider
	Name, Format string
	APIFormat    EmbeddingAPIFormat
}

type EmbeddingResponse struct {
	Vectors          [][]float64
	TokenUsage       TokenUsage
	Model, RequestID string
	Headers          http.Header
}

type Error struct {
	Kind       ErrorKind
	Message    string
	StatusCode int
	Body       string
	Headers    http.Header
	RequestID  string
	Cause      error
}

type ErrorKind string

type Event struct {
	Type        string           `json:"type"`
	Chunk       string           `json:"chunk,omitempty"`
	CallID      string           `json:"call_id,omitempty"`
	Name        string           `json:"name,omitempty"`
	Usage       TokenUsage       `json:"usage,omitempty"`
	Image       *Part            `json:"image,omitempty"`
	Call        *ToolCall        `json:"call,omitempty"`
	BuiltinCall *BuiltinToolCall `json:"builtin_call,omitempty"`
	Citation    *Citation        `json:"citation,omitempty"`
	Response    *Response        `json:"response,omitempty"`
}

type Extension interface {
	OnStart(provider, operation, model string) any
	OnRetry(state any, err error, attempt int, delay time.Duration)
	OnFinish(state, response any, err error)
}

type ExtensionFuncs struct {
	Start  func(provider, operation, model string) any
	Retry  func(state any, err error, attempt int, delay time.Duration)
	Finish func(state, response any, err error)
}

type FilePart struct {
	Field, Filename, MediaType string
	Data                       []byte
}

type GitHubCLIAuth struct{ Hostname, Executable string }

type HTTPRequest struct {
	Path   string
	Body   map[string]any
	Params map[string]string
	Files  []FilePart
}

type HeaderAuth struct{ Name, Value string }

type History interface {
	Read(context.Context) ([]Message, error)
	Write(context.Context, []Message) error
}

type ImageAPIFormat interface {
	Name() string
	Headers() http.Header
	Generate(model, prompt string, options Options) (HTTPRequest, error)
	Edit(model, prompt string, images []Part, mask *Part, options Options) (HTTPRequest, error)
	Parse(map[string]any) (ImageResponse, error)
}

type ImageModel struct {
	Provider     *Provider
	Name, Format string
	APIFormat    ImageAPIFormat
}

type ImageResponse struct {
	ImageParts     []Part
	RevisedPrompts []*string
	TokenUsage     TokenUsage
	RequestID      string
	Headers        http.Header
}

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

type Message struct {
	Role      string
	Parts     []Part
	ToolCalls []ToolCall
	ToolCall  *ToolCall
	IsError   bool
}

type ModelInfo struct {
	ID, DisplayName string
	Raw             map[string]any
}

type OAuth2Auth struct{ AccessToken string }

type OpenRouterAuth struct{ APIKey string }

type Options map[string]any

type OutputSchema struct {
	Name   string
	Schema map[string]any
}

type Part struct {
	Type      string         `json:"type"`
	Text      string         `json:"-"`
	MediaType string         `json:"media_type,omitempty"`
	Data      []byte         `json:"data,omitempty"`
	URL       string         `json:"url,omitempty"`
	APIFormat string         `json:"api_format,omitempty"`
	Payload   map[string]any `json:"payload,omitempty"`
}

type Provider struct {
	Name, APIBase string
	// contains filtered or unexported fields
}

type ProviderConfig struct {
	APIKey, APIBase, APIFormat, EnvPrefix, Resource string
	Auth                                            Auth
	Headers                                         http.Header
	ExtraBody                                       map[string]any
	HTTPClient                                      *http.Client
	Timeout                                         time.Duration
	MaxRetries                                      *int
	RetryDelay, MaxRetryDelay                       *time.Duration
	Extensions                                      []Extension
}

type ProviderSpec struct {
	Name, APIBase, ModelsPath, AuthHeader string
	Formats                               []string
	// SelectFormat overrides chat dialect selection for custom providers.
	SelectFormat          func(model, format string) ChatFormat
	SelectEmbeddingFormat func(model, format string) EmbeddingAPIFormat
	SelectImageFormat     func(model, format string) ImageAPIFormat
	SelectDecisionFormat  func(model, format string) DecisionAPIFormat
	ModelsParams          func(previous any) map[string]string
	ParseModels           func(data any) ([]ModelInfo, error)
}

type Question struct {
	Kind         string
	Instructions any
	Criteria     any
}

type Response struct {
	Message          Message           `json:"message"`
	TokenUsage       TokenUsage        `json:"token_usage"`
	Output           any               `json:"output"`
	FinishReason     string            `json:"finish_reason,omitempty"`
	Refusal          string            `json:"refusal,omitempty"`
	Citations        []Citation        `json:"citations"`
	BuiltinToolCalls []BuiltinToolCall `json:"builtin_tool_calls"`
	ID               string            `json:"id,omitempty"`
	Model            string            `json:"model,omitempty"`
	RequestID        string            `json:"request_id,omitempty"`
	Headers          http.Header       `json:"-"`
}

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

type ServerSentEvent struct {
	Event string
	Data  string
}

type Stream struct {
	Headers   http.Header
	RequestID string
	// contains filtered or unexported fields
}

type StreamParser interface {
	Feed(event, data string) ([]Delta, error)
	Finish() error
}

type TokenAuth struct {
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

type TokenUsage struct {
	InputTokens      int `json:"input_tokens"`
	OutputTokens     int `json:"output_tokens"`
	ReasoningTokens  int `json:"reasoning_tokens"`
	CachedTokens     int `json:"cached_tokens"`
	CacheWriteTokens int `json:"cache_write_tokens"`
}

type Tool struct {
	Name        string         `json:"name"`
	Description string         `json:"description"`
	Parameters  map[string]any `json:"parameters"`
	Strict      bool           `json:"strict,omitempty"`
}

type ToolCall struct {
	ID        string         `json:"id"`
	Name      string         `json:"name"`
	Arguments string         `json:"arguments"`
	Metadata  map[string]any `json:"metadata,omitempty"`
}

type ToolCallFragment struct {
	Key       string
	ID        string
	Name      string
	Arguments string
	Metadata  map[string]any
	Done      bool
}

type UserLocation struct {
	City     string `json:"city"`
	Region   string `json:"region"`
	Country  string `json:"country"`
	Timezone string `json:"timezone"`
}

type WireFormat struct {
	Format  string
	Dialect string
}