@gugacoder/agentic-sdk 0.2.0

package/dist/tools/bash.d.ts

@@ -0,0 +1,550 @@
+export declare function createBashTool(opts?: {
+    autoApprove?: boolean;
+}): ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("ai").FlexibleSchema<string>;
+    execute?: never;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type?: undefined | "function";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("ai").FlexibleSchema<string>;
+    execute?: never;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "dynamic";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("ai").FlexibleSchema<string>;
+    execute?: never;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    supportsDeferredResults?: boolean;
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type?: undefined | "function";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "dynamic";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    supportsDeferredResults?: boolean;
+});
+export declare const bashTool: ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("ai").FlexibleSchema<string>;
+    execute?: never;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type?: undefined | "function";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("ai").FlexibleSchema<string>;
+    execute?: never;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "dynamic";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("ai").FlexibleSchema<string>;
+    execute?: never;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    supportsDeferredResults?: boolean;
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type?: undefined | "function";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "dynamic";
+}) | ({
+    description?: string;
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("ai").FlexibleSchema<{
+        command: string;
+        timeout?: number | undefined;
+    }>;
+    inputExamples?: {
+        input: NoInfer<{
+            command: string;
+            timeout?: number | undefined;
+        }>;
+    }[] | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }> | undefined;
+    strict?: boolean;
+    onInputStart?: (options: import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+    } & import("ai").ToolExecutionOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
+} & {
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            command: string;
+            timeout?: number | undefined;
+        };
+        output: string;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    supportsDeferredResults?: boolean;
+});

package/dist/tools/bash.js

@@ -0,0 +1,43 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { exec } from "node:child_process";
+const MAX_OUTPUT = 30_000;
+const DEFAULT_TIMEOUT = 120_000;
+export function createBashTool(opts) {
+    const baseTool = tool({
+        description: "Executes a bash command and returns stdout/stderr. Timeout defaults to 120s.",
+        inputSchema: z.object({
+            command: z.string().describe("The bash command to execute"),
+            timeout: z
+                .number()
+                .optional()
+                .describe("Timeout in milliseconds (max 600000)"),
+        }),
+        execute: async ({ command, timeout }) => {
+            const ms = Math.min(timeout ?? DEFAULT_TIMEOUT, 600_000);
+            return new Promise((resolve) => {
+                exec(command, { timeout: ms, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+                    let output = "";
+                    if (stdout)
+                        output += stdout;
+                    if (stderr)
+                        output += (output ? "\n" : "") + stderr;
+                    if (err && !stdout && !stderr) {
+                        output = `Error: ${err.message}`;
+                    }
+                    if (output.length > MAX_OUTPUT) {
+                        output = output.slice(0, MAX_OUTPUT) + "\n...[truncated]";
+                    }
+                    resolve(output || "(no output)");
+                });
+            });
+        },
+    });
+    if (opts?.autoApprove === false) {
+        return Object.assign(baseTool, {
+            needsApproval: async () => true,
+        });
+    }
+    return baseTool;
+}
+export const bashTool = createBashTool();

package/dist/tools/batch.d.ts

@@ -0,0 +1,13 @@
+import { type Tool } from "ai";
+/**
+ * Factory that creates the Batch tool for parallel tool execution.
+ *
+ * Receives the resolved tool registry so it can look up tools by name.
+ * The Batch tool itself is excluded from the registry to prevent recursion.
+ */
+export declare function createBatchTool(toolRegistry: Record<string, Tool>): Tool<{
+    tool_calls: {
+        tool: string;
+        parameters: Record<string, any>;
+    }[];
+}, string>;

package/dist/tools/batch.js

@@ -0,0 +1,84 @@
+import { tool } from "ai";
+import { z } from "zod";
+const MAX_OUTPUT = 50_000;
+/**
+ * Factory that creates the Batch tool for parallel tool execution.
+ *
+ * Receives the resolved tool registry so it can look up tools by name.
+ * The Batch tool itself is excluded from the registry to prevent recursion.
+ */
+export function createBatchTool(toolRegistry) {
+    // Build the list of available tool names (excluding Batch itself)
+    const availableTools = Object.keys(toolRegistry).filter((name) => name !== "Batch");
+    return tool({
+        description: "Execute 2-10 tool calls simultaneously in parallel using Promise.allSettled(). " +
+            "Partial failures do not cancel other calls. " +
+            "Batch cannot call itself (no recursion). " +
+            `Available tools: ${availableTools.join(", ")}`,
+        inputSchema: z.object({
+            tool_calls: z
+                .array(z.object({
+                tool: z
+                    .string()
+                    .describe("Name of the tool to call (must be a registered tool)"),
+                parameters: z
+                    .record(z.any())
+                    .describe("Parameters to pass to the tool"),
+            }))
+                .min(2)
+                .max(10)
+                .describe("Array of tool calls to execute in parallel (2-10 items)"),
+        }),
+        execute: async ({ tool_calls }) => {
+            // Validate: no Batch inside Batch
+            const batchCalls = tool_calls.filter((tc) => tc.tool === "Batch");
+            if (batchCalls.length > 0) {
+                return "Error: Batch cannot call itself. Remove Batch from tool_calls.";
+            }
+            // Validate: all tools exist
+            const unknownTools = tool_calls.filter((tc) => !availableTools.includes(tc.tool));
+            if (unknownTools.length > 0) {
+                const names = unknownTools.map((tc) => tc.tool).join(", ");
+                return `Error: Unknown tool(s): ${names}. Available: ${availableTools.join(", ")}`;
+            }
+            // Execute all calls in parallel
+            const promises = tool_calls.map(async (tc, index) => {
+                const targetTool = toolRegistry[tc.tool];
+                if (!targetTool.execute) {
+                    return { index, tool: tc.tool, result: `Error: Tool "${tc.tool}" has no execute function.` };
+                }
+                try {
+                    const result = await targetTool.execute(tc.parameters, {
+                        toolCallId: `batch-${index}-${tc.tool}`,
+                        messages: [],
+                        abortSignal: undefined,
+                    });
+                    return { index, tool: tc.tool, result: String(result) };
+                }
+                catch (err) {
+                    return {
+                        index,
+                        tool: tc.tool,
+                        result: `Error: ${err.message ?? String(err)}`,
+                    };
+                }
+            });
+            const settled = await Promise.allSettled(promises);
+            const parts = [];
+            for (const outcome of settled) {
+                if (outcome.status === "fulfilled") {
+                    const { index, tool: toolName, result } = outcome.value;
+                    parts.push(`### [${index}] ${toolName}\n\n${result}`);
+                }
+                else {
+                    parts.push(`### [?] Error\n\n${outcome.reason?.message ?? String(outcome.reason)}`);
+                }
+            }
+            let output = parts.join("\n\n---\n\n");
+            if (output.length > MAX_OUTPUT) {
+                output = output.slice(0, MAX_OUTPUT) + "\n...[truncated at 50KB]";
+            }
+            return output;
+        },
+    });
+}

package/dist/tools/brave-search.d.ts

@@ -0,0 +1,6 @@
+import type { WebSearchResult } from "./web-search.js";
+/**
+ * Brave Web Search API client.
+ * Docs: https://api.search.brave.com/app#/documentation/web-search
+ */
+export declare function braveSearch(query: string, numResults: number, apiKey: string): Promise<WebSearchResult[]>;