agent

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
	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 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
	ShouldStopAfterTurn ShouldStopAfterTurnFunc
	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 AgentToolFunc struct {
	AgentToolSpec
	Run ToolExecuteFunc
}

type AgentToolResult struct {
	Content        ai.ToolResultContent
	Details        any
	Usage          *ai.Usage
	AddedToolNames *[]string
	Terminate      *bool
}

type AgentToolSpec struct {
	Name             string
	Label            string
	Description      string
	Parameters       ai.JSONSchema
	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 {
	Block  bool
	Reason string
}

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

type EventSink func(ctx context.Context, event AgentEvent) 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 = ShouldStopAfterTurnContext

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

type PrepareNextTurnWithoutContextFunc func(context.Context) (*AgentLoopTurnUpdate, error)

type QueueMode string

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

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

type ShouldStopAfterTurnFunc func(context.Context, ShouldStopAfterTurnContext) (bool, 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
}

type ToolExecutionMode string

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

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

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

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

type TurnStartEvent struct{}