tools

package
v0.150.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 19, 2026 License: Apache-2.0 Imports: 53 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ToolNameMemory = "Memory"

	OperationRead   = "read"
	OperationWrite  = "write"
	OperationDelete = "delete"

	MemoryTypeUser      = "user"
	MemoryTypeFeedback  = "feedback"
	MemoryTypeProject   = "project"
	MemoryTypeReference = "reference"
)
View Source 
const (
	ErrorNotAbsolutePath  = "NOT_ABSOLUTE_PATH"
	ErrorNotFound         = "NOT_FOUND"
	ErrorFileEmpty        = "FILE_EMPTY"
	ErrorPDFParseError    = "PDF_PARSE_ERROR"
	ErrorUnreadableBinary = "UNREADABLE_BINARY"
)

Error constants for consistent error handling

View Source 
const (
	DefaultOffset     = 1
	DefaultLimit      = 2000
	MaxLineLength     = 2000
	EmptyFileReminder = "The file exists but is empty."
)

Constants for defaults and limits

View Source 
const (
	ToolName      = "Write"
	DefaultFormat = "text"
	JSONFormat    = "json"
)

Variables

This section is empty.

Functions

func IsComputerUseTool 

func IsComputerUseTool(toolName string) bool

IsComputerUseTool returns true if the given tool name is a computer use tool Computer use tools operate directly on the computer (mouse, keyboard, screenshot) and bypass the standard approval flow

func NewPaneInspector added in v0.126.0 

func NewPaneInspector() func(ctx context.Context, paneID, sessionID string) domain.PaneObservation

NewPaneInspector returns a pane inspector (a func yielding a domain.PaneObservation) backed by the subagent result file, the approval sidecar, and the tmux pane's liveness. The interactive subagent monitor (interactiveSubagentJob) calls it to watch interactive subagents for completion and pending approvals. It NEVER returns pane content as the delivered message - the pane is rendered TUI chrome (input box, status bar), which is noise in the main conversation; only the result file's last assistant message is delivered. The Screen snapshot it returns is used ONLY for the monitor's idle-by-stability check, never delivered.

func ScaleAPIToScreen 

func ScaleAPIToScreen(apiX, apiY, apiWidth, apiHeight, screenWidth, screenHeight int) (int, int)

ScaleAPIToScreen converts coordinates from API space (Claude's screenshot) to screen space (actual display) using Anthropic's proportional scaling approach.

This implementation follows the official Anthropic computer-use-demo strategy: - Simple proportional scaling with separate X/Y factors - No letterboxing - screenshots are force-resized to exact dimensions - Handles aspect ratio mismatches automatically through independent scaling

Parameters:

  • apiX, apiY: Coordinates from Claude's response (in screenshot space)
  • apiWidth, apiHeight: Target screenshot dimensions (e.g., 1024x768)
  • screenWidth, screenHeight: Actual logical screen dimensions

Returns:

  • screenX, screenY: Coordinates in actual screen space for mouse operations

Example: 

API screenshot: 1024x768
Actual screen: 2048x1536
API coordinate (512, 384) → Screen coordinate (1024, 768)

Types

type A2AQueryAgentResult 

type A2AQueryAgentResult struct {
	AgentName string         `json:"agent_name"`
	Query     string         `json:"query"`
	Response  *adk.AgentCard `json:"response"`
	Success   bool           `json:"success"`
	Message   string         `json:"message"`
	Duration  time.Duration  `json:"duration"`
}

type A2AQueryAgentTool 

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

func NewA2AQueryAgentTool 

func NewA2AQueryAgentTool(cfg *config.Config) *A2AQueryAgentTool

func (*A2AQueryAgentTool) Definition 

func (t *A2AQueryAgentTool) Definition() sdk.ChatCompletionTool

func (*A2AQueryAgentTool) Execute 

func (t *A2AQueryAgentTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

func (*A2AQueryAgentTool) FormatForLLM 

func (t *A2AQueryAgentTool) FormatForLLM(result *domain.ToolExecutionResult) string

func (*A2AQueryAgentTool) FormatForUI 

func (t *A2AQueryAgentTool) FormatForUI(result *domain.ToolExecutionResult) string

func (*A2AQueryAgentTool) FormatPreview 

func (t *A2AQueryAgentTool) FormatPreview(result *domain.ToolExecutionResult) string

func (*A2AQueryAgentTool) FormatResult 

func (t *A2AQueryAgentTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

func (*A2AQueryAgentTool) IsEnabled 

func (t *A2AQueryAgentTool) IsEnabled() bool

func (*A2AQueryAgentTool) ShouldAlwaysExpand 

func (t *A2AQueryAgentTool) ShouldAlwaysExpand() bool

func (*A2AQueryAgentTool) ShouldCollapseArg 

func (t *A2AQueryAgentTool) ShouldCollapseArg(key string) bool

func (*A2AQueryAgentTool) Validate 

func (t *A2AQueryAgentTool) Validate(args map[string]any) error

type A2AQueryTaskResult 

type A2AQueryTaskResult struct {
	AgentName string        `json:"agent_name"`
	ContextID string        `json:"context_id"`
	TaskID    string        `json:"task_id"`
	Task      *adk.Task     `json:"task"`
	Success   bool          `json:"success"`
	Message   string        `json:"message"`
	Duration  time.Duration `json:"duration"`
}

type A2AQueryTaskTool 

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

func NewA2AQueryTaskTool 

func NewA2AQueryTaskTool(cfg *config.Config, liveness domain.JobLivenessReporter) *A2AQueryTaskTool

func (*A2AQueryTaskTool) Definition 

func (t *A2AQueryTaskTool) Definition() sdk.ChatCompletionTool

func (*A2AQueryTaskTool) Execute 

func (t *A2AQueryTaskTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

func (*A2AQueryTaskTool) FormatForLLM 

func (t *A2AQueryTaskTool) FormatForLLM(result *domain.ToolExecutionResult) string

func (*A2AQueryTaskTool) FormatForUI 

func (t *A2AQueryTaskTool) FormatForUI(result *domain.ToolExecutionResult) string

func (*A2AQueryTaskTool) FormatPreview 

func (t *A2AQueryTaskTool) FormatPreview(result *domain.ToolExecutionResult) string

func (*A2AQueryTaskTool) FormatResult 

func (t *A2AQueryTaskTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

func (*A2AQueryTaskTool) IsEnabled 

func (t *A2AQueryTaskTool) IsEnabled() bool

func (*A2AQueryTaskTool) ShouldAlwaysExpand 

func (t *A2AQueryTaskTool) ShouldAlwaysExpand() bool

func (*A2AQueryTaskTool) ShouldCollapseArg 

func (t *A2AQueryTaskTool) ShouldCollapseArg(key string) bool

func (*A2AQueryTaskTool) Validate 

func (t *A2AQueryTaskTool) Validate(args map[string]any) error

type A2ASubmitTaskResult 

type A2ASubmitTaskResult struct {
	TaskID     string    `json:"task_id"`
	ContextID  string    `json:"context_id,omitempty"`
	AgentURL   string    `json:"agent_url"`
	State      string    `json:"state"`
	Message    string    `json:"message"`
	TaskResult string    `json:"task_result,omitempty"`
	Success    bool      `json:"success"`
	Task       *adk.Task `json:"task,omitempty"`
}

A2ASubmitTaskResult represents the result of an A2A task operation

type A2ASubmitTaskTool 

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

A2ASubmitTaskTool handles A2A task submission and management

func NewA2ASubmitTaskTool 

func NewA2ASubmitTaskTool(cfg *config.Config, taskTracker domain.A2ATaskTracker, submitter domain.JobSubmitter) *A2ASubmitTaskTool

NewA2ASubmitTaskTool creates a new A2A task tool

func NewA2ASubmitTaskToolWithClient 

func NewA2ASubmitTaskToolWithClient(cfg *config.Config, taskTracker domain.A2ATaskTracker, submitter domain.JobSubmitter, client client.A2AClient) *A2ASubmitTaskTool

NewA2ASubmitTaskToolWithClient creates a new A2A task tool with an injected client (for testing)

func (*A2ASubmitTaskTool) Definition 

func (t *A2ASubmitTaskTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*A2ASubmitTaskTool) Execute 

func (t *A2ASubmitTaskTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the tool with given arguments

func (*A2ASubmitTaskTool) FormatForLLM 

func (t *A2ASubmitTaskTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*A2ASubmitTaskTool) FormatForUI 

func (t *A2ASubmitTaskTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*A2ASubmitTaskTool) FormatPreview 

func (t *A2ASubmitTaskTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*A2ASubmitTaskTool) FormatResult 

func (t *A2ASubmitTaskTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*A2ASubmitTaskTool) IsEnabled 

func (t *A2ASubmitTaskTool) IsEnabled() bool

IsEnabled returns whether this tool is enabled

func (*A2ASubmitTaskTool) ShouldAlwaysExpand 

func (t *A2ASubmitTaskTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*A2ASubmitTaskTool) ShouldCollapseArg 

func (t *A2ASubmitTaskTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*A2ASubmitTaskTool) Validate 

func (t *A2ASubmitTaskTool) Validate(args map[string]any) error

Validate checks if the tool arguments are valid

type ActivateAppTool 

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

ActivateAppTool switches focus to a specific application

func NewActivateAppTool 

func NewActivateAppTool(cfg *config.Config) *ActivateAppTool

NewActivateAppTool creates a new ActivateApp tool

func (*ActivateAppTool) Definition 

func (t *ActivateAppTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for ActivateApp

func (*ActivateAppTool) Execute 

func (t *ActivateAppTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute executes the ActivateApp tool

func (*ActivateAppTool) FormatForLLM 

func (t *ActivateAppTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*ActivateAppTool) FormatPreview 

func (t *ActivateAppTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview formats the result for display preview

func (*ActivateAppTool) FormatResult 

func (t *ActivateAppTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats the result based on the requested format type

func (*ActivateAppTool) IsEnabled 

func (t *ActivateAppTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled

func (*ActivateAppTool) ShouldAlwaysExpand 

func (t *ActivateAppTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*ActivateAppTool) ShouldCollapseArg 

func (t *ActivateAppTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*ActivateAppTool) Validate 

func (t *ActivateAppTool) Validate(args map[string]any) error

Validate validates ActivateApp arguments

type AgentSubResult added in v0.124.0 

type AgentSubResult struct {
	Label     string `json:"label"`
	SessionID string `json:"session_id"`
	Success   bool   `json:"success"`
	Result    string `json:"result,omitempty"`
	Error     string `json:"error,omitempty"`
}

AgentSubResult is the per-subagent outcome reported back to the LLM.

type AgentTaskSpec added in v0.124.0 

type AgentTaskSpec struct {
	Label        string
	Description  string
	Model        string
	Files        []string
	SystemPrompt string
	// Mode is the subagent's capability, resolved from the `type` argument:
	// ReadOnly -> AgentModeReadOnly (Explore-like, no approval), ReadWrite ->
	// AgentModeStandard (can mutate, approval applies).
	Mode domain.AgentMode
}

AgentTaskSpec is one delegated unit of work within an Agent tool call.

type AgentTool added in v0.124.0 

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

AgentTool spawns local subagents (each an `infer agent` subprocess) in parallel and folds their results back into the main context. It is the lightweight, no-A2A-server complement to the A2A tools.

func NewAgentTool added in v0.124.0 

func NewAgentTool(cfg *config.Config, tracker domain.SubagentTracker, submitter domain.JobSubmitter) *AgentTool

NewAgentTool creates the Agent tool. tracker is the session's SubagentTracker (the data store the subagent control tools read); submitter is the job supervisor that monitors async/interactive subagents to completion.

func (*AgentTool) Definition added in v0.124.0 

func (t *AgentTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*AgentTool) Execute added in v0.124.0 

func (t *AgentTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the tool with the given arguments.

func (*AgentTool) FormatForLLM added in v0.124.0 

func (t *AgentTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM renders a structured detail block for the assistant.

func (*AgentTool) FormatForUI added in v0.124.0 

func (t *AgentTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI renders the tool call header with a single-line preview.

func (*AgentTool) FormatPreview added in v0.124.0 

func (t *AgentTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a compact one-line preview.

func (*AgentTool) FormatResult added in v0.124.0 

func (t *AgentTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*AgentTool) IsEnabled added in v0.124.0 

func (t *AgentTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled (and below the depth limit).

func (*AgentTool) ShouldAlwaysExpand added in v0.124.0 

func (t *AgentTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand keeps the result block collapsed by default.

func (*AgentTool) ShouldCollapseArg added in v0.124.0 

func (t *AgentTool) ShouldCollapseArg(string) bool

ShouldCollapseArg keeps the Agent tool's arguments visible rather than collapsing them to "...". The task description is the one thing a user needs to see when approving an Agent call - and unlike Write/Edit there is no diff or preview below the summary to fall back on - so it must show in the approval prompt and the tool-call line. Long values are truncated by the surrounding view's width budget.

func (*AgentTool) Validate added in v0.124.0 

func (t *AgentTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type AgentToolResult added in v0.124.0 

type AgentToolResult struct {
	Mode       string           `json:"mode"`
	Wait       bool             `json:"wait"`
	Dispatched int              `json:"dispatched"`
	Subagents  []AgentSubResult `json:"subagents,omitempty"`
	Message    string           `json:"message,omitempty"`
}

AgentToolResult is the structured payload of an Agent tool call.

type ApproveSubagentTool added in v0.126.0 

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

ApproveSubagentTool relays the user's approve/reject decision to an interactive subagent that is blocked on a tool-approval prompt (the parent is notified with a "[Subagent Awaiting Approval: ...]" message). approve presses Enter on the pane's default-focused [Approve] button; reject presses Escape. The tool is always approval-gated so the human confirms the relay in the MAIN chat.

func NewApproveSubagentTool added in v0.126.0 

func NewApproveSubagentTool(cfg *config.Config, tracker domain.SubagentTracker) *ApproveSubagentTool

NewApproveSubagentTool creates a new ApproveSubagent tool over the session's SubagentTracker.

func (*ApproveSubagentTool) Definition added in v0.126.0 

func (t *ApproveSubagentTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*ApproveSubagentTool) Execute added in v0.126.0 

func (t *ApproveSubagentTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute relays the decision to the named subagent's pane.

func (*ApproveSubagentTool) FormatForLLM added in v0.126.0 

func (t *ApproveSubagentTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption.

func (*ApproveSubagentTool) FormatPreview added in v0.126.0 

func (t *ApproveSubagentTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*ApproveSubagentTool) FormatResult added in v0.126.0 

func (t *ApproveSubagentTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*ApproveSubagentTool) IsEnabled added in v0.126.0 

func (t *ApproveSubagentTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled.

func (*ApproveSubagentTool) ShouldAlwaysExpand added in v0.126.0 

func (t *ApproveSubagentTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded.

func (*ApproveSubagentTool) ShouldCollapseArg added in v0.126.0 

func (t *ApproveSubagentTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed.

func (*ApproveSubagentTool) Validate added in v0.126.0 

func (t *ApproveSubagentTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type AskUserQuestionTool added in v0.124.0 

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

AskUserQuestionTool presents the user with a small interactive form of 1-4 multiple-choice questions during plan mode and returns the chosen answers to the agent so it can fold them into the plan before RequestPlanApproval.

It is read-only (no approval gate) and only reaches the user when a chat TUI is present: the brokering capability is injected into the execution context only on the chat path. On headless/no-TTY runs the broker is absent and the tool degrades gracefully instead of blocking.

func NewAskUserQuestionTool added in v0.124.0 

func NewAskUserQuestionTool(cfg *config.Config) *AskUserQuestionTool

NewAskUserQuestionTool creates a new AskUserQuestion tool.

func (*AskUserQuestionTool) Definition added in v0.124.0 

func (t *AskUserQuestionTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*AskUserQuestionTool) Execute added in v0.124.0 

func (t *AskUserQuestionTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute presents the questions to the user and returns their answers. The tool blocks (in its own goroutine) until the user submits, dismisses, or the session is cancelled. When no interactive user is reachable it returns a graceful result telling the model to proceed with assumptions.

func (*AskUserQuestionTool) FormatForLLM added in v0.124.0 

func (t *AskUserQuestionTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption.

func (*AskUserQuestionTool) FormatForUI added in v0.124.0 

func (t *AskUserQuestionTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display.

func (*AskUserQuestionTool) FormatPreview added in v0.124.0 

func (t *AskUserQuestionTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*AskUserQuestionTool) FormatResult added in v0.124.0 

func (t *AskUserQuestionTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*AskUserQuestionTool) IsEnabled added in v0.124.0 

func (t *AskUserQuestionTool) IsEnabled() bool

IsEnabled returns whether the AskUserQuestion tool is enabled.

func (*AskUserQuestionTool) ShouldAlwaysExpand added in v0.124.0 

func (t *AskUserQuestionTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand keeps the collected answers expanded in the conversation by default - the Q&A is the whole point of the tool, so it shouldn't be hidden behind a collapsed one-liner.

func (*AskUserQuestionTool) ShouldCollapseArg added in v0.124.0 

func (t *AskUserQuestionTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display.

func (*AskUserQuestionTool) Validate added in v0.124.0 

func (t *AskUserQuestionTool) Validate(args map[string]any) error

Validate checks that the AskUserQuestion arguments satisfy the schema bounds.

type BashOutputTool 

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

BashOutputTool retrieves output from background bash shells

func NewBashOutputTool 

func NewBashOutputTool(cfg *config.Config, shellService domain.BackgroundShellService) *BashOutputTool

NewBashOutputTool creates a new BashOutput tool

func (*BashOutputTool) Definition 

func (t *BashOutputTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the SDK

func (*BashOutputTool) Execute 

func (t *BashOutputTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute retrieves output from a background shell

func (*BashOutputTool) FormatForLLM 

func (t *BashOutputTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*BashOutputTool) FormatForUI 

func (t *BashOutputTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*BashOutputTool) FormatPreview 

func (t *BashOutputTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*BashOutputTool) FormatResult 

func (t *BashOutputTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*BashOutputTool) IsEnabled 

func (t *BashOutputTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled

func (*BashOutputTool) ShouldAlwaysExpand 

func (t *BashOutputTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*BashOutputTool) ShouldCollapseArg 

func (t *BashOutputTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if a specific argument should be collapsed in UI

func (*BashOutputTool) Validate 

func (t *BashOutputTool) Validate(args map[string]any) error

Validate validates the tool arguments

type BashResult 

type BashResult struct {
	Command  string `json:"command"`
	Output   string `json:"output"`
	Error    string `json:"error,omitempty"`
	ExitCode int    `json:"exit_code"`
	Duration string `json:"duration"`
}

BashResult represents the internal result of a bash command execution

type BashTool 

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

BashTool handles bash command execution with security validation

func NewBashTool 

func NewBashTool(cfg *config.Config, backgroundShellService domain.BackgroundShellService) *BashTool

NewBashTool creates a new bash tool

func (*BashTool) Definition 

func (t *BashTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM. The command parameter is intentionally not constrained by an enum: the set of auto-approved commands is per-mode (and may be ".*"), so it cannot be expressed as a fixed schema. The effective allow-list for the active mode is surfaced in the system prompt instead; off-list commands still execute via approval (chat) or are rejected with a reason (agent mode).

func (*BashTool) Execute 

func (t *BashTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the bash tool with given arguments

func (*BashTool) FormatForLLM 

func (t *BashTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*BashTool) FormatForUI 

func (t *BashTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*BashTool) FormatPreview 

func (t *BashTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*BashTool) FormatResult 

func (t *BashTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*BashTool) FormatResultBody added in v0.118.0 

func (t *BashTool) FormatResultBody(result *domain.ToolExecutionResult) string

FormatResultBody returns the command's primary output for the collapsed preview and the full-on-failure view. Unlike FormatPreview it never truncates, and on a non-zero exit it surfaces the exit code and error so failures are fully visible.

func (*BashTool) IsEnabled 

func (t *BashTool) IsEnabled() bool

IsEnabled returns whether the bash tool is enabled

func (*BashTool) ShouldAlwaysExpand 

func (t *BashTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*BashTool) ShouldCollapseArg 

func (t *BashTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*BashTool) Validate 

func (t *BashTool) Validate(args map[string]any) error

Validate checks the bash tool arguments. It has no agent-mode context, so the allow-check uses standard mode (the interactive default, and what `infer tools validate` reports). The authoritative, mode-aware gate is in executeBash.

type CloseSubagentTool added in v0.126.0 

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

CloseSubagentTool closes a subagent. For an interactive subagent it harvests its last assistant message (result file) and kills the tmux pane; for a headless one it cancels the running subprocess. The subagent analogue of KillShell.

func NewCloseSubagentTool added in v0.126.0 

func NewCloseSubagentTool(cfg *config.Config, tracker domain.SubagentTracker, stopJob domain.JobStopper) *CloseSubagentTool

NewCloseSubagentTool creates a new CloseSubagent tool over the session's SubagentTracker. stopJob ends the supervised monitor of a closed interactive subagent (may be nil, e.g. when the supervisor is unavailable, in which case the tool falls back to killing the pane directly).

func (*CloseSubagentTool) Definition added in v0.126.0 

func (t *CloseSubagentTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*CloseSubagentTool) Execute added in v0.126.0 

func (t *CloseSubagentTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute closes the named subagent.

func (*CloseSubagentTool) FormatForLLM added in v0.126.0 

func (t *CloseSubagentTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption.

func (*CloseSubagentTool) FormatPreview added in v0.126.0 

func (t *CloseSubagentTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*CloseSubagentTool) FormatResult added in v0.126.0 

func (t *CloseSubagentTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*CloseSubagentTool) IsEnabled added in v0.126.0 

func (t *CloseSubagentTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled.

func (*CloseSubagentTool) ShouldAlwaysExpand added in v0.126.0 

func (t *CloseSubagentTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded.

func (*CloseSubagentTool) ShouldCollapseArg added in v0.126.0 

func (t *CloseSubagentTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed.

func (*CloseSubagentTool) Validate added in v0.126.0 

func (t *CloseSubagentTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type DeleteResult 

type DeleteResult struct {
	Path              string   `json:"path"`
	DeletedFiles      []string `json:"deleted_files"`
	DeletedDirs       []string `json:"deleted_dirs"`
	TotalFilesDeleted int      `json:"total_files_deleted"`
	TotalDirsDeleted  int      `json:"total_dirs_deleted"`
	WildcardExpanded  bool     `json:"wildcard_expanded"`
	Errors            []string `json:"errors,omitempty"`
}

DeleteResult represents the result of a delete operation

type DeleteTool 

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

DeleteTool handles file and directory deletion operations

func NewDeleteTool 

func NewDeleteTool(cfg *config.Config) *DeleteTool

NewDeleteTool creates a new delete tool

func (*DeleteTool) Definition 

func (t *DeleteTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*DeleteTool) Execute 

func (t *DeleteTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the delete tool with given arguments

func (*DeleteTool) FormatForLLM 

func (t *DeleteTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*DeleteTool) FormatForUI 

func (t *DeleteTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*DeleteTool) FormatPreview 

func (t *DeleteTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*DeleteTool) FormatResult 

func (t *DeleteTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*DeleteTool) IsEnabled 

func (t *DeleteTool) IsEnabled() bool

IsEnabled returns whether the delete tool is enabled

func (*DeleteTool) ShouldAlwaysExpand 

func (t *DeleteTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*DeleteTool) ShouldCollapseArg 

func (t *DeleteTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*DeleteTool) Validate 

func (t *DeleteTool) Validate(args map[string]any) error

Validate checks if the delete tool arguments are valid

type EditOperation 

type EditOperation struct {
	OldString  string
	NewString  string
	ReplaceAll bool
}

EditOperation represents a single edit operation

type EditTool 

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

EditTool handles exact string replacements in files with strict safety rules

func NewEditTool 

func NewEditTool(cfg *config.Config) *EditTool

NewEditTool creates a new edit tool

func NewEditToolWithRegistry 

func NewEditToolWithRegistry(cfg *config.Config, registry ReadToolTracker) *EditTool

NewEditToolWithRegistry creates a new edit tool with a registry for read tracking

func (*EditTool) Definition 

func (t *EditTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*EditTool) Execute 

func (t *EditTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the edit tool with given arguments

func (*EditTool) FormatForLLM 

func (t *EditTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*EditTool) FormatForUI 

func (t *EditTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*EditTool) FormatPreview 

func (t *EditTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*EditTool) FormatResult 

func (t *EditTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*EditTool) GetDiffInfo 

func (t *EditTool) GetDiffInfo(args map[string]any) *components.DiffInfo

GetDiffInfo implements the DiffFormatter interface

func (*EditTool) IsEnabled 

func (t *EditTool) IsEnabled() bool

IsEnabled returns whether the edit tool is enabled

func (*EditTool) ShouldAlwaysExpand 

func (t *EditTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*EditTool) ShouldCollapseArg 

func (t *EditTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*EditTool) Validate 

func (t *EditTool) Validate(args map[string]any) error

Validate checks if the edit tool arguments are valid

type FileReadResult 

type FileReadResult struct {
	FilePath  string `json:"file_path"`
	Content   string `json:"content"`
	Size      int64  `json:"size"`
	StartLine int    `json:"start_line,omitempty"`
	EndLine   int    `json:"end_line,omitempty"`
	Error     string `json:"error,omitempty"`
}

FileReadResult represents the internal result of a file read operation

type GetFocusedAppTool 

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

GetFocusedAppTool gets the currently focused application

func NewGetFocusedAppTool 

func NewGetFocusedAppTool(cfg *config.Config) *GetFocusedAppTool

NewGetFocusedAppTool creates a new GetFocusedApp tool

func (*GetFocusedAppTool) Definition 

func (t *GetFocusedAppTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for GetFocusedApp

func (*GetFocusedAppTool) Execute 

func (t *GetFocusedAppTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute executes the GetFocusedApp tool

func (*GetFocusedAppTool) FormatForLLM 

func (t *GetFocusedAppTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*GetFocusedAppTool) FormatPreview 

func (t *GetFocusedAppTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview formats the result for display preview

func (*GetFocusedAppTool) FormatResult 

func (t *GetFocusedAppTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats the result based on the requested format type

func (*GetFocusedAppTool) IsEnabled 

func (t *GetFocusedAppTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled

func (*GetFocusedAppTool) ShouldAlwaysExpand 

func (t *GetFocusedAppTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*GetFocusedAppTool) ShouldCollapseArg 

func (t *GetFocusedAppTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*GetFocusedAppTool) Validate 

func (t *GetFocusedAppTool) Validate(args map[string]any) error

Validate validates GetFocusedApp arguments

type GetLatestScreenshotTool 

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

GetLatestScreenshotTool retrieves the latest screenshot from the circular buffer This tool is used when screenshot streaming is enabled to avoid redundant captures

func NewGetLatestScreenshotTool 

func NewGetLatestScreenshotTool(cfg *config.Config, provider domain.ScreenshotProvider) *GetLatestScreenshotTool

NewGetLatestScreenshotTool creates a new tool that reads from the screenshot buffer

func (*GetLatestScreenshotTool) Definition 

func (t *GetLatestScreenshotTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*GetLatestScreenshotTool) Execute 

func (t *GetLatestScreenshotTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute retrieves the latest screenshot from the buffer

func (*GetLatestScreenshotTool) FormatForLLM 

func (t *GetLatestScreenshotTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*GetLatestScreenshotTool) FormatPreview 

func (t *GetLatestScreenshotTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*GetLatestScreenshotTool) FormatResult 

func (t *GetLatestScreenshotTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*GetLatestScreenshotTool) IsEnabled 

func (t *GetLatestScreenshotTool) IsEnabled() bool

IsEnabled returns whether this tool is enabled

func (*GetLatestScreenshotTool) ShouldAlwaysExpand 

func (t *GetLatestScreenshotTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*GetLatestScreenshotTool) ShouldCollapseArg 

func (t *GetLatestScreenshotTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*GetLatestScreenshotTool) Validate 

func (t *GetLatestScreenshotTool) Validate(args map[string]any) error

Validate checks if the tool arguments are valid

type GetSubagentResultTool added in v0.126.0 

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

GetSubagentResultTool returns the latest output of an interactive subagent by returning the subagent chat's last assistant message (from its result file). It is the subagent analogue of BashOutput.

func NewGetSubagentResultTool added in v0.126.0 

func NewGetSubagentResultTool(cfg *config.Config, tracker domain.SubagentTracker) *GetSubagentResultTool

NewGetSubagentResultTool creates a new GetSubagentResult tool over the session's SubagentTracker.

func (*GetSubagentResultTool) Definition added in v0.126.0 

func (t *GetSubagentResultTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*GetSubagentResultTool) Execute added in v0.126.0 

func (t *GetSubagentResultTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute returns the latest output of the named subagent.

func (*GetSubagentResultTool) FormatForLLM added in v0.126.0 

func (t *GetSubagentResultTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption.

func (*GetSubagentResultTool) FormatPreview added in v0.126.0 

func (t *GetSubagentResultTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*GetSubagentResultTool) FormatResult added in v0.126.0 

func (t *GetSubagentResultTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*GetSubagentResultTool) IsEnabled added in v0.126.0 

func (t *GetSubagentResultTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled.

func (*GetSubagentResultTool) ShouldAlwaysExpand added in v0.126.0 

func (t *GetSubagentResultTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded.

func (*GetSubagentResultTool) ShouldCollapseArg added in v0.126.0 

func (t *GetSubagentResultTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed.

func (*GetSubagentResultTool) Validate added in v0.126.0 

func (t *GetSubagentResultTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type GoogleSearchItem 

type GoogleSearchItem struct {
	Title   string `json:"title"`
	Link    string `json:"link"`
	Snippet string `json:"snippet"`
}

GoogleSearchItem represents a single search result from Google API

type GoogleSearchResponse 

type GoogleSearchResponse struct {
	Items []GoogleSearchItem `json:"items"`
}

GoogleSearchResponse represents the response from Google Custom Search API

type GrepCount 

type GrepCount struct {
	File  string `json:"file"`
	Count int    `json:"count"`
}

GrepCount represents match count per file

type GrepMatch 

type GrepMatch struct {
	File string `json:"file"`
	Line int    `json:"line"`
	Text string `json:"text"`
}

GrepMatch represents a single match with line content

type GrepResult 

type GrepResult struct {
	Pattern    string      `json:"pattern"`
	OutputMode string      `json:"output_mode"`
	Files      []string    `json:"files,omitempty"`
	Matches    []GrepMatch `json:"matches,omitempty"`
	Counts     []GrepCount `json:"counts,omitempty"`
	Total      int         `json:"total"`
	Truncated  bool        `json:"truncated"`
	Duration   string      `json:"duration"`
	Error      string      `json:"error,omitempty"`
}

GrepResult represents the result of a grep operation

type GrepTool 

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

GrepTool handles search operations with ripgrep fallback to Go implementation

func NewGrepTool 

func NewGrepTool(cfg *config.Config) *GrepTool

NewGrepTool creates a new grep tool

func (*GrepTool) Definition 

func (t *GrepTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*GrepTool) Execute 

func (t *GrepTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the grep tool with given arguments

func (*GrepTool) FormatForLLM 

func (t *GrepTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*GrepTool) FormatForUI 

func (t *GrepTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*GrepTool) FormatPreview 

func (t *GrepTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*GrepTool) FormatResult 

func (t *GrepTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*GrepTool) IsEnabled 

func (t *GrepTool) IsEnabled() bool

IsEnabled returns whether the grep tool is enabled

func (*GrepTool) ShouldAlwaysExpand 

func (t *GrepTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*GrepTool) ShouldCollapseArg 

func (t *GrepTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*GrepTool) Validate 

func (t *GrepTool) Validate(args map[string]any) error

Validate checks if the grep tool arguments are valid

type KeyboardTypeTool 

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

KeyboardTypeTool types text or sends key combinations

func NewKeyboardTypeTool 

func NewKeyboardTypeTool(cfg *config.Config, rateLimiter domain.RateLimiter, displayProvider display.Provider) *KeyboardTypeTool

NewKeyboardTypeTool creates a new keyboard type tool

func (*KeyboardTypeTool) Definition 

func (t *KeyboardTypeTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*KeyboardTypeTool) Execute 

func (t *KeyboardTypeTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the keyboard type tool with given arguments

func (*KeyboardTypeTool) FormatForLLM 

func (t *KeyboardTypeTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*KeyboardTypeTool) FormatPreview 

func (t *KeyboardTypeTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*KeyboardTypeTool) FormatResult 

func (t *KeyboardTypeTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*KeyboardTypeTool) IsEnabled 

func (t *KeyboardTypeTool) IsEnabled() bool

IsEnabled returns whether this tool is enabled

func (*KeyboardTypeTool) ShouldAlwaysExpand 

func (t *KeyboardTypeTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*KeyboardTypeTool) ShouldCollapseArg 

func (t *KeyboardTypeTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*KeyboardTypeTool) Validate 

func (t *KeyboardTypeTool) Validate(args map[string]any) error

Validate checks if the tool arguments are valid

type KillShellTool 

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

KillShellTool cancels a running background shell

func NewKillShellTool 

func NewKillShellTool(cfg *config.Config, shellService domain.BackgroundShellService) *KillShellTool

NewKillShellTool creates a new KillShell tool

func (*KillShellTool) Definition 

func (t *KillShellTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the SDK

func (*KillShellTool) Execute 

func (t *KillShellTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute cancels a background shell

func (*KillShellTool) FormatForLLM 

func (t *KillShellTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*KillShellTool) FormatForUI 

func (t *KillShellTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*KillShellTool) FormatPreview 

func (t *KillShellTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*KillShellTool) FormatResult 

func (t *KillShellTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*KillShellTool) IsEnabled 

func (t *KillShellTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled

func (*KillShellTool) ShouldAlwaysExpand 

func (t *KillShellTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*KillShellTool) ShouldCollapseArg 

func (t *KillShellTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if a specific argument should be collapsed in UI

func (*KillShellTool) Validate 

func (t *KillShellTool) Validate(args map[string]any) error

Validate validates the tool arguments

type ListShellsTool 

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

ListShellsTool implements listing of background shells

func NewListShellsTool 

func NewListShellsTool(cfg *config.Config, shellService domain.BackgroundShellService) *ListShellsTool

NewListShellsTool creates a new ListShells tool

func (*ListShellsTool) Definition 

func (t *ListShellsTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*ListShellsTool) Execute 

func (t *ListShellsTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute lists all background shells

func (*ListShellsTool) FormatPreview 

func (t *ListShellsTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview

func (*ListShellsTool) FormatResult 

func (t *ListShellsTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats the result for display

func (*ListShellsTool) IsEnabled 

func (t *ListShellsTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled

func (*ListShellsTool) ShouldAlwaysExpand 

func (t *ListShellsTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded

func (*ListShellsTool) ShouldCollapseArg 

func (t *ListShellsTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed

func (*ListShellsTool) Validate 

func (t *ListShellsTool) Validate(args map[string]any) error

Validate validates the tool arguments (none required for ListShells)

type ListSubagentsTool added in v0.126.0 

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

ListSubagentsTool lists local subagents spawned by the Agent tool. For interactive (tmux-pane) subagents it reports the pane's live status so the main agent can tell which have finished. It is the subagent analogue of ListShells.

func NewListSubagentsTool added in v0.126.0 

func NewListSubagentsTool(cfg *config.Config, tracker domain.SubagentTracker) *ListSubagentsTool

NewListSubagentsTool creates a new ListSubagents tool over the session's SubagentTracker.

func (*ListSubagentsTool) Definition added in v0.126.0 

func (t *ListSubagentsTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*ListSubagentsTool) Execute added in v0.126.0 

func (t *ListSubagentsTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute lists all tracked subagents.

func (*ListSubagentsTool) FormatPreview added in v0.126.0 

func (t *ListSubagentsTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview.

func (*ListSubagentsTool) FormatResult added in v0.126.0 

func (t *ListSubagentsTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats the result for display.

func (*ListSubagentsTool) IsEnabled added in v0.126.0 

func (t *ListSubagentsTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled.

func (*ListSubagentsTool) ShouldAlwaysExpand added in v0.126.0 

func (t *ListSubagentsTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded.

func (*ListSubagentsTool) ShouldCollapseArg added in v0.126.0 

func (t *ListSubagentsTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed.

func (*ListSubagentsTool) Validate added in v0.126.0 

func (t *ListSubagentsTool) Validate(args map[string]any) error

Validate checks the tool arguments (none required for ListSubagents).

type MCPTool 

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

MCPTool wraps an MCP server tool to implement the domain.Tool interface

func NewMCPTool 

func NewMCPTool(
	serverName, toolName, description string,
	inputSchema any,
	clientManager domain.MCPClient,
	mcpConfig *config.MCPConfig,
) *MCPTool

NewMCPTool creates a new MCP tool wrapper

func (*MCPTool) Definition 

func (t *MCPTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*MCPTool) Execute 

func (t *MCPTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the MCP tool with given arguments

func (*MCPTool) FormatForLLM 

func (t *MCPTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*MCPTool) FormatForUI 

func (t *MCPTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*MCPTool) FormatPreview 

func (t *MCPTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*MCPTool) FormatResult 

func (t *MCPTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*MCPTool) IsEnabled 

func (t *MCPTool) IsEnabled() bool

IsEnabled returns whether this MCP tool is enabled

func (*MCPTool) ShouldAlwaysExpand 

func (t *MCPTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*MCPTool) ShouldCollapseArg 

func (t *MCPTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*MCPTool) Validate 

func (t *MCPTool) Validate(args map[string]any) error

Validate checks if the tool arguments are valid

type MemoryTool added in v0.126.0 

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

MemoryTool implements persistent, cross-session agent memory as a directory of individual fact-files catalogued by an index (MEMORY.md). Each fact is one Markdown file with YAML frontmatter; the tool keeps the index in sync.

func NewMemoryTool added in v0.126.0 

func NewMemoryTool(cfg *config.Config, backend domain.MemoryBackend, proj project.Identity) *MemoryTool

NewMemoryTool creates a new memory tool. backend syncs the memory directory to a remote after a write/delete (nil-safe: a nil backend, or the local no-op backend, means no remote sync). This is the chat push path - post_session would push after every message, so the tool triggers the push instead. proj is the detected project the process runs in (zero value = global scope); it decides where project-scoped facts are filed.

func (*MemoryTool) Definition added in v0.126.0 

func (t *MemoryTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*MemoryTool) Execute added in v0.126.0 

func (t *MemoryTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the memory tool with the given arguments.

func (*MemoryTool) FormatForLLM added in v0.126.0 

func (t *MemoryTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with expanded structure.

func (*MemoryTool) FormatForUI added in v0.126.0 

func (t *MemoryTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display.

func (*MemoryTool) FormatPreview added in v0.126.0 

func (t *MemoryTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*MemoryTool) FormatResult added in v0.126.0 

func (t *MemoryTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*MemoryTool) IsEnabled added in v0.126.0 

func (t *MemoryTool) IsEnabled() bool

IsEnabled returns whether the memory tool is enabled.

func (*MemoryTool) ShouldAlwaysExpand added in v0.126.0 

func (t *MemoryTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI.

func (*MemoryTool) ShouldCollapseArg added in v0.126.0 

func (t *MemoryTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display.

func (*MemoryTool) Validate added in v0.126.0 

func (t *MemoryTool) Validate(args map[string]any) error

Validate checks the memory tool arguments.

type MemoryToolResult added in v0.126.0 

type MemoryToolResult struct {
	Operation   string `json:"operation"`
	Name        string `json:"name,omitempty"`
	Type        string `json:"type,omitempty"`
	Project     string `json:"project,omitempty"`
	Description string `json:"description,omitempty"`
	Path        string `json:"path,omitempty"`
	Content     string `json:"content,omitempty"`
	Message     string `json:"message,omitempty"`
	Size        int64  `json:"size,omitempty"`
	Indexed     bool   `json:"indexed,omitempty"`
}

MemoryToolResult represents the result of a memory tool operation.

type MouseClickTool 

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

MouseClickTool performs mouse clicks

func NewMouseClickTool 

func NewMouseClickTool(cfg *config.Config, rateLimiter domain.RateLimiter, displayProvider display.Provider, stateManager computerUseState) *MouseClickTool

NewMouseClickTool creates a new mouse click tool

func (*MouseClickTool) Definition 

func (t *MouseClickTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*MouseClickTool) Execute 

func (t *MouseClickTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the mouse click tool with given arguments

func (*MouseClickTool) FormatForLLM 

func (t *MouseClickTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*MouseClickTool) FormatPreview 

func (t *MouseClickTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*MouseClickTool) FormatResult 

func (t *MouseClickTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*MouseClickTool) IsEnabled 

func (t *MouseClickTool) IsEnabled() bool

IsEnabled returns whether this tool is enabled

func (*MouseClickTool) ShouldAlwaysExpand 

func (t *MouseClickTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*MouseClickTool) ShouldCollapseArg 

func (t *MouseClickTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*MouseClickTool) Validate 

func (t *MouseClickTool) Validate(args map[string]any) error

Validate checks if the tool arguments are valid

type MouseMoveTool 

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

MouseMoveTool moves the mouse cursor to specified coordinates

func NewMouseMoveTool 

func NewMouseMoveTool(cfg *config.Config, rateLimiter domain.RateLimiter, displayProvider display.Provider, stateManager domain.EventBridgeManager) *MouseMoveTool

NewMouseMoveTool creates a new mouse move tool

func (*MouseMoveTool) Definition 

func (t *MouseMoveTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*MouseMoveTool) Execute 

func (t *MouseMoveTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the mouse move tool with given arguments

func (*MouseMoveTool) FormatForLLM 

func (t *MouseMoveTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*MouseMoveTool) FormatPreview 

func (t *MouseMoveTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*MouseMoveTool) FormatResult 

func (t *MouseMoveTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*MouseMoveTool) IsEnabled 

func (t *MouseMoveTool) IsEnabled() bool

IsEnabled returns whether this tool is enabled

func (*MouseMoveTool) ShouldAlwaysExpand 

func (t *MouseMoveTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*MouseMoveTool) ShouldCollapseArg 

func (t *MouseMoveTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*MouseMoveTool) Validate 

func (t *MouseMoveTool) Validate(args map[string]any) error

Validate checks if the tool arguments are valid

type MouseScrollTool 

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

MouseScrollTool scrolls the mouse wheel

func NewMouseScrollTool 

func NewMouseScrollTool(cfg *config.Config, rateLimiter domain.RateLimiter, displayProvider display.Provider) *MouseScrollTool

NewMouseScrollTool creates a new mouse scroll tool

func (*MouseScrollTool) Definition 

func (t *MouseScrollTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*MouseScrollTool) Execute 

func (t *MouseScrollTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the mouse scroll tool with given arguments

func (*MouseScrollTool) FormatForLLM 

func (t *MouseScrollTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*MouseScrollTool) FormatPreview 

func (t *MouseScrollTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview formats a short preview of tool execution

func (*MouseScrollTool) FormatResult 

func (t *MouseScrollTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats the result based on the requested format type

func (*MouseScrollTool) IsEnabled 

func (t *MouseScrollTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled

func (*MouseScrollTool) ShouldAlwaysExpand 

func (t *MouseScrollTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*MouseScrollTool) ShouldCollapseArg 

func (t *MouseScrollTool) ShouldCollapseArg(argName string) bool

ShouldCollapseArg determines if an argument should be collapsed in UI

func (*MouseScrollTool) Validate 

func (t *MouseScrollTool) Validate(args map[string]any) error

Validate validates the tool arguments

type MultiEditTool 

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

MultiEditTool handles multiple exact string replacements in a single file atomically

func NewMultiEditTool 

func NewMultiEditTool(cfg *config.Config) *MultiEditTool

NewMultiEditTool creates a new multi-edit tool

func NewMultiEditToolWithRegistry 

func NewMultiEditToolWithRegistry(cfg *config.Config, registry ReadToolTracker) *MultiEditTool

NewMultiEditToolWithRegistry creates a new multi-edit tool with a registry for read tracking

func (*MultiEditTool) Definition 

func (t *MultiEditTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*MultiEditTool) Execute 

func (t *MultiEditTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the multi-edit tool with given arguments

func (*MultiEditTool) FormatForLLM 

func (t *MultiEditTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*MultiEditTool) FormatForUI 

func (t *MultiEditTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*MultiEditTool) FormatPreview 

func (t *MultiEditTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*MultiEditTool) FormatResult 

func (t *MultiEditTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*MultiEditTool) GetDiffInfo 

func (t *MultiEditTool) GetDiffInfo(args map[string]any) *components.DiffInfo

GetDiffInfo implements the DiffFormatter interface

func (*MultiEditTool) IsEnabled 

func (t *MultiEditTool) IsEnabled() bool

IsEnabled returns whether the multi-edit tool is enabled

func (*MultiEditTool) ShouldAlwaysExpand 

func (t *MultiEditTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*MultiEditTool) ShouldCollapseArg 

func (t *MultiEditTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg delegates to the formatter's collapse logic

func (*MultiEditTool) Validate 

func (t *MultiEditTool) Validate(args map[string]any) error

Validate checks if the multi-edit tool arguments are valid

type ParameterExtractor 

type ParameterExtractor struct{}

ParameterExtractor handles centralized parameter extraction and validation

func NewParameterExtractor 

func NewParameterExtractor() *ParameterExtractor

NewParameterExtractor creates a new ParameterExtractor

func (*ParameterExtractor) ExtractWriteParams 

func (p *ParameterExtractor) ExtractWriteParams(params map[string]any) (*WriteParams, error)

ExtractWriteParams extracts and validates write operation parameters

func (*ParameterExtractor) ToWriteRequest 

func (p *ParameterExtractor) ToWriteRequest(params *WriteParams) filewriter.WriteRequest

ToWriteRequest converts WriteParams to a filewriter.WriteRequest

type ReadSubagentScreenTool added in v0.126.0 

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

ReadSubagentScreenTool returns the raw terminal screen of an interactive subagent's tmux pane - the rendered TUI, chrome included. Unlike GetSubagentResult (which returns the clean last assistant message and refuses while the subagent is running) this is for inspecting/driving the live TUI (e.g. TUI testing), so it works regardless of the subagent's status. Read-only.

func NewReadSubagentScreenTool added in v0.126.0 

func NewReadSubagentScreenTool(cfg *config.Config, tracker domain.SubagentTracker) *ReadSubagentScreenTool

NewReadSubagentScreenTool creates a new ReadSubagentScreen tool over the session's SubagentTracker.

func (*ReadSubagentScreenTool) Definition added in v0.126.0 

func (t *ReadSubagentScreenTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*ReadSubagentScreenTool) Execute added in v0.126.0 

func (t *ReadSubagentScreenTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute captures the named subagent's terminal screen.

func (*ReadSubagentScreenTool) FormatForLLM added in v0.126.0 

func (t *ReadSubagentScreenTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption.

func (*ReadSubagentScreenTool) FormatPreview added in v0.126.0 

func (t *ReadSubagentScreenTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*ReadSubagentScreenTool) FormatResult added in v0.126.0 

func (t *ReadSubagentScreenTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*ReadSubagentScreenTool) IsEnabled added in v0.126.0 

func (t *ReadSubagentScreenTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled.

func (*ReadSubagentScreenTool) ShouldAlwaysExpand added in v0.126.0 

func (t *ReadSubagentScreenTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded.

func (*ReadSubagentScreenTool) ShouldCollapseArg added in v0.126.0 

func (t *ReadSubagentScreenTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed.

func (*ReadSubagentScreenTool) Validate added in v0.126.0 

func (t *ReadSubagentScreenTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type ReadTool 

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

ReadTool handles file reading operations with deterministic behavior

func NewReadTool 

func NewReadTool(cfg *config.Config) *ReadTool

NewReadTool creates a new read tool

func (*ReadTool) Definition 

func (t *ReadTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*ReadTool) Execute 

func (t *ReadTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the read tool with given arguments

func (*ReadTool) FormatForLLM 

func (t *ReadTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*ReadTool) FormatForUI 

func (t *ReadTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*ReadTool) FormatPreview 

func (t *ReadTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*ReadTool) FormatResult 

func (t *ReadTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*ReadTool) FormatResultBody added in v0.118.0 

func (t *ReadTool) FormatResultBody(result *domain.ToolExecutionResult) string

FormatResultBody returns the file content for the collapsed preview.

func (*ReadTool) IsEnabled 

func (t *ReadTool) IsEnabled() bool

IsEnabled returns whether the read tool is enabled

func (*ReadTool) ShouldAlwaysExpand 

func (t *ReadTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*ReadTool) ShouldCollapseArg 

func (t *ReadTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*ReadTool) Validate 

func (t *ReadTool) Validate(args map[string]any) error

Validate checks if the read tool arguments are valid

type ReadToolTracker 

type ReadToolTracker interface {
	IsReadToolUsed() bool
	// RecordFileRead snapshots a file's modtime/size at the moment it was read (or written by us).
	RecordFileRead(path string, modTime time.Time, size int64)
	// LastReadInfo returns the snapshot recorded for path, and whether one exists.
	LastReadInfo(path string) (modTime time.Time, size int64, known bool)
}

ReadToolTracker interface for tracking read tool usage and per-file read freshness.

type Registry 

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

Registry manages all available tools

func NewRegistry 

func NewRegistry(cfg *config.Config, imageService domain.ImageService, mcpManager domain.MCPManager, shellService domain.BackgroundShellService, stateManager computerUseState, screenshotProvider domain.ScreenshotProvider, taskTracker domain.A2ATaskTracker, stores *storage.Stores) *Registry

NewRegistry creates a new tool registry with self-contained tools. taskTracker must be provided by the caller (typically the container, which constructs the unified BackgroundTaskRegistry and passes its A2A view in here so all tools observe the same tracker the agent's wait loop does). stores provides the storage backends for the Schedule and RequestPlanApproval tools; it may be nil when storage failed to initialize, in which case those tools fail at execution with a clear error.

func (*Registry) GetA2ATaskTracker added in v0.101.0 

func (r *Registry) GetA2ATaskTracker() domain.A2ATaskTracker

GetA2ATaskTracker returns the task tracker instance

func (*Registry) GetBackgroundShellService 

func (r *Registry) GetBackgroundShellService() domain.BackgroundShellService

GetBackgroundShellService returns the background shell service instance

func (*Registry) GetTool 

func (r *Registry) GetTool(name string) (domain.Tool, error)

GetTool retrieves a tool by name

func (*Registry) GetToolDefinitions 

func (r *Registry) GetToolDefinitions() []sdk.ChatCompletionTool

GetToolDefinitions returns definitions for all enabled tools

func (*Registry) IsReadToolUsed 

func (r *Registry) IsReadToolUsed() bool

IsReadToolUsed returns whether the Read tool has been used

func (*Registry) IsToolEnabled 

func (r *Registry) IsToolEnabled(name string) bool

IsToolEnabled checks if a specific tool is enabled

func (*Registry) LastReadInfo added in v0.119.0 

func (r *Registry) LastReadInfo(path string) (time.Time, int64, bool)

LastReadInfo returns the snapshot recorded for path (by absolute path) and whether one exists.

func (*Registry) ListAvailableTools 

func (r *Registry) ListAvailableTools() []string

ListAvailableTools returns names of all available and enabled tools

func (*Registry) RecordFileRead added in v0.119.0 

func (r *Registry) RecordFileRead(path string, modTime time.Time, size int64)

RecordFileRead snapshots a file's modtime/size, keyed by its absolute path. Called when the Read tool reads a file and refreshed after Edit/MultiEdit/Write so the agent's own writes do not look like external modifications.

func (*Registry) RegisterMCPServerTools 

func (r *Registry) RegisterMCPServerTools(serverName string, tools []domain.MCPDiscoveredTool) int

RegisterMCPServerTools dynamically registers tools from an MCP server. The serverName must match a client registered with the MCPManager - the lookup is O(1) via MCPManager.GetClient and performs no network I/O.

func (*Registry) SetMemoryBackend added in v0.127.0 

func (r *Registry) SetMemoryBackend(backend domain.MemoryBackend)

SetMemoryBackend wires the memory sync backend into the Memory tool so a write/delete pushes to the remote. The container calls this after constructing the shared backend; it re-registers the Memory tool so the backend takes effect. A nil backend (or the local no-op backend) means no remote sync.

func (*Registry) SetReadToolUsed 

func (r *Registry) SetReadToolUsed()

SetReadToolUsed marks that the Read tool has been used. Tool calls in one assistant turn execute concurrently, so this must be safe under parallel use.

func (*Registry) SetScreenshotProvider 

func (r *Registry) SetScreenshotProvider(provider domain.ScreenshotProvider)

SetScreenshotProvider updates the screenshot provider for tools that need it

func (*Registry) SetScreenshotServer 

func (r *Registry) SetScreenshotServer(provider domain.ScreenshotProvider)

SetScreenshotServer dynamically registers the GetLatestScreenshot tool This should be called after the screenshot server is started

func (*Registry) UnregisterMCPServerTools 

func (r *Registry) UnregisterMCPServerTools(serverName string) int

UnregisterMCPServerTools removes all tools from a specific MCP server

type RequestPlanApprovalTool 

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

RequestPlanApprovalTool handles requesting plan approval from the user. On execute it persists the plan to the injected PlanStorage so users have an auditable record of every plan the agent produced - even when they reject it.

func NewRequestPlanApprovalTool 

func NewRequestPlanApprovalTool(cfg *config.Config, planStore storage.PlanStorage) *RequestPlanApprovalTool

NewRequestPlanApprovalTool creates a new RequestPlanApproval tool. planStore may be nil when storage failed to initialize; Execute then fails with a clear error.

func (*RequestPlanApprovalTool) Definition 

func (t *RequestPlanApprovalTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*RequestPlanApprovalTool) Execute 

func (t *RequestPlanApprovalTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the RequestPlanApproval tool with given arguments. It persists the plan to PlanStorage and returns the plan content plus an infer://plans/<id> URI so downstream consumers can surface both to the user and the LLM.

func (*RequestPlanApprovalTool) FormatForLLM 

func (t *RequestPlanApprovalTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption

func (*RequestPlanApprovalTool) FormatForUI 

func (t *RequestPlanApprovalTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*RequestPlanApprovalTool) FormatPreview 

func (t *RequestPlanApprovalTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*RequestPlanApprovalTool) FormatResult 

func (t *RequestPlanApprovalTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*RequestPlanApprovalTool) IsEnabled 

func (t *RequestPlanApprovalTool) IsEnabled() bool

IsEnabled returns whether the RequestPlanApproval tool is enabled

func (*RequestPlanApprovalTool) ShouldAlwaysExpand 

func (t *RequestPlanApprovalTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*RequestPlanApprovalTool) ShouldCollapseArg 

func (t *RequestPlanApprovalTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*RequestPlanApprovalTool) Validate 

func (t *RequestPlanApprovalTool) Validate(args map[string]any) error

Validate checks if the RequestPlanApproval tool arguments are valid. The title is rejected up front when it contains path separators or ".." so we never even attempt to slug a malicious title.

type ScheduleTool added in v0.104.0 

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

ScheduleTool lets the LLM create, inspect, and remove recurring jobs that are executed by the channels-manager daemon's scheduler. Jobs are persisted through the injected storage backend; the daemon hot-reloads by polling it.

func NewScheduleTool added in v0.104.0 

func NewScheduleTool(cfg *config.Config, store storage.ScheduledJobStorage) *ScheduleTool

NewScheduleTool creates a new Schedule tool. store may be nil when storage failed to initialize; Execute then fails with a clear error.

func (*ScheduleTool) Definition added in v0.104.0 

func (t *ScheduleTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*ScheduleTool) Execute added in v0.104.0 

func (t *ScheduleTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the Schedule tool with the given arguments.

func (*ScheduleTool) FormatForLLM added in v0.104.0 

func (t *ScheduleTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM renders a structured detail block for the assistant.

func (*ScheduleTool) FormatForUI added in v0.104.0 

func (t *ScheduleTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI renders the tool call header with a single-line preview.

func (*ScheduleTool) FormatPreview added in v0.104.0 

func (t *ScheduleTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a compact one-line preview.

func (*ScheduleTool) FormatResult added in v0.104.0 

func (t *ScheduleTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*ScheduleTool) IsEnabled added in v0.104.0 

func (t *ScheduleTool) IsEnabled() bool

IsEnabled returns whether the Schedule tool is enabled.

func (*ScheduleTool) ShouldAlwaysExpand added in v0.104.0 

func (t *ScheduleTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand keeps the result block expanded by default.

func (*ScheduleTool) ShouldCollapseArg added in v0.104.0 

func (t *ScheduleTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg controls per-arg collapsing in the chat UI.

func (*ScheduleTool) Validate added in v0.104.0 

func (t *ScheduleTool) Validate(args map[string]any) error

Validate checks if the schedule tool arguments are well-formed before execution. It only validates structure - semantic checks (channel exists, job exists) happen in Execute.

type ScheduleToolResult added in v0.104.0 

type ScheduleToolResult struct {
	Operation string                 `json:"operation"`
	Job       *domain.ScheduledJob   `json:"job,omitempty"`
	Jobs      []*domain.ScheduledJob `json:"jobs,omitempty"`
	Message   string                 `json:"message,omitempty"`
}

ScheduleToolResult is the structured payload returned to the LLM.

type SearchOptions 

type SearchOptions struct {
	CaseInsensitive bool
	ShowLineNumbers bool
	ContextBefore   int
	ContextAfter    int
	Multiline       bool
	GlobPattern     string
	FileType        string
	HeadLimit       int
}

SearchOptions holds configuration for the search operation

type SendSubagentInputTool added in v0.126.0 

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

SendSubagentInputTool types text and/or named keys into an interactive subagent's tmux pane - to re-prompt it or drive its TUI. When it submits a prompt (submit=true) it re-arms the completion watcher so the main agent is notified when the subagent finishes the resulting turn (no polling).

func NewSendSubagentInputTool added in v0.126.0 

func NewSendSubagentInputTool(cfg *config.Config, tracker domain.SubagentTracker) *SendSubagentInputTool

NewSendSubagentInputTool creates a new SendSubagentInput tool over the session's SubagentTracker.

func (*SendSubagentInputTool) Definition added in v0.126.0 

func (t *SendSubagentInputTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*SendSubagentInputTool) Execute added in v0.126.0 

func (t *SendSubagentInputTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute sends the input to the named subagent's pane.

func (*SendSubagentInputTool) FormatForLLM added in v0.126.0 

func (t *SendSubagentInputTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption.

func (*SendSubagentInputTool) FormatPreview added in v0.126.0 

func (t *SendSubagentInputTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*SendSubagentInputTool) FormatResult added in v0.126.0 

func (t *SendSubagentInputTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*SendSubagentInputTool) IsEnabled added in v0.126.0 

func (t *SendSubagentInputTool) IsEnabled() bool

IsEnabled reports whether the tool is enabled.

func (*SendSubagentInputTool) ShouldAlwaysExpand added in v0.126.0 

func (t *SendSubagentInputTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand returns whether results should always be expanded.

func (*SendSubagentInputTool) ShouldCollapseArg added in v0.126.0 

func (t *SendSubagentInputTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg returns whether an argument should be collapsed.

func (*SendSubagentInputTool) Validate added in v0.126.0 

func (t *SendSubagentInputTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type TodoWriteTool 

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

TodoWriteTool handles structured task list management for coding sessions

func NewTodoWriteTool 

func NewTodoWriteTool(cfg *config.Config) *TodoWriteTool

NewTodoWriteTool creates a new TodoWrite tool

func (*TodoWriteTool) Definition 

func (t *TodoWriteTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*TodoWriteTool) Execute 

func (t *TodoWriteTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the TodoWrite tool with given arguments

func (*TodoWriteTool) FormatForLLM 

func (t *TodoWriteTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*TodoWriteTool) FormatForUI 

func (t *TodoWriteTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display Returns minimal format as todo updates are shown in the dedicated todo component

func (*TodoWriteTool) FormatPreview 

func (t *TodoWriteTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*TodoWriteTool) FormatResult 

func (t *TodoWriteTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*TodoWriteTool) IsEnabled 

func (t *TodoWriteTool) IsEnabled() bool

IsEnabled returns whether the TodoWrite tool is enabled

func (*TodoWriteTool) ShouldAlwaysExpand 

func (t *TodoWriteTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI Returns false since todos are shown in the dedicated todo component

func (*TodoWriteTool) ShouldCollapseArg 

func (t *TodoWriteTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*TodoWriteTool) Validate 

func (t *TodoWriteTool) Validate(args map[string]any) error

Validate checks if the TodoWrite tool arguments are valid

type TreeResult 

type TreeResult struct {
	Path            string `json:"path"`
	Output          string `json:"output"`
	TotalFiles      int    `json:"total_files"`
	TotalDirs       int    `json:"total_dirs"`
	MaxDepth        int    `json:"max_depth"`
	MaxFiles        int    `json:"max_files"`
	ShowHidden      bool   `json:"show_hidden"`
	Format          string `json:"format"`
	UsingNativeTree bool   `json:"using_native_tree"`
	Truncated       bool   `json:"truncated"`
}

TreeResult represents the internal result of a tree operation

type TreeTool 

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

TreeTool handles directory tree visualization operations

func NewTreeTool 

func NewTreeTool(cfg *config.Config) *TreeTool

NewTreeTool creates a new tree tool

func (*TreeTool) Definition 

func (t *TreeTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*TreeTool) Execute 

func (t *TreeTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the tree tool with given arguments

func (*TreeTool) FormatForLLM 

func (t *TreeTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*TreeTool) FormatForUI 

func (t *TreeTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*TreeTool) FormatPreview 

func (t *TreeTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*TreeTool) FormatResult 

func (t *TreeTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*TreeTool) FormatResultBody added in v0.118.0 

func (t *TreeTool) FormatResultBody(result *domain.ToolExecutionResult) string

FormatResultBody returns the rendered directory tree for the collapsed preview.

func (*TreeTool) IsEnabled 

func (t *TreeTool) IsEnabled() bool

IsEnabled returns whether the tree tool is enabled

func (*TreeTool) ShouldAlwaysExpand 

func (t *TreeTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*TreeTool) ShouldCollapseArg 

func (t *TreeTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*TreeTool) Validate 

func (t *TreeTool) Validate(args map[string]any) error

Validate checks if the tree tool arguments are valid

type WaitTool added in v0.139.0 

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

WaitTool blocks inside a single tool execution until a condition is met (shells exit, file event, or check command succeeds), then returns once with the outcome. Waiting costs zero chat completions.

func NewWaitTool added in v0.139.0 

func NewWaitTool(cfg *config.Config, shellService domain.BackgroundShellService) *WaitTool

NewWaitTool creates a new Wait tool.

func (*WaitTool) Definition added in v0.139.0 

func (t *WaitTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM.

func (*WaitTool) Execute added in v0.139.0 

func (t *WaitTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the Wait tool with given arguments.

func (*WaitTool) FormatForLLM added in v0.139.0 

func (t *WaitTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption. Condition details (last output, exit codes, shell states) are included even on failure so the model can see why the wait ended and decide what to do next.

func (*WaitTool) FormatForUI added in v0.139.0 

func (t *WaitTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display.

func (*WaitTool) FormatPreview added in v0.139.0 

func (t *WaitTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display.

func (*WaitTool) FormatResult added in v0.139.0 

func (t *WaitTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts.

func (*WaitTool) IsEnabled added in v0.139.0 

func (t *WaitTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled.

func (*WaitTool) ShouldAlwaysExpand added in v0.139.0 

func (t *WaitTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI.

func (*WaitTool) ShouldCollapseArg added in v0.139.0 

func (t *WaitTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display.

func (*WaitTool) Validate added in v0.139.0 

func (t *WaitTool) Validate(args map[string]any) error

Validate checks the tool arguments.

type WebFetchTool 

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

WebFetchTool handles content fetching operations

func NewWebFetchTool 

func NewWebFetchTool(cfg *config.Config) *WebFetchTool

NewWebFetchTool creates a new fetch tool

func (*WebFetchTool) Definition 

func (t *WebFetchTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*WebFetchTool) Execute 

func (t *WebFetchTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the fetch tool with given arguments

func (*WebFetchTool) FormatForLLM 

func (t *WebFetchTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*WebFetchTool) FormatForUI 

func (t *WebFetchTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*WebFetchTool) FormatPreview 

func (t *WebFetchTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*WebFetchTool) FormatResult 

func (t *WebFetchTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*WebFetchTool) IsEnabled 

func (t *WebFetchTool) IsEnabled() bool

IsEnabled returns whether the fetch tool is enabled

func (*WebFetchTool) ShouldAlwaysExpand 

func (t *WebFetchTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*WebFetchTool) ShouldCollapseArg 

func (t *WebFetchTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*WebFetchTool) Validate 

func (t *WebFetchTool) Validate(args map[string]any) error

Validate checks if the fetch tool arguments are valid

type WebSearchTool 

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

WebSearchTool handles web search operations

func NewWebSearchTool 

func NewWebSearchTool(cfg *config.Config) *WebSearchTool

NewWebSearchTool creates a new web search tool

func (*WebSearchTool) Definition 

func (t *WebSearchTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*WebSearchTool) Execute 

func (t *WebSearchTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the web search tool with given arguments

func (*WebSearchTool) FormatForLLM 

func (t *WebSearchTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with detailed information

func (*WebSearchTool) FormatForUI 

func (t *WebSearchTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*WebSearchTool) FormatPreview 

func (t *WebSearchTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*WebSearchTool) FormatResult 

func (t *WebSearchTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*WebSearchTool) IsEnabled 

func (t *WebSearchTool) IsEnabled() bool

IsEnabled returns whether the web search tool is enabled

func (*WebSearchTool) ShouldAlwaysExpand 

func (t *WebSearchTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*WebSearchTool) ShouldCollapseArg 

func (t *WebSearchTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*WebSearchTool) Validate 

func (t *WebSearchTool) Validate(args map[string]any) error

Validate checks if the web search tool arguments are valid

type WriteParams 

type WriteParams struct {
	FilePath string
	Content  string
}

WriteParams represents extracted parameters for write operations

type WriteTool 

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

WriteTool implements a refactored WriteTool with clean architecture

func NewWriteTool 

func NewWriteTool(cfg *config.Config) *WriteTool

NewWriteTool creates a new write tool with clean architecture

func (*WriteTool) Definition 

func (t *WriteTool) Definition() sdk.ChatCompletionTool

Definition returns the tool definition for the LLM

func (*WriteTool) Enabled 

func (t *WriteTool) Enabled() bool

Enabled returns whether the tool is enabled

func (*WriteTool) Execute 

func (t *WriteTool) Execute(ctx context.Context, args map[string]any) (*domain.ToolExecutionResult, error)

Execute runs the write tool with given arguments

func (*WriteTool) FormatForLLM 

func (t *WriteTool) FormatForLLM(result *domain.ToolExecutionResult) string

FormatForLLM formats the result for LLM consumption with expanded tree structure

func (*WriteTool) FormatForUI 

func (t *WriteTool) FormatForUI(result *domain.ToolExecutionResult) string

FormatForUI formats the result for UI display

func (*WriteTool) FormatPreview 

func (t *WriteTool) FormatPreview(result *domain.ToolExecutionResult) string

FormatPreview returns a short preview of the result for UI display

func (*WriteTool) FormatResult 

func (t *WriteTool) FormatResult(result *domain.ToolExecutionResult, formatType domain.FormatterType) string

FormatResult formats tool execution results for different contexts

func (*WriteTool) IsEnabled 

func (t *WriteTool) IsEnabled() bool

IsEnabled returns whether the tool is enabled (interface compliance)

func (*WriteTool) ShouldAlwaysExpand 

func (t *WriteTool) ShouldAlwaysExpand() bool

ShouldAlwaysExpand determines if tool results should always be expanded in UI

func (*WriteTool) ShouldCollapseArg 

func (t *WriteTool) ShouldCollapseArg(key string) bool

ShouldCollapseArg determines if an argument should be collapsed in display

func (*WriteTool) Validate 

func (t *WriteTool) Validate(args map[string]any) error

Validate checks if the write tool arguments are valid

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.