@kernel.chat/kbot 3.99.31 → 3.99.34

package/dist/tools/swarm-2026-04.js

@@ -0,0 +1,91 @@
+// Tools landed via the 2026-04 capability swarm — parity with OpenClaw +
+// ChatGPT/Codex April 2026 ships. Single registration entry-point so the
+// lazy registry picks them up alongside everything else.
+import { registerTool } from './index.js';
+import { imageThoughtfulTool } from './image-thoughtful.js';
+import { channelSendTool, channelReceiveTool } from './channel-tools.js';
+import { fileLibraryAddTool, fileLibraryListTool, fileLibrarySearchTool, fileLibraryGetTool, } from './file-library-tools.js';
+import { workspaceAgentTools } from './workspace-agent-tools.js';
+import { computerCoordinatorTools } from './computer-coordinator-tools.js';
+import { SECURITY_AGENT_TOOLS } from './security-agent-tools.js';
+import { anthropicManagedAgentTools } from './anthropic-managed-agents-tools.js';
+function adaptCoordinatorTool(t) {
+    const props = t.inputSchema.properties ?? {};
+    const required = new Set(t.inputSchema.required ?? []);
+    const parameters = {};
+    for (const [key, val] of Object.entries(props)) {
+        parameters[key] = {
+            type: val.type ?? 'string',
+            description: val.description ?? '',
+            required: required.has(key),
+            ...(val.items ? { items: val.items } : {}),
+        };
+    }
+    return {
+        name: t.name,
+        description: t.description,
+        parameters,
+        execute: async (args) => {
+            try {
+                const res = await t.handler(args);
+                return typeof res === 'string' ? res : JSON.stringify(res, null, 2);
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+        tier: 'free',
+    };
+}
+function adaptSecurityTool(t) {
+    // zod object shape extraction — best-effort parameter map for the API surface
+    const shape = t.schema._def?.shape?.() ??
+        t.schema.shape ??
+        {};
+    const parameters = {};
+    for (const [key, zodType] of Object.entries(shape)) {
+        const optional = typeof zodType.isOptional === 'function'
+            ? zodType.isOptional()
+            : false;
+        parameters[key] = {
+            type: 'string',
+            description: zodType.description ?? '',
+            required: !optional,
+        };
+    }
+    return {
+        name: t.name,
+        description: t.description,
+        parameters,
+        execute: async (args) => {
+            try {
+                const parsed = t.schema.parse(args);
+                const res = await t.run(parsed);
+                return typeof res === 'string' ? res : JSON.stringify(res, null, 2);
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+        tier: 'free',
+    };
+}
+export function registerSwarm2026Tools() {
+    registerTool(imageThoughtfulTool);
+    registerTool(channelSendTool);
+    registerTool(channelReceiveTool);
+    registerTool(fileLibraryAddTool);
+    registerTool(fileLibraryListTool);
+    registerTool(fileLibrarySearchTool);
+    registerTool(fileLibraryGetTool);
+    for (const t of workspaceAgentTools)
+        registerTool(t);
+    for (const t of anthropicManagedAgentTools)
+        registerTool(t);
+    for (const t of computerCoordinatorTools)
+        registerTool(adaptCoordinatorTool(t));
+    for (const t of SECURITY_AGENT_TOOLS) {
+        registerTool(adaptSecurityTool(t));
+    }
+}
+//# sourceMappingURL=swarm-2026-04.js.map

package/dist/tools/visa-payments.js

@@ -132,7 +132,7 @@ export function registerVisaPaymentTools() {
     });
     registerTool({
         name: 'visa_purchase',
-        description: 'Purchase a digital resource (API key, domain, cloud credits, SaaS subscription) via Visa CLI. The agent can autonomously buy resources needed for task completion.',
+        description: 'Purchase a digital resource (API key, domain, cloud credits, SaaS subscription) via the Visa CLI on the user\'s machine. The user\'s configured spend limit applies; purchases over $100 require manual confirmation in the CLI. Use only when the user has authorized a purchase.',
         parameters: {
             service: { type: 'string', description: 'Service name (e.g., "vercel", "aws", "namecheap", "openai")', required: true },
             product: { type: 'string', description: 'Product or plan to purchase', required: true },

package/dist/tools/workspace-agent-tools.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Workspace Agent kbot tool definitions.
+ *
+ * NOT registered in tools/index.ts. Wire up via `registerWorkspaceAgentTools()`
+ * from a higher-level bootstrap once the feature is shipped.
+ *
+ * Each tool returns a string (the kbot tool contract). State persists via
+ * the WorkspaceAgent class — file at <root>/<id>.json.
+ */
+import type { ToolDefinition } from './index.js';
+export declare const workspaceAgentCreate: ToolDefinition;
+export declare const workspaceAgentStart: ToolDefinition;
+export declare const workspaceAgentResume: ToolDefinition;
+export declare const workspaceAgentStatus: ToolDefinition;
+export declare const workspaceAgentStop: ToolDefinition;
+export declare const workspaceAgentList: ToolDefinition;
+/** Convenience array — caller can iterate to register all six. */
+export declare const workspaceAgentTools: ToolDefinition[];
+//# sourceMappingURL=workspace-agent-tools.d.ts.map

package/dist/tools/workspace-agent-tools.js

@@ -0,0 +1,191 @@
+/**
+ * Workspace Agent kbot tool definitions.
+ *
+ * NOT registered in tools/index.ts. Wire up via `registerWorkspaceAgentTools()`
+ * from a higher-level bootstrap once the feature is shipped.
+ *
+ * Each tool returns a string (the kbot tool contract). State persists via
+ * the WorkspaceAgent class — file at <root>/<id>.json.
+ */
+import { WorkspaceAgent, } from '../workspace-agents.js';
+function getAgent(opts) {
+    return new WorkspaceAgent(opts ?? {});
+}
+function fmt(value) {
+    if (typeof value === 'string')
+        return value;
+    return '```json\n' + JSON.stringify(value, null, 2) + '\n```';
+}
+function parseJsonArray(raw, field) {
+    if (raw === undefined || raw === null || raw === '')
+        return [];
+    if (Array.isArray(raw))
+        return raw.map(String);
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return [];
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!Array.isArray(parsed)) {
+                throw new Error(`${field} must be a JSON array`);
+            }
+            return parsed.map(String);
+        }
+        catch (e) {
+            // accept comma-separated as a convenience
+            if (!trimmed.startsWith('[')) {
+                return trimmed
+                    .split(',')
+                    .map(s => s.trim())
+                    .filter(Boolean);
+            }
+            throw e;
+        }
+    }
+    throw new Error(`${field} must be a string or array`);
+}
+export const workspaceAgentCreate = {
+    name: 'workspace_agent_create',
+    description: 'Create a long-running named workspace agent. Persists at ~/.kbot/workspace-agents/<id>.json. ' +
+        'Names must be unique per workspace. Permissions enforced via allowedTools whitelist + scopes.',
+    parameters: {
+        name: {
+            type: 'string',
+            description: 'Unique name for this agent in the workspace.',
+            required: true,
+        },
+        mission: {
+            type: 'string',
+            description: '1–3 sentence mission the agent will pursue across sessions.',
+            required: true,
+        },
+        allowedTools: {
+            type: 'string',
+            description: 'JSON array (or comma-separated list) of tool names this agent may invoke. Empty = no tool calls.',
+        },
+        scopes: {
+            type: 'string',
+            description: 'JSON array (or comma-separated list) of capability scopes, e.g. ["read:files","write:tools","invoke:slack"].',
+        },
+    },
+    tier: 'free',
+    async execute(args) {
+        try {
+            const allowedTools = parseJsonArray(args.allowedTools, 'allowedTools');
+            const scopes = parseJsonArray(args.scopes, 'scopes');
+            const result = await getAgent().create({
+                name: String(args.name),
+                mission: String(args.mission),
+                allowedTools,
+                scopes,
+            });
+            return fmt({ created: result });
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+export const workspaceAgentStart = {
+    name: 'workspace_agent_start',
+    description: 'Start a workspace agent on a task. Transitions status to "running", invokes the planner, persists tool calls into history.',
+    parameters: {
+        agentId: { type: 'string', description: 'Agent id from create.', required: true },
+        taskInput: {
+            type: 'string',
+            description: 'Task prompt to plan and execute.',
+            required: true,
+        },
+    },
+    tier: 'free',
+    async execute(args) {
+        try {
+            const result = await getAgent().start(String(args.agentId), String(args.taskInput));
+            return fmt({ started: result });
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+export const workspaceAgentResume = {
+    name: 'workspace_agent_resume',
+    description: 'Resume a paused or failed workspace agent. Loads state from disk and transitions to running.',
+    parameters: {
+        agentId: { type: 'string', description: 'Agent id.', required: true },
+    },
+    tier: 'free',
+    async execute(args) {
+        try {
+            const state = await getAgent().resume(String(args.agentId));
+            return fmt({
+                resumed: { id: state.id, name: state.name, status: state.status },
+            });
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+export const workspaceAgentStatus = {
+    name: 'workspace_agent_status',
+    description: 'Get full state for a workspace agent (status, history, plan).',
+    parameters: {
+        agentId: { type: 'string', description: 'Agent id.', required: true },
+    },
+    tier: 'free',
+    async execute(args) {
+        try {
+            const state = await getAgent().status(String(args.agentId));
+            return fmt(state);
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+export const workspaceAgentStop = {
+    name: 'workspace_agent_stop',
+    description: 'Stop a running workspace agent. Transitions status to "paused".',
+    parameters: {
+        agentId: { type: 'string', description: 'Agent id.', required: true },
+    },
+    tier: 'free',
+    async execute(args) {
+        try {
+            const state = await getAgent().stop(String(args.agentId));
+            return fmt({
+                stopped: { id: state.id, name: state.name, status: state.status },
+            });
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+export const workspaceAgentList = {
+    name: 'workspace_agent_list',
+    description: 'List all workspace agents in this workspace.',
+    parameters: {},
+    tier: 'free',
+    async execute() {
+        try {
+            const list = await getAgent().list();
+            return fmt({ agents: list, count: list.length });
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+/** Convenience array — caller can iterate to register all six. */
+export const workspaceAgentTools = [
+    workspaceAgentCreate,
+    workspaceAgentStart,
+    workspaceAgentResume,
+    workspaceAgentStatus,
+    workspaceAgentStop,
+    workspaceAgentList,
+];
+//# sourceMappingURL=workspace-agent-tools.js.map

package/dist/workspace-agents.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Workspace Agents — long-running named agents bound to a workspace with
+ * permissions and resumable state. Parity with OpenAI's Workspace Agents
+ * (Apr 2026). Wraps the hierarchical planner at ./planner/hierarchical/.
+ *
+ * State JSON shape (one file per agent at <root>/<id>.json):
+ *   { id, name, mission, allowedTools, scopes, status, createdAt, updatedAt,
+ *     currentPlanId?, history: [{ ts, event, data }] }
+ *
+ * Storage root: process.env.KBOT_WORKSPACE_AGENTS_ROOT
+ *               ?? <homedir>/.kbot/workspace-agents
+ *
+ * Permissions: every tool invocation must pass through `gate(toolName)` which
+ * checks `allowedTools`. Scopes are recorded but enforcement is per-tool via
+ * the allowedTools whitelist.
+ */
+import type { AgentOptions } from './agent.js';
+export type WorkspaceAgentStatus = 'idle' | 'running' | 'paused' | 'completed' | 'failed';
+export type Scope = string;
+export interface HistoryEvent {
+    ts: string;
+    event: string;
+    data?: unknown;
+}
+export interface WorkspaceAgentState {
+    id: string;
+    name: string;
+    mission: string;
+    allowedTools: string[];
+    scopes: Scope[];
+    status: WorkspaceAgentStatus;
+    createdAt: string;
+    updatedAt: string;
+    currentPlanId?: string;
+    history: HistoryEvent[];
+}
+export interface CreateOptions {
+    name: string;
+    mission: string;
+    allowedTools?: string[];
+    scopes?: Scope[];
+}
+export interface CreateResult {
+    id: string;
+    name: string;
+}
+export interface StartResult {
+    id: string;
+    status: WorkspaceAgentStatus;
+    planId?: string;
+    steps: unknown[];
+}
+export interface ListEntry {
+    id: string;
+    name: string;
+    status: WorkspaceAgentStatus;
+}
+export declare class ScopeError extends Error {
+    readonly toolName: string;
+    constructor(toolName: string, message?: string);
+}
+export declare class WorkspaceAgentError extends Error {
+    constructor(message: string);
+}
+export declare function defaultRoot(): string;
+/** A single tool call surfaced by the planner, ready to be gated + recorded. */
+export interface PlannerToolCall {
+    tool: string;
+    args?: unknown;
+    result?: unknown;
+}
+export interface PlannerStartResult {
+    planId: string;
+    steps: unknown[];
+    /**
+     * Optional list of tool calls the planner produced. When present, the
+     * WorkspaceAgent will run each through `gate()` and `recordToolCall()`,
+     * capturing `tool_blocked` events for any that ScopeError out.
+     */
+    toolCalls?: PlannerToolCall[];
+    /**
+     * Free-form notes the planner wants surfaced as history events. Each entry
+     * becomes a `planner_note` event on the agent's timeline.
+     */
+    notes?: string[];
+}
+export type PlannerStartFn = (taskInput: string, state: WorkspaceAgentState, agentOpts?: AgentOptions | null) => Promise<PlannerStartResult>;
+/**
+ * Default planner adapter — implements the 3-tier strategy:
+ *
+ *   Tier 1: KBOT_PLANNER=hierarchical AND non-null agentOpts → real
+ *           HierarchicalPlanner.planAndExecute. Tool calls extracted from
+ *           the resulting Action.steps and surfaced for gating.
+ *   Tier 2: HierarchicalPlanner module loadable but no agentOpts → call
+ *           createGoal only; emit a TODO note; return early.
+ *   Tier 3: Module import fails (e.g. test env) → deterministic stub
+ *           `{ planId: 'stub', steps: [] }`.
+ *
+ * The function never throws on planner-internal failures: each tier degrades
+ * to the next so the WorkspaceAgent.start() lifecycle stays predictable.
+ */
+export declare const defaultPlannerStart: PlannerStartFn;
+export interface WorkspaceAgentOptions {
+    /** Override storage root. Defaults to env or ~/.kbot/workspace-agents. */
+    root?: string;
+    /** Override planner adapter (used by tests). */
+    plannerStart?: PlannerStartFn;
+}
+export declare class WorkspaceAgent {
+    private readonly root;
+    private readonly plannerStart;
+    constructor(opts?: WorkspaceAgentOptions);
+    create(opts: CreateOptions): Promise<CreateResult>;
+    start(agentId: string, taskInput: string, agentOpts?: AgentOptions | null): Promise<StartResult>;
+    resume(agentId: string): Promise<WorkspaceAgentState>;
+    stop(agentId: string): Promise<WorkspaceAgentState>;
+    status(agentId: string): Promise<WorkspaceAgentState>;
+    list(): Promise<ListEntry[]>;
+    /**
+     * Permission gate. Throws ScopeError if the tool isn't in allowedTools and
+     * appends a `tool_denied` event to history. On allow, appends `tool_allowed`.
+     */
+    gate(agentId: string, toolName: string): Promise<void>;
+    /**
+     * Append a tool-call record to the agent's history. Caller must call
+     * `gate()` first; this method does NOT enforce permissions.
+     */
+    recordToolCall(agentId: string, toolName: string, args: unknown, result?: unknown): Promise<void>;
+    private appendEvent;
+    private requireState;
+}
+//# sourceMappingURL=workspace-agents.d.ts.map