@botbotgo/agent-harness 0.0.294 → 0.0.296

package/dist/protocol/acp/client.js

@@ -33,6 +33,13 @@ function isNotification(value) {
         && typeof value.method === "string"
         && !Object.hasOwn(value, "id");
 }
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    if (!text.trim()) {
+        return undefined;
+    }
+    return JSON.parse(text);
+}
 export function createAcpStdioClient(options) {
     const idPrefix = options.idPrefix?.trim() || "acp";
     let sequence = 0;
@@ -149,3 +156,139 @@ export function createAcpStdioClient(options) {
         },
     };
 }
+export function createAcpHttpClient(options) {
+    let closed = false;
+    let requestSequence = 0;
+    const listeners = new Set();
+    const eventsAbort = new AbortController();
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const completed = (async () => {
+        const response = await fetch(options.eventsUrl, {
+            method: "GET",
+            headers: {
+                accept: "text/event-stream",
+            },
+            signal: eventsAbort.signal,
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`ACP HTTP events request failed with status ${response.status}.`);
+        }
+        resolveReady?.();
+        resolveReady = undefined;
+        rejectReady = undefined;
+        const reader = response.body
+            .pipeThrough(new TextDecoderStream())
+            .getReader();
+        let buffer = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += value;
+                let splitIndex = buffer.indexOf("\n\n");
+                while (splitIndex >= 0) {
+                    const frame = buffer.slice(0, splitIndex);
+                    buffer = buffer.slice(splitIndex + 2);
+                    const dataLines = frame
+                        .split("\n")
+                        .map((line) => line.trimEnd())
+                        .filter((line) => line.startsWith("data:"))
+                        .map((line) => line.slice("data:".length).trim());
+                    if (dataLines.length > 0) {
+                        try {
+                            const parsed = JSON.parse(dataLines.join("\n"));
+                            if (isNotification(parsed)) {
+                                for (const listener of Array.from(listeners)) {
+                                    try {
+                                        listener(parsed);
+                                    }
+                                    catch {
+                                        // Ignore listener failures so one subscriber cannot tear down the transport.
+                                    }
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore malformed SSE payloads.
+                        }
+                    }
+                    splitIndex = buffer.indexOf("\n\n");
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    })().catch((error) => {
+        rejectReady?.(error);
+        resolveReady = undefined;
+        rejectReady = undefined;
+        if (!closed && !(error instanceof DOMException && error.name === "AbortError")) {
+            throw error;
+        }
+    });
+    return {
+        async request(method, params) {
+            if (closed) {
+                throw new Error("ACP http client is closed.");
+            }
+            await ready;
+            const response = await fetch(options.rpcUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: `acp-http-${++requestSequence}`,
+                    method,
+                    ...(params === undefined ? {} : { params }),
+                }),
+            });
+            const parsed = await parseJsonResponse(response);
+            if (!isResponse(parsed)) {
+                throw new Error("ACP http client received a non-JSON-RPC response.");
+            }
+            if ("error" in parsed) {
+                throw new AcpClientError(parsed.error);
+            }
+            return parsed.result;
+        },
+        async notify(method, params) {
+            if (closed) {
+                throw new Error("ACP http client is closed.");
+            }
+            await ready;
+            await fetch(options.rpcUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    method,
+                    ...(params === undefined ? {} : { params }),
+                }),
+            });
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        async close() {
+            closed = true;
+            eventsAbort.abort();
+            await completed.catch(() => undefined);
+            listeners.clear();
+        },
+    };
+}

package/dist/resource/resource-impl.js

@@ -634,13 +634,30 @@ async function loadRemoteResource(source, workspaceRoot) {
 export async function ensureResourceSources(sources = [], workspaceRoot = process.cwd()) {
     await Promise.all(sources.map((source) => loadRemoteResource(source, workspaceRoot)));
 }
+function resolveBundledFallbackRoot(kind) {
+    const suffix = kind === "skills" ? ["resources", "skills"] : ["config"];
+    const candidates = [
+        path.resolve(resourceDir, "..", ...suffix),
+        path.resolve(resourceDir, "..", "..", ...suffix),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
 export function defaultResourceSkillsRoot() {
-    const provider = requireLocalResource("default resource skill resolution");
-    return preferProviderValue(provider, (candidate) => candidate.defaultResourceSkillsRoot?.(), (candidate) => candidate.builtinSkillsRoot?.()) ?? "";
+    if (localResource) {
+        return preferProviderValue(localResource, (candidate) => candidate.defaultResourceSkillsRoot?.(), (candidate) => candidate.builtinSkillsRoot?.()) ?? "";
+    }
+    return resolveBundledFallbackRoot("skills") ?? requireLocalResource("default resource skill resolution").defaultResourceSkillsRoot?.() ?? "";
 }
 export function defaultResourceConfigRoot() {
-    const provider = requireLocalResource("default resource config resolution");
-    return (preferProviderValue(provider, (candidate) => candidate.defaultResourceConfigRoot?.(), (candidate) => candidate.builtinConfigRoot?.() ?? candidate.builtinDefaultsRoot?.()) ?? "");
+    if (localResource) {
+        return (preferProviderValue(localResource, (candidate) => candidate.defaultResourceConfigRoot?.(), (candidate) => candidate.builtinConfigRoot?.() ?? candidate.builtinDefaultsRoot?.()) ?? "");
+    }
+    return resolveBundledFallbackRoot("config") ?? requireLocalResource("default resource config resolution").defaultResourceConfigRoot?.() ?? "";
 }
 export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
     await ensureResourceSources(sources, workspaceRoot);

package/dist/resources/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@botbotgo/agent-harness-default-resources",
+  "private": true,
+  "type": "module",
+  "description": "Default starter skills packaged with the repository workspace."
+}

package/dist/resources/skills/approval-execution-policy/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: approval-execution-policy
+description: Treat side effects, command execution, and external actions as governed runtime decisions.
+---
+
+# Approval And Execution Policy
+
+Use this skill whenever the task may write files, run commands, access external systems, send messages, or trigger other side effects.
+
+## Workflow
+
+1. Classify the next action as low risk or side-effectful.
+2. Continue directly only when the action is clearly safe and allowed by the runtime.
+3. Request approval before destructive, external, privileged, or ambiguous actions.
+4. After approval, execute only the action that was approved and report the result plainly.
+
+## Rules
+
+- Do not hide risky commands or external calls inside a larger action.
+- If the safest next step is to inspect more context, inspect first.
+- If approval is needed, explain why in one concrete sentence.
+- When an action is denied or unavailable, continue with the safest useful fallback instead of pretending it succeeded.

package/dist/resources/skills/completion-discipline/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: completion-discipline
+description: Finish the task cleanly, verify what you can, and leave the user with a clear outcome.
+---
+
+# Completion Discipline
+
+Use this skill at the end of any non-trivial task.
+
+## Workflow
+
+1. Check whether the user's request is actually complete.
+2. Verify the changed or inspected area with the smallest relevant check.
+3. Distinguish completed work, unverified areas, and blocked follow-up.
+4. Return a concise final answer that makes the outcome easy to trust.
+
+## Rules
+
+- Do not stop at a half-finished plan when a concrete next action is still available.
+- Do not claim success without stating what was verified.
+- If tests or commands were not run, say so explicitly.
+- Prefer a short, high-signal wrap-up over a changelog dump.

package/dist/resources/skills/delegation-discipline/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: delegation-discipline
+description: Delegate only when a subagent is clearly the best fit and the handoff can be bounded cleanly.
+---
+
+# Delegation Discipline
+
+Use this skill when the runtime exposes subagents and the task may benefit from delegation.
+
+## Workflow
+
+1. Decide whether the host can finish the next critical-path step itself.
+2. Delegate only if a subagent has a clearly matching purpose and the handoff can be stated in one bounded ask.
+3. Keep blocking work local when waiting on a delegated answer would only add latency.
+4. Integrate delegated output into one final response instead of forwarding raw subagent output.
+
+## Rules
+
+- Do not delegate by reflex.
+- Do not split work into subagents unless that separation improves quality or speed.
+- Do not ask a subagent to rediscover context the host already has unless the subagent truly needs it.
+- If no suitable subagent exists, continue locally.

package/dist/resources/skills/safe-editing/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: safe-editing
+description: Make the smallest workspace change that solves the task, then verify it.
+---
+
+# Safe Editing
+
+Use this skill when the request requires changing files, prompts, configuration, or generated content in the workspace.
+
+## Workflow
+
+1. Identify the exact target file or files before editing.
+2. Prefer a localized change over rewriting large blocks.
+3. Keep naming, structure, and surrounding conventions consistent with the existing workspace.
+4. After the edit, run the smallest reasonable verification step and report the outcome.
+
+## Rules
+
+- Do not rewrite whole files when a bounded edit is enough.
+- Do not silently undo unrelated user work.
+- If a change could have side effects, call them out explicitly.
+- If verification is blocked, explain what was checked and what remains unverified.

package/dist/resources/skills/workspace-inspection/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: workspace-inspection
+description: Inspect the current workspace before making claims or edits.
+---
+
+# Workspace Inspection
+
+Use this skill when the request depends on the current workspace, repository, files, configuration, or local runtime state.
+
+## Workflow
+
+1. Start with lightweight discovery such as `list_files` or `search_files`.
+2. Read only the files needed to establish the relevant facts.
+3. Ground every conclusion in inspected workspace evidence rather than memory or guesses.
+4. If the workspace does not contain the needed evidence, say that clearly before proposing a next step.
+
+## Rules
+
+- Do not claim a file, config value, dependency, or code path exists until you inspected it.
+- Prefer the smallest fact set that can support the next action.
+- When the user asks for analysis only, stop after inspection and a clear explanation.
+- When the user asks for a change, inspect first and then move to the smallest safe edit.

package/dist/runtime/adapter/runtime-adapter-support.d.ts

@@ -1,5 +1,4 @@
-export declare function truncateLines(lines: string[], maxChars?: number): string;
-export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): {
+export type BuiltinTodoSnapshot = {
     total: number;
     pending: number;
     completed: number;
@@ -8,3 +7,6 @@ export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unkn
         status: string;
     }>;
 };
+export declare function truncateLines(lines: string[], maxChars?: number): string;
+export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): BuiltinTodoSnapshot;
+export declare function formatBuiltinTodoSnapshot(snapshot: BuiltinTodoSnapshot): string;

package/dist/runtime/adapter/runtime-adapter-support.js

@@ -27,3 +27,13 @@ export function summarizeBuiltinWriteTodosArgs(args) {
         items,
     };
 }
+export function formatBuiltinTodoSnapshot(snapshot) {
+    if (snapshot.total === 0) {
+        return "No todos tracked.";
+    }
+    const lines = [
+        `Tracked ${snapshot.total} todo item(s): ${snapshot.pending} pending, ${snapshot.completed} completed.`,
+        ...snapshot.items.map((item, index) => `${index + 1}. [${item.status}] ${item.content}`),
+    ];
+    return truncateLines(lines);
+}

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -105,6 +105,80 @@ export type BuiltinMiddlewareBackend = {
         exitCode: number | null;
         truncated: boolean;
     };
+    fetchUrl?: (url: string) => Promise<string | {
+        content?: string | Uint8Array;
+        body?: string | Uint8Array;
+        status?: number;
+        statusText?: string;
+        error?: string;
+    }> | string | {
+        content?: string | Uint8Array;
+        body?: string | Uint8Array;
+        status?: number;
+        statusText?: string;
+        error?: string;
+    };
+    httpRequest?: (request: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+    }) => Promise<string | {
+        content?: string | Uint8Array;
+        body?: string | Uint8Array;
+        status?: number;
+        statusText?: string;
+        headers?: Record<string, string>;
+        error?: string;
+    }> | string | {
+        content?: string | Uint8Array;
+        body?: string | Uint8Array;
+        status?: number;
+        statusText?: string;
+        headers?: Record<string, string>;
+        error?: string;
+    };
+    sendMessage?: (message: {
+        destination: string;
+        message: string;
+        subject?: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<string | {
+        ok?: boolean;
+        id?: string;
+        error?: string;
+    }> | string | {
+        ok?: boolean;
+        id?: string;
+        error?: string;
+    };
+    requestApproval?: (request: {
+        action: string;
+        reason?: string;
+        details?: Record<string, unknown>;
+    }) => Promise<string | {
+        approved?: boolean;
+        id?: string;
+        error?: string;
+    }> | string | {
+        approved?: boolean;
+        id?: string;
+        error?: string;
+    };
+    scheduleTask?: (task: {
+        instruction: string;
+        when: string;
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<string | {
+        ok?: boolean;
+        id?: string;
+        error?: string;
+    }> | string | {
+        ok?: boolean;
+        id?: string;
+        error?: string;
+    };
 };
 export type BuiltinExecutableTool = {
     name: string;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
-import { summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+import { formatBuiltinTodoSnapshot, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
 function toDisplayContent(content) {
     if (typeof content === "string") {
         return content;
@@ -11,8 +11,31 @@ function toDisplayContent(content) {
     }
     return "";
 }
+function notAvailable(toolName, capability) {
+    return `Error: ${toolName} is not available. This backend does not support ${capability}.`;
+}
+function formatHttpResponse(result) {
+    if (result?.error) {
+        return result.error;
+    }
+    const content = toDisplayContent(result?.body ?? result?.content);
+    const status = typeof result?.status === "number" ? `${result.status}${result.statusText ? ` ${result.statusText}` : ""}` : null;
+    const headerLines = result?.headers ? Object.entries(result.headers).map(([key, value]) => `${key}: ${value}`) : [];
+    const lines = [
+        ...(status ? [`Status: ${status}`] : []),
+        ...(headerLines.length > 0 ? ["Headers:", ...headerLines] : []),
+        ...(content ? ["Body:", content] : []),
+    ];
+    return lines.length > 0 ? lines.join("\n") : "Request completed.";
+}
 export async function createBuiltinMiddlewareTools(backend, options) {
     const tools = new Map();
+    let todoSnapshot = {
+        total: 0,
+        pending: 0,
+        completed: 0,
+        items: [],
+    };
     tools.set("write_todos", {
         name: "write_todos",
         schema: z.object({
@@ -21,6 +44,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         invoke: async (input) => {
             const args = isRecord(input) ? input : {};
             const summary = summarizeBuiltinWriteTodosArgs(args);
+            todoSnapshot = summary;
             return {
                 ok: true,
                 tool: "write_todos",
@@ -29,6 +53,16 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             };
         },
     });
+    tools.set("read_todos", {
+        name: "read_todos",
+        schema: z.object({}).passthrough(),
+        invoke: async () => ({
+            ok: true,
+            tool: "read_todos",
+            message: formatBuiltinTodoSnapshot(todoSnapshot),
+            summary: todoSnapshot,
+        }),
+    });
     tools.set("ls", {
         name: "ls",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
@@ -48,6 +82,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             return truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`));
         },
     });
+    tools.set("list_files", {
+        name: "list_files",
+        schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
+        invoke: async (input) => tools.get("ls").invoke(input),
+    });
     tools.set("read_file", {
         name: "read_file",
         schema: z.object({
@@ -142,6 +181,25 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             return truncateLines(lines);
         },
     });
+    tools.set("search_files", {
+        name: "search_files",
+        schema: z.object({
+            query: z.string(),
+            path: z.string().optional().default("/"),
+            glob: z.string().nullable().optional(),
+            search_type: z.enum(["content", "path"]).optional().default("content"),
+        }).passthrough(),
+        invoke: async (input) => {
+            const typed = isRecord(input) ? input : {};
+            const query = typeof typed.query === "string" ? typed.query : "";
+            const path = typeof typed.path === "string" ? typed.path : "/";
+            const globPattern = typeof typed.glob === "string" ? typed.glob : null;
+            const searchType = typed.search_type === "path" ? "path" : "content";
+            return searchType === "path"
+                ? tools.get("glob").invoke({ pattern: query, path })
+                : tools.get("grep").invoke({ pattern: query, path, glob: globPattern });
+        },
+    });
     tools.set("execute", {
         name: "execute",
         schema: z.object({ command: z.string() }).passthrough(),
@@ -161,6 +219,131 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             return parts.join("");
         },
     });
+    tools.set("run_command", {
+        name: "run_command",
+        schema: z.object({ command: z.string() }).passthrough(),
+        invoke: async (input) => tools.get("execute").invoke(input),
+    });
+    tools.set("fetch_url", {
+        name: "fetch_url",
+        schema: z.object({ url: z.string() }).passthrough(),
+        invoke: async (input) => {
+            if (typeof backend.fetchUrl !== "function") {
+                return notAvailable("fetch_url", "URL fetching");
+            }
+            const typed = isRecord(input) ? input : {};
+            const result = await Promise.resolve(backend.fetchUrl(typeof typed.url === "string" ? typed.url : ""));
+            if (typeof result === "string") {
+                return result;
+            }
+            return formatHttpResponse(result);
+        },
+    });
+    tools.set("http_request", {
+        name: "http_request",
+        schema: z.object({
+            url: z.string(),
+            method: z.string().optional(),
+            headers: z.record(z.string(), z.string()).optional(),
+            body: z.string().optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            if (typeof backend.httpRequest !== "function") {
+                return notAvailable("http_request", "structured HTTP requests");
+            }
+            const typed = isRecord(input) ? input : {};
+            const result = await Promise.resolve(backend.httpRequest({
+                url: typeof typed.url === "string" ? typed.url : "",
+                method: typeof typed.method === "string" ? typed.method : undefined,
+                headers: typed.headers && typeof typed.headers === "object" && !Array.isArray(typed.headers)
+                    ? Object.fromEntries(Object.entries(typed.headers).filter(([, value]) => typeof value === "string"))
+                    : undefined,
+                body: typeof typed.body === "string" ? typed.body : undefined,
+            }));
+            if (typeof result === "string") {
+                return result;
+            }
+            return formatHttpResponse(result);
+        },
+    });
+    tools.set("send_message", {
+        name: "send_message",
+        schema: z.object({
+            destination: z.string(),
+            message: z.string(),
+            subject: z.string().optional(),
+            metadata: z.record(z.string(), z.unknown()).optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            if (typeof backend.sendMessage !== "function") {
+                return notAvailable("send_message", "message delivery");
+            }
+            const typed = isRecord(input) ? input : {};
+            const result = await Promise.resolve(backend.sendMessage({
+                destination: typeof typed.destination === "string" ? typed.destination : "",
+                message: typeof typed.message === "string" ? typed.message : "",
+                subject: typeof typed.subject === "string" ? typed.subject : undefined,
+                metadata: isRecord(typed.metadata) ? typed.metadata : undefined,
+            }));
+            if (typeof result === "string") {
+                return result;
+            }
+            return result?.error ?? `Message sent to '${typeof typed.destination === "string" ? typed.destination : ""}'${result?.id ? ` (id: ${result.id})` : ""}.`;
+        },
+    });
+    tools.set("request_approval", {
+        name: "request_approval",
+        schema: z.object({
+            action: z.string(),
+            reason: z.string().optional(),
+            details: z.record(z.string(), z.unknown()).optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            if (typeof backend.requestApproval !== "function") {
+                return notAvailable("request_approval", "approval requests");
+            }
+            const typed = isRecord(input) ? input : {};
+            const result = await Promise.resolve(backend.requestApproval({
+                action: typeof typed.action === "string" ? typed.action : "",
+                reason: typeof typed.reason === "string" ? typed.reason : undefined,
+                details: isRecord(typed.details) ? typed.details : undefined,
+            }));
+            if (typeof result === "string") {
+                return result;
+            }
+            if (result?.error) {
+                return result.error;
+            }
+            return result?.approved === true
+                ? `Approval granted for '${typeof typed.action === "string" ? typed.action : ""}'${result.id ? ` (id: ${result.id})` : ""}.`
+                : `Approval requested for '${typeof typed.action === "string" ? typed.action : ""}'${result?.id ? ` (id: ${result.id})` : ""}.`;
+        },
+    });
+    tools.set("schedule_task", {
+        name: "schedule_task",
+        schema: z.object({
+            instruction: z.string(),
+            when: z.string(),
+            name: z.string().optional(),
+            metadata: z.record(z.string(), z.unknown()).optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            if (typeof backend.scheduleTask !== "function") {
+                return notAvailable("schedule_task", "task scheduling");
+            }
+            const typed = isRecord(input) ? input : {};
+            const result = await Promise.resolve(backend.scheduleTask({
+                instruction: typeof typed.instruction === "string" ? typed.instruction : "",
+                when: typeof typed.when === "string" ? typed.when : "",
+                name: typeof typed.name === "string" ? typed.name : undefined,
+                metadata: isRecord(typed.metadata) ? typed.metadata : undefined,
+            }));
+            if (typeof result === "string") {
+                return result;
+            }
+            return result?.error ?? `Scheduled task '${typeof typed.name === "string" ? typed.name : typeof typed.instruction === "string" ? typed.instruction : ""}' for ${typeof typed.when === "string" ? typed.when : ""}${result?.id ? ` (id: ${result.id})` : ""}.`;
+        },
+    });
     if (options.includeTaskTool && options.invokeTaskTool) {
         tools.set("task", {
             name: "task",
@@ -170,6 +353,14 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             }).passthrough(),
             invoke: options.invokeTaskTool,
         });
+        tools.set("delegate_task", {
+            name: "delegate_task",
+            schema: z.object({
+                description: z.string(),
+                subagent_type: z.string(),
+            }).passthrough(),
+            invoke: async (input) => tools.get("task").invoke(input),
+        });
     }
     return tools;
 }