@tyvm/knowhow 0.0.138 → 0.0.141

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/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/modules.ts

@@ -39,15 +39,146 @@ function ensureKnowhowPackageJson(knowhowDir: string): void {
   }
 }
 
+/**
+ * Options that control how a module is installed via npm.
+ */
+interface InstallOptions {
+  /**
+   * When true, force npm to run the module's install/build lifecycle scripts
+   * (preinstall/install/postinstall) in the foreground.
+   *
+   * This matters for native modules like `isolated-vm`, whose `install` script
+   * (`node-gyp-build || node-gyp rebuild`) selects/copies the correct prebuilt
+   * binary (or compiles from source). npm 11 and some org/CI policies block
+   * install scripts by default, which leaves native deps in a broken/mismatched
+   * state that later aborts the process at require-time (e.g. the
+   * `IsolateSpecificSize` assertion). Passing this flag ensures those scripts
+   * actually run so the right binary is in place.
+   */
+  allowScripts?: boolean;
+}
+
 /**
  * Run `npm install --prefix <knowhowDir> <mod>` so that modules land in
  * .knowhow/node_modules rather than the project's node_modules.
+ *
+ * When `allowScripts` is set, we explicitly force install lifecycle scripts to
+ * run (`--foreground-scripts --ignore-scripts=false`) so native modules build
+ * correctly even under npm 11 / restrictive org policies that skip scripts by
+ * default.
  */
-function npmInstallToKnowhow(mod: string, knowhowDir: string): void {
-  execSync(`npm install --prefix "${knowhowDir}" ${mod}`, {
+function npmInstallToKnowhow(
+  mod: string,
+  knowhowDir: string,
+  options: InstallOptions = {}
+): void {
+  const scriptFlags = options.allowScripts
+    ? " --foreground-scripts --ignore-scripts=false"
+    : "";
+  execSync(`npm install --prefix "${knowhowDir}" ${mod}${scriptFlags}`, {
     stdio: "inherit",
     encoding: "utf-8",
   });
+
+  // When scripts weren't explicitly allowed, npm 11+ (and restrictive org/CI
+  // policies) silently *skip* package install/build scripts. For native addons
+  // like isolated-vm this leaves the package present but its native binary
+  // unbuilt — which later aborts at runtime with a cryptic error. Detect that
+  // situation now and tell the user exactly how to fix it (re-run with
+  // --allow-scripts) rather than letting them hit the runtime crash.
+  if (!options.allowScripts) {
+    warnIfInstallScriptsSkipped(knowhowDir);
+  }
+}
+
+/**
+ * Names of lifecycle scripts that run during `npm install` and typically build
+ * native code. If a freshly-installed package declares any of these AND we
+ * installed without allowing scripts, they were skipped.
+ */
+const INSTALL_LIFECYCLE_SCRIPTS = ["preinstall", "install", "postinstall"];
+
+/**
+ * Walk the installed dependency tree under <knowhowDir>/node_modules and return
+ * the names of packages that declare native/build install-lifecycle scripts.
+ *
+ * This reads the *actually installed* package.json files (rather than querying
+ * the registry) so it works offline, reflects the real resolved tree, and
+ * catches transitive dependencies (e.g. isolated-vm pulled in by a module).
+ */
+function findPackagesWithInstallScripts(knowhowDir: string): string[] {
+  const nodeModules = path.join(knowhowDir, "node_modules");
+  const found = new Set<string>();
+
+  const readPkgScripts = (pkgDir: string): void => {
+    const pkgJsonPath = path.join(pkgDir, "package.json");
+    if (!fs.existsSync(pkgJsonPath)) return;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      const scripts = pkg.scripts ?? {};
+      const hasInstallScript = INSTALL_LIFECYCLE_SCRIPTS.some(
+        (s) => typeof scripts[s] === "string" && scripts[s].trim().length > 0
+      );
+      if (hasInstallScript && pkg.name) {
+        found.add(pkg.name);
+      }
+    } catch {
+      // ignore malformed package.json
+    }
+  };
+
+  const scanDir = (dir: string): void => {
+    if (!fs.existsSync(dir)) return;
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === ".bin" || entry.name === ".cache") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.name.startsWith("@")) {
+        // scope directory — recurse one level into the scoped packages
+        scanDir(full);
+        continue;
+      }
+      readPkgScripts(full);
+      // Recurse into nested node_modules for hoisting edge cases.
+      const nested = path.join(full, "node_modules");
+      if (fs.existsSync(nested)) scanDir(nested);
+    }
+  };
+
+  scanDir(nodeModules);
+  return Array.from(found).sort();
+}
+
+/**
+ * Check whether the just-installed tree contains packages with install scripts
+ * (that were skipped because --allow-scripts wasn't passed) and, if so, print a
+ * clear warning telling the user to re-run with --allow-scripts.
+ */
+function warnIfInstallScriptsSkipped(knowhowDir: string): void {
+  let pkgsWithScripts: string[] = [];
+  try {
+    pkgsWithScripts = findPackagesWithInstallScripts(knowhowDir);
+  } catch {
+    return;
+  }
+  if (pkgsWithScripts.length === 0) return;
+
+  console.warn(
+    "\n⚠️  Some installed packages have native install/build scripts that may have\n" +
+      "   been skipped (npm 11+ blocks install scripts by default):\n" +
+      pkgsWithScripts.map((p) => `     • ${p}`).join("\n") +
+      "\n\n   If a module fails to load at runtime (e.g. isolated-vm), re-run the\n" +
+      "   install with --allow-scripts so these build steps can run:\n\n" +
+      "     knowhow modules install <module> --allow-scripts\n" +
+      "     # or\n" +
+      "     knowhow modules setup --allow-scripts\n"
+  );
 }
 
 /**
@@ -289,9 +420,14 @@ export function addModulesCommand(program: Command): void {
       "Add default built-in modules to your config and install them into .knowhow/node_modules"
     )
     .option("--global", "Use the global config (~/.knowhow/knowhow.json)")
+    .option(
+      "--allow-scripts",
+      "Allow modules' native install/build scripts to run (needed for native deps like isolated-vm under npm 11)"
+    )
     .action(async (opts) => {
       try {
         const isGlobal: boolean = opts.global ?? false;
+        const allowScripts: boolean = opts.allowScripts ?? false;
         const cfg = isGlobal ? await getGlobalConfig() : await getConfig();
         const configLabel = isGlobal
           ? "~/.knowhow/knowhow.json"
@@ -307,10 +443,16 @@ export function addModulesCommand(program: Command): void {
         let anyChanges = false;
         for (const mod of BUILTIN_MODULES) {
           if (!mod.startsWith(".") && !mod.startsWith("/")) {
-            if (!isModuleInstalled(mod, knowhowDir)) {
+            // Reinstall if the module isn't installed yet, OR if the user
+            // explicitly passed --allow-scripts. In the latter case the whole
+            // point is to (re-)run the native install/build scripts (e.g.
+            // isolated-vm's node-gyp build), so skipping because the package
+            // is "already installed" would silently do nothing — which is
+            // exactly the confusing "Nothing to do" case we want to avoid.
+            if (!isModuleInstalled(mod, knowhowDir) || allowScripts) {
               const installTarget = await fetchLatestCompatibleVersion(mod);
               console.log(`📦 Installing ${installTarget}...`);
-              npmInstallToKnowhow(installTarget, knowhowDir);
+              npmInstallToKnowhow(installTarget, knowhowDir, { allowScripts });
               console.log(`✅ Installed ${mod}`);
               anyChanges = true;
             }
@@ -346,9 +488,14 @@ export function addModulesCommand(program: Command): void {
     )
     .option("--global", "Use the global config (~/.knowhow/knowhow.json)")
     .option("--latest", "Force install the latest version (bypasses package-lock)")
+    .option(
+      "--allow-scripts",
+      "Allow the module's native install/build scripts to run (needed for native deps like isolated-vm under npm 11)"
+    )
     .action(async (moduleName: string | undefined, opts) => {
       try {
         const isGlobal: boolean = opts.global ?? false;
+        const allowScripts: boolean = opts.allowScripts ?? false;
         const cfg = isGlobal ? await getGlobalConfig() : await getConfig();
         const configLabel = isGlobal
           ? "~/.knowhow/knowhow.json"
@@ -374,7 +521,7 @@ export function addModulesCommand(program: Command): void {
           for (const mod of installable) {
             console.log(`  📦 Installing ${mod}...`);
             const installTarget = opts.latest ? await fetchLatestCompatibleVersion(mod) : mod;
-            npmInstallToKnowhow(installTarget, knowhowDir);
+            npmInstallToKnowhow(installTarget, knowhowDir, { allowScripts });
             console.log(`  ✅ Installed ${mod}`);
           }
           console.log(`\n🎉 All modules installed!`);
@@ -384,7 +531,7 @@ export function addModulesCommand(program: Command): void {
         // Install the specified module
         const installTarget = opts.latest ? await fetchLatestCompatibleVersion(moduleName) : moduleName;
         console.log(`📦 Installing ${installTarget} into ${knowhowDir}/node_modules...`);
-        npmInstallToKnowhow(installTarget, knowhowDir);
+        npmInstallToKnowhow(installTarget, knowhowDir, { allowScripts });
         console.log(`✅ Installed ${moduleName}`);
 
         // Add to config if not already there
@@ -453,10 +600,15 @@ export function addModulesCommand(program: Command): void {
     )
     .option("--global", "Use the global config (~/.knowhow/knowhow.json)")
     .option("-y, --yes", "Skip confirmation prompt and update all outdated modules automatically")
+    .option(
+      "--allow-scripts",
+      "Allow modules' native install/build scripts to run (needed for native deps like isolated-vm under npm 11)"
+    )
     .action(async (opts) => {
       try {
         const isGlobal: boolean = opts.global ?? false;
         const skipConfirm: boolean = opts.yes ?? false;
+        const allowScripts: boolean = opts.allowScripts ?? false;
         const cfg = isGlobal ? await getGlobalConfig() : await getConfig();
         const configLabel = isGlobal
           ? "~/.knowhow/knowhow.json"
@@ -540,7 +692,7 @@ export function addModulesCommand(program: Command): void {
         console.log("");
         for (const { mod, compatibleVersion } of toUpdate) {
           console.log(`  📦 Updating ${compatibleVersion}...`);
-          npmInstallToKnowhow(compatibleVersion, knowhowDir);
+          npmInstallToKnowhow(compatibleVersion, knowhowDir, { allowScripts });
           console.log(`  ✅ Updated ${mod}`);
         }
         console.log(`\n🎉 Update complete! ${toUpdate.length} module(s) updated.`);

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