tool

package module

Go to main page

Versions in this module

v0

v0.2.3

Oct 23, 2026

v0.2.2

Oct 17, 2026

Changes in this version

type DelegateManager

+ func (dm *DelegateManager) SetMCPExecutor(fn func(context.Context, string, string, map[string]any) (string, error))

type Registry

+ func (r *Registry) ReplaceCategory(category Category, tools []*Tool) error

type Tool

+ InputSchema map[string]any

v0.2.1

Oct 17, 2026

v0.2.0

Oct 17, 2026

Changes in this version

+ func DelegateExecutionSessionID(ctx context.Context) string

+ func DelegateTaskID(ctx context.Context) string

+ func ExtractDelegateWorkspace(contextStr string) string

+ func RegisterBuiltinComputerTools(r *Registry, manager ComputerManager, cfg ComputerUseConfig)

+ func RegisterRuntimeBuiltinTools(r *Registry, mediaProcessor ...*multimodal.Processor)

+ func RegisterRuntimeBuiltinToolsWithConfig(r *Registry, searchCfg *WebSearchConfig, opencliCfg *OpenCLIConfig, ...)

+ type AgentExecutorFunc func(ctx context.Context, description, contextStr string) (string, error)

+ type AgentExecutorOptions struct

+ AllowRecursiveDelegate bool

+ type AgentExecutorWithOptionsFunc func(ctx context.Context, description, contextStr string, ...) (string, error)

+ type ApprovalRequiredError struct

+ Action computer.Action

+ Actions []computer.Action

+ Reason string

+ Tool string

+ func (e *ApprovalRequiredError) Error() string

+ type AutonomyStartFunc func() error

+ type AutonomyToolService struct

+ func NewAutonomyToolService(kit *autonomy.AutonomyKit, start ...AutonomyStartFunc) *AutonomyToolService

+ func (s *AutonomyToolService) HandleAutonomy(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleHeartbeatTrigger(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleQueueAdd(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleQueueList(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleQueueUpdate(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleReport(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleScaleDown(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleScaleUp(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleSetWorkers(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleStatus(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleWorkerList(args map[string]any) (string, error)

+ func (s *AutonomyToolService) HandleWorkerSpawn(args map[string]any) (string, error)

+ func (s *AutonomyToolService) RegisterTools(r *Registry)

+ type BuiltinToolService struct

+ func NewBuiltinToolService(searchCfg *WebSearchConfig, opencliCfg *OpenCLIConfig, ...) *BuiltinToolService

+ func (s *BuiltinToolService) RegisterTools(r *Registry)

+ func (s *BuiltinToolService) ReloadMedia(r *Registry, defaultImageProvider string, mediaProcessor *multimodal.Processor, ...)

+ func (s *BuiltinToolService) SetComputerUseService(service *ComputerUseToolService)

+ type CodexToolService struct

+ func NewCodexToolService(manager *codex.Manager) *CodexToolService

+ func (s *CodexToolService) Close() error

+ func (s *CodexToolService) RegisterTools(r *Registry)

+ type ComputerManager interface

+ Observe func(context.Context, string, computer.ObserveRequest) (computer.Observation, error)

+ Step func(context.Context, string, computer.Action) (computer.Observation, error)

+ type ComputerUseConfig = computer.ToolConfig

+ type ComputerUseToolService struct

+ func NewComputerUseToolService(manager ComputerManager, cfg ComputerUseConfig) *ComputerUseToolService

+ func (s *ComputerUseToolService) ActTool() *Tool

+ func (s *ComputerUseToolService) ObserveTool() *Tool

+ func (s *ComputerUseToolService) RegisterTools(r *Registry)

+ type CredentialProvider interface

+ WithCredential func(context.Context, string, func([]byte) error) error

+ type CronSaveFunc func() error

+ type CronTaskFactory func(id, mode, command string, metadata map[string]string) func() error

+ type CronToolService struct

+ func NewCronToolService(engine *cronpkg.Engine, save CronSaveFunc, buildTask CronTaskFactory) *CronToolService

+ func (s *CronToolService) HandleAdd(args map[string]any) (string, error)

+ func (s *CronToolService) HandleCron(args map[string]any) (string, error)

+ func (s *CronToolService) HandleList(args map[string]any) (string, error)

+ func (s *CronToolService) HandlePause(args map[string]any) (string, error)

+ func (s *CronToolService) HandleRemove(args map[string]any) (string, error)

+ func (s *CronToolService) HandleResume(args map[string]any) (string, error)

+ func (s *CronToolService) HandleStatus(args map[string]any) (string, error)

+ func (s *CronToolService) HandleValidate(args map[string]any) (string, error)

+ func (s *CronToolService) RegisterTools(r *Registry)

+ type DelegateConfig struct

+ AutoApprove bool

+ ChildAllowRecursive bool

+ ChildAutoApprove bool

+ ChildDisabledTools []string

+ ChildDuplicateLimit int

+ ChildMaxIterations int

+ ChildRepeatToolLimit int

+ ChildTimeout time.Duration

+ ChildToolOnlyLimit int

+ MaxChildren int

+ MaxConcurrent int

+ MaxResultBytesInline int

+ MaxTimeout time.Duration

+ MinTimeout time.Duration

+ Timeout time.Duration

+ func DefaultDelegateConfig() DelegateConfig

+ type DelegateManager struct

+ func NewDelegateManager(cfg DelegateConfig) *DelegateManager

+ func (dm *DelegateManager) CancelTask(taskID, reason string) error

+ func (dm *DelegateManager) Config() DelegateConfig

+ func (dm *DelegateManager) DelegateParallel(descriptions []string, contextStr string, timeout time.Duration) *ParallelDelegateResult

+ func (dm *DelegateManager) DelegateParallelTool() *Tool

+ func (dm *DelegateManager) DelegateToMCP(ctx context.Context, serverName, toolName string, args map[string]any, ...) (*DelegateTask, error)

+ func (dm *DelegateManager) DelegateToSkill(ctx context.Context, skillName, description string, priority TaskPriority) (*DelegateTask, error)

+ func (dm *DelegateManager) RecordExecutionMetrics(taskID string, toolCalls int, lastTool string)

+ func (dm *DelegateManager) RetryTask(taskID string) (string, error)

+ func (dm *DelegateManager) RunExplorationHandoff(ctx context.Context, ownerSessionID, description, contextStr string, ...) (taskID, summary string, err error)

+ func (dm *DelegateManager) SetAgentExecutor(fn AgentExecutorFunc)

+ func (dm *DelegateManager) SetAgentExecutorWithOptions(fn AgentExecutorWithOptionsFunc)

+ func (dm *DelegateManager) SetSessionInitializer(fn func(*DelegateTask) error)

+ func (dm *DelegateManager) SetTaskStore(store taskstore.Store)

+ type DelegateTarget int

+ const TargetAgent

+ const TargetMCP

+ const TargetSkill

+ func (t DelegateTarget) String() string

+ type DelegateTask struct

+ AllowRecursiveDelegate bool

+ CompletedAt time.Time

+ Context string

+ Description string

+ Error string

+ ExecutionSessionID string

+ ID string

+ LastTool string

+ Mode taskstore.Mode

+ OwnerSessionID string

+ OwnerSource string

+ ParentSessionID string

+ PlannedMode taskstore.Mode

+ PlannerSummary string

+ RequestKey string

+ Result string

+ Role string

+ StartedAt time.Time

+ Status TaskStatus

+ ToolCalls int

+ Workspace string

+ type EphemeralCredentialTerminalToolService struct

+ func NewEphemeralCredentialTerminalToolService(resolver CredentialProvider) *EphemeralCredentialTerminalToolService

+ func (s *EphemeralCredentialTerminalToolService) Close() error

+ func (s *EphemeralCredentialTerminalToolService) RegisterTools(r *Registry)

+ func (s *EphemeralCredentialTerminalToolService) RevokeSession(scope string)

+ func (s *EphemeralCredentialTerminalToolService) VisibleTools(scope string) []map[string]any

+ type EphemeralCredentialToolService struct

+ func NewEphemeralCredentialToolService(resolver CredentialProvider) *EphemeralCredentialToolService

+ func (s *EphemeralCredentialToolService) Close() error

+ func (s *EphemeralCredentialToolService) RegisterTools(r *Registry)

+ func (s *EphemeralCredentialToolService) RevokeSession(scope string)

+ func (s *EphemeralCredentialToolService) VisibleTools(scope string) []map[string]any

+ type GrokToolService struct

+ func NewGrokToolService(manager *grok.Manager) *GrokToolService

+ func (s *GrokToolService) Close() error

+ func (s *GrokToolService) RegisterTools(r *Registry)

+ type HeartbeatToolService struct

+ func NewHeartbeatToolService(trigger func(args map[string]any) (string, error), ...) *HeartbeatToolService

+ func (s *HeartbeatToolService) RegisterTools(r *Registry)

+ type ImageGenerationDefaults struct

+ Background string

+ Count int

+ Model string

+ OutputCompression int

+ OutputFormat string

+ Quality string

+ Size string

+ type MemoryToolService struct

+ func NewMemoryToolService(store memory.ToolBackend) *MemoryToolService

+ func (s *MemoryToolService) HandleContext(exec ExecutionContext, args map[string]any) (ToolCallResult, error)

+ func (s *MemoryToolService) HandleHygiene(args map[string]any) (string, error)

+ func (s *MemoryToolService) HandleRecall(args map[string]any) (string, error)

+ func (s *MemoryToolService) HandleRecallDetailed(args map[string]any) (ToolCallResult, error)

+ func (s *MemoryToolService) HandleRemember(args map[string]any) (string, error)

+ type NapCatCrossGroupReadConfig struct

+ AllowedGroups []string

+ BlockedGroups []string

+ Enabled bool

+ LogAccess bool

+ RequireConfirmation bool

+ type NapCatGroupReader interface

+ GetGroupInfo func(context.Context, string) (napcat.GroupInfo, error)

+ GetGroupMessageHistory func(context.Context, string, int, int) ([]napcat.GroupMessage, error)

+ ListGroups func(context.Context) ([]napcat.GroupInfo, error)

+ type ParallelDelegateResult struct

+ FailedCount int

+ Results []string

+ SuccessCount int

+ Summary string

+ TotalDuration time.Duration

+ type ParallelDelegateTask struct

+ CompletedAt time.Time

+ Context string

+ Description string

+ Error string

+ ID string

+ Result string

+ StartedAt time.Time

+ Status TaskStatus

+ type PrioritizedTask struct

+ Context string

+ EnqueuedAt time.Time

+ Priority TaskPriority

+ Target DelegateTarget

+ TargetName string

+ Task *DelegateTask

+ type PriorityTaskQueue struct

+ func NewPriorityTaskQueue() *PriorityTaskQueue

+ func (q *PriorityTaskQueue) Clear()

+ func (q *PriorityTaskQueue) Dequeue() (*PrioritizedTask, bool)

+ func (q *PriorityTaskQueue) Enqueue(task *PrioritizedTask)

+ func (q *PriorityTaskQueue) Len() int

+ func (q *PriorityTaskQueue) List() []*PrioritizedTask

+ func (q *PriorityTaskQueue) Peek() (*PrioritizedTask, bool)

+ type RAGToolService struct

+ func NewRAGToolService(manager rag.Backend) *RAGToolService

+ func (s *RAGToolService) HandleIndex(args map[string]any) (string, error)

+ func (s *RAGToolService) HandleSearch(args map[string]any) (string, error)

+ type Services struct

+ Autonomy *AutonomyToolService

+ Builtin *BuiltinToolService

+ Codex *CodexToolService

+ Cron *CronToolService

+ Delegate *DelegateManager

+ Ephemeral *EphemeralCredentialToolService

+ EphemeralTerminal *EphemeralCredentialTerminalToolService

+ Grok *GrokToolService

+ Heartbeat *HeartbeatToolService

+ Memory *MemoryToolService

+ OpenCLI *OpenCLIConfig

+ RAG *RAGToolService

+ SearchCfg *WebSearchConfig

+ Skills *SkillToolService

+ func NewServices(searchCfg *WebSearchConfig, opencliCfg *OpenCLIConfig, ...) *Services

+ func (s *Services) Close() error

+ func (s *Services) PendingApprovals() []PendingApproval

+ func (s *Services) RegisterCoreTools(r *Registry)

+ func (s *Services) ReloadMediaTools(r *Registry, defaultImageProvider string, mediaProcessor *multimodal.Processor, ...)

+ func (s *Services) RespondApproval(ctx context.Context, provider, approvalID, decision string) (PendingApproval, error)

+ func (s *Services) RevokeEphemeralSession(sessionID string)

+ func (s *Services) SetComputerUseService(service *ComputerUseToolService) *Services

+ type TTSDefaults struct

+ Format string

+ Model string

+ Speed float64

+ Voice string

+ type TaskCache struct

+ func NewTaskCache(ttl time.Duration) *TaskCache

+ func (c *TaskCache) Clean() int

+ func (c *TaskCache) Clear()

+ func (c *TaskCache) Delete(key string)

+ func (c *TaskCache) Get(key string) (*DelegateTask, bool)

+ func (c *TaskCache) Set(key string, task *DelegateTask)

+ func (c *TaskCache) Size() int

+ type TaskPriority int

+ const PriorityCritical

+ const PriorityHigh

+ const PriorityLow

+ const PriorityNormal

+ func ParseTaskPriority(s string) (TaskPriority, error)

+ func (p TaskPriority) String() string

+ type TaskStatus int

+ const StatusCancelled

+ const StatusCompleted

+ const StatusFailed

+ const StatusPending

+ const StatusRunning

+ func (s TaskStatus) String() string

type Tool

+ func DelegateCancelTool(dm *DelegateManager) *Tool

+ func DelegateTaskTool(dm *DelegateManager) *Tool

+ func DelegateToMCPTool(dm *DelegateManager) *Tool

+ func DelegateToSkillTool(dm *DelegateManager) *Tool

+ func ImageAnalyzeTool(processor *multimodal.Processor, defaultProvider string) *Tool

+ func ImageGenerateTool(generator multimodal.ImageGenerator, defaults ImageGenerationDefaults) *Tool

+ func ImageReadTool() *Tool

+ func ImageTool(processor *multimodal.Processor, defaultProvider string, ...) *Tool

+ func ListTasksTool(dm *DelegateManager) *Tool

+ func NapCatReadGroupTool(reader NapCatGroupReader, cfg NapCatCrossGroupReadConfig) *Tool

+ func SubagentTool(dm *DelegateManager) *Tool

+ func TaskStatusTool(dm *DelegateManager) *Tool

+ func TextToSpeechTool(synthesizer multimodal.SpeechSynthesizer, defaults TTSDefaults) *Tool

+ func WaitForTasksTool(dm *DelegateManager) *Tool

v0.1.0

Oct 17, 2026

Changes in this version

+ const InstallAborted

+ const InstallConfirmed

+ const InstallFailed

+ const InstallProbing

+ const InstallReady

+ const InstallRejected

+ const InstallScanning

+ const InstallStaging

+ const SeverityBlock

+ const SeverityInfo

+ const SeverityWarn

+ const SkillVersion

+ const SourceArchive

+ const SourcePath

+ func AnnotateToolCall(name, arguments, result string) string

+ func AnnotateToolCallWithTemplates(name, arguments, result string, templates map[string]string) string

+ func BoolArg(v any, rest ...any) bool

+ func BoundedIntArg(args map[string]any, key string, def, minValue, maxValue int) int

+ func CheckCollisions(summary *CapabilitySummary, existing *SkillRegistry, tools *Registry) []string

+ func CloneToolArgs(args map[string]any) map[string]any

+ func CompressOutput(output string, config OutputCompressConfig) string

+ func CopyLocalDir(src, dest string, limits InstallLimits) (*extractStats, error)

+ func DedupOutputs(outputs map[string]string) map[string]string

+ func DefaultTierConfigs() map[SubTier]TierConfig

+ func ExpandSandboxPath(path string) string

+ func ExtractArchive(archivePath, dest string, limits InstallLimits) (*extractStats, error)

+ func ExtractDocumentText(path string) (text, format string, err error)

+ func FormatAuditEntry(entry AuditEntry) string

+ func MergeToolParams(base map[string]Param, groups ...map[string]Param) map[string]Param

+ func MoveDir(src, dst string) error

+ func NormalizeRoot(root, skillDirName string) (string, error)

+ func NumberArg(v any) (float64, bool)

+ func ParallelCompressOutputs(outputs map[string]string, config OutputCompressConfig) map[string]string

+ func ParamSchema(p Param) map[string]any

+ func PrettyStructuredValue(v any) (string, error)

+ func RegisterBuiltinTools(r *Registry)

+ func RegisterBuiltinToolsWithConfig(r *Registry, searchCfg *WebSearchConfig, opencliCfg *OpenCLIConfig)

+ func RegisterMCPTools(r *Registry, client *MCPClient)

+ func RegisterSkillTools(r *Registry, skills []*SkillInfo, ...)

+ func ResolveWorkspacePath(path string) (string, error)

+ func SandboxWorkspaceDir() string

+ func StringArg(v any) string

+ func ToOpenAIName(name string) string

+ func ToolAction(args map[string]any) string

+ func TruncateOutput(output string, maxChars int) string

+ func TruncateOutputs(outputs map[string]string, maxChars int) map[string]string

+ func ValidSkillName(name string) bool

+ func ValidateFetchURL(rawURL string) error

+ func ValidateHTTPMethod(method string, allowMutation bool) error

+ func ValidatePath(path string) error

+ func ValidateRequestHeader(name, value string) error

+ type ApprovalOption struct

+ ID string

+ Kind string

+ Label string

+ type AuditEntry struct

+ Args map[string]any

+ Duration time.Duration

+ Error string

+ OutputSize int

+ Panic bool

+ Result string

+ SkillName string

+ Success bool

+ Timestamp time.Time

+ ToolName string

+ type AuditStats struct

+ AvgDuration time.Duration

+ FailedInvocations int

+ PanicCount int

+ SuccessfulInvocations int

+ TotalDuration time.Duration

+ TotalInvocations int

+ type CapabilitySummary struct

+ Aliases []string

+ Collisions []string

+ Description string

+ Name string

+ ProbeErrors []string

+ Probed bool

+ Scripts []string

+ Summary string

+ Tools []CapabilityTool

+ type CapabilityTool struct

+ Command []string

+ Description string

+ ExposeToModel bool

+ FullName string

+ Name string

+ Origin string

+ type Category string

+ const CatBuiltin

+ const CatDelegate

+ const CatMCP

+ const CatSkill

+ type ErrQuotaExceeded struct

+ Reason string

+ Tool string

+ UserID string

+ func (e ErrQuotaExceeded) Error() string

+ type ErrToolDenied struct

+ func (e ErrToolDenied) Error() string

+ type ErrToolDisabled struct

+ func (e ErrToolDisabled) Error() string

+ type ErrToolNotFound struct

+ func (e ErrToolNotFound) Error() string

+ type ExecutionContext struct

+ AutoApprove bool

+ Context context.Context

+ Sandbox *sandbox.Snapshot

+ SessionID string

+ Source string

+ UserID string

+ UserRequest string

+ type FilesystemPolicy struct

+ AllowOutsideSandbox bool

+ AllowedReadRoots []string

+ func DefaultFilesystemPolicy() FilesystemPolicy

+ func FilesystemPolicyFromOptional(policies []FilesystemPolicy) FilesystemPolicy

+ type Gateway struct

+ func NewGateway(registry *Registry) *Gateway

+ func (g *Gateway) Execute(name string, args map[string]any, userID string) (*GatewayResult, error)

+ func (g *Gateway) ExecuteWithContext(name string, args map[string]any, userID string, exec ExecutionContext) (*GatewayResult, error)

+ func (g *Gateway) ExecuteWithShellContext(name string, args map[string]any, userID string, sc *ShellContext) (*GatewayResult, error)

+ func (g *Gateway) ExecuteWithShellExecutionContext(name string, args map[string]any, userID string, sc *ShellContext, ...) (*GatewayResult, error)

+ func (g *Gateway) Router() *ToolRouter

+ func (g *Gateway) Subscriptions() *SubscriptionManager

+ func (g *Gateway) Tracker() *UsageTracker

+ type GatewayResult struct

+ Duration time.Duration

+ Metadata map[string]any

+ Observations []Observation

+ Output string

+ Success bool

+ Timestamp time.Time

+ ToolName string

+ func (r *GatewayResult) Format() string

+ type InstallHistory struct

+ Action string

+ At time.Time

+ Digest string

+ VersionID string

+ type InstallLimits struct

+ BlockOnSecrets bool

+ MaxArchiveBytes int64

+ MaxCompressionRatio int

+ MaxFiles int

+ MaxPathDepth int

+ MaxPathLen int

+ MaxSingleFileBytes int64

+ MaxUncompressedBytes int64

+ func DefaultInstallLimits() InstallLimits

+ type InstallManager struct

+ func NewInstallManager(cfg InstallManagerConfig) *InstallManager

+ func (m *InstallManager) Abort(id string) error

+ func (m *InstallManager) Confirm(id string, acceptWarnings bool) (*InstallRecord, error)

+ func (m *InstallManager) GC()

+ func (m *InstallManager) ListStaged() []*InstallRecord

+ func (m *InstallManager) Prepare(id string) (*InstallRecord, error)

+ func (m *InstallManager) Rollback(name, versionID string) error

+ func (m *InstallManager) SetRuntime(reload func() (int, error), registry func() *SkillRegistry, ...)

+ func (m *InstallManager) StageArchive(filename string, read func(dst string) error) (string, *InstallRecord, error)

+ func (m *InstallManager) StageLocalDir(srcDir string) (string, *InstallRecord, error)

+ func (m *InstallManager) Staged(id string) (*InstallRecord, error)

+ func (m *InstallManager) Store() *InstallStore

+ func (m *InstallManager) Uninstall(name string, purge bool) (string, error)

+ func (m *InstallManager) Versions(name string) []string

+ type InstallManagerConfig struct

+ AllowedLocalRoots []string

+ KeepVersions int

+ LedgerPath string

+ Limits InstallLimits

+ ProbeCLI bool

+ ProbeTimeout time.Duration

+ SkillsDir string

+ StagingDir string

+ StagingTTL time.Duration

+ TrialBudget time.Duration

+ VersionsDir string

+ type InstallRecord struct

+ Capability *CapabilitySummary

+ CreatedAt time.Time

+ Digest string

+ Error string

+ History []InstallHistory

+ InstallID string

+ InstalledAt time.Time

+ Mode string

+ Name string

+ Scan *ScanReport

+ Source InstallSource

+ State string

+ Tools []string

+ UpdatedAt time.Time

+ Version string

+ func (r *InstallRecord) CanConfirm() bool

+ type InstallSource struct

+ Kind string

+ Origin string

+ Size int64

+ type InstallStore struct

+ func NewInstallStore(path string) *InstallStore

+ func (s *InstallStore) Get(name string) (*InstallRecord, bool)

+ func (s *InstallStore) List() []*InstallRecord

+ func (s *InstallStore) Load() (*Ledger, error)

+ func (s *InstallStore) Path() string

+ func (s *InstallStore) Remove(name string) error

+ func (s *InstallStore) Save(ledger *Ledger) error

+ func (s *InstallStore) Upsert(rec *InstallRecord) error

+ type Ledger struct

+ Skills map[string]*InstallRecord

+ Updated time.Time

+ Version int

+ type MCPClient struct

+ func NewMCPClient() *MCPClient

+ func (c *MCPClient) AddServer(cfg MCPServerConfig)

+ func (c *MCPClient) CallTool(serverName, toolName string, args map[string]any) (string, error)

+ func (c *MCPClient) ListServers() []MCPServerConfig

+ func (c *MCPClient) ListTools(serverName string) ([]MCPToolInfo, error)

+ func (c *MCPClient) RemoveServer(name string)

+ type MCPError struct

+ Code int

+ Message string

+ func (e *MCPError) Error() string

+ type MCPRequest struct

+ ID int

+ JSONRPC string

+ Method string

+ Params any

+ type MCPResponse struct

+ Error *MCPError

+ ID int

+ JSONRPC string

+ Result json.RawMessage

+ type MCPServerConfig struct

+ APIKey string

+ Enabled bool

+ Name string

+ URL string

+ type MCPToolInfo struct

+ Description string

+ Name string

+ Parameters map[string]any

+ type Observation struct

+ ActiveWindow string

+ CapturedAt time.Time

+ DisplayID string

+ FilePath string

+ FrameID string

+ Height int

+ ImageData []byte

+ ImageURL string

+ Kind string

+ Metadata map[string]any

+ MimeType string

+ SHA256 string

+ ScaleFactor float64

+ Width int

+ WindowBounds Rect

+ type OpenCLIConfig = opencli.Config

+ type OutputCompressConfig struct

+ EnableDedup bool

+ EnableSummary bool

+ EnableTruncate bool

+ MaxChars int

+ func DefaultOutputCompressConfig() OutputCompressConfig

+ type Param struct

+ Default any

+ Description string

+ Required bool

+ Schema map[string]any

+ Type string

+ type PendingApproval struct

+ CreatedAt time.Time

+ ID string

+ Method string

+ Options []ApprovalOption

+ Params map[string]any

+ Provider string

+ Reason string

+ SessionID string

+ Summary string

+ ThreadID string

+ TurnID string

+ type PermissionLevel int

+ const PermApprove

+ const PermAuto

+ const PermDeny

+ func (p PermissionLevel) String() string

+ type Quota struct

+ Limit int

+ ResetAt time.Time

+ ToolName string

+ Used int

+ Window string

+ type Rect struct

+ Height int

+ Width int

+ X int

+ Y int

+ type Registry struct

+ func NewRegistry() *Registry

+ func (r *Registry) Call(name string, args map[string]any) (string, error)

+ func (r *Registry) CallDetailed(name string, args map[string]any) (ToolCallResult, error)

+ func (r *Registry) CallDetailedWithContext(name string, args map[string]any, exec ExecutionContext) (ToolCallResult, error)

+ func (r *Registry) CallDetailedWithShellContext(name string, args map[string]any, sc *ShellContext) (ToolCallResult, error)

+ func (r *Registry) CallDetailedWithShellExecutionContext(name string, args map[string]any, sc *ShellContext, exec ExecutionContext) (ToolCallResult, error)

+ func (r *Registry) CallWithContext(name string, args map[string]any, exec ExecutionContext) (string, error)

+ func (r *Registry) CallWithShellContext(name string, args map[string]any, sc *ShellContext) (string, error)

+ func (r *Registry) CheckPermission(name string) (PermissionLevel, error)

+ func (r *Registry) Count() int

+ func (r *Registry) Disable(name string) error

+ func (r *Registry) Enable(name string) error

+ func (r *Registry) FormatToolList() string

+ func (r *Registry) Get(name string) (*Tool, bool)

+ func (r *Registry) List() []*Tool

+ func (r *Registry) ListByCategory(cat Category) []*Tool

+ func (r *Registry) ListEnabled() []*Tool

+ func (r *Registry) ListModelVisible() []*Tool

+ func (r *Registry) Register(tool *Tool)

+ func (r *Registry) SetPermissionOverride(name string, perm PermissionLevel) error

+ func (r *Registry) Unregister(name string)

+ type RouteRule struct

+ Enabled bool

+ Name string

+ Priority int

+ Target string

+ ToolPattern string

+ type SandboxConfig struct

+ EnableAuditLog bool

+ MaxExecutionTime time.Duration

+ MaxOutputSize int

+ func DefaultSandboxConfig() SandboxConfig

+ type SandboxError struct

+ Message string

+ Oversize bool

+ Panic bool

+ Timeout bool

+ ToolName string

+ func (e *SandboxError) Error() string

+ type ScanFinding struct

+ Detail string

+ Line int

+ Path string

+ Rule string

+ Severity string

+ type ScanReport struct

+ Blocked bool

+ Bytes int64

+ Digest string

+ Files int

+ Findings []ScanFinding

+ ScannedAt time.Time

+ Warnings int

+ func ScanSkillDir(skillDir string, limits InstallLimits) (*ScanReport, error)

+ func (r *ScanReport) BlockingFindings() []ScanFinding

+ type ShellContext struct

+ Cwd string

+ Env map[string]string

+ type SkillCandidate struct

+ Name string

+ Reason string

+ Score int

+ type SkillDocSection struct

+ End int

+ Heading string

+ Level int

+ Start int

+ type SkillExecutor struct

+ func NewSkillExecutor() *SkillExecutor

+ func (e *SkillExecutor) Execute(skill *SkillInfo, toolDef SkillToolDef, args map[string]any) (string, error)

+ func (e *SkillExecutor) HandlerFor(skill *SkillInfo, toolDef SkillToolDef) (func(args map[string]any) (string, error), error)

+ type SkillInfo struct

+ Aliases []string

+ Available bool

+ Description string

+ Dir string

+ Name string

+ Summary string

+ Tools []SkillToolDef

+ type SkillLoader struct

+ func NewSkillLoader(skillsDir string) *SkillLoader

+ func (sl *SkillLoader) Load(path string) (*SkillInfo, error)

+ func (sl *SkillLoader) LoadAll() ([]*SkillInfo, error)

+ func (sl *SkillLoader) WithCLIInspect(enabled bool, timeout time.Duration) *SkillLoader

+ func (sl *SkillLoader) WithProbeEnv(env []string) *SkillLoader

+ type SkillMetadata struct

+ Author string

+ Dependencies []string

+ Description string

+ Dir string

+ Error string

+ Labels map[string]string

+ LoadedAt time.Time

+ Name string

+ State SkillState

+ Tools []string

+ Version string

+ type SkillReadContent struct

+ NextOffset int

+ Offset int

+ Text string

+ TotalChars int

+ Truncated bool

+ type SkillRegistry struct

+ func NewSkillRegistry(registry *Registry, loader *SkillLoader) *SkillRegistry

+ func (sr *SkillRegistry) Count() int

+ func (sr *SkillRegistry) CountByState(state SkillState) int

+ func (sr *SkillRegistry) Disable(name string) error

+ func (sr *SkillRegistry) Discover() ([]*SkillMetadata, error)

+ func (sr *SkillRegistry) Enable(name string) error

+ func (sr *SkillRegistry) EnableAll() error

+ func (sr *SkillRegistry) Get(name string) (*SkillMetadata, bool)

+ func (sr *SkillRegistry) HealthCheck() map[string][]string

+ func (sr *SkillRegistry) List() []*SkillMetadata

+ func (sr *SkillRegistry) ListByState(state SkillState) []*SkillMetadata

+ func (sr *SkillRegistry) Load(name string) error

+ func (sr *SkillRegistry) LoadAll() error

+ func (sr *SkillRegistry) Register(name string) error

+ func (sr *SkillRegistry) RegisterAll() error

+ func (sr *SkillRegistry) Reload(name string) error

+ func (sr *SkillRegistry) ResolveLoadOrder() ([]string, error)

+ func (sr *SkillRegistry) SetExecutor(executor *SkillExecutor)

+ func (sr *SkillRegistry) SetMetadata(name string, version, author string, dependencies []string, ...) error

+ func (sr *SkillRegistry) SkillInfos() []*SkillInfo

+ func (sr *SkillRegistry) Unload(name string) error

+ func (sr *SkillRegistry) UnloadAll()

+ func (sr *SkillRegistry) UnwatchState(id string)

+ func (sr *SkillRegistry) Validate(name string) error

+ func (sr *SkillRegistry) ValidateAll() error

+ func (sr *SkillRegistry) WatchState(id string, callback func(name string, from, to SkillState))

+ type SkillSandbox struct

+ func NewSkillSandbox(registry *Registry, config SandboxConfig) *SkillSandbox

+ func (sb *SkillSandbox) AuditLog() []AuditEntry

+ func (sb *SkillSandbox) AuditLogForSkill(skillName string) []AuditEntry

+ func (sb *SkillSandbox) AuditLogForTool(toolName string) []AuditEntry

+ func (sb *SkillSandbox) AuditStats() AuditStats

+ func (sb *SkillSandbox) ClearAuditLog()

+ func (sb *SkillSandbox) Execute(toolName string, args map[string]any) (string, error)

+ func (sb *SkillSandbox) ExecuteWithContext(ctx context.Context, toolName string, args map[string]any) (string, error)

+ type SkillState int

+ const SkillDisabled

+ const SkillDiscovered

+ const SkillEnabled

+ const SkillError

+ const SkillLoaded

+ const SkillRegistered

+ const SkillUnloaded

+ func (s SkillState) String() string

+ type SkillToolDef struct

+ Command []string

+ Description string

+ ExposeToModel bool

+ Handler func(args map[string]any) (string, error)

+ Name string

+ Parameters map[string]Param

+ type SkillToolService struct

+ func NewSkillToolService(skills []*SkillInfo) *SkillToolService

+ func (s *SkillToolService) HandleRead(args map[string]any) (string, error)

+ func (s *SkillToolService) RegisterReadTool(r *Registry)

+ func (s *SkillToolService) RegisterSkillTools(r *Registry)

+ type SubTier int

+ const SubBasic

+ const SubEnterprise

+ const SubFree

+ const SubPro

+ func ParseSubTier(s string) (SubTier, error)

+ func (t SubTier) String() string

+ type SubscriptionManager struct

+ func NewSubscriptionManager() *SubscriptionManager

+ func (sm *SubscriptionManager) CanUse(userID, toolName string) bool

+ func (sm *SubscriptionManager) GetSubscription(userID string) *UserSubscription

+ func (sm *SubscriptionManager) GetTierConfig(tier SubTier) TierConfig

+ func (sm *SubscriptionManager) ListSubscriptions() []UserSubscription

+ func (sm *SubscriptionManager) RecordUsage(userID, toolName string)

+ func (sm *SubscriptionManager) SetTierConfig(tier SubTier, config TierConfig)

+ func (sm *SubscriptionManager) Subscribe(userID string, tier SubTier, duration time.Duration) error

+ func (sm *SubscriptionManager) Unsubscribe(userID string)

+ type TierConfig struct

+ AllowedCategories []Category

+ MaxCallsPerDay int

+ MaxCallsPerHour int

+ Priority int

+ Tier SubTier

+ type Tool struct

+ Category Category

+ ContextDetailedHandler func(exec ExecutionContext, args map[string]any) (ToolCallResult, error)

+ Description string

+ DetailedHandler func(args map[string]any) (ToolCallResult, error)

+ Enabled bool

+ Handler func(args map[string]any) (string, error)

+ HiddenFromModel bool

+ Name string

+ ParallelSafe bool

+ Parameters map[string]Param

+ Permission PermissionLevel

+ PermissionFor func(args map[string]any) PermissionLevel

+ PolicySafe bool

+ ShellAware bool

+ Source string

+ func AskUserTool() *Tool

+ func CSVQueryTool() *Tool

+ func CalculateTool() *Tool

+ func CurrentTimeTool() *Tool

+ func DBSchemaTool() *Tool

+ func DataQueryTool() *Tool

+ func DataTool() *Tool

+ func DocumentReadTool(policies ...FilesystemPolicy) *Tool

+ func FileDeleteTool() *Tool

+ func FileListTool(policies ...FilesystemPolicy) *Tool

+ func FileMkdirTool() *Tool

+ func FileMoveTool() *Tool

+ func FilePatchTool() *Tool

+ func FileReadTool(policies ...FilesystemPolicy) *Tool

+ func FileWriteTool() *Tool

+ func HTTPRequestTool() *Tool

+ func LogTool() *Tool

+ func MemoryHygieneTool(handler func(args map[string]any) (string, error)) *Tool

+ func MemoryTool(remember, hygiene func(args map[string]any) (string, error), ...) *Tool

+ func OpenCLITool(cfg *OpenCLIConfig, fallbackCfg *WebSearchConfig) *Tool

+ func RAGIndexTool(handler func(args map[string]any) (string, error)) *Tool

+ func RAGSearchTool(handler func(args map[string]any) (string, error)) *Tool

+ func RecallTool(handler func(args map[string]any) (string, error), ...) *Tool

+ func RememberTool(handler func(args map[string]any) (string, error)) *Tool

+ func RequestCredentialTool() *Tool

+ func SQLQueryTool() *Tool

+ func TerminalTool() *Tool

+ func WebFetchTool(cfg *WebSearchConfig) *Tool

+ func WebSearchTool(cfg *WebSearchConfig) *Tool

+ func (t *Tool) EffectivePermission(args map[string]any) PermissionLevel

+ func (t *Tool) ToOpenAIFormat() map[string]any

+ type ToolCallResult struct

+ Metadata map[string]any

+ Observations []Observation

+ Output string

+ type ToolRouter struct

+ func NewToolRouter(registry *Registry) *ToolRouter

+ func (r *ToolRouter) AddAlias(alias, target string) error

+ func (r *ToolRouter) AddRoute(rule RouteRule)

+ func (r *ToolRouter) DisableRoute(name string) error

+ func (r *ToolRouter) EnableRoute(name string) error

+ func (r *ToolRouter) FormatRoutes() string

+ func (r *ToolRouter) ListAliases() map[string]string

+ func (r *ToolRouter) ListRoutes() []RouteRule

+ func (r *ToolRouter) RemoveAlias(alias string)

+ func (r *ToolRouter) RemoveRoute(name string)

+ func (r *ToolRouter) Resolve(name string) (string, error)

+ type TraceRecord struct

+ Annotation string

+ Arguments string

+ DurationMS int64

+ Error string

+ ID string

+ Name string

+ Result string

+ Status string

+ Success bool

+ func NewTraceRecord(name, arguments, result string, duration time.Duration) TraceRecord

+ func NewTraceRecordWithTemplates(name, arguments, result string, duration time.Duration, ...) TraceRecord

+ type TrialOptions struct

+ ProbeCLI bool

+ ProbeTimeout time.Duration

+ TotalBudget time.Duration

+ type TrialResult struct

+ Capability *CapabilitySummary

+ Info *SkillInfo

+ func TrialLoad(stagingRoot string, opts TrialOptions) (*TrialResult, error)

+ type UsageRecord struct

+ Duration time.Duration

+ Success bool

+ Timestamp time.Time

+ ToolName string

+ type UsageStats struct

+ AvgDuration time.Duration

+ FailedCalls int

+ LastUsed time.Time

+ SuccessCalls int

+ ToolName string

+ TotalCalls int

+ TotalDuration time.Duration

+ func (s UsageStats) Format() string

+ type UsageTracker struct

+ func NewUsageTracker() *UsageTracker

+ func (t *UsageTracker) CheckQuota(userID, toolName string) bool

+ func (t *UsageTracker) GetAllUsage(userID string) []UsageStats

+ func (t *UsageTracker) GetQuota(userID, toolName string) *Quota

+ func (t *UsageTracker) GetUsage(userID, toolName string) UsageStats

+ func (t *UsageTracker) IncrementUsage(userID, toolName string)

+ func (t *UsageTracker) ListQuotas(userID string) []Quota

+ func (t *UsageTracker) Record(userID, toolName string, duration time.Duration, success bool)

+ func (t *UsageTracker) RemoveQuota(userID, toolName string)

+ func (t *UsageTracker) SetQuota(userID, toolName, window string, limit int) error

+ type UserSubscription struct

+ AutoRenew bool

+ ExpiresAt time.Time

+ StartedAt time.Time

+ Tier SubTier

+ UserID string

+ func (s *UserSubscription) IsActive() bool

+ type WebSearchConfig struct

+ APIKey string

+ BaseURL string

+ MaxResults int

+ Provider string

+ Proxy string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL