@tyvm/knowhow 0.0.137 → 0.0.140

package/src/commands/agents.ts

@@ -493,6 +493,76 @@ async function cmdAttach(taskIdOrIndex: string | undefined, opts: { index?: stri
   await startChat(`/attach ${resolvedId}`);
 }
 
+/**
+ * Print the final answer (the result of the agent's finalAnswer tool call) for
+ * a completed task. Reads `metadata.result`, falling back to the last assistant
+ * message in the thread if `result` isn't present. This lets a human read what
+ * a finished agent concluded with, even if they never attached before it ended.
+ */
+async function cmdAnswer(
+  taskIdOrIndex: string | undefined,
+  opts: { index?: string; raw: boolean }
+): Promise<void> {
+  const value = opts.index ?? taskIdOrIndex;
+  if (!value) {
+    console.error("Provide a task ID or use -i <number> to select by index.");
+    process.exit(1);
+  }
+
+  const resolvedId = resolveTaskId(value, true);
+  if (!resolvedId) {
+    console.error(`Task not found: ${value}`);
+    const rows = buildRows(true);
+    if (rows.length > 0) {
+      console.error("\nAvailable tasks:");
+      rows.forEach((r, i) => console.error(`  ${i + 1}. ${r.displayId}`));
+    }
+    process.exit(1);
+    return;
+  }
+
+  const meta = loadMeta(resolvedId);
+  if (!meta) {
+    console.error(`No metadata found for task: ${resolvedId}`);
+    process.exit(1);
+    return;
+  }
+
+  // Prefer the stored finalAnswer result; fall back to the last assistant message.
+  let answer: string | undefined =
+    typeof meta.result === "string" && meta.result.trim()
+      ? meta.result
+      : undefined;
+
+  if (!answer) {
+    const threads: any[][] = meta.threads ?? [];
+    if (threads.length > 0) {
+      answer = lastAssistantMessage(threads[threads.length - 1]);
+    }
+  }
+
+  if (opts.raw) {
+    console.log(answer ?? "");
+    return;
+  }
+
+  const status = getStatus(resolvedId, meta);
+  if (!answer) {
+    console.log(`\n📭 No final answer available for task: ${resolvedId}`);
+    console.log(`   Status: ${status}`);
+    if (status !== "completed") {
+      console.log(`   The agent hasn't finished yet — attach with 'knowhow agents attach' to follow it.`);
+    }
+    return;
+  }
+
+  console.log(`\n💬 Final answer for task: ${resolvedId}`);
+  console.log(`   Agent: ${meta.agentName ?? "?"}  |  Status: ${status}  |  Cost: ${meta.totalCostUsd != null ? "$" + (meta.totalCostUsd as number).toFixed(4) : "?"}`);
+  console.log("─".repeat(80));
+  console.log(answer);
+  console.log("─".repeat(80) + "\n");
+}
+
 
 
 // ---------------------------------------------------------------------------
@@ -553,4 +623,17 @@ export function addAgentsCommand(program: Command): void {
     .action(async (taskId: string | undefined, opts: { index?: string }) => {
       await cmdAttach(taskId, opts);
     });
+
+  agents
+    .command("answer [taskId]")
+    .description(
+      "Print the final answer (finalAnswer result) of a completed agent task, formatted for reading. " +
+        "Reads metadata.result, falling back to the last assistant message. " +
+        "Accepts a full task ID, partial substring, or -i <number> for row index from 'agents list'."
+    )
+    .option("-i, --index <number>", "Select task by row number from 'agents list'")
+    .option("--raw", "Print only the raw answer text (no header/formatting)", false)
+    .action(async (taskId: string | undefined, opts: { index?: string; raw: boolean }) => {
+      await cmdAnswer(taskId, opts);
+    });
 }

package/src/commands/hash.ts

@@ -90,8 +90,9 @@ export function addHashCommand(program: Command): void {
 
         const currentHash = hashFiles(inputFiles);
 
-        // --save mode: record into .hashes.json under hashes[name][inputGlob] = hash
-        if (opts.save) {
+        // Standalone --save mode (no --run): record hash immediately and exit.
+        // When --run is also present, --save is handled inside the --run branch below.
+        if (opts.save && !opts.run) {
           if (!hashes[opts.name]) hashes[opts.name] = {};
           hashes[opts.name][opts.input] = currentHash;
           await saveHashes(hashes);

package/src/commands/misc.ts

@@ -66,6 +66,10 @@ export function addGenerateCommand(program: Command): void {
       "--sync-fs",
       "Enable filesystem sync for agent-driven sources (creates .knowhow/processes/agents/<taskId>/ so tasks appear in `knowhow agents list`)"
     )
+    .option(
+      "--sync-remote",
+      "Push agent-driven sources' work to a remote Knowhow task (identified by the source's taskId)"
+    )
     .option(
       "--force",
       "Skip hash checks and regenerate all matching sources regardless of whether inputs/outputs have changed"
@@ -83,6 +87,7 @@ export function addGenerateCommand(program: Command): void {
       name?: string;
       filter?: string;
       syncFs?: boolean;
+      syncRemote?: boolean;
       force?: boolean;
       concurrency?: number;
       plan?: boolean;
@@ -99,6 +104,7 @@ export function addGenerateCommand(program: Command): void {
         name: options.name,
         filter: options.filter,
         syncFs: options.syncFs,
+        syncRemote: options.syncRemote,
         force: options.force,
         concurrency: options.concurrency,
       });

package/src/commands/services.ts

@@ -49,6 +49,20 @@ export async function setupServices() {
 
   Tools.addContext("Mcp", Mcp);
 
+  // The `agentCall` tool + function are registered by AgentService on the
+  // global ToolsService (AllTools), not on the LazyToolsService we build here.
+  // Copy it across so agents/scripts using this Tools instance can delegate to
+  // other agents via agentCall (matching startAgentTask availability).
+  try {
+    const agentCallDef = AllTools.getTool?.("agentCall");
+    const agentCallFn = AllTools.getFunction?.("agentCall");
+    if (agentCallDef) Tools.addTool(agentCallDef);
+    if (agentCallFn) Tools.setFunction("agentCall", agentCallFn);
+  } catch (_) {
+    // Non-fatal: if agentCall isn't registered yet, agents can still use
+    // startAgentTask for delegation.
+  }
+
   Agents.setAgentContext(agentContext);
 
   console.log("🔌 Connecting to MCP...");

package/src/generate.ts

@@ -51,6 +51,12 @@ export interface GenerateOptions {
    * so they appear in `knowhow agents list`. Overrides the per-source syncFs flag.
    */
   syncFs?: boolean;
+  /**
+   * When true, agent-driven sources push their work to a remote Knowhow task
+   * (identified by the source's taskId). Overrides the per-source syncRemote
+   * flag. Requires the sources to run as agents with a known taskId.
+   */
+  syncRemote?: boolean;
   /** When true, skip hash checks and regenerate all matching sources regardless of changes */
   force?: boolean;
   /**
@@ -58,6 +64,14 @@ export interface GenerateOptions {
    * dependency wave. Defaults to 3. Set to 1 for fully sequential execution.
    */
   concurrency?: number;
+  /**
+   * In-memory generation sources. When provided, these are used INSTEAD of the
+   * sources defined in `.knowhow/knowhow.json`. This enables callers (e.g. an
+   * agent using the `runGenerate` tool) to define arbitrary pipelines at
+   * runtime without persisting them to config — supporting complex task
+   * orchestration with `dependsOn`, per-source `agent`, analysis, etc.
+   */
+  sources?: GenerationSource[];
 }
 
 // ---------------------------------------------------------------------------
@@ -416,12 +430,14 @@ async function runSource(
   console.log("Generating", source.input, "to", source.output);
 
   const effectiveSyncFs = options.syncFs ?? source.syncFs;
+  const effectiveSyncRemote = options.syncRemote ?? source.syncRemote;
   const agentOpts: AgentOptions | undefined = source.agent
     ? {
         syncFs: effectiveSyncFs,
+        syncRemote: effectiveSyncRemote,
         taskId:
           source.taskId ??
-          (effectiveSyncFs
+          (effectiveSyncFs || effectiveSyncRemote
             ? `generate:${source.output.replace(/[^a-zA-Z0-9_.-]/g, "_")}`
             : undefined),
         maxTimeLimit: source.maxTimeLimit,
@@ -469,8 +485,14 @@ async function runSource(
 // ---------------------------------------------------------------------------
 
 export async function generate(options: GenerateOptions = {}): Promise<void> {
-  const config = await getConfig();
-  const allSources = config.sources ?? [];
+  let allSources: GenerationSource[];
+  if (options.sources && options.sources.length > 0) {
+    // In-memory pipeline definition — bypass config entirely.
+    allSources = options.sources;
+  } else {
+    const config = await getConfig();
+    allSources = config.sources ?? [];
+  }
   const sources = allSources.filter((s) => sourceMatchesFilter(s, options));
 
   if ((options.name || options.filter) && sources.length === 0) {

package/src/services/AgentService.ts

@@ -104,11 +104,29 @@ export class AgentService {
     }
   }
 
-  public async callAgent(name: string, query: string): Promise<string> {
+  /**
+   * Run a registered agent and return both its final answer and the cost it
+   * incurred. Returning cost (from the agent's own `getTotalCostUsd()`) lets
+   * callers — notably the script sandbox — account subagent spend against a
+   * budget. The `answer` string preserves the previous plain-string behavior
+   * for consumers that only care about the response.
+   */
+  public async callAgent(
+    name: string,
+    query: string
+  ): Promise<{ answer: string; costUsd: number }> {
     const agent = this.agents.get(name);
     if (!agent) {
-      return `Agent ${name} not found. Options are: ${this.listAgents()}`;
+      return {
+        answer: `Agent ${name} not found. Options are: ${this.listAgents()}`,
+        costUsd: 0,
+      };
     }
-    return agent.call(query);
+    const answer = await agent.call(query);
+    const costUsd =
+      typeof (agent as any).getTotalCostUsd === "function"
+        ? (agent as any).getTotalCostUsd()
+        : 0;
+    return { answer, costUsd };
   }
 }

package/src/services/AgentSyncFs.ts

@@ -11,6 +11,8 @@ export interface FsSyncOptions {
   taskId: string;
   prompt: string;
   agentName?: string;
+  /** The taskId of the parent agent that spawned this task, if any. */
+  parentTaskId?: string;
 }
 
 /**
@@ -62,8 +64,15 @@ export class AgentSyncFs {
       await this.writeInput("");
       await this.writeMetadata({
         taskId: this.taskId,
+        // Record the OS process id of this agent subprocess so orchestrating
+        // tools (e.g. waitForAgentCompleted) can detect a crashed-but-not-
+        // finalized task via process-liveness. This is the child's own pid,
+        // so it needs no coordination with the spawner and never touches
+        // execCommand's child processes.
+        pid: process.pid,
         prompt: options.prompt,
         agentName: options.agentName || "unknown",
+        ...(options.parentTaskId ? { parentTaskId: options.parentTaskId } : {}),
         startTime: new Date().toISOString(),
         status: "running",
       });
@@ -492,11 +501,58 @@ export class AgentSyncFs {
           console.error(`❌ Error cleaning up ${entry.name}:`, error);
         }
       }
+
+      // Also clean up old execCommand background log files in .knowhow/processes/*.txt
+      await AgentSyncFs.cleanupOldProcessLogs(threeDaysMs);
     } catch (error) {
       console.error(`❌ Error during cleanup:`, error);
     }
   }
 
+  /**
+   * Clean up old execCommand background log files (.knowhow/processes/*.txt).
+   * These are created by the execCommand tool when running background/long-lived
+   * commands, and are never cleaned up otherwise.
+   */
+  private static async cleanupOldProcessLogs(maxAgeMs: number): Promise<void> {
+    try {
+      // execCommand writes logs to the parent of the agents dir: .knowhow/processes
+      const processesPath = path.dirname(AgentSyncFs.sharedBasePath);
+
+      try {
+        await fs.access(processesPath);
+      } catch {
+        return;
+      }
+
+      const entries = await fs.readdir(processesPath, { withFileTypes: true });
+      const now = Date.now();
+
+      for (const entry of entries) {
+        // Only target the .txt log files that execCommand creates; leave the
+        // agents/ directory (and any other subdirectories) alone.
+        if (!entry.isFile() || !entry.name.endsWith(".txt")) continue;
+
+        const logPath = path.join(processesPath, entry.name);
+
+        try {
+          const stats = await fs.stat(logPath);
+          const age = now - stats.mtimeMs;
+
+          if (age > maxAgeMs) {
+            console.log(`🧹 Cleaning up old process log file: ${entry.name}`);
+            await fs.rm(logPath, { force: true });
+          }
+        } catch (error) {
+          // Skip if we can't stat or delete
+          console.error(`❌ Error cleaning up log ${entry.name}:`, error);
+        }
+      }
+    } catch (error) {
+      console.error(`❌ Error during process log cleanup:`, error);
+    }
+  }
+
   /**
    * Start periodic cleanup process
    */

package/src/services/AgentSyncKnowhowWeb.ts

@@ -13,7 +13,7 @@ import { wait } from "../utils";
 
 export interface SyncOptions {
   messageId?: string;
-  existingKnowhowTaskId?: string;
+  syncRemote?: boolean;
   prompt: string;
 }
 

package/src/services/EventService.ts

@@ -255,7 +255,10 @@ export class EventService extends EventEmitter {
     this.emit(this.eventTypes.agentsRegister, { name: agent.name, agent });
   }
 
-  callAgent(name: string, query: string): Promise<string> {
+  callAgent(
+    name: string,
+    query: string
+  ): Promise<{ answer: string; costUsd: number }> {
     return new Promise((resolve, reject) => {
       this.emit(this.eventTypes.agentsCall, { name, query, resolve, reject });
     });

package/src/services/KnowhowClient.ts

@@ -122,6 +122,13 @@ export interface GitCredentialResponse {
 }
 
 export function loadKnowhowJwt(): string {
+  // Check env var first — this is how cloud workers/CI runners get auth
+  // (injected via KNOWHOW_JWT env var in the runner's .env file by GithubRunnerService).
+  // This avoids depending on a potentially stale .knowhow/.jwt file from the snapshot.
+  if (process.env.KNOWHOW_JWT) {
+    return process.env.KNOWHOW_JWT;
+  }
+
   const jwtFile = path.join(process.cwd(), ".knowhow", ".jwt");
   if (!fs.existsSync(jwtFile)) {
     return "";

package/src/services/LazyToolsService.ts

@@ -1,5 +1,5 @@
 import { minimatch } from "minimatch";
-import { ToolsService, ToolContext } from "./Tools";
+import { ToolsService, ToolContext, ToolCallContext } from "./Tools";
 import { Tool } from "../clients/types";
 import { ToolCall } from "../clients/types";
 import {
@@ -140,7 +140,11 @@ export class LazyToolsService extends ToolsService {
   }
 
   // Override callTool to auto-enable tools that are in allTools but not yet enabled
-  async callTool(toolCall: ToolCall, enabledTools?: string[]) {
+  async callTool(
+    toolCall: ToolCall,
+    enabledTools?: string[],
+    callContext?: ToolCallContext
+  ) {
     const functionName = toolCall.function.name;
 
     // If the tool isn't currently visible but exists in allTools, auto-enable it.
@@ -160,7 +164,7 @@ export class LazyToolsService extends ToolsService {
 
     // Always use the current enabled tool names after any auto-enable above,
     // so the base class check sees the freshly-enabled tool in the allowed list.
-    return super.callTool(toolCall, this.getToolNames());
+    return super.callTool(toolCall, this.getToolNames(), callContext);
   }
 
   // Internal: Update visible tools based on patterns

package/src/services/MinimalToolsService.ts

@@ -1,4 +1,4 @@
-import { ToolsService, ToolContext } from "./Tools";
+import { ToolsService, ToolContext, ToolCallContext } from "./Tools";
 import { Tool, ToolCall } from "../clients/types";
 import { callTool } from "../agents/tools/minimal/callTool";
 import { inspectTools } from "../agents/tools/minimal/inspectTools";
@@ -107,7 +107,11 @@ export class MinimalToolsService extends ToolsService {
    * Used both by direct calls (agent calls the tool by its real name) and by
    * the callTool meta-tool (agent calls callTool({ name, args })).
    */
-  private async dispatchToTool(toolCall: ToolCall, resolvedName: string) {
+  private async dispatchToTool(
+    toolCall: ToolCall,
+    resolvedName: string,
+    callContext?: ToolCallContext
+  ) {
     // Temporarily surface the target tool in the visible list so base
     // ToolsService.callTool can find its definition, then restore state.
     const alreadyVisible = super
@@ -123,7 +127,7 @@ export class MinimalToolsService extends ToolsService {
       }
     }
 
-    const result = await super.callTool(toolCall, [resolvedName]);
+    const result = await super.callTool(toolCall, [resolvedName], callContext);
 
     // Remove the temporarily-added tool to keep the visible set stable
     if (!alreadyVisible) {
@@ -136,7 +140,11 @@ export class MinimalToolsService extends ToolsService {
   /**
    * Delegates to the full catalog for resolution, then runs via callToolByName.
    */
-  async callTool(toolCall: ToolCall, enabledTools?: string[]): Promise<any> {
+  async callTool(
+    toolCall: ToolCall,
+    enabledTools?: string[],
+    callContext?: ToolCallContext
+  ): Promise<any> {
     const functionName = toolCall.function.name;
 
     // Base tools (callTool, inspectTools, finalAnswer) → standard dispatch
@@ -145,7 +153,7 @@ export class MinimalToolsService extends ToolsService {
       .some((t) => t.function.name === functionName);
 
     if (isBaseTool) {
-      return super.callTool(toolCall, this.getToolNames());
+      return super.callTool(toolCall, this.getToolNames(), callContext);
     }
 
     // Extended tools: called directly by name (not via the callTool meta-tool).
@@ -158,10 +166,10 @@ export class MinimalToolsService extends ToolsService {
     );
 
     if (existsInCatalog) {
-      return this.dispatchToTool(toolCall, functionName);
+      return this.dispatchToTool(toolCall, functionName, callContext);
     }
 
     // Not found anywhere - let the base class produce the standard error.
-    return super.callTool(toolCall, [functionName]);
+    return super.callTool(toolCall, [functionName], callContext);
   }
 }

package/src/services/SyncedAgentWatcher.ts

@@ -58,6 +58,8 @@ export interface AttachableAgent {
   unpause(): void | Promise<void>;
   kill(): void | Promise<void>;
   interrupt(message?: string): void | Promise<void>;
+  /** Force conversation compaction at the next loop iteration (local agents only). */
+  requestCompact?(): void;
   addPendingUserMessage(message: Message): void;
 }
 

package/src/services/SyncerService.ts

@@ -13,10 +13,16 @@ export interface SyncerOptions {
   messageId?: string;
   /** Force fs sync even if messageId is provided */
   syncFs?: boolean;
-  /** Use an existing Knowhow task ID instead of creating a new one */
-  existingKnowhowTaskId?: string;
+  /**
+   * Push the agent's work to a remote Knowhow task. When set (and there is no
+   * messageId), the `taskId` is treated as the remote task ID to attach to and
+   * push updates to, rather than creating a new remote task.
+   */
+  syncRemote?: boolean;
   /** Agent name to persist in metadata.json */
   agentName?: string;
+  /** The taskId of the parent agent that spawned this task, if any. */
+  parentTaskId?: string;
 }
 
 export interface AgentSyncer {
@@ -37,7 +43,8 @@ export interface AgentSyncer {
  *
  * Decision logic:
  *   - Always sets up AgentSyncFs (primary local syncer)
- *   - If messageId is present AND syncFs is not forced AND no existingKnowhowTaskId → also sets up AgentSyncKnowhowWeb
+ *   - If messageId is present AND syncFs is not forced → creates a new remote task via AgentSyncKnowhowWeb
+ *   - If syncRemote is set (and no messageId) → attaches to the remote task identified by taskId
  */
 export class SyncerService implements AgentSyncer {
   private fsSync: AgentSyncFs;
@@ -59,11 +66,23 @@ export class SyncerService implements AgentSyncer {
     this.active = true;
     this.useWebSync = false;
 
-    // Determine whether to use web sync
+    // Determine whether to CREATE a new remote (web) task: only when we have a
+    // messageId and aren't forcing fs-only. A messageId means "definitely
+    // remote" — create a fresh remote task from that message.
     const shouldUseWebSync =
       !!options.messageId &&
-      !options.syncFs &&
-      !options.existingKnowhowTaskId;
+      !options.syncFs;
+
+    // Determine whether to ATTACH to an already-existing remote task and push
+    // local work to it (no creation needed). This is the "--sync-remote" path:
+    // the caller wants to push work to the remote task identified by taskId.
+    // We only auto-attach when there is NO messageId (messageId always creates
+    // a fresh remote task above).
+    //
+    // This is orthogonal to fs sync: we can push to the remote task AND keep
+    // the local .knowhow/processes/agents/<id>/ files in sync at the same time.
+    const shouldAttachExisting =
+      !!options.syncRemote && !options.messageId && !!options.taskId;
 
     // Always create fs sync task first
     console.log(
@@ -73,6 +92,7 @@ export class SyncerService implements AgentSyncer {
       taskId: options.taskId,
       prompt: options.prompt,
       agentName: options.agentName,
+      parentTaskId: options.parentTaskId,
     });
 
     // Optionally create web sync task
@@ -89,6 +109,15 @@ export class SyncerService implements AgentSyncer {
       }
     }
 
+    // Attach live web sync to an existing remote task (push updates to it).
+    if (!shouldUseWebSync && shouldAttachExisting) {
+      this.useWebSync = true;
+      this.createdTaskId = options.taskId;
+      console.log(
+        `🌐 Attaching web sync to existing remote task: ${options.taskId}`
+      );
+    }
+
     return fsTaskId;
   }
 

package/src/services/Tools.ts

@@ -16,6 +16,28 @@ import { PluginService } from "../plugins/plugins";
 import { McpService } from "./Mcp";
 import { BehaviorsService } from "./BehaviorsService";
 
+/**
+ * Per-invocation context passed into a tool call as `_ctx`.
+ *
+ * This is threaded through `callTool` and delivered to the tool implementation
+ * as the LAST positional argument (for positional tools) or merged onto the
+ * args object under the `_ctx` key (for non-positional tools).
+ *
+ * It enables self-referential tools: the calling agent can pass itself in via
+ * `caller`, so tools can read `caller.getCurrentTaskId()`, call
+ * `caller.addPendingUserMessage(...)`, subscribe to its events, etc. — without
+ * relying on shared mutable state on the ToolsService (which would break under
+ * concurrent tool usage).
+ */
+export interface ToolCallContext {
+  /** The agent (or other entity) that initiated this tool call. */
+  caller?: any;
+  /** The task id of the calling agent, if known. */
+  taskId?: string;
+  /** Arbitrary additional per-call context. */
+  [key: string]: any;
+}
+
 export interface ToolContext {
   Agents?: AgentService;
   Events?: EventService;
@@ -174,7 +196,11 @@ export class ToolsService {
     this.addFunctions(functions);
   }
 
-  async callTool(toolCall: ToolCall, enabledTools = this.getToolNames()) {
+  async callTool(
+    toolCall: ToolCall,
+    enabledTools = this.getToolNames(),
+    callContext?: ToolCallContext
+  ) {
     const functionName = toolCall.function.name;
     let functionArgs: any;
 
@@ -219,10 +245,21 @@ export class ToolsService {
       const properties = toolDefinition?.function?.parameters?.properties || {};
       const isPositional =
         toolDefinition?.function?.parameters?.positional || false;
-      const fnArgs = isPositional
+
+      // Thread the per-call context (`_ctx`) into the invocation so tools can be
+      // self-referential (e.g. read the calling agent off `_ctx.caller`).
+      // - positional tools receive `_ctx` as the LAST positional argument
+      // - non-positional tools receive it merged onto the args object as `_ctx`
+      const ctx: ToolCallContext = { ...(callContext || {}), Tools: this };
+
+      const positionalArgs = isPositional
         ? Object.keys(properties).map((p) => functionArgs[p])
         : functionArgs;
 
+      const fnArgs = isPositional
+        ? [...positionalArgs, ctx]
+        : { ...functionArgs, _ctx: ctx };
+
       // Execute the function
       const rawResponse = isPositional
         ? functionToCall.call(this, ...fnArgs)
@@ -250,7 +287,10 @@ export class ToolsService {
       // Handle special case for parallel tool use
       if (functionName === "multi_tool_use.parallel") {
         // Extract tool_calls array from arguments
-        const toolCallsArg = Array.isArray(fnArgs) ? fnArgs : [fnArgs];
+        // Use the original (un-`_ctx`-augmented) args for extraction.
+        const toolCallsArg = Array.isArray(functionArgs)
+          ? functionArgs
+          : [functionArgs];
         const toolCalls = Array.isArray(toolCallsArg) ? toolCallsArg : [];
 
         const calls = toolCalls as {