wave-agent-sdk 0.16.8 → 0.16.9

package/src/managers/toolManager.ts

@@ -45,8 +45,6 @@ import { logger } from "../utils/globalLogger.js";
 
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type { SkillMetadata } from "../types/skills.js";
-import { toolSearchTool } from "../tools/toolSearchTool.js";
-import { isDeferredTool } from "../utils/isDeferredTool.js";
 import { startToolSpan, endToolSpan } from "../telemetry/sessionTracing.js";
 
 export interface ToolManagerOptions {
@@ -134,7 +132,6 @@ class ToolManager {
       webFetchTool,
       enterWorktreeTool,
       exitWorktreeTool,
-      toolSearchTool,
     ];
 
     for (const tool of builtInTools) {
@@ -210,7 +207,7 @@ class ToolManager {
       permissionMode: effectivePermissionMode,
       canUseToolCallback,
       permissionManager,
-      toolManager: this, // Allow ToolSearchTool to access the tool manager
+      toolManager: this,
       taskManager:
         this.container.get<import("../services/taskManager.js").TaskManager>(
           "TaskManager",
@@ -349,13 +346,10 @@ class ToolManager {
     availableSkills?: SkillMetadata[];
     workdir?: string;
     isSubagent?: boolean;
-    /** Set of discovered deferred tool names to include in the API call */
-    discoveredTools?: Set<string>;
   }): ChatCompletionFunctionTool[] {
     const permissionManager =
       this.container.get<PermissionManager>("PermissionManager");
     const effectivePermissionMode = this.getPermissionMode();
-    const discoveredTools = options?.discoveredTools;
     const builtInToolsConfig = Array.from(this.toolsRegistry.values())
       .filter((tool) => {
         // If tool is explicitly denied by name in permission rules, filter it out
@@ -380,10 +374,6 @@ class ToolManager {
             effectivePermissionMode !== "bypassPermissions"
           );
         }
-        // Exclude deferred tools that haven't been discovered yet
-        if (isDeferredTool(tool) && !discoveredTools?.has(tool.name)) {
-          return false;
-        }
         return true;
       })
       .map((tool) => {
@@ -406,10 +396,6 @@ class ToolManager {
         if (permissionManager?.isToolDenied(tool.function.name)) {
           return false;
         }
-        // Exclude MCP tools that haven't been discovered yet
-        if (discoveredTools && !discoveredTools.has(tool.function.name)) {
-          return false;
-        }
         return true;
       });
     return [...builtInToolsConfig, ...mcpToolsConfig];
@@ -453,23 +439,6 @@ class ToolManager {
     return this.container.get<PermissionManager>("PermissionManager");
   }
 
-  /**
-   * Get the names of all deferred tools (those that require ToolSearch to discover).
-   */
-  public getDeferredToolNames(): string[] {
-    const permissionManager =
-      this.container.get<PermissionManager>("PermissionManager");
-    const builtInDeferred = Array.from(this.toolsRegistry.values())
-      .filter((tool) => isDeferredTool(tool))
-      .filter((tool) => !permissionManager?.isToolDenied(tool.name))
-      .map((tool) => tool.name);
-    const mcpDeferred = this.mcpManager
-      .getMcpToolsConfig()
-      .filter((tool) => !permissionManager?.isToolDenied(tool.function.name))
-      .map((tool) => tool.function.name);
-    return [...builtInDeferred, ...mcpDeferred];
-  }
-
   /**
    * Get the task manager
    */

package/src/prompts/index.ts

@@ -18,9 +18,7 @@ import {
   READ_TOOL_NAME,
   GLOB_TOOL_NAME,
   GREP_TOOL_NAME,
-  TOOL_SEARCH_TOOL_NAME,
 } from "../constants/tools.js";
-import { isDeferredTool } from "../utils/isDeferredTool.js";
 
 export const BASE_SYSTEM_PROMPT = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
 
@@ -260,17 +258,6 @@ export function buildSystemPrompt(
     prompt += `\n\n${TOOL_POLICY}`;
   }
 
-  // List available deferred tool names with descriptions so the model knows they exist
-  // and can decide which ones to discover via ToolSearch
-  const deferredTools = tools.filter(isDeferredTool);
-  if (deferredTools.length > 0) {
-    const lines = deferredTools.map((t) => {
-      const desc = t.config.function?.description;
-      return desc ? `${t.name} - ${desc}` : t.name;
-    });
-    prompt += `\n\n<available-deferred-tools>\n${lines.join("\n")}\nThese tools are NOT loaded yet — call ${TOOL_SEARCH_TOOL_NAME} first to discover their schemas before invoking them.</available-deferred-tools>`;
-  }
-
   prompt += `\n\n${OUTPUT_EFFICIENCY_PROMPT}`;
   prompt += `\n\n${TONE_AND_STYLE_PROMPT}`;
 

package/src/services/authService.ts

@@ -15,12 +15,16 @@ import {
 } from "fs";
 import * as path from "path";
 import * as os from "os";
+import { randomBytes } from "crypto";
 import { createServer, Server } from "http";
 import { URL } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import type { AuthConfig, AuthUser } from "../types/auth.js";
 
+/** Persistent anonymous ID for telemetry fallback when SSO is not authenticated. */
+let _anonymousId: string | undefined;
+
 const execFileAsync = promisify(execFile);
 
 export class AuthService {
@@ -312,3 +316,55 @@ export class AuthService {
 }
 
 export const authService = AuthService.getInstance();
+
+/**
+ * Get or create a persistent anonymous ID for telemetry.
+ *
+ * Stored in ~/.wave/config.json as { anonymousId: "..." }.
+ * Generated once on first run (32-byte random hex) and reused thereafter.
+ * Falls back to an in-memory ID if file I/O fails.
+ */
+export function getOrCreateAnonymousId(): string {
+  if (_anonymousId) return _anonymousId;
+
+  try {
+    const configPath = path.join(os.homedir(), ".wave", "config.json");
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content) as { anonymousId?: string };
+      if (config.anonymousId) {
+        _anonymousId = config.anonymousId;
+        return _anonymousId;
+      }
+    }
+
+    // Generate and persist
+    _anonymousId = randomBytes(32).toString("hex");
+    const waveDir = path.dirname(configPath);
+    if (!existsSync(waveDir)) {
+      mkdirSync(waveDir, { recursive: true });
+    }
+    const existing = existsSync(configPath)
+      ? (JSON.parse(readFileSync(configPath, "utf-8")) as Record<
+          string,
+          unknown
+        >)
+      : {};
+    writeFileSync(
+      configPath,
+      JSON.stringify({ ...existing, anonymousId: _anonymousId }, null, 2),
+      "utf-8",
+    );
+    chmodSync(configPath, 0o600);
+  } catch {
+    // File I/O failed — use in-memory fallback
+    _anonymousId = randomBytes(32).toString("hex");
+  }
+
+  return _anonymousId;
+}
+
+/** @internal — reset anonymous ID cache for testing only */
+export function __resetAnonymousIdForTesting(): void {
+  _anonymousId = undefined;
+}

package/src/services/configurationService.ts

@@ -461,8 +461,7 @@ export class ConfigurationService {
     }
 
     // Resolve custom headers from environment: env (settings.json) > process.env
-    const envCustomHeaders =
-      process.env.WAVE_CUSTOM_HEADERS || process.env.WAVE_CUSTOM_HEADERS || "";
+    const envCustomHeaders = process.env.WAVE_CUSTOM_HEADERS || "";
     const parsedEnvHeaders = parseCustomHeaders(envCustomHeaders);
 
     // Merge headers: env headers < options < override
@@ -497,19 +496,13 @@ export class ConfigurationService {
     maxTokens?: number,
     permissionMode?: PermissionMode,
   ): ModelConfig {
-    // Resolve agent model: override > options > env (settings.json) > process.env
+    // Resolve agent model: override > options > process.env (includes settings.json env)
     const resolvedAgentModel =
-      model ||
-      this.options.model ||
-      process.env.WAVE_MODEL ||
-      process.env.WAVE_MODEL;
+      model || this.options.model || process.env.WAVE_MODEL;
 
-    // Resolve fast model: override > options > env (settings.json) > process.env
+    // Resolve fast model: override > options > process.env (includes settings.json env)
     const resolvedFastModel =
-      fastModel ||
-      this.options.fastModel ||
-      process.env.WAVE_FAST_MODEL ||
-      process.env.WAVE_FAST_MODEL;
+      fastModel || this.options.fastModel || process.env.WAVE_FAST_MODEL;
 
     // Validate required fields
     if (!resolvedAgentModel) {
@@ -572,8 +565,7 @@ export class ConfigurationService {
     }
 
     // Try env (settings.json) first, then process.env
-    const envMaxInputTokens =
-      process.env.WAVE_MAX_INPUT_TOKENS || process.env.WAVE_MAX_INPUT_TOKENS;
+    const envMaxInputTokens = process.env.WAVE_MAX_INPUT_TOKENS;
     if (envMaxInputTokens) {
       const parsed = parseInt(envMaxInputTokens, 10);
       if (!isNaN(parsed)) {
@@ -677,8 +669,7 @@ export class ConfigurationService {
     }
 
     // Try env (settings.json) first, then process.env
-    const envMaxOutputTokens =
-      process.env.WAVE_MAX_OUTPUT_TOKENS || process.env.WAVE_MAX_OUTPUT_TOKENS;
+    const envMaxOutputTokens = process.env.WAVE_MAX_OUTPUT_TOKENS;
     if (envMaxOutputTokens) {
       const parsed = parseInt(envMaxOutputTokens, 10);
       if (!isNaN(parsed) && parsed > 0) {
@@ -704,8 +695,7 @@ export class ConfigurationService {
     const models = new Set<string>();
 
     // Add current model from options or environment
-    const currentModel =
-      this.options.model || process.env.WAVE_MODEL || process.env.WAVE_MODEL;
+    const currentModel = this.options.model || process.env.WAVE_MODEL;
     if (currentModel) {
       models.add(currentModel);
     }

package/src/services/pluginLoader.ts

@@ -14,7 +14,6 @@ import {
   parseAgentFile,
   type SubagentConfiguration,
 } from "../utils/subagentParser.js";
-import { resolveMcpConfig } from "../managers/mcpManager.js";
 import { logger } from "../utils/globalLogger.js";
 
 export class PluginLoader {
@@ -143,7 +142,8 @@ export class PluginLoader {
     const mcpPath = path.join(pluginPath, ".mcp.json");
     try {
       const content = await fs.readFile(mcpPath, "utf-8");
-      return resolveMcpConfig(JSON.parse(content)) as McpConfig;
+      // Return raw config — let McpManager resolve templates and capture originalUrl
+      return JSON.parse(content) as McpConfig;
     } catch {
       return undefined;
     }

package/src/telemetry/instrumentation.ts

@@ -18,7 +18,10 @@ import type {
   LogRecordExporter,
   ReadableLogRecord,
 } from "@opentelemetry/sdk-logs";
-import { AuthService } from "../services/authService.js";
+import {
+  AuthService,
+  getOrCreateAnonymousId,
+} from "../services/authService.js";
 
 // Lazy-loaded OTEL modules — only imported when telemetry is initialized
 let sdkNode: typeof import("@opentelemetry/sdk-node") | undefined;
@@ -471,8 +474,11 @@ export function isInitialized(): boolean {
 export { JsonlSpanExporter, JsonlLogExporter };
 
 /**
- * Get telemetry attributes based on the authenticated SSO user.
- * Returns user.id and user.email when SSO authenticated, empty object otherwise.
+ * Get telemetry attributes for the current session.
+ *
+ * Priority:
+ * 1. SSO authenticated → server-provided user.id + user.email
+ * 2. Not authenticated → persistent anonymous ID from ~/.wave/config.json
  */
 export function getTelemetryAttributes(): Record<string, string> {
   try {
@@ -487,5 +493,7 @@ export function getTelemetryAttributes(): Record<string, string> {
   } catch {
     // AuthService not available or not authenticated
   }
-  return {};
+
+  // Fallback to anonymous ID
+  return { "user.id": getOrCreateAnonymousId() };
 }

package/src/tools/buildTool.ts

@@ -24,8 +24,6 @@ export interface ToolDef {
     params: Record<string, unknown>,
     context: ToolContext,
   ) => string;
-  shouldDefer?: boolean;
-  alwaysLoad?: boolean;
   additionalProperties?: boolean;
 }
 
@@ -59,7 +57,5 @@ export function buildTool(def: ToolDef): ToolPlugin {
     execute: def.execute,
     prompt: promptFn,
     formatCompactParams: def.formatCompactParams,
-    shouldDefer: def.shouldDefer ?? false,
-    alwaysLoad: def.alwaysLoad ?? false,
   };
 }

package/src/tools/cronCreateTool.ts

@@ -48,7 +48,6 @@ Returns a job ID you can pass to CronDelete.`;
 
 export const cronCreateTool: ToolPlugin = {
   name: CRON_CREATE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/cronDeleteTool.ts

@@ -7,7 +7,6 @@ const CRON_DELETE_PROMPT = `Cancel a cron job previously scheduled with CronCrea
 
 export const cronDeleteTool: ToolPlugin = {
   name: CRON_DELETE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/cronListTool.ts

@@ -7,7 +7,6 @@ const CRON_LIST_PROMPT = `List all cron jobs scheduled via CronCreate in this se
 
 export const cronListTool: ToolPlugin = {
   name: CRON_LIST_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/enterWorktreeTool.ts

@@ -48,7 +48,6 @@ export const ENTER_WORKTREE_TOOL_PROMPT = `Use this tool ONLY when the user expl
 
 export const enterWorktreeTool: ToolPlugin = {
   name: ENTER_WORKTREE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/exitWorktreeTool.ts

@@ -47,7 +47,6 @@ If called outside an EnterWorktree session, the tool is a **no-op**: it reports
 
 export const exitWorktreeTool: ToolPlugin = {
   name: EXIT_WORKTREE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/taskManagementTools.ts

@@ -9,7 +9,6 @@ import {
 
 export const taskCreateTool: ToolPlugin = {
   name: TASK_CREATE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {
@@ -144,7 +143,6 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 
 export const taskGetTool: ToolPlugin = {
   name: TASK_GET_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {
@@ -204,7 +202,6 @@ Returns full task details:
 
 export const taskUpdateTool: ToolPlugin = {
   name: TASK_UPDATE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {
@@ -559,7 +556,6 @@ Set up task dependencies:
 
 export const taskListTool: ToolPlugin = {
   name: TASK_LIST_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/types.ts

@@ -31,21 +31,6 @@ export interface ToolPlugin {
     workdir?: string;
     isSubagent?: boolean;
   }) => string;
-  /**
-   * When true, this tool is deferred — it's not sent to the API until the model
-   * discovers it via ToolSearch. MCP tools are always deferred.
-   */
-  shouldDefer?: boolean;
-  /**
-   * When true, this tool is never deferred — its full schema always appears in
-   * the initial prompt even when tool search is enabled.
-   */
-  alwaysLoad?: boolean;
-  /**
-   * When true, this is an MCP tool (auto-set by McpManager). MCP tools are
-   * always deferred unless they have alwaysLoad: true.
-   */
-  isMcp?: boolean;
 }
 
 export interface ToolResult {

package/src/tools/webFetchTool.ts

@@ -103,7 +103,6 @@ const GITHUB_URL_ERROR =
 
 export const webFetchTool: ToolPlugin = {
   name: WEB_FETCH_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/types/mcp.ts

@@ -26,7 +26,14 @@ export interface McpTool {
 export interface McpServerStatus {
   name: string;
   config: McpServerConfig;
-  status: "disconnected" | "connected" | "connecting" | "error";
+  /** Pre-resolution URL with template variables (e.g. ${WAVE_SSO_TOKEN}) preserved for safe display */
+  originalUrl?: string;
+  status:
+    | "disconnected"
+    | "connected"
+    | "connecting"
+    | "reconnecting"
+    | "error";
   tools?: McpTool[];
   toolCount?: number;
   capabilities?: string[];

package/src/utils/mcpUtils.ts

@@ -91,7 +91,6 @@ export function createMcpToolPlugin(
   return {
     name: prefixedName,
     config: mcpToolToOpenAITool(mcpTool, serverName),
-    isMcp: true, // MCP tools are always deferred
     async execute(
       args: Record<string, unknown>,
       context?: ToolContext,

package/dist/tools/toolSearchTool.d.ts

@@ -1,15 +0,0 @@
-/**
- * ToolSearchTool - Discovers deferred tool schemas on demand.
- *
- * When tool deferral is enabled, deferred tools are not sent to the API.
- * The model must call this tool to discover a deferred tool's full schema
- * before it can invoke it.
- *
- * Query formats:
- * - "select:ToolName" — direct selection by name (comma-separated for multiple)
- * - "notebook jupyter" — keyword search, up to max_results best matches
- * - "+slack send" — require "slack" in the name, rank by remaining terms
- */
-import { ToolPlugin } from "./types.js";
-export declare const toolSearchTool: ToolPlugin;
-//# sourceMappingURL=toolSearchTool.d.ts.map

package/dist/tools/toolSearchTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolSearchTool.d.ts","sourceRoot":"","sources":["../../src/tools/toolSearchTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA4GjE,eAAO,MAAM,cAAc,EAAE,UAuH5B,CAAC"}

package/dist/tools/toolSearchTool.js

@@ -1,200 +0,0 @@
-/**
- * ToolSearchTool - Discovers deferred tool schemas on demand.
- *
- * When tool deferral is enabled, deferred tools are not sent to the API.
- * The model must call this tool to discover a deferred tool's full schema
- * before it can invoke it.
- *
- * Query formats:
- * - "select:ToolName" — direct selection by name (comma-separated for multiple)
- * - "notebook jupyter" — keyword search, up to max_results best matches
- * - "+slack send" — require "slack" in the name, rank by remaining terms
- */
-import { isDeferredTool, TOOL_SEARCH_TOOL_NAME, } from "../utils/isDeferredTool.js";
-function formatSchema(tool) {
-    const desc = tool.config.function.description || "";
-    const params = JSON.stringify(tool.config.function.parameters || {}, null, 2);
-    return `${tool.name}: ${desc}\nParameters: ${params}`;
-}
-/**
- * Parse tool name into searchable parts (handles CamelCase and underscores).
- */
-function parseToolName(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, "$1 $2") // CamelCase to spaces
-        .replace(/_/g, " ")
-        .toLowerCase()
-        .split(/\s+/)
-        .filter(Boolean);
-}
-/**
- * Keyword search over deferred tools by name and description.
- * Matches Claude Code's scoring: required terms (+prefix) must all match,
- * optional terms contribute to ranking.
- */
-function keywordSearch(query, deferredTools, maxResults) {
-    const queryLower = query.toLowerCase().trim();
-    const queryTerms = queryLower.split(/\s+/).filter(Boolean);
-    // Exact match fast path
-    const exact = deferredTools.find((t) => t.name.toLowerCase() === queryLower);
-    if (exact)
-        return [exact];
-    // Partition into required (+prefixed) and optional terms
-    const requiredTerms = [];
-    const optionalTerms = [];
-    for (const term of queryTerms) {
-        if (term.startsWith("+") && term.length > 1) {
-            requiredTerms.push(term.slice(1));
-        }
-        else {
-            optionalTerms.push(term);
-        }
-    }
-    const allScoringTerms = requiredTerms.length > 0
-        ? [...requiredTerms, ...optionalTerms]
-        : queryTerms;
-    // Pre-filter to tools matching ALL required terms
-    let candidateTools = deferredTools;
-    if (requiredTerms.length > 0) {
-        candidateTools = deferredTools.filter((tool) => {
-            const parts = parseToolName(tool.name);
-            const desc = (tool.config.function.description || "").toLowerCase();
-            return requiredTerms.every((term) => parts.includes(term) ||
-                parts.some((p) => p.includes(term)) ||
-                desc.includes(term));
-        });
-    }
-    // Score each tool
-    const scored = candidateTools
-        .map((tool) => {
-        const parts = parseToolName(tool.name);
-        const desc = (tool.config.function.description || "").toLowerCase();
-        let score = 0;
-        for (const term of allScoringTerms) {
-            // Exact part match (high weight)
-            if (parts.includes(term)) {
-                score += tool.isMcp ? 12 : 10;
-            }
-            else if (parts.some((p) => p.includes(term))) {
-                score += tool.isMcp ? 6 : 5;
-            }
-            // Full name fallback
-            if (tool.name.toLowerCase().includes(term) && score === 0) {
-                score += 3;
-            }
-            // Description match
-            if (desc.includes(term)) {
-                score += 2;
-            }
-        }
-        return { tool, score };
-    })
-        .filter((s) => s.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, maxResults)
-        .map((s) => s.tool);
-    return scored;
-}
-export const toolSearchTool = {
-    name: TOOL_SEARCH_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: TOOL_SEARCH_TOOL_NAME,
-            description: `Fetches full schema definitions for deferred tools so they can be called.
-
-Deferred tools appear by name and description in <available-deferred-tools> messages. The full parameter schema is NOT loaded yet — use this tool to fetch it before invoking a deferred tool. This tool takes a query, matches it against the deferred tool list, and returns the matched tools' complete JSONSchema definitions inside a <functions> block. Once a tool's schema appears in that result, it is callable exactly like any tool defined at the top of the prompt.
-
-Result format: each matched tool appears as one <function>{"description": "...", "name": "...", "parameters": {...}}`,
-            parameters: {
-                type: "object",
-                properties: {
-                    query: {
-                        type: "string",
-                        description: 'Search query for finding deferred tools. Supports: "select:ToolName" for direct lookup, or keyword search like "notebook jupyter". Use "+term" to require a term (e.g. "+slack send").',
-                    },
-                    max_results: {
-                        type: "number",
-                        description: "Maximum number of results to return for keyword search (default: 5).",
-                    },
-                },
-                required: ["query"],
-                additionalProperties: false,
-            },
-        },
-    },
-    shouldDefer: false, // Always available
-    execute: async (args, context) => {
-        const { query, max_results = 5 } = args;
-        if (!query) {
-            return {
-                success: false,
-                content: "",
-                error: "Missing required 'query' parameter",
-            };
-        }
-        if (!context.toolManager) {
-            return {
-                success: false,
-                content: "",
-                error: "ToolManager not available in context",
-            };
-        }
-        const allTools = context.toolManager.list();
-        const deferredTools = allTools.filter(isDeferredTool);
-        // Handle select: prefix
-        const selectMatch = query.match(/^select:(.+)$/i);
-        if (selectMatch) {
-            const requested = selectMatch[1]
-                .split(",")
-                .map((s) => s.trim())
-                .filter(Boolean);
-            const found = [];
-            const missing = [];
-            for (const toolName of requested) {
-                const tool = deferredTools.find((t) => t.name === toolName) ??
-                    allTools.find((t) => t.name === toolName);
-                if (tool) {
-                    if (!found.some((f) => f.name === tool.name))
-                        found.push(tool);
-                }
-                else {
-                    missing.push(toolName);
-                }
-            }
-            if (found.length === 0) {
-                return {
-                    success: false,
-                    content: "",
-                    error: `No matching deferred tools found for: ${missing.join(", ")}`,
-                };
-            }
-            const result = found.map(formatSchema).join("\n\n---\n\n");
-            const shortResult = `Discovered tools: ${found.map((t) => t.name).join(", ")}`;
-            return {
-                success: true,
-                content: result,
-                shortResult,
-            };
-        }
-        // Keyword search
-        const matches = keywordSearch(query, deferredTools, max_results);
-        if (matches.length === 0) {
-            return {
-                success: false,
-                content: "",
-                error: `No matching deferred tools found for query: "${query}". Available deferred tools: ${getDeferredToolNamesList(deferredTools)}`,
-            };
-        }
-        const result = matches.map(formatSchema).join("\n\n---\n\n");
-        const shortResult = `Found ${matches.length} tools: ${matches.map((t) => t.name).join(", ")}`;
-        return {
-            success: true,
-            content: result,
-            shortResult,
-        };
-    },
-};
-function getDeferredToolNamesList(tools) {
-    return tools.map((t) => t.name).join(", ");
-}