@tyvm/knowhow 0.0.98 → 0.0.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.98",
+  "version": "0.0.100",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -11,6 +11,7 @@
     "test:debug": "node --inspect-brk ../../node_modules/jest/bin/jest.js --detectOpenHandles --forceExit --testTimeout 300000",
     "compile": "npm run clean && tsc",
     "clean": "rm -rf ts_build",
+    "node:build": "bash scripts/build-for-node.sh",
     "start": "npm run compile && node --no-node-snapshot ts_build/src/server/index.js",
     "dataset:diffs:generate": "ts-node src/dataset/diffs/generate.ts",
     "dataset:diffs:jsonl": "ts-node src/dataset/diffs/jsonl.ts",

package/scripts/build-for-node.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+# Usage: bash scripts/build-for-node.sh [node-version]
+# Example: bash scripts/build-for-node.sh 24        # any Node 24.x
+# Example: bash scripts/build-for-node.sh 20.19.0   # exact version
+# Example: npm run node:build 24
+#
+# This script:
+#   1. Compiles TypeScript with Node 20 (required for workspace deps)
+#   2. Creates /tmp/knowhow-node-<major> with the compiled output
+#   3. Installs the correct isolated-vm version for the target node in that dir
+#   4. Symlinks the package globally for ALL installed nvm versions matching the target
+#
+# This approach avoids polluting the workspace node_modules with a different
+# isolated-vm ABI, so Node 20 and Node 24 builds can coexist.
+
+set -e
+
+TARGET_VERSION="${1:-}"
+
+if [ -z "$TARGET_VERSION" ]; then
+  echo "Usage: $0 <node-version>"
+  echo "Example: $0 24"
+  echo "Example: $0 20.19.0"
+  exit 1
+fi
+
+# Extract the major version number for staging dir naming and glob matching
+TARGET_MAJOR="$(echo "$TARGET_VERSION" | cut -d. -f1)"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACKAGE_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+echo "📦 Package dir: $PACKAGE_DIR"
+
+# --- Find Node 20 for compiling TypeScript ---
+NODE20_BIN=""
+for dir in "$HOME/.nvm/versions/node"/v20.*/bin; do
+  if [ -f "$dir/node" ]; then
+    NODE20_BIN="$dir/node"
+    break
+  fi
+done
+
+if [ -z "$NODE20_BIN" ]; then
+  echo "⚠️  Node 20 not found via nvm, falling back to current node for TS compile"
+  NODE20_BIN="$(which node)"
+fi
+
+NODE20_NPM="$(dirname "$NODE20_BIN")/npm"
+echo "🔨 Compiling TypeScript with: $NODE20_BIN ($(${NODE20_BIN} --version))"
+
+# --- Compile TypeScript ---
+cd "$PACKAGE_DIR"
+"$NODE20_NPM" run compile
+echo "✅ TypeScript compiled"
+
+# --- Find target Node binaries ---
+# If exact version given (e.g. 20.19.0), match exactly. Otherwise match all patch versions.
+TARGET_NODE_BINS=()
+
+if echo "$TARGET_VERSION" | grep -qE '^\d+\.\d+\.\d+$'; then
+  # Exact version like 20.19.0
+  exact_dir="$HOME/.nvm/versions/node/v${TARGET_VERSION}/bin"
+  if [ -f "$exact_dir/node" ]; then
+    TARGET_NODE_BINS+=("$exact_dir/node")
+  fi
+else
+  # Major only — collect all patch versions
+  for dir in "$HOME/.nvm/versions/node"/v${TARGET_MAJOR}.*/bin; do
+    if [ -f "$dir/node" ]; then
+      TARGET_NODE_BINS+=("$dir/node")
+    fi
+  done
+fi
+
+if [ ${#TARGET_NODE_BINS[@]} -eq 0 ]; then
+  echo "❌ Node $TARGET_VERSION not found in ~/.nvm/versions/node/"
+  echo "   Run: nvm install $TARGET_VERSION"
+  exit 1
+fi
+
+# Use the last (latest patch) for building
+TARGET_NODE_BIN="${TARGET_NODE_BINS[${#TARGET_NODE_BINS[@]}-1]}"
+TARGET_NODE_NPM="$(dirname "$TARGET_NODE_BIN")/npm"
+TARGET_NODE_DIR="$(dirname "$TARGET_NODE_BIN")"
+TARGET_NODE_ACTUAL_VERSION="$("$TARGET_NODE_BIN" --version)"
+
+echo "🎯 Found Node $TARGET_VERSION installs: ${TARGET_NODE_BINS[*]}"
+echo "🔨 Building with: $TARGET_NODE_BIN ($TARGET_NODE_ACTUAL_VERSION)"
+
+# --- Pick the right isolated-vm version for the target node ---
+# isolated-vm@5.x supports Node <22, isolated-vm@6.x requires Node >=22
+if [ "$TARGET_MAJOR" -ge 22 ]; then
+  IVM_VERSION="^6.0.0"
+  echo "📌 Using isolated-vm@6.x (Node >= 22)"
+else
+  IVM_VERSION="^5.0.4"
+  echo "📌 Using isolated-vm@5.x (Node < 22)"
+fi
+
+# --- Create staging directory ---
+STAGING_DIR="/tmp/knowhow-node-${TARGET_MAJOR}"
+rm -rf "$STAGING_DIR"
+mkdir -p "$STAGING_DIR"
+echo ""
+echo "📁 Staging dir: $STAGING_DIR"
+
+# --- Copy compiled output and package files into staging dir ---
+echo "📋 Copying compiled output to staging dir..."
+cp -r "$PACKAGE_DIR/ts_build" "$STAGING_DIR/ts_build"
+cp -r "$PACKAGE_DIR/bin" "$STAGING_DIR/bin" 2>/dev/null || true
+cp "$PACKAGE_DIR/package.json" "$STAGING_DIR/package.json"
+for item in README.md LICENSE .npmignore; do
+  [ -e "$PACKAGE_DIR/$item" ] && cp "$PACKAGE_DIR/$item" "$STAGING_DIR/" || true
+done
+
+# --- Patch package.json for target isolated-vm version ---
+echo "📝 Patching package.json for isolated-vm $IVM_VERSION..."
+"$NODE20_BIN" -e "
+  const fs = require('fs');
+  const pkg = JSON.parse(fs.readFileSync('$STAGING_DIR/package.json', 'utf8'));
+  pkg.dependencies['isolated-vm'] = '$IVM_VERSION';
+  // Remove workspace protocol deps that won't resolve outside the monorepo
+  if (pkg.dependencies) {
+    for (const [k, v] of Object.entries(pkg.dependencies)) {
+      if (String(v).startsWith('workspace:')) delete pkg.dependencies[k];
+    }
+  }
+  fs.writeFileSync('$STAGING_DIR/package.json', JSON.stringify(pkg, null, 2));
+  console.log('✅ package.json patched');
+"
+
+# --- Install deps in staging dir using target node ---
+echo ""
+echo "📦 Installing dependencies in staging dir with Node $TARGET_MAJOR..."
+cd "$STAGING_DIR"
+# Prepend target node bin to PATH so npm/node-gyp uses the correct node version
+PATH="$TARGET_NODE_DIR:$PATH" "$TARGET_NODE_NPM" install --no-save 2>&1
+echo "✅ Dependencies installed (isolated-vm compiled for Node $TARGET_MAJOR)"
+
+# --- Symlink globally for ALL matching Node version installs ---
+PKG_NAME="$("$NODE20_BIN" -e "console.log(require('$STAGING_DIR/package.json').name)")"
+PKG_BIN_NAME="$("$NODE20_BIN" -e "const b=require('$STAGING_DIR/package.json').bin; console.log(Object.keys(b)[0])")"
+PKG_BIN_FILE="$("$NODE20_BIN" -e "const b=require('$STAGING_DIR/package.json').bin; console.log(Object.values(b)[0])")"
+
+echo ""
+echo "🔗 Linking $PKG_NAME globally for all Node $TARGET_MAJOR installs..."
+for node_bin in "${TARGET_NODE_BINS[@]}"; do
+  node_prefix="$("$node_bin" -e "const p=require('path');console.log(p.join(p.dirname(process.execPath),'..'))" 2>/dev/null)"
+  global_modules="$node_prefix/lib/node_modules"
+  global_bin="$node_prefix/bin"
+  mkdir -p "$global_modules/@tyvm"
+  rm -rf "$global_modules/$PKG_NAME"
+  ln -sf "$STAGING_DIR" "$global_modules/$PKG_NAME"
+  rm -f "$global_bin/$PKG_BIN_NAME"
+  ln -sf "$global_modules/$PKG_NAME/$PKG_BIN_FILE" "$global_bin/$PKG_BIN_NAME"
+  echo "✅ $("$node_bin" --version): $global_modules/$PKG_NAME → $STAGING_DIR"
+done
+
+echo ""
+echo "🎉 Done! Switch to Node $TARGET_MAJOR and run: knowhow"
+echo "   nvm use $TARGET_MAJOR && knowhow"

package/src/agents/tools/list.ts

@@ -459,6 +459,7 @@ export const includedTools = [
           },
         },
         required: ["provider"],
+        positional: true,
       },
       returns: {
         type: "object",

package/src/cli.ts

@@ -138,7 +138,7 @@ async function main() {
         console.log(`Current version: ${version}`);
 
         console.log("📦 Installing latest version from npm...");
-        execSync("npm install -g knowhow@latest", {
+        execSync("npm install -g @tyvm/knowhow@latest", {
           stdio: "inherit",
           encoding: "utf-8",
         });
@@ -489,6 +489,23 @@ async function main() {
       }
     });
 
+  program
+    .command("cloudworker")
+    .description("Create or sync a cloud worker with your local knowhow config")
+    .option("--create", "Create a new cloud worker with synced config and files")
+    .option("--push <uid>", "Push/sync local config and files to an existing cloud worker")
+    .option("--name <name>", "Name for the cloud worker (used with --create)")
+    .option("--dry-run", "Print what would be synced without doing it")
+    .action(async (options) => {
+      try {
+        const { cloudWorker } = await import("./cloudWorker");
+        await cloudWorker(options);
+      } catch (error) {
+        console.error("Error running cloudworker:", error);
+        process.exit(1);
+      }
+    });
+
   program
     .command("script")
     .description("Run a local tool script file using the executeScript sandbox")

package/src/clients/index.ts

@@ -217,7 +217,12 @@ export class AIClient {
     for (const entry of providers) {
       const client = this.resolveClient(entry);
 
-      if (!client) continue;
+      if (!client) {
+        if (entry.provider === "knowhow") {
+          console.warn(`⚠️  Knowhow provider is not logged in. Run 'knowhow login' to enable Knowhow models.`);
+        }
+        continue;
+      }
 
       const reg = this.providerRegistry[entry.provider];
 
@@ -493,11 +498,19 @@ export class AIClient {
       return foundByModel;
     }
 
-    console.log("unable to find", {
-      provider,
-      model,
-      all: this.listAllModels(),
-    });
+    const allModels = this.listAllModels();
+    const hasKnowhowModels =
+      allModels["knowhow"] && allModels["knowhow"].length > 0;
+    const knowhowIsConfigured = Object.keys(allModels).includes("knowhow");
+
+    console.warn(`⚠️  Unable to find model '${model}' for provider '${provider}'.`);
+    console.warn(`   Available providers: ${Object.keys(allModels).join(", ") || "(none)"}`);
+
+    if (!hasKnowhowModels && !knowhowIsConfigured) {
+      console.warn(`   Tip: Run 'knowhow login' to enable Knowhow models.`);
+    } else if (!hasKnowhowModels) {
+      console.warn(`   Tip: The Knowhow provider returned no models. Try running 'knowhow login' to re-authenticate.`);
+    }
 
     return { provider, model };
   }

package/src/cloudWorker.ts

@@ -0,0 +1,314 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+import { KnowhowSimpleClient, KNOWHOW_API_URL } from "./services/KnowhowClient";
+import { loadJwt } from "./login";
+import { getConfig, updateConfig, getLanguageConfig } from "./config";
+import { services } from "./services";
+import { Language, Config } from "./types";
+import { S3Service } from "./services/S3";
+
+export interface CloudWorkerOptions {
+  create?: boolean;
+  push?: string; // uid of existing cloud worker
+  name?: string; // optional name for create
+  apiUrl?: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Represents a file to be synced to the remote cloud worker
+ */
+interface FileToSync {
+  localPath: string;
+  remotePath: string;
+  downloadLocalPath?: string; // override localPath used when worker downloads the file
+}
+
+/**
+ * Build the worker config JSON from the local knowhow config
+ */
+function buildWorkerConfigJson(config: Config, files: { remotePath: string; localPath: string; direction?: string }[]) {
+  return {
+    promptsDir: config.promptsDir,
+    modules: config.modules,
+    plugins: config.plugins,
+    lintCommands: config.lintCommands,
+    embedSources: config.embedSources,
+    sources: config.sources,
+    agents: config.agents,
+    files,
+    worker: {
+      tunnel: {
+        allowedPorts: config.worker?.tunnel?.allowedPorts ?? [],
+      },
+    },
+  };
+}
+
+/**
+ * Collect all files from the .knowhow directory that should be synced
+ */
+async function collectFilesToSync(projectName: string): Promise<FileToSync[]> {
+  const filesToSync: FileToSync[] = [];
+
+  // Helper to add file if it exists
+  const addIfExists = (localPath: string, remotePath: string) => {
+    if (fs.existsSync(localPath)) {
+      filesToSync.push({ localPath, remotePath });
+    }
+  };
+
+  // .knowhow/language.json
+  addIfExists(".knowhow/language.json", `${projectName}/.knowhow/language.json`);
+
+  // .knowhow/hashes.json
+  addIfExists(".knowhow/hashes.json", `${projectName}/.knowhow/hashes.json`);
+
+  // .knowhow/prompts/**/*
+  const promptFiles = await glob(".knowhow/prompts/**/*", { nodir: true });
+  for (const filePath of promptFiles) {
+    const relativeToDotKnowhow = filePath.replace(/^\.knowhow\//, "");
+    const remotePath = `${projectName}/.knowhow/${relativeToDotKnowhow}`;
+    filesToSync.push({ localPath: filePath, remotePath });
+  }
+
+  // .knowhow/scripts/**/* (if exists)
+  if (fs.existsSync(".knowhow/scripts")) {
+    const scriptFiles = await glob(".knowhow/scripts/**/*", { nodir: true });
+    for (const filePath of scriptFiles) {
+      const relativeToDotKnowhow = filePath.replace(/^\.knowhow\//, "");
+      const remotePath = `${projectName}/.knowhow/${relativeToDotKnowhow}`;
+      filesToSync.push({ localPath: filePath, remotePath });
+    }
+  }
+
+  // .knowhow/skills/**/* (if exists)
+  if (fs.existsSync(".knowhow/skills")) {
+    const skillFiles = await glob(".knowhow/skills/**/*", { nodir: true });
+    for (const filePath of skillFiles) {
+      const relativeToDotKnowhow = filePath.replace(/^\.knowhow\//, "");
+      const remotePath = `${projectName}/.knowhow/${relativeToDotKnowhow}`;
+      filesToSync.push({ localPath: filePath, remotePath });
+    }
+  }
+
+  return filesToSync;
+}
+
+/**
+ * Collect files referenced in language.json sources
+ */
+async function collectLanguageReferencedFiles(
+  language: Language,
+  projectName: string
+): Promise<FileToSync[]> {
+  const filesToSync: FileToSync[] = [];
+
+  for (const term of Object.keys(language)) {
+    const entry = language[term];
+    if (!entry.sources) continue;
+
+    for (const source of entry.sources) {
+      if (source.kind !== "file" || !source.data) continue;
+
+      for (const filePath of source.data) {
+        // Normalize the path (strip leading ./)
+        const normalizedPath = filePath.replace(/^\.\//, "");
+
+        // Skip the main knowhow config — it should not be synced to the language folder
+        // as it would overwrite the worker's own config
+        if (normalizedPath === ".knowhow/knowhow.json") continue;
+
+        if (fs.existsSync(normalizedPath)) {
+          const basename = path.basename(normalizedPath);
+          const remotePath = `${projectName}/.knowhow/language/${basename}`;
+          // localPath is the original path so the worker downloads it to the right place
+          filesToSync.push({ localPath: normalizedPath, remotePath, downloadLocalPath: normalizedPath });
+        }
+      }
+    }
+  }
+
+  return filesToSync;
+}
+
+/**
+ * Upload a single file to the cloud worker's file storage
+ */
+async function uploadSingleFile(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  localPath: string,
+  remotePath: string,
+  dryRun: boolean
+): Promise<void> {
+  console.log(`  ⬆️  Uploading ${localPath} → ${remotePath}`);
+
+  if (dryRun) {
+    console.log(`     [DRY RUN] Would upload from ${localPath}`);
+    return;
+  }
+
+  if (!fs.existsSync(localPath)) {
+    console.warn(`     ⚠️  Local file not found, skipping: ${localPath}`);
+    return;
+  }
+
+  const presignedUrl = await client.getOrgFilePresignedUploadUrl(remotePath);
+  await s3Service.uploadToPresignedUrl(presignedUrl, localPath);
+  await client.markOrgFileUploadComplete(remotePath);
+
+  const stats = fs.statSync(localPath);
+  console.log(`     ✓ Uploaded ${stats.size} bytes`);
+}
+
+/**
+ * Main cloudWorker command handler
+ */
+export async function cloudWorker(options: CloudWorkerOptions) {
+  const {
+    create = false,
+    push,
+    name,
+    apiUrl = KNOWHOW_API_URL,
+    dryRun = false,
+  } = options;
+
+  if (!create && !push) {
+    console.error("❌ Please specify --create or --push <uid>");
+    process.exit(1);
+  }
+
+  // Load JWT token
+  const jwt = await loadJwt();
+  if (!jwt) {
+    console.error("❌ No JWT token found. Please run 'knowhow login' first.");
+    process.exit(1);
+  }
+
+  // Load local config
+  const config = await getConfig();
+  if (!config || Object.keys(config).length === 0) {
+    console.error("❌ No knowhow config found. Please run 'knowhow init' first.");
+    process.exit(1);
+  }
+
+  // Load language config
+  const language = await getLanguageConfig();
+
+  // Get project name from current directory
+  const projectName = path.basename(process.cwd());
+  console.log(`📁 Project name: ${projectName}`);
+
+  // Create API client
+  const client = new KnowhowSimpleClient(apiUrl, jwt);
+
+  // Get S3 service
+  const { AwsS3 } = services();
+
+  // Step 1: Collect all files to sync
+  console.log("\n📂 Collecting files to sync...");
+  const mainFiles = await collectFilesToSync(projectName);
+  const languageFiles = await collectLanguageReferencedFiles(language, projectName);
+
+  // Deduplicate by remotePath
+  const allFilesMap = new Map<string, FileToSync>();
+  for (const f of [...mainFiles, ...languageFiles]) {
+    allFilesMap.set(f.remotePath, f);
+  }
+  const allFiles = Array.from(allFilesMap.values());
+
+  console.log(`   Found ${allFiles.length} files to sync`);
+
+  if (dryRun) {
+    console.log("\n📋 Files that would be synced:");
+    for (const f of allFiles) {
+      console.log(`   ${f.localPath} → ${f.remotePath}`);
+    }
+  }
+
+  // Step 2: Build the config.files array for all synced files
+  const configFilesEntries = allFiles.map((f) => ({
+    remotePath: f.remotePath,
+    localPath: f.downloadLocalPath ?? f.localPath,
+    direction: "download" as const,
+  }));
+
+  // Step 3: Update config.files and save
+  console.log("\n💾 Updating config.files with sync entries...");
+  if (!dryRun) {
+    // Preserve any existing files entries not in our set
+    const existingFiles = config.files || [];
+    const newRemotePaths = new Set(configFilesEntries.map((e) => e.remotePath));
+
+    // Keep entries that don't overlap with new ones
+    const preserved = existingFiles.filter(
+      (e) => !newRemotePaths.has(e.remotePath)
+    );
+
+    config.files = [...preserved, ...configFilesEntries];
+    await updateConfig(config);
+    console.log(`   ✓ Updated config with ${config.files.length} file entries`);
+  } else {
+    console.log(`   [DRY RUN] Would update config with ${configFilesEntries.length} file entries`);
+  }
+
+  // Step 4: Build workerConfigJson
+  const workerConfigJson = buildWorkerConfigJson(config, configFilesEntries);
+
+  // Step 5: Upload all files
+  console.log(`\n🚀 Uploading ${allFiles.length} files...`);
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const file of allFiles) {
+    try {
+      await uploadSingleFile(client, AwsS3, file.localPath, file.remotePath, dryRun);
+      successCount++;
+    } catch (error) {
+      console.error(`  ❌ Failed to upload ${file.localPath}: ${error.message}`);
+      failCount++;
+    }
+  }
+
+  console.log(`\n   ✓ Upload complete: ${successCount} succeeded, ${failCount} failed`);
+
+  // Step 6: Create or update cloud worker
+  if (create) {
+    const workerName = name || `${projectName}-worker`;
+    console.log(`\n🌩️  Creating cloud worker "${workerName}"...`);
+
+    if (dryRun) {
+      console.log(`   [DRY RUN] Would create cloud worker with name: ${workerName}`);
+      console.log(`   [DRY RUN] workerConfigJson:`, JSON.stringify(workerConfigJson, null, 2));
+    } else {
+      const result = await client.createCloudWorker({
+        name: workerName,
+        workerConfigJson,
+      });
+      const createdWorker = result.data;
+      console.log(`   ✓ Cloud worker created!`);
+      console.log(`   ID: ${createdWorker.id}`);
+      console.log(`   Name: ${createdWorker.name}`);
+      console.log(`\n💡 To push updates later, run:`);
+      console.log(`   knowhow cloudworker --push ${createdWorker.id}`);
+    }
+  } else if (push) {
+    console.log(`\n🌩️  Updating cloud worker "${push}"...`);
+
+    if (dryRun) {
+      console.log(`   [DRY RUN] Would update cloud worker ${push}`);
+      console.log(`   [DRY RUN] workerConfigJson:`, JSON.stringify(workerConfigJson, null, 2));
+    } else {
+      await client.updateCloudWorker(push, { workerConfigJson });
+      console.log(`   ✓ Cloud worker updated!`);
+    }
+  }
+
+  if (failCount > 0) {
+    console.warn(`\n⚠️  ${failCount} file(s) failed to upload.`);
+  } else {
+    console.log(`\n✅ Cloud worker sync complete!`);
+  }
+}

package/src/services/KnowhowClient.ts

@@ -648,4 +648,48 @@ export class KnowhowSimpleClient {
     );
     return response.data;
   }
+
+  // ============================================
+  // Cloud Worker Methods
+  // ============================================
+
+  /**
+   * List all cloud workers for the current user's org
+   */
+  async listCloudWorkers() {
+    await this.checkJwt();
+    return http.get<
+      { id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }[]
+    >(`${this.baseUrl}/api/cloud-workers`, { headers: this.headers });
+  }
+
+  /**
+   * Create a new cloud worker
+   */
+  async createCloudWorker(data: {
+    name: string;
+    workerConfigJson?: Record<string, unknown>;
+  }) {
+    await this.checkJwt();
+    return http.post<{ id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }>(
+      `${this.baseUrl}/api/cloud-workers`,
+      data,
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Update an existing cloud worker
+   */
+  async updateCloudWorker(
+    id: string,
+    data: { workerConfigJson?: Record<string, unknown> }
+  ) {
+    await this.checkJwt();
+    return http.put<{ id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }>(
+      `${this.baseUrl}/api/cloud-workers/${id}`,
+      data,
+      { headers: this.headers }
+    );
+  }
 }

package/src/services/LazyToolsService.ts

@@ -125,23 +125,24 @@ export class LazyToolsService extends ToolsService {
   async callTool(toolCall: ToolCall, enabledTools?: string[]) {
     const functionName = toolCall.function.name;
 
-    // If no explicit enabledTools list was provided and the tool isn't currently
-    // visible, check if it exists in allTools and auto-enable it
-    if (!enabledTools) {
-      const isCurrentlyEnabled = this.tools.some(
-        (t) => t.function.name === functionName
-      );
-      const existsInAll = this.allTools.some(
-        (t) => t.function.name === functionName
-      );
+    // If the tool isn't currently visible but exists in allTools, auto-enable it.
+    // This handles the case where the agent explicitly calls a tool without first
+    // enabling it via listAvailableTools/enableTools.
+    const isCurrentlyEnabled = this.tools.some(
+      (t) => t.function.name === functionName
+    );
+    const existsInAll = this.allTools.some(
+      (t) => t.function.name === functionName
+    );
 
-      if (!isCurrentlyEnabled && existsInAll) {
-        // Auto-enable by adding the tool name as an exact pattern
-        this.enableTools([functionName]);
-      }
+    if (!isCurrentlyEnabled && existsInAll) {
+      // Auto-enable by adding the tool name as an exact pattern
+      this.enableTools([functionName]);
     }
 
-    return super.callTool(toolCall, enabledTools ?? this.getToolNames());
+    // 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());
   }
 
   // Internal: Update visible tools based on patterns