llmagent

type AfterModelCallback func(ctx agent.CallbackContext, resp *model.Response, err error) (*model.Response, error)

type AfterToolCallback func(ctx tool.Context, t tool.Tool, args, result map[string]any, err error) (map[string]any, error)

type BeforeModelCallback func(ctx agent.CallbackContext, req *model.Request) (*model.Response, error)

type BeforeToolCallback func(ctx tool.Context, t tool.Tool, args map[string]any) (map[string]any, error)

type Config struct {
	// Name must be unique within the agent tree.
	Name string

	// DisplayName is the human-readable name used for UI/Chat attribution.
	// If empty, defaults to Name.
	DisplayName string

	// Description helps LLMs decide when to delegate to this agent.
	Description string

	// Model is the LLM to use for generation.
	Model model.LLM

	// Instruction guides the agent's behavior.
	// Supports template placeholders like {variable} resolved from state.
	Instruction string

	// EnableStreaming enables token-by-token streaming from the LLM.
	// When false (default), responses are returned as complete chunks.
	EnableStreaming bool

	// InstructionProvider allows dynamic instruction generation.
	// Takes precedence over Instruction if set.
	InstructionProvider InstructionProvider

	// GlobalInstruction applies to all agents in the tree.
	// Only the root agent's GlobalInstruction is used.
	GlobalInstruction string

	// GlobalInstructionProvider allows dynamic global instruction.
	GlobalInstructionProvider InstructionProvider

	// GenerateConfig contains LLM generation settings.
	GenerateConfig *model.GenerateConfig

	// Tools available to the agent.
	Tools []tool.Tool

	// Toolsets provide dynamic tool resolution.
	Toolsets []tool.Toolset

	// SubAgents can receive delegated tasks.
	SubAgents []agent.Agent

	// BeforeAgentCallbacks run before the agent starts.
	BeforeAgentCallbacks []agent.BeforeAgentCallback

	// AfterAgentCallbacks run after the agent completes.
	AfterAgentCallbacks []agent.AfterAgentCallback

	// BeforeModelCallbacks run before each LLM call.
	BeforeModelCallbacks []BeforeModelCallback

	// AfterModelCallbacks run after each LLM call.
	AfterModelCallbacks []AfterModelCallback

	// BeforeToolCallbacks run before each tool execution.
	BeforeToolCallbacks []BeforeToolCallback

	// AfterToolCallbacks run after each tool execution.
	AfterToolCallbacks []AfterToolCallback

	// DisallowTransferToParent prevents delegation to parent agent.
	DisallowTransferToParent bool

	// DisallowTransferToPeers prevents delegation to sibling agents.
	DisallowTransferToPeers bool

	// IncludeContents controls conversation history inclusion.
	IncludeContents IncludeContents

	// OutputKey saves agent output to session state under this key.
	OutputKey string

	// InputSchema validates input when agent is used as a tool.
	InputSchema map[string]any

	// OutputSchema enforces structured output format.
	OutputSchema map[string]any

	// OutputSchemaName identifies the schema.
	OutputSchemaName string

	// OutputSchemaStrict enables strict schema validation.
	OutputSchemaStrict *bool

	// Reasoning configures the chain-of-thought reasoning loop.
	// When nil, defaults are applied (semantic termination, 100 max iterations).
	Reasoning *ReasoningConfig

	// WorkingMemory is the context window management strategy.
	// Controls how conversation history is filtered to fit within LLM limits.
	// If nil, all history is included (no filtering).
	WorkingMemory memory.WorkingMemoryStrategy

	// AutoRecall enables automatic memory recall.
	AutoRecall bool

	// AutoRecallLimit limits the number of recalled memories.
	AutoRecallLimit int

	// ContextProvider retrieves relevant context for RAG.
	// When set, the agent will query the provider with user input
	// and inject relevant context into the conversation.
	ContextProvider ContextProvider

	// RequestProcessors are custom processors added to the request pipeline.
	// These run AFTER the default processors.
	RequestProcessors []RequestProcessor

	// ResponseProcessors are custom processors added to the response pipeline.
	// These run AFTER the default processors.
	ResponseProcessors []ResponseProcessor

	// Pipeline allows complete customization of the processor pipeline.
	// If set, RequestProcessors and ResponseProcessors are ignored.
	Pipeline *Pipeline

	// MetricsRecorder records tool execution metrics.
	// If nil, metrics are not recorded (no-op).
	MetricsRecorder observability.Recorder

	// DisableSafetyProtocols disables the automatic injection of safety protocols
	// (Tool Reliability and Chain of Thought).
	DisableSafetyProtocols bool
}

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

type ContextProvider func(ctx agent.ReadonlyContext, query string) (string, error)

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

type FunctionCallInfo struct {
	ID   string
	Name string
	Args map[string]any
}

type FunctionResponseInfo struct {
	ID      string
	Name    string
	Content string
}

type IncludeContents string

type InstructionProvider func(ctx agent.ReadonlyContext) (string, error)

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

type ProcessorContext interface {
	agent.InvocationContext

	// Agent returns the LLM agent being processed.
	LLMAgent() *llmAgent

	// Tools returns all available tools for this agent.
	Tools() []tool.Tool

	// ToolDefinitions returns tool definitions for the LLM.
	ToolDefinitions() ([]tool.Definition, error)
}

type ReasoningConfig struct {
	// MaxIterations is a SAFETY limit (not the primary termination condition).
	// The loop terminates when semantic conditions are met (no tool calls, etc.)
	// Default: 100 (high enough to not interfere with normal operation)
	MaxIterations int

	// EnableExitTool adds the exit_loop tool for explicit termination.
	EnableExitTool bool

	// EnableEscalateTool adds the escalate tool for parent delegation.
	EnableEscalateTool bool

	// CompletionInstruction is appended to help the model know when to stop.
	CompletionInstruction string
}

type RequestProcessor func(ctx ProcessorContext, req *model.Request) error

type ResponseProcessor func(ctx ProcessorContext, req *model.Request, resp *model.Response) error