engine

type AfterToolCallContext struct {
	AssistantMessage *ai.AssistantMessage
	ToolCall         *ai.ToolCall
	Args             any
	Result           AgentToolResult
	IsError          bool
	Context          *AgentContext
}

type AfterToolCallFunc func(context.Context, AfterToolCallContext) (*AfterToolCallResult, error)

type AfterToolCallResult struct {
	Content    ai.ToolResultContent
	Details    any
	DetailsSet bool
	// StructuredContent replaces the result's; when Content is replaced
	// without it, the old structured content is dropped as no longer matching.
	StructuredContent any
	IsError           *bool
	Usage             *ai.Usage
	Terminate         *bool
}

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

type AgentContext struct {
	SystemPrompt string
	Messages     AgentMessages
	Tools        []AgentTool
}

type AgentDisplayState struct {
	HasModel      bool
	ModelID       string
	Provider      ai.ProviderID
	ContextWindow float64
	Reasoning     bool
	ThinkingLevel ThinkingLevel
}

type AgentEndEvent struct {
	Messages AgentMessages
}

type AgentEvent interface {
	Type() AgentEventType
	// contains filtered or unexported methods
}

type AgentEventType string

type AgentLoopConfig struct {
	ai.SimpleStreamOptions
	Model               *ai.Model
	ConvertToLLM        ConvertToLLMFunc
	TransformContext    TransformContextFunc
	GetAPIKey           GetAPIKeyFunc
	GetRequestAuth      GetRequestAuthFunc
	GetModelHeaders     GetModelHeadersFunc
	FinishTurn          FinishTurnFunc
	PrepareRequest      PrepareRequestFunc
	PrepareNextTurn     PrepareNextTurnFunc
	GetSteeringMessages GetQueuedMessagesFunc
	GetFollowUpMessages GetQueuedMessagesFunc
	ToolExecution       ToolExecutionMode
	BeforeToolCall      BeforeToolCallFunc
	AfterToolCall       AfterToolCallFunc
	Now                 func() int64
}

type AgentLoopTurnUpdate struct {
	Context       *AgentContext
	Model         *ai.Model
	ThinkingLevel *ThinkingLevel
}

type AgentMessage = any

type AgentMessages []AgentMessage

type AgentOption func(*agentOptions)

type AgentStartEvent struct{}

type AgentState struct {
	SystemPrompt     string
	Model            *ai.Model
	ThinkingLevel    ThinkingLevel
	Tools            []AgentTool
	Messages         AgentMessages
	IsStreaming      bool
	StreamingMessage AgentMessage
	PendingToolCalls map[string]struct{}
	ErrorMessage     *string
}

type AgentTool interface {
	Spec() AgentToolSpec
	Execute(context.Context, string, any, AgentToolUpdateCallback) (AgentToolResult, error)
}

type AgentToolCallOutcome struct {
	ToolCall *ai.ToolCall
	Result   AgentToolResult
	IsError  bool
}

type AgentToolFunc struct {
	AgentToolSpec
	Run ToolExecuteFunc
}

type AgentToolResult struct {
	Content ai.ToolResultContent
	Details any
	// StructuredContent is the machine-readable result matching the tool's
	// output schema, for programmatic callers; the model sees Content.
	StructuredContent any
	Usage             *ai.Usage
	AddedToolNames    *[]string
	// IsError reports a failure without returning an error: the model sees
	// Content as an error result, while Details and StructuredContent remain.
	IsError   bool
	Terminate *bool
}

type AgentToolSpec struct {
	Name                string
	Label               string
	Description         string
	Parameters          ai.JSONSchema
	ConstrainedSampling *ai.ConstrainedSamplingConfig
	PrepareArguments    PrepareArgumentsFunc
	ExecutionMode       ToolExecutionMode
}

type AgentToolUpdateCallback func(AgentToolResult)

type BeforeToolCallContext struct {
	AssistantMessage *ai.AssistantMessage
	ToolCall         *ai.ToolCall
	Args             any
	Context          *AgentContext
}

type BeforeToolCallFunc func(context.Context, BeforeToolCallContext) (*BeforeToolCallResult, error)

type BeforeToolCallResult struct {
	// Approved is explicit host consent; a nonblocking hook alone grants nothing.
	Approved bool `json:"-"`
	Block    bool
	Reason   string
}

type ConvertToLLMFunc func(context.Context, AgentMessages) (ai.MessageList, error)

type EventSink func(ctx context.Context, event AgentEvent) error

type FinishTurnFunc func(context.Context, TurnContext) (TurnAction, error)

type GetAPIKeyFunc func(context.Context, ai.ProviderID) (*string, error)

type GetModelHeadersFunc func(context.Context, *ai.Model, *string, ai.ProviderEnv) (*map[string]string, error)

type GetQueuedMessagesFunc func(context.Context) (AgentMessages, error)

type GetRequestAuthFunc func(context.Context, ai.ProviderID) (*RequestAuth, error)

type MessageEndEvent struct {
	Message AgentMessage
}

type MessageStartEvent struct {
	Message AgentMessage
}

type MessageUpdateEvent struct {
	// Upstream constructs this literal with assistantMessageEvent before message.
	AssistantMessageEvent ai.AssistantMessageEvent
	Message               AgentMessage
}

type ParallelExecutionPreparer interface {
	PrepareParallelExecution(context.Context, any) (context.Context, func(), error)
}

type PrepareArgumentsFunc func(args any) (any, error)

type PrepareNextTurnContext = TurnContext

type PrepareNextTurnFunc func(context.Context, PrepareNextTurnContext) (*AgentLoopTurnUpdate, error)

type PrepareRequestContext struct {
	Context       *AgentContext
	Model         *ai.Model
	ThinkingLevel ThinkingLevel
}

type PrepareRequestFunc func(context.Context, PrepareRequestContext) (*AgentLoopTurnUpdate, error)

type QueueMode string

type RequestAuth struct {
	APIKey  *string
	Headers ai.ProviderHeaders
	Env     ai.ProviderEnv
	BaseURL *string
}

type RunToolCallOptions struct {
	Tools            []AgentTool
	AssistantMessage *ai.AssistantMessage
	Context          AgentContext
	Model            *ai.Model
	BeforeToolCall   BeforeToolCallFunc
	AfterToolCall    AfterToolCallFunc
	OnUpdate         AgentToolUpdateCallback
}

type SessionLoop func(context.Context, AgentMessages, AgentContext, AgentLoopConfig, EventSink) error

type StreamFn func(
	ctx context.Context,
	model *ai.Model,
	requestContext ai.Context,
	options *ai.SimpleStreamOptions,
) (ai.AssistantMessageEventStream, error)

type ThinkingLevel = ai.ModelThinkingLevel

type ToolExecuteFunc func(
	ctx context.Context,
	toolCallID string,
	params any,
	onUpdate AgentToolUpdateCallback,
) (AgentToolResult, error)

type ToolExecutionEndEvent struct {
	ToolCallID       string
	ToolName         string
	Result           AgentToolResult
	IsError          bool
	ParentToolCallID string
}

type ToolExecutionMode string

type ToolExecutionStartEvent struct {
	ToolCallID       string
	ToolName         string
	Args             map[string]any
	ParentToolCallID string
	// contains filtered or unexported fields
}

type ToolExecutionUpdateEvent struct {
	ToolCallID       string
	ToolName         string
	Args             map[string]any
	PartialResult    AgentToolResult
	ParentToolCallID string
	// contains filtered or unexported fields
}

type TransformContextFunc func(context.Context, AgentMessages) (AgentMessages, error)

type TurnAction string

type TurnContext struct {
	Message     *ai.AssistantMessage
	ToolResults []*ai.ToolResultMessage
	Context     *AgentContext
	NewMessages AgentMessages
}

type TurnEndEvent struct {
	Message     AgentMessage
	ToolResults []*ai.ToolResultMessage
}

type TurnStartEvent struct{}