llm

type APIConnectOptions struct {
	MaxRetry      int
	RetryInterval time.Duration
	Timeout       time.Duration
}

type APIConnectionError struct {
	*APIError
}

type APIError struct {
	Message   string
	Body      any
	Retryable bool
}

type APIStatusError struct {
	*APIError
	StatusCode int
	RequestID  string
}

type APITimeoutError struct {
	*APIConnectionError
}

type AgentConfigUpdate struct {
	ID                  string
	Instructions        *string
	InstructionVariants *Instructions
	ToolsAdded          []string
	ToolsRemoved        []string
	CreatedAt           time.Time
}

type AgentHandoff struct {
	ID         string
	OldAgentID *string
	NewAgentID string
	CreatedAt  time.Time
}

type AudioContent struct {
	Frames     []any
	Transcript string
}

type ChatChunk struct {
	ID    string
	Delta *ChoiceDelta
	Usage *CompletionUsage
}

type ChatContent struct {
	Text         string
	Image        *ImageContent
	Audio        *AudioContent
	Instructions *Instructions
}

type ChatContext struct {
	Items []ChatItem
	// contains filtered or unexported fields
}

type ChatContextCopyOptions struct {
	ExcludeFunctionCall bool
	ExcludeInstructions bool
	ExcludeEmptyMessage bool
	ExcludeHandoff      bool
	ExcludeConfigUpdate bool
	Tools               []interface{}
}

type ChatContextDictOptions struct {
	IncludeImage        bool
	IncludeAudio        bool
	IncludeTimestamp    bool
	IncludeOptionalNull bool
	ExcludeFunctionCall bool
	ExcludeMetrics      bool
	ExcludeConfigUpdate bool
}

type ChatContextMergeOptions struct {
	ExcludeFunctionCall bool
	ExcludeInstructions bool
	ExcludeConfigUpdate bool
}

type ChatContextProviderFormatOptions struct {
	InjectDummyUserMessage    *bool
	InjectTrailingUserMessage *bool
	ThoughtSignatures         map[string][]byte
}

type ChatContextSummarizeOptions struct {
	KeepLastTurns int
}

type ChatContextUpsertOptions struct {
	AllowTypeMismatch bool
}

type ChatItem interface {
	GetID() string
	GetType() string
	GetCreatedAt() time.Time
}

type ChatMessage struct {
	ID                   string
	Role                 ChatRole
	Content              []ChatContent
	Interrupted          bool
	TranscriptConfidence *float64
	Extra                map[string]any
	Metrics              map[string]any
	CreatedAt            time.Time
}

type ChatMessageArgs struct {
	ID          string
	Role        ChatRole
	Content     []ChatContent
	Text        string
	Interrupted bool
	CreatedAt   time.Time
	Extra       map[string]any
	Metrics     map[string]any
}

type ChatOption func(*ChatOptions)

type ChatOptions struct {
	Tools                []Tool
	ToolChoice           ToolChoice
	ParallelToolCalls    bool
	ParallelToolCallsSet bool
	ConnectOptions       *APIConnectOptions
	ExtraParams          map[string]any
	ResponseFormat       map[string]any
}

type ChatRole string

type ChoiceDelta struct {
	Role      ChatRole
	Content   string
	Flush     bool
	ToolCalls []FunctionToolCall
	Extra     map[string]any
}

type CollectedResponse struct {
	Text      string
	ToolCalls []FunctionToolCall
	Usage     *CompletionUsage
	Extra     map[string]any
}

type CompletionUsage struct {
	CompletionTokens    int
	PromptTokens        int
	PromptCachedTokens  int
	CacheCreationTokens int
	CacheReadTokens     int
	TotalTokens         int
	ServiceTier         string
}

type DiffOps struct {
	ToRemove []string
	ToCreate [][2]*string // [previous_item_id, id]
	ToUpdate [][2]*string // [previous_item_id, id]
}

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

type FallbackAdapter struct {
	MetricsEmitter
	ErrorEmitter
	// contains filtered or unexported fields
}

type FallbackAdapterOptions struct {
	AttemptTimeout   time.Duration
	MaxRetryPerLLM   int
	RetryInterval    time.Duration
	RetryOnChunkSent bool
}

type FallbackAllFailedError struct {
	Count    int
	Labels   []string
	Duration time.Duration
	Err      error
	APIError *APIConnectionError
}

type FallbackAvailabilityChangedEvent struct {
	LLM       LLM
	Index     int
	Available bool
}

type FallbackAvailabilityChangedHandler func(FallbackAvailabilityChangedEvent)

type FunctionCall struct {
	ID        string
	CallID    string
	Name      string
	Arguments string
	Extra     map[string]any
	GroupID   *string
	CreatedAt time.Time
}

type FunctionCallOutput struct {
	ID        string
	CallID    string
	Name      string
	Output    string
	IsError   bool
	CreatedAt time.Time
}

type FunctionCallResult struct {
	FncCall    FunctionCall
	FncCallOut *FunctionCallOutput
	RawOutput  any
	RawError   error
}

type FunctionToolCall struct {
	ID        string `json:"-"`
	Type      string
	Name      string
	Arguments string
	CallID    string
	Extra     map[string]any
}

type GenerationCreatedEvent struct {
	MessageCh     <-chan MessageGeneration
	FunctionCh    <-chan *FunctionCall
	ResponseID    string
	UserInitiated bool
}

type ImageContent struct {
	ID              string
	Image           any
	InferenceWidth  *int
	InferenceHeight *int
	InferenceDetail string
	MimeType        string
}

type InputSpeechStoppedEvent struct {
	UserTranscriptionEnabled bool
}

type InputTranscriptionCompleted struct {
	ItemID       string
	ContentIndex int
	Transcript   string
	IsFinal      bool
	Confidence   *float64
}

type Instructions struct {
	Audio string
	Text  string
	// contains filtered or unexported fields
}

type LLM interface {
	Chat(ctx context.Context, chatCtx *ChatContext, opts ...ChatOption) (LLMStream, error)
}

type LLMError struct {
	Type        string
	Timestamp   time.Time
	Label       string
	Err         error
	Recoverable bool
}

type LLMErrorHandler func(*LLMError)

type LLMMetricsHandler func(*telemetry.LLMMetrics)

type LLMStream interface {
	Next() (*ChatChunk, error)
	Close() error
}

type MCPServer interface {
	Initialize(ctx context.Context) error
	Initialized() bool
	InvalidateCache()
	ListTools(ctx context.Context) ([]Tool, error)
	Close() error
}

type MCPServerHTTP struct {
	URL           string
	TransportType string
	AllowedTools  []string
	Headers       map[string]string
	// contains filtered or unexported fields
}

type MCPServerStdio struct {
	Command string
	Args    []string
	Env     map[string]string
	Cwd     string
	// contains filtered or unexported fields
}

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

type MessageGeneration struct {
	MessageID    string
	TextCh       <-chan string
	TimedTextCh  <-chan RealtimeTimedText
	AudioCh      <-chan *model.AudioFrame
	ModalitiesCh <-chan []string
}

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

type MetricsReport struct {
	Usage     telemetry.UsageSummary
	CreatedAt time.Time
}

type ProviderTool interface {
	Tool
	IsProviderTool() bool
}

type RealtimeCapabilities struct {
	MessageTruncation       bool
	TurnDetection           bool
	UserTranscription       bool
	AutoToolReplyGeneration bool
	AudioOutput             bool
	ManualFunctionCalls     bool
	MutableChatContext      bool
	MutableInstructions     bool
	MutableTools            bool
	PerResponseToolChoice   bool
	SupportsSay             bool
}

type RealtimeError struct {
	Message string
	Err     error
}

type RealtimeEvent struct {
	Type               RealtimeEventType
	ItemID             string
	ContentIndex       int
	Data               []byte // For audio frames
	Text               string // For text deltas
	TimedText          *RealtimeTimedText
	Function           *FunctionToolCall
	Generation         *GenerationCreatedEvent
	RemoteItem         *RemoteItemAddedEvent
	Reconnect          *RealtimeSessionReconnectedEvent
	InputTranscription *InputTranscriptionCompleted
	SpeechStopped      *InputSpeechStoppedEvent
	Metrics            *telemetry.RealtimeModelMetrics
	Error              error
}

type RealtimeEventType string

type RealtimeGenerateReplyOptions struct {
	Instructions    string
	InstructionsSet bool
	ToolChoice      ToolChoice
	Tools           []Tool
}

type RealtimeModel interface {
	Capabilities() RealtimeCapabilities
	Session() (RealtimeSession, error)
	Close() error
}

type RealtimeModelError struct {
	Type        string
	Timestamp   time.Time
	Label       string
	Err         error
	Recoverable bool
}

type RealtimeSession interface {
	UpdateInstructions(instructions string) error
	UpdateChatContext(chatCtx *ChatContext) error
	UpdateTools(tools []Tool) error
	UpdateOptions(options RealtimeSessionOptions) error
	GenerateReply(options RealtimeGenerateReplyOptions) error
	Say(text string) error
	Truncate(options RealtimeTruncateOptions) error
	Interrupt() error
	Close() error
	EventCh() <-chan RealtimeEvent
	PushAudio(frame *model.AudioFrame) error
	PushVideo(frame *images.VideoFrame) error
	CommitAudio() error
	ClearAudio() error
}

type RealtimeSessionOptions struct {
	ToolChoice                  ToolChoice
	ToolChoiceSet               bool
	Voice                       string
	VoiceSet                    bool
	OutputMedium                string
	OutputMediumSet             bool
	Speed                       float64
	SpeedSet                    bool
	MaxResponseOutputTokens     any
	MaxResponseOutputTokensSet  bool
	Truncation                  any
	TruncationSet               bool
	Tracing                     any
	TracingSet                  bool
	Reasoning                   any
	ReasoningSet                bool
	TurnDetection               any
	TurnDetectionSet            bool
	InputAudioTranscription     any
	InputAudioTranscriptionSet  bool
	InputAudioNoiseReduction    any
	InputAudioNoiseReductionSet bool
}

type RealtimeSessionReconnectedEvent struct{}

type RealtimeTimedText struct {
	Text      string
	StartTime float64
}

type RealtimeTruncateOptions struct {
	MessageID       string
	Modalities      []string
	AudioEndMillis  int
	AudioTranscript *string
}

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

type RemoteItemAddedEvent struct {
	PreviousItemID    string
	PreviousItemIDSet bool
	Item              ChatItem
}

type SerializedImage struct {
	InferenceDetail string
	MIMEType        string
	DataBytes       []byte
	ExternalURL     string
}

type StopResponse struct{}

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

type Tool interface {
	ID() string
	Name() string
	Description() string
	Parameters() map[string]any
	Execute(ctx context.Context, args string) (string, error)
}

type ToolChoice any

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

type ToolDuplicateMode string

type ToolDuplicateModer interface {
	ToolDuplicateMode() ToolDuplicateMode
}

type ToolError struct {
	Message string
}

type ToolFlag uint64

type ToolFlagger interface {
	ToolFlags() ToolFlag
}

type Toolset interface {
	ID() string
	Tools() []Tool
}