@wrongstack/tools 0.310.1 → 0.313.1

package/dist/batch-tool-use.js

@@ -1,191 +1,6 @@
-// src/batch-tool-use.ts
 import {
-  GOVERNED_TOOL_EXECUTOR_META_KEY
-} from "@wrongstack/core/types";
-var BATCHABLE_TOOL_NAMES = [
-  "read",
-  "glob",
-  "grep",
-  "tree",
-  "codebase-stats",
-  "codebase-search",
-  "language_info",
-  "tool_search",
-  "memory_for_file",
-  "memory_for_path",
-  "memory_search"
-];
-var BATCHABLE_TOOLS = new Set(BATCHABLE_TOOL_NAMES);
-var MAX_BATCH_CALLS = 8;
-var MAX_PARALLEL_BATCH_CALLS = 3;
-var batchToolUseTool = {
-  name: "batch_tool_use",
-  category: "Meta",
-  description: "Execute a small batch of independent, read-only discovery calls. Process, mutation, browser-action, MCP, delegation, and nested meta tools are not eligible.",
-  usageHint: `BOUNDED READ-ONLY BATCHING:
-
-- Use only for a small set of independent reads or searches that are all needed now.
-- Do not wrap normal sequential reasoning or every tool call in a batch.
-- \`parallel: true\` (default) runs at most three eligible calls concurrently.
-- \`stop_on_error: true\` makes it fail fast on the first error.
-- Eligible tools: ${BATCHABLE_TOOL_NAMES.join(", ")}.`,
-  permission: "confirm",
-  // Scheduling barrier: keep the outer meta-call out of ToolExecutor's
-  // non-mutating fan-out even though every eligible inner tool is read-only.
-  mutating: true,
-  timeoutMs: 12e4,
-  capabilities: ["tool.meta"],
-  icon: "meta",
-  inputSchema: {
-    type: "object",
-    properties: {
-      calls: {
-        type: "array",
-        maxItems: MAX_BATCH_CALLS,
-        items: {
-          type: "object",
-          properties: {
-            tool: {
-              type: "string",
-              enum: [...BATCHABLE_TOOL_NAMES],
-              description: "An explicitly batch-safe, read-only discovery tool."
-            },
-            input: { type: "object" }
-          },
-          required: ["tool"]
-        },
-        description: `Up to ${MAX_BATCH_CALLS} independent, batch-safe read calls.`
-      },
-      stop_on_error: {
-        type: "boolean",
-        description: "Stop execution on first error (default: false)"
-      },
-      parallel: {
-        type: "boolean",
-        description: "Execute calls in parallel (default: true)"
-      }
-    },
-    required: ["calls"]
-  },
-  async execute(input, ctx, _opts) {
-    if (!input?.calls || input.calls.length === 0) {
-      return {
-        results: [],
-        total: 0,
-        succeeded: 0,
-        failed: 0,
-        stop_on_error: false
-      };
-    }
-    if (input.calls.length > MAX_BATCH_CALLS) {
-      throw new Error(`batch_tool_use: calls must contain at most ${MAX_BATCH_CALLS} items`);
-    }
-    const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
-    if (typeof governedExecute !== "function") {
-      return {
-        results: input.calls.map((call) => ({
-          tool: call.tool,
-          success: false,
-          error: "governed nested execution is unavailable; call the tool directly",
-          executionMs: 0
-        })),
-        total: input.calls.length,
-        succeeded: 0,
-        failed: input.calls.length,
-        stop_on_error: input.stop_on_error ?? false
-      };
-    }
-    const results = [];
-    let succeeded = 0;
-    let failed = 0;
-    if (input.parallel !== false) {
-      const allResults = await mapWithConcurrency(
-        input.calls,
-        MAX_PARALLEL_BATCH_CALLS,
-        (call) => executeSingle(call, ctx, governedExecute)
-      );
-      results.push(...allResults);
-      succeeded = allResults.filter((r) => r.success).length;
-      failed = allResults.filter((r) => !r.success).length;
-    } else {
-      for (const call of input.calls) {
-        const result = await executeSingle(call, ctx, governedExecute);
-        results.push(result);
-        if (result.success) {
-          succeeded++;
-        } else {
-          failed++;
-          if (input.stop_on_error) break;
-        }
-      }
-    }
-    return {
-      results,
-      total: input.calls.length,
-      succeeded,
-      failed,
-      stop_on_error: input.stop_on_error ?? false
-    };
-  }
-};
-async function mapWithConcurrency(items, limit, run) {
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  const worker = async () => {
-    while (nextIndex < items.length) {
-      const index = nextIndex++;
-      results[index] = await run(items[index]);
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
-  return results;
-}
-async function executeSingle(call, ctx, governedExecute) {
-  const start = Date.now();
-  if (call.tool === batchToolUseTool.name) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: "recursive batch_tool_use execution is not allowed",
-      executionMs: Date.now() - start
-    };
-  }
-  const tool = (ctx.catalogTools ?? ctx.tools).find(
-    (candidate) => candidate.name === call.tool
-  );
-  if (!tool) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: `tool "${call.tool}" not found`,
-      executionMs: Date.now() - start
-    };
-  }
-  if (!BATCHABLE_TOOLS.has(tool.name) || tool.mutating) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: `tool "${call.tool}" is not eligible for batch execution; call it directly. Allowed: ${BATCHABLE_TOOL_NAMES.join(", ")}`,
-      executionMs: Date.now() - start
-    };
-  }
-  try {
-    const result = await governedExecute(call.tool, call.input);
-    return {
-      tool: call.tool,
-      success: result.success,
-      ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
-      executionMs: Date.now() - start
-    };
-  } catch (e) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: e instanceof Error ? e.message : String(e),
-      executionMs: Date.now() - start
-    };
-  }
-}
+  batchToolUseTool
+} from "./chunk-U4VAATKP.js";
 export {
   batchToolUseTool
 };