tools

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

type ACPOptionInfo struct {
	ID   string
	Name string
}

type ACPRuntimePool interface {
	CreateAgentRuntime(ctx context.Context, botID, agentID, runtimeOwnerAccountID string) (ACPRuntimeSummary, error)
	CloseAgentRuntime(botID, runtimeID string) error
}

type ACPRuntimeSummary struct {
	RuntimeID      string
	DefaultModelID string
	CurrentModelID string
	Models         []ACPOptionInfo
	CurrentEffort  string
	Efforts        []ACPOptionInfo
}

type AskUserProvider struct{}

type Attachment struct {
	Type        string         `json:"type"`
	Path        string         `json:"path,omitempty"`
	URL         string         `json:"url,omitempty"`
	Base64      string         `json:"base64,omitempty"`
	PlatformKey string         `json:"platform_key,omitempty"`
	Mime        string         `json:"mime,omitempty"`
	Name        string         `json:"name,omitempty"`
	ContentHash string         `json:"content_hash,omitempty"`
	Size        int64          `json:"size,omitempty"`
	Metadata    map[string]any `json:"metadata,omitempty"`
}

type AvailableTools = toolset.Available

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

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

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

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

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

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

type HistoryMessageReader interface {
	ListLatestBySession(ctx context.Context, sessionID string, limit int32) ([]messagepkg.Message, error)
	ListBeforeBySession(ctx context.Context, sessionID string, before time.Time, limit int32) ([]messagepkg.Message, error)
	GetByIDBySession(ctx context.Context, sessionID string, messageID string) (messagepkg.Message, error)
}

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

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

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

type MemorySettingsReader interface {
	GetBot(ctx context.Context, botID string) (settings.Settings, error)
}

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

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

type MessageSnapshotEntry struct {
	Message         sdk.Message
	SourceMessageID string
}

type NativeToolApprovalService interface {
	EvaluatePolicy(ctx context.Context, input toolapproval.CreatePendingInput) (toolapproval.Evaluation, error)
	CreatePending(ctx context.Context, input toolapproval.CreatePendingInput) (toolapproval.Request, error)
	Get(ctx context.Context, approvalID string) (toolapproval.Request, error)
	Reject(ctx context.Context, approvalID, actorID, reason string) (toolapproval.Request, error)
	WaitForDecision(ctx context.Context, approvalID string) (toolapproval.Request, error)
	RegisterWaiter(approvalID string) func()
}

type NativeToolEventSink interface {
	AppendToolEvent(session mcp.ToolSessionContext, event mcp.ToolStreamEvent) bool
}

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

type NativeToolSourceOptions struct {
	AllowAll        bool
	AllowTools      map[string]bool
	Approval        NativeToolApprovalService
	UserInput       NativeToolUserInputService
	ToolEvents      NativeToolEventSink
	ToolOutputLimit ToolOutputLimit
}

type NativeToolUserInputService interface {
	CreatePending(ctx context.Context, input userinput.CreatePendingInput) (userinput.Request, error)
	Cancel(ctx context.Context, input userinput.CancelInput) (userinput.Request, error)
	WaitForRegisteredResponse(ctx context.Context, requestID string) (userinput.Request, error)
	// RegisterWaiter must be called before the pending request is announced
	// to users, or an instant answer can be misjudged as orphaned.
	RegisterWaiter(requestID string) func()
}

type ProviderLabeler interface {
	ProviderLabel() string
}

type Reaction struct {
	Emoji     string `json:"emoji"`
	MessageID string `json:"message_id"`
	Remove    bool   `json:"remove,omitempty"`
}

type ReadMediaToolOutput struct {
	Public         ReadMediaToolResult
	ImageBase64    string
	ImageMediaType string
	FileBase64     string
	FileMediaType  string
	Filename       string
}

type ReadMediaToolResult struct {
	OK    bool   `json:"ok"`
	Path  string `json:"path,omitempty"`
	Mime  string `json:"mime,omitempty"`
	Size  int    `json:"size,omitempty"`
	Error string `json:"error,omitempty"`
}

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

type Scheduler interface {
	List(ctx context.Context, botID string) ([]sched.Schedule, error)
	Get(ctx context.Context, id string) (sched.Schedule, error)
	Create(ctx context.Context, botID string, req sched.CreateRequest) (sched.Schedule, error)
	Update(ctx context.Context, id string, req sched.UpdateRequest) (sched.Schedule, error)
	Delete(ctx context.Context, id string) error
}

type SessionContext struct {
	BotID                string
	ChatID               string
	SessionID            string
	SessionType          string
	UserID               string
	ChannelIdentityID    string
	SessionToken         string //nolint:gosec // carries session credential material at runtime
	CurrentPlatform      string
	ReplyTarget          string
	ConversationType     string
	CanRequestUserInput  bool
	CanListUserInput     bool
	SupportsImageInput   bool
	SupportsFileInput    bool
	IsSubagent           bool
	CurrentModelUUID     string
	CurrentModelID       string
	CurrentModelProvider string
	// ReasoningStoredEffort and ReasoningRequestedEffort are the unresolved
	// parent-turn inputs. A tool that selects another model must resolve them for
	// that model rather than inheriting the parent's provider-specific decision.
	ReasoningStoredEffort    string
	ReasoningRequestedEffort string
	ForkContext              *MessageSnapshot
	// WorkspaceTargetID is the request-scoped default for file and command
	// tools. An explicit tool target_id still takes precedence.
	WorkspaceTargetID   string
	WorkspaceTargetKind string
	WorkspaceTargetName string
	// WorkdirPath is the session's immutable working directory. When set,
	// relative tool paths resolve under it and exec defaults its cwd to it.
	WorkdirPath               string
	Skills                    map[string]SkillDetail
	TimezoneLocation          *time.Location
	Emitter                   StreamEmitter
	LiveStream                bool
	ContextBudgetMaxTokens    int
	ContextToolExchangePolicy *contextfrag.ToolExchangePolicy
}

type SessionLister interface {
	ListByBot(ctx context.Context, botID string) ([]session.Thread, error)
}

type SkillDetail struct {
	Description string
	Content     string
	Path        string
}

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

type SpawnAgent interface {
	Generate(ctx context.Context, cfg SpawnRunConfig) (*SpawnResult, error)
	GenerateWithWatchdog(ctx context.Context, cfg SpawnRunConfig, touchFn func()) (*SpawnResult, error)
}

type SpawnAttemptDisposition uint8

type SpawnIdentity struct {
	BotID               string
	ChatID              string
	SessionID           string
	UserID              string
	ChannelIdentityID   string
	CurrentPlatform     string
	ReplyTarget         string
	ConversationType    string
	SessionToken        string //nolint:gosec // #nosec G117 -- session identifier, not a secret
	WorkspaceTargetID   string
	WorkspaceTargetKind string
	WorkspaceTargetName string
	WorkdirPath         string
	TimezoneLocation    *time.Location
	IsSubagent          bool
}

type SpawnLoopConfig struct {
	Enabled bool
}

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

type SpawnResult struct {
	Messages         []sdk.Message
	Text             string
	Usage            *sdk.Usage
	ContextLifecycle *contextfrag.LifecycleSnapshot
	// Persisted reports that incremental step persistence owned this run's
	// history, so the caller must not persist the result again.
	Persisted bool
}

type SpawnRunConfig struct {
	RunID         string
	Model         *sdk.Model
	ModelUUID     string
	ModelID       string
	ModelProvider string
	System        string
	Query         string
	SessionType   string
	Identity      SpawnIdentity
	LoopDetection SpawnLoopConfig
	Messages      []sdk.Message
	// ReasoningConfig is the thinking decision resolved for the subagent's own
	// model. It replaces a lone effort string that was never assigned, which is
	// how subagents came to run with no reasoning configuration at all (#983).
	ReasoningConfig *models.ReasoningConfig
	// Keep the unresolved parent-turn inputs as well, so a nested subagent can
	// resolve the same override against its own selected model.
	ReasoningStoredEffort     string
	ReasoningRequestedEffort  string
	PromptCacheTTL            string
	ChatCompletionsCompat     string
	SupportsImageInput        bool
	SupportsFileInput         bool
	SupportsToolCall          bool
	Skills                    map[string]SkillDetail
	BackgroundManager         *background.Manager
	ContextBudgetMaxTokens    int
	ContextToolExchangePolicy *contextfrag.ToolExchangePolicy
	// TurnRequestMessageID is the persisted task user message this run's
	// assistant and tool rows bind to, so incremental step persistence files
	// them into the same history turn the runtime view names.
	TurnRequestMessageID string
	// OnStepPersisted, if set, is called after a complete or interrupted step of
	// this run has been durably persisted. The spawn provider uses it to stop
	// retrying an attempt that has already produced durable output (and possibly
	// real side effects): replaying the turn from the top would do that work twice.
	OnStepPersisted func()
	// Attempt is one-based and MaxAttempts is the total outer-attempt budget.
	// ResolveAttempt is called at most once after a failed native attempt. It is
	// the spawn provider's authoritative disposition: retry keeps the admitted
	// run live, abort records owning cancellation, and failure ends the run.
	// ResolveCompletion arbitrates a clean native end against concurrent owning
	// cancellation before that end is published; it returns Completed, Abort for
	// an explicit stop, or Failure for another owning-context failure.
	// ReconcileTerminal applies the outcome selected by the session runtime when
	// terminal publication races a routed control such as AbortControl.
	Attempt           int
	MaxAttempts       int
	ResolveAttempt    func(error) SpawnAttemptDisposition
	ResolveCompletion func() SpawnAttemptDisposition
	ReconcileTerminal func(SpawnAttemptDisposition)
}

type Speech struct {
	Text string `json:"text"`
}

type StreamEmitter func(ToolStreamEvent)

type StreamEventType string

type SubagentAdmission struct {
	RunID        string
	TurnID       string
	TurnPosition int64
}

type SubagentAdmitter interface {
	// AdmitSubagentRun returns the context the run must execute in, the
	// admitted identity, and the terminal write that releases the thread's
	// slot, or an error naming why nothing was started. turn.ErrSessionBusy
	// means the agent is already working; turn.ErrDuplicateTurn means this
	// task already has a run.
	AdmitSubagentRun(ctx context.Context, botID, threadID, invocationID string, submission []byte) (context.Context, SubagentAdmission, func(SubagentTerminal), error)
}

type SubagentTerminal struct {
	Cause            error
	ContextLifecycle *contextfrag.LifecycleSnapshot
	OutcomeResolved  bool
	Outcome          SpawnAttemptDisposition
}

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

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

type ToolName = toolname.Name

type ToolOutputLimit = contextlimit.ToolOutputLimit

type ToolProvider interface {
	Tools(ctx context.Context, session SessionContext) ([]sdk.Tool, error)
}

type ToolStreamEvent struct {
	Type StreamEventType
	// ToolCallID identifies the tool call that produced this side effect, so
	// downstream persistence can anchor it to the right message (and keep the
	// live ordering after a history reload). Empty when unknown.
	ToolCallID  string
	Attachments []Attachment
	Reactions   []Reaction
	Speeches    []Speech
}

type ToolUsage interface {
	Usage(ctx context.Context, session SessionContext, available AvailableTools) string
}

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

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

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

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

type WorkdirLister interface {
	List(ctx context.Context, botID string, includeArchived bool) ([]workdir.Workdir, error)
}

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