loop

type Agent ¶

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

Agent implements the AgentService interface with direct chat functionality

func NewAgent(
	client sdk.Client,
	toolService agentdomain.ToolService,
	approvalPolicy agentdomain.ApprovalPolicy,
	cfg *config.Config,
	conversationRepo convdomain.ConversationRepository,
	a2aAgents func() string,
	skillsService agentdomain.SkillsService,
	messageQueue convdomain.MessageQueue,
	stateManager stateStore,
	optimizer convdomain.ConversationOptimizer,
	bgRegistry scheddomain.BackgroundTaskRegistry,
	rolloverManager convdomain.SessionRollover,
	tokenizer usageEstimator,
	hookProvider agentdomain.HookCommandProvider,
	pluginInstructions func() string,
) *Agent

func (s *Agent) BuildSystemPrompt() string

func (s *Agent) CancelRequest(requestID string) error

func (s *Agent) GetMetrics(requestID string) *agentdomain.ChatMetrics

func (s *Agent) GetReasoningEffort() string

func (s *Agent) RunWithStream(ctx context.Context, req *agentdomain.AgentRequest) (<-chan agentdomain.ChatEvent, error)

func (s *Agent) SetCurrentModelFn(fn func() string)

func (s *Agent) SetMemoryBackend(backend memory.MemoryBackend)

func (s *Agent) SetReasoningEffort(effort string) error

func (s *Agent) SetTelemetryRecorder(rec *telemetry.Recorder)

func (s *Agent) SystemPromptSections() []PromptSection

func (s *Agent) VolatileTailText() (string, bool)

type ApprovalTools ¶

type ApprovalTools interface {
	agentdomain.ToolManifestLookup
	GetTool(name string) (agentdomain.Tool, error)
}

ApprovalTools is what the approval policy needs to know about the tools: a tool's manifest, and the tool itself when it approves per call. The registry and the tool service both satisfy it.

type JudgeApprover ¶

type JudgeApprover interface {
	Judge(ctx context.Context, in agentdomain.JudgeInput) (agentdomain.JudgeVerdict, error)
}

JudgeApprover decides one pending tool call by asking a small LLM whether it serves the user's intent and is safe. The judge is the approver selected by approval_behaviour "judge" / agent mode auto-with-judge: it is always reachable, so headless and CI get a real approver instead of blocking.

type LLMJudge ¶

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

LLMJudge implements JudgeApprover with one no-tools GenerateContent call (same shape as GenerateLLMSummary: direct client call, SkipMCP, its own timeout, bounded max_tokens). The judge.yaml on_error policy decides what a failed call means: deny (default) fails closed with a distinguishable reason - the same default as the no-approver block path - allow approves.

func NewLLMJudge(client sdk.Client, cfg *config.Config) *LLMJudge

func (j *LLMJudge) Judge(ctx context.Context, in agentdomain.JudgeInput) (agentdomain.JudgeVerdict, error)

type PromptSection ¶

type PromptSection struct {
	Name     string
	Text     string
	Volatile bool
}

PromptSection is one labeled part of the assembled prompt context, exposed for diagnostics (e.g. per-section token estimates in `infer debug`). Text is the raw part as it appears in the prompt, including any separator prefix. Volatile marks sections delivered via the per-request tail message rather than the static system prompt.

type StandardApprovalPolicy ¶

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

StandardApprovalPolicy implements the default approval policy with the following rules:

1. A tool that approves per call (agentdomain.CallApprover) decides for itself, ahead of the agent mode
2. Auto-accept mode bypasses all approval 2.5. ReadOnly mode (Explore-like subagent) bypasses approval; its toolset is read-only by construction so nothing it can call mutates. Neither needs a call the mode does not make available: execution rejects it
3. Non-chat (headless agent) mode bypasses approval; there the Bash tool's own per-mode gate (executeBash) decides what runs
4. Bash commands are governed by the per-mode allow-list (sandbox.IsBashCommandAllowed): reached only in chat, non-auto mode, so allowed commands bypass approval and anything off-list prompts the user
5. Other tools follow their own require_approval setting, then their manifest's default, then the global require_approval setting

func NewStandardApprovalPolicy(cfg *config.Config, stateManager agentdomain.AgentModeState, tools ApprovalTools) *StandardApprovalPolicy

func (p *StandardApprovalPolicy) ShouldRequireApproval(
	ctx context.Context,
	toolCall *sdk.ChatCompletionMessageToolCall,
	isChatMode bool,
) bool