@kernel.chat/kbot 3.99.31 → 3.99.33

package/dist/tools/file-library-tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * File Library tool definitions.
+ *
+ * These mirror ChatGPT's File Library surface: add, list, search, get.
+ * Definitions only — NOT registered here. Wire-up belongs in tools/index.ts.
+ */
+import type { ToolDefinition } from "./index.js";
+export declare const fileLibraryAddTool: ToolDefinition;
+export declare const fileLibraryListTool: ToolDefinition;
+export declare const fileLibrarySearchTool: ToolDefinition;
+export declare const fileLibraryGetTool: ToolDefinition;
+//# sourceMappingURL=file-library-tools.d.ts.map

package/dist/tools/file-library-tools.js

@@ -0,0 +1,191 @@
+/**
+ * File Library tool definitions.
+ *
+ * These mirror ChatGPT's File Library surface: add, list, search, get.
+ * Definitions only — NOT registered here. Wire-up belongs in tools/index.ts.
+ */
+import { getDefaultFileLibrary, } from "../file-library.js";
+const VALID_SOURCES = [
+    "user-upload",
+    "agent-output",
+    "tool-output",
+];
+function lib() {
+    return getDefaultFileLibrary();
+}
+function asString(v) {
+    return v === undefined || v === null ? "" : String(v);
+}
+function fmtEntry(e) {
+    return {
+        id: e.id,
+        name: e.name,
+        mimeType: e.mimeType,
+        size: e.size,
+        createdAt: e.createdAt,
+        source: e.source,
+        tags: e.tags,
+    };
+}
+export const fileLibraryAddTool = {
+    name: "file_library_add",
+    description: "Save a file into the local File Library. Provide content (utf8 string) or base64-encoded bytes. Returns the new entry id and metadata.",
+    tier: "free",
+    parameters: {
+        name: {
+            type: "string",
+            description: "File name (e.g. 'report.md')",
+            required: true,
+        },
+        mimeType: {
+            type: "string",
+            description: "MIME type (e.g. 'text/markdown', 'application/pdf')",
+            required: true,
+        },
+        source: {
+            type: "string",
+            description: "Origin: 'user-upload' | 'agent-output' | 'tool-output'",
+            required: true,
+        },
+        content: {
+            type: "string",
+            description: "UTF-8 text content. Omit if using contentBase64.",
+        },
+        contentBase64: {
+            type: "string",
+            description: "Base64-encoded bytes. Omit if using content.",
+        },
+        tags: {
+            type: "array",
+            description: "Optional tags",
+            items: { type: "string" },
+        },
+    },
+    async execute(args) {
+        const name = asString(args.name);
+        const mimeType = asString(args.mimeType);
+        const sourceRaw = asString(args.source);
+        if (!VALID_SOURCES.includes(sourceRaw)) {
+            return `Error: source must be one of ${VALID_SOURCES.join(", ")}`;
+        }
+        const content = args.content === undefined ? undefined : asString(args.content);
+        const contentBase64 = args.contentBase64 === undefined
+            ? undefined
+            : asString(args.contentBase64);
+        if ((content === undefined && contentBase64 === undefined) ||
+            (content !== undefined && contentBase64 !== undefined)) {
+            return "Error: provide exactly one of `content` or `contentBase64`";
+        }
+        const tags = Array.isArray(args.tags)
+            ? args.tags.filter((t) => typeof t === "string")
+            : undefined;
+        try {
+            const entry = contentBase64 !== undefined
+                ? await lib().addFile({
+                    name,
+                    mimeType,
+                    source: sourceRaw,
+                    buffer: Buffer.from(contentBase64, "base64"),
+                    tags,
+                })
+                : await lib().addFile({
+                    name,
+                    mimeType,
+                    source: sourceRaw,
+                    content,
+                    tags,
+                });
+            return JSON.stringify(fmtEntry(entry), null, 2);
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};
+export const fileLibraryListTool = {
+    name: "file_library_list",
+    description: "List files in the File Library, newest first. Optional filters: limit, since (ISO date), tag.",
+    tier: "free",
+    parameters: {
+        limit: { type: "number", description: "Max entries to return" },
+        since: {
+            type: "string",
+            description: "ISO 8601 date — only entries created at or after this time",
+        },
+        tag: { type: "string", description: "Filter to entries that have this tag" },
+    },
+    async execute(args) {
+        const limit = typeof args.limit === "number" ? args.limit : undefined;
+        const since = args.since === undefined ? undefined : asString(args.since);
+        const tag = args.tag === undefined ? undefined : asString(args.tag);
+        try {
+            const entries = await lib().listFiles({ limit, since, tag });
+            return JSON.stringify({ count: entries.length, entries: entries.map(fmtEntry) }, null, 2);
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};
+export const fileLibrarySearchTool = {
+    name: "file_library_search",
+    description: "Search the File Library. Modes: 'name' (substring on name), 'content' (substring on text contents), 'both' (union).",
+    tier: "free",
+    parameters: {
+        query: { type: "string", description: "Substring to match", required: true },
+        mode: {
+            type: "string",
+            description: "'name' | 'content' | 'both'",
+            required: true,
+        },
+    },
+    async execute(args) {
+        const query = asString(args.query);
+        const mode = asString(args.mode);
+        if (mode !== "name" && mode !== "content" && mode !== "both") {
+            return "Error: mode must be 'name' | 'content' | 'both'";
+        }
+        try {
+            const entries = await lib().searchFiles({ query, mode });
+            return JSON.stringify({ count: entries.length, entries: entries.map(fmtEntry) }, null, 2);
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};
+export const fileLibraryGetTool = {
+    name: "file_library_get",
+    description: "Fetch a file by id. For text mimes returns utf-8 content; for binary returns base64.",
+    tier: "free",
+    parameters: {
+        id: { type: "string", description: "File id (sha256 hex)", required: true },
+        encoding: {
+            type: "string",
+            description: "'utf8' | 'base64' (default: auto by mimeType)",
+        },
+    },
+    async execute(args) {
+        const id = asString(args.id);
+        const encodingArg = args.encoding === undefined ? undefined : asString(args.encoding);
+        try {
+            const got = await lib().getFile(id);
+            if (!got)
+                return `Error: file not found: ${id}`;
+            const { entry, buffer } = got;
+            const isText = /^text\//i.test(entry.mimeType) ||
+                /^application\/(json|yaml|x-yaml|xml|javascript|typescript)$/i.test(entry.mimeType);
+            const encoding = encodingArg === "utf8" || encodingArg === "base64"
+                ? encodingArg
+                : isText
+                    ? "utf8"
+                    : "base64";
+            const content = encoding === "utf8" ? buffer.toString("utf8") : buffer.toString("base64");
+            return JSON.stringify({ entry: fmtEntry(entry), encoding, content }, null, 2);
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};
+//# sourceMappingURL=file-library-tools.js.map

package/dist/tools/image-thoughtful.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { ToolDefinition } from './index.js';
+export declare const imageThoughtfulInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    aspect_ratio: z.ZodDefault<z.ZodOptional<z.ZodEnum<["1:1", "16:9", "9:16", "4:3", "3:4"]>>>;
+    thinking_steps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    style_hints: z.ZodOptional<z.ZodString>;
+    reference_image_url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    aspect_ratio: "1:1" | "16:9" | "9:16" | "4:3" | "3:4";
+    thinking_steps: number;
+    style_hints?: string | undefined;
+    reference_image_url?: string | undefined;
+}, {
+    prompt: string;
+    aspect_ratio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
+    thinking_steps?: number | undefined;
+    style_hints?: string | undefined;
+    reference_image_url?: string | undefined;
+}>;
+export type ImageThoughtfulInput = z.infer<typeof imageThoughtfulInputSchema>;
+export interface ImageThoughtfulOutput {
+    url: string;
+    plan: string;
+    refinements: string[];
+    final_prompt: string;
+}
+export declare function runImageThoughtful(rawInput: unknown, env?: NodeJS.ProcessEnv): Promise<ImageThoughtfulOutput>;
+export declare const imageThoughtfulTool: ToolDefinition;
+//# sourceMappingURL=image-thoughtful.d.ts.map

package/dist/tools/image-thoughtful.js

@@ -0,0 +1,233 @@
+// kbot Image Thoughtful Tool
+// Mirrors OpenAI's "Images 2.0 with thinking": plan → refine (1..N) → generate.
+// The thinking phase uses gpt-4o-mini chat completions; the final generation
+// hits the OpenAI Images API (gpt-image-2). Reference images are forwarded as
+// input_image when supplied.
+import { z } from 'zod';
+// ─────────────────────────────────────────────────────────────────────────
+// Schema
+// ─────────────────────────────────────────────────────────────────────────
+const AspectRatio = z.enum(['1:1', '16:9', '9:16', '4:3', '3:4']);
+export const imageThoughtfulInputSchema = z.object({
+    prompt: z.string().min(1, 'prompt is required'),
+    aspect_ratio: AspectRatio.optional().default('1:1'),
+    thinking_steps: z.number().int().min(1).max(5).optional().default(3),
+    style_hints: z.string().optional(),
+    reference_image_url: z.string().url().optional(),
+});
+// ─────────────────────────────────────────────────────────────────────────
+// Aspect ratio → image API "size"
+// ─────────────────────────────────────────────────────────────────────────
+const SIZE_MAP = {
+    '1:1': '1024x1024',
+    '16:9': '1792x1024',
+    '9:16': '1024x1792',
+    '4:3': '1408x1056',
+    '3:4': '1056x1408',
+};
+// ─────────────────────────────────────────────────────────────────────────
+// OpenAI helpers (built-in fetch, no SDK)
+// ─────────────────────────────────────────────────────────────────────────
+const OPENAI_CHAT_URL = 'https://api.openai.com/v1/chat/completions';
+const OPENAI_IMAGE_URL = 'https://api.openai.com/v1/images/generations';
+const PLANNING_MODEL = 'gpt-4o-mini';
+const IMAGE_MODEL = 'gpt-image-2';
+async function openaiChat(apiKey, messages, opts = {}) {
+    const body = {
+        model: PLANNING_MODEL,
+        messages,
+        temperature: opts.temperature ?? 0.4,
+    };
+    if (opts.jsonMode) {
+        body.response_format = { type: 'json_object' };
+    }
+    const res = await fetch(OPENAI_CHAT_URL, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`OpenAI chat failed: ${res.status} ${res.statusText} ${text}`.trim());
+    }
+    const data = (await res.json());
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+        throw new Error('OpenAI chat returned no content');
+    }
+    return content;
+}
+async function openaiImage(apiKey, prompt, size, referenceImageUrl) {
+    const body = {
+        model: IMAGE_MODEL,
+        prompt,
+        size,
+        n: 1,
+    };
+    if (referenceImageUrl) {
+        body.input_image = referenceImageUrl;
+    }
+    const res = await fetch(OPENAI_IMAGE_URL, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`OpenAI image failed: ${res.status} ${res.statusText} ${text}`.trim());
+    }
+    const data = (await res.json());
+    const url = data.data?.[0]?.url;
+    if (!url) {
+        // gpt-image-* sometimes returns b64; surface that as a data URL
+        const b64 = data.data?.[0]?.b64_json;
+        if (b64)
+            return `data:image/png;base64,${b64}`;
+        throw new Error('OpenAI image returned no url');
+    }
+    return url;
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Plan + refine loop
+// ─────────────────────────────────────────────────────────────────────────
+function planSystemPrompt() {
+    return [
+        'You are an expert art director planning an image before generation.',
+        'Return a JSON object with keys: composition, palette, key_elements, mood, lighting, style.',
+        'Keep each value to one or two sentences. Be concrete and visual.',
+    ].join(' ');
+}
+function critiqueSystemPrompt() {
+    return [
+        'You are a critic refining an image plan. Read the prompt and the current plan,',
+        'identify the single weakest element, and return an improved JSON plan with the',
+        'same keys (composition, palette, key_elements, mood, lighting, style).',
+        'Do not restate the brief — produce the next iteration of the plan only.',
+    ].join(' ');
+}
+function finalPromptSystemPrompt() {
+    return [
+        'You compose the final image-generation prompt. Combine the brief, plan, and any',
+        'style hints into a single cohesive paragraph (no JSON, no headings, no lists).',
+        'Lead with subject and composition, then palette, lighting, mood, and style.',
+    ].join(' ');
+}
+function buildPlanUserContent(input) {
+    const parts = [
+        {
+            type: 'text',
+            text: [
+                `Brief: ${input.prompt}`,
+                `Aspect ratio: ${input.aspect_ratio}`,
+                input.style_hints ? `Style hints: ${input.style_hints}` : null,
+            ]
+                .filter(Boolean)
+                .join('\n'),
+        },
+    ];
+    if (input.reference_image_url) {
+        parts.push({ type: 'input_image', image_url: input.reference_image_url });
+    }
+    return parts;
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Tool definition
+// ─────────────────────────────────────────────────────────────────────────
+export async function runImageThoughtful(rawInput, env = process.env) {
+    const input = imageThoughtfulInputSchema.parse(rawInput);
+    const apiKey = env.OPENAI_API_KEY;
+    if (!apiKey) {
+        throw new Error('OPENAI_API_KEY is not set');
+    }
+    // 1. Plan
+    const plan = await openaiChat(apiKey, [
+        { role: 'system', content: planSystemPrompt() },
+        { role: 'user', content: buildPlanUserContent(input) },
+    ], { jsonMode: true, temperature: 0.5 });
+    // 2. Refine (thinking_steps - 1 critiques; thinking_steps=1 means no refinement)
+    const refinements = [];
+    let currentPlan = plan;
+    for (let i = 1; i < input.thinking_steps; i++) {
+        const next = await openaiChat(apiKey, [
+            { role: 'system', content: critiqueSystemPrompt() },
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: `Brief: ${input.prompt}` },
+                    { type: 'text', text: `Current plan: ${currentPlan}` },
+                ],
+            },
+        ], { jsonMode: true, temperature: 0.5 });
+        refinements.push(next);
+        currentPlan = next;
+    }
+    // 3. Compose final prompt
+    const finalPromptText = await openaiChat(apiKey, [
+        { role: 'system', content: finalPromptSystemPrompt() },
+        {
+            role: 'user',
+            content: [
+                `Brief: ${input.prompt}`,
+                input.style_hints ? `Style hints: ${input.style_hints}` : '',
+                `Plan: ${currentPlan}`,
+            ]
+                .filter(Boolean)
+                .join('\n\n'),
+        },
+    ], { temperature: 0.4 });
+    // 4. Generate
+    const url = await openaiImage(apiKey, finalPromptText, SIZE_MAP[input.aspect_ratio], input.reference_image_url);
+    return {
+        url,
+        plan,
+        refinements,
+        final_prompt: finalPromptText,
+    };
+}
+export const imageThoughtfulTool = {
+    name: 'image_thoughtful',
+    description: 'Generate an image with an explicit plan/refine loop. Plans the image (composition, palette, key elements), critiques and refines the plan, then issues the final OpenAI image generation. Returns the image URL plus the full reasoning trail.',
+    tier: 'pro',
+    parameters: {
+        prompt: {
+            type: 'string',
+            description: 'What to draw — the brief.',
+            required: true,
+        },
+        aspect_ratio: {
+            type: 'string',
+            description: 'One of "1:1", "16:9", "9:16", "4:3", "3:4". Default "1:1".',
+            default: '1:1',
+        },
+        thinking_steps: {
+            type: 'number',
+            description: 'How many plan iterations to run (1..5). Default 3. 1 skips refinement.',
+            default: 3,
+        },
+        style_hints: {
+            type: 'string',
+            description: 'Optional style guidance ("oil painting", "ukiyo-e", "isometric vector").',
+        },
+        reference_image_url: {
+            type: 'string',
+            description: 'Optional URL of a reference image. Passed to the planning model and forwarded to the image API as input_image.',
+        },
+    },
+    async execute(args) {
+        try {
+            const out = await runImageThoughtful(args);
+            return JSON.stringify(out, null, 2);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error: ${message}`;
+        }
+    },
+};
+//# sourceMappingURL=image-thoughtful.js.map

package/dist/tools/index.js

@@ -338,6 +338,7 @@ const LAZY_MODULE_IMPORTS = [
     { path: './stream-vod.js', registerFn: 'registerStreamVODTools' },
     { path: './stream-commands.js', registerFn: 'registerStreamCommandsTools' },
     { path: '../coordinator.js', registerFn: 'registerCoordinatorTools' },
+    { path: './swarm-2026-04.js', registerFn: 'registerSwarm2026Tools' },
 ];
 /** Track whether lazy tools have been registered */
 let lazyToolsRegistered = false;

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { type SecurityReport } from '../agents/security-agent.js';
+export declare const securityAgentScanSchema: z.ZodObject<{
+    target: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["scan", "scan-and-fix", "report-only"]>>;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    mode: "scan" | "scan-and-fix" | "report-only";
+}, {
+    target: string;
+    mode?: "scan" | "scan-and-fix" | "report-only" | undefined;
+}>;
+export declare const securityAgentReportSchema: z.ZodObject<{
+    target: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+}, {
+    target: string;
+}>;
+export interface SecurityAgentToolDef<TArgs, TResult> {
+    name: string;
+    description: string;
+    schema: z.ZodTypeAny;
+    run: (args: TArgs) => Promise<TResult>;
+}
+export declare const securityAgentScan: SecurityAgentToolDef<z.infer<typeof securityAgentScanSchema>, SecurityReport>;
+export declare const securityAgentReport: SecurityAgentToolDef<z.infer<typeof securityAgentReportSchema>, string>;
+export declare const SECURITY_AGENT_TOOLS: (SecurityAgentToolDef<{
+    target: string;
+    mode: "scan" | "scan-and-fix" | "report-only";
+}, SecurityReport> | SecurityAgentToolDef<{
+    target: string;
+}, string>)[];
+//# sourceMappingURL=security-agent-tools.d.ts.map

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

@@ -0,0 +1,30 @@
+// kbot tool definitions for the unified security agent.
+// NOT registered in tools/index.ts — wire them in deliberately when promoting
+// the security agent surface (see guardian/hacker integration notes).
+import { z } from 'zod';
+import { runSecurityAgent } from '../agents/security-agent.js';
+export const securityAgentScanSchema = z.object({
+    target: z.string().describe('Absolute or relative directory to scan'),
+    mode: z.enum(['scan', 'scan-and-fix', 'report-only']).default('scan'),
+});
+export const securityAgentReportSchema = z.object({
+    target: z.string().describe('Directory to scan and produce a Markdown report for'),
+});
+export const securityAgentScan = {
+    name: 'security_agent_scan',
+    description: 'Run the kbot security agent over a directory. Modes: scan | scan-and-fix | report-only. ' +
+        'Returns the full structured SecurityReport.',
+    schema: securityAgentScanSchema,
+    run: async (args) => runSecurityAgent({ target: args.target, mode: args.mode }),
+};
+export const securityAgentReport = {
+    name: 'security_agent_report',
+    description: 'Run the kbot security agent in read-only mode and return only the Markdown summary.',
+    schema: securityAgentReportSchema,
+    run: async (args) => {
+        const report = await runSecurityAgent({ target: args.target, mode: 'report-only' });
+        return report.summary;
+    },
+};
+export const SECURITY_AGENT_TOOLS = [securityAgentScan, securityAgentReport];
+//# sourceMappingURL=security-agent-tools.js.map

package/dist/tools/swarm-2026-04.d.ts

@@ -0,0 +1,2 @@
+export declare function registerSwarm2026Tools(): void;
+//# sourceMappingURL=swarm-2026-04.d.ts.map

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/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