llm

type Annotation struct {
	Type       AnnotationType `json:"type"`                 // Type of annotation
	StartIndex int            `json:"start_index"`          // Start position in message text (0-based)
	EndIndex   int            `json:"end_index"`            // End position in message text (0-based)
	URL        string         `json:"url"`                  // Source URL
	Title      string         `json:"title"`                // Source title
	CitedText  string         `json:"cited_text,omitempty"` // Optional: text being cited (for context)
	Index      int            `json:"index"`                // Display index (1-based for UI)
}

type AnnotationType string

type BenchmarkScenario struct {
	Name      string
	Generator StreamGenerator
}

type BotConfig struct {
	ID                 string `json:"id"`
	Name               string `json:"name"`
	DisplayName        string `json:"displayName"`
	CustomInstructions string `json:"customInstructions"`
	ServiceID          string `json:"serviceID"`

	// Model is the optional model override for this bot.
	// If not specified, the service's DefaultModel will be used.
	Model string `json:"model"`

	// Service is deprecated and kept only for backwards compatibility during migration.
	Service *ServiceConfig `json:"service,omitempty"`

	EnableVision       bool               `json:"enableVision"`
	DisableTools       bool               `json:"disableTools"`
	ChannelAccessLevel ChannelAccessLevel `json:"channelAccessLevel"`
	ChannelIDs         []string           `json:"channelIDs"`
	UserAccessLevel    UserAccessLevel    `json:"userAccessLevel"`
	UserIDs            []string           `json:"userIDs"`
	TeamIDs            []string           `json:"teamIDs"`
	MaxFileSize        int64              `json:"maxFileSize"`

	// EnabledNativeTools contains the list of enabled native tools for this bot
	// For OpenAI: ["web_search", "file_search", "code_interpreter"] (only works when UseResponsesAPI is true)
	// For Anthropic: ["web_search"]
	EnabledNativeTools []string `json:"enabledNativeTools"`

	// ReasoningEnabled determines whether reasoning/thinking is enabled for this bot
	// Applicable to OpenAI (with ResponsesAPI) and Anthropic
	ReasoningEnabled bool `json:"reasoningEnabled"`

	// ReasoningEffort determines the reasoning effort level for OpenAI models
	// Valid values: "minimal", "low", "medium", "high"
	// Only applicable to OpenAI with ResponsesAPI enabled
	// Default: "medium"
	ReasoningEffort string `json:"reasoningEffort"`

	// ThinkingBudget determines the token budget for Anthropic thinking
	// Must be at least 1024 and cannot exceed the OutputTokenLimit
	// Only applicable to Anthropic
	// Default: 1/4 of OutputTokenLimit, capped at 8192
	ThinkingBudget int `json:"thinkingBudget"`
}

type ChannelAccessLevel int

type CompletionRequest struct {
	Posts   []Post
	Context *Context
}

type Context struct {
	// Server
	Time        string
	ServerName  string
	CompanyName string

	// Location
	Team    *model.Team
	Channel *model.Channel
	Thread  []Post // Normalized posts that already have been formatted. nil if not in a thread or a root post

	// User that is making the request
	RequestingUser *model.User

	// Bot Specific
	BotName            string
	BotUsername        string
	BotUserID          string
	BotModel           string
	CustomInstructions string

	Tools             *ToolStore
	DisabledToolsInfo []ToolInfo // Info about tools that are unavailable in the current context (e.g., DM-only tools in a channel)
	Parameters        map[string]interface{}
}

type ContextOption func(*Context)

type EventType int

type File struct {
	MimeType string
	Size     int64
	Reader   io.Reader
}

type LanguageModel interface {
	ChatCompletion(conversation CompletionRequest, opts ...LanguageModelOption) (*TextStreamResult, error)
	ChatCompletionNoStream(conversation CompletionRequest, opts ...LanguageModelOption) (string, error)

	CountTokens(text string) int
	InputTokenLimit() int
}

type LanguageModelConfig struct {
	Model              string
	MaxGeneratedTokens int
	EnableVision       bool
	JSONOutputFormat   *jsonschema.Schema
	ToolsDisabled      bool
	ReasoningDisabled  bool
}

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

type LanguageModelOption func(*LanguageModelConfig)

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

type LanguageModelWrapper func(LanguageModel) LanguageModel

type MetricsObserver interface {
	ObserveTokenUsage(botName, teamID, userID string, inputTokens, outputTokens int)
}

type ModelInfo struct {
	ID          string `json:"id"`
	DisplayName string `json:"displayName"`
}

type Post struct {
	Role               PostRole
	Message            string
	Files              []File
	ToolUse            []ToolCall
	Reasoning          string // Extended thinking/reasoning content from models that support it
	ReasoningSignature string // Signature for thinking blocks (opaque verification field)
}

type PostRole int

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

type ReasoningData struct {
	Text      string // The reasoning/thinking text content
	Signature string // Opaque verification signature from the model
}

type ServiceConfig struct {
	ID           string `json:"id"`
	Name         string `json:"name"`
	Type         string `json:"type"`
	APIKey       string `json:"apiKey"`
	OrgID        string `json:"orgId"`
	DefaultModel string `json:"defaultModel"`
	APIURL       string `json:"apiURL"`
	Region       string `json:"region"` // For AWS Bedrock region

	// AWS IAM credentials for Bedrock (optional, takes precedence over APIKey)
	AWSAccessKeyID     string `json:"awsAccessKeyID"`
	AWSSecretAccessKey string `json:"awsSecretAccessKey"`

	// Renaming the JSON field to inputTokenLimit would require a migration, leaving as is for now.
	InputTokenLimit         int  `json:"tokenLimit"`
	StreamingTimeoutSeconds int  `json:"streamingTimeoutSeconds"`
	SendUserID              bool `json:"sendUserID"`

	// Otherwise known as maxTokens
	OutputTokenLimit int `json:"outputTokenLimit"`

	// UseResponsesAPI determines whether to use the new OpenAI Responses API
	// Only applicable to OpenAI and OpenAI-compatible services
	UseResponsesAPI bool `json:"useResponsesAPI"`
}

type StreamGenerator struct {
	// TotalTextSize is the total bytes of text to generate
	TotalTextSize int
	// ChunkSize is the size of each text chunk
	ChunkSize int
	// IncludeReasoning adds reasoning events before text events
	IncludeReasoning bool
	// IncludeToolCalls ends with tool calls instead of normal end event
	IncludeToolCalls bool
	// IncludeUsage adds a usage event before end
	IncludeUsage bool
	// IncludeAnnotations adds annotation events
	IncludeAnnotations bool
}

type TextStreamEvent struct {
	Type  EventType
	Value any
}

type TextStreamResult struct {
	Stream <-chan TextStreamEvent
}

type TokenUsage struct {
	InputTokens  int64 `json:"input_tokens"`
	OutputTokens int64 `json:"output_tokens"`
}

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

type Tool struct {
	Name        string
	Description string
	Schema      any
	Resolver    ToolResolver
}

type ToolArgumentGetter func(args any) error

type ToolAuthError struct {
	ServerName string `json:"server_name"`
	AuthURL    string `json:"auth_url"`
	Error      error  `json:"error"`
}

type ToolCall struct {
	ID          string          `json:"id"`
	Name        string          `json:"name"`
	Description string          `json:"description"`
	Arguments   json.RawMessage `json:"arguments"`
	Result      string          `json:"result"`
	Status      ToolCallStatus  `json:"status"`
}

type ToolCallStatus int

type ToolInfo struct {
	Name        string
	Description string
}

type ToolResolver func(context *Context, argsGetter ToolArgumentGetter) (string, error)

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

type TraceLog interface {
	Info(message string, keyValuePairs ...any)
}

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

type UserAccessLevel int