@yourgpt/llm-sdk 2.1.3 → 2.1.4-alpha.0

package/dist/index.mjs

@@ -1147,6 +1147,279 @@ var GenerateResult = class {
   }
 };
 
+// src/server/tool-selection.ts
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+var MIN_SCORE = 0.1;
+function unique(values) {
+  return [...new Set(values)];
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9_\s-]/g, " ").split(/\s+/).filter((token) => token.length > 1);
+}
+function stringifyContent(content) {
+  if (typeof content === "string") return content;
+  if (!content) return "";
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+function buildToolQuery(messages) {
+  return messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-3).map((m) => stringifyContent(m.content)).filter(Boolean).join(" ");
+}
+function buildSearchText(tool2) {
+  return [
+    tool2.name.replace(/_/g, " "),
+    tool2.description,
+    tool2.category ?? "",
+    tool2.group ?? "",
+    ...tool2.profiles ?? [],
+    ...tool2.searchKeywords ?? []
+  ].filter(Boolean).join(" ");
+}
+function matchesSelector(tool2, selector, activeProfile) {
+  const normalized = selector.trim().toLowerCase();
+  if (!normalized) return false;
+  if (normalized === "*" || normalized === "all") return true;
+  if (normalized === tool2.name.toLowerCase()) return true;
+  if (normalized.startsWith("group:")) {
+    return (tool2.group ?? "").toLowerCase() === normalized.slice(6);
+  }
+  if (normalized.startsWith("category:")) {
+    return (tool2.category ?? "").toLowerCase() === normalized.slice(9);
+  }
+  if (normalized.startsWith("profile:")) {
+    return (tool2.profiles ?? []).map((v) => v.toLowerCase()).includes(normalized.slice(8));
+  }
+  if (activeProfile && normalized === activeProfile.toLowerCase()) {
+    return (tool2.profiles ?? []).map((v) => v.toLowerCase()).includes(normalized);
+  }
+  return false;
+}
+function scoreTool(tool2, queryTokens, activeProfile) {
+  const haystack = [
+    tool2.name,
+    tool2.description,
+    tool2.category,
+    tool2.group,
+    ...tool2.profiles ?? [],
+    ...tool2.searchKeywords ?? []
+  ].filter(Boolean).join(" ").toLowerCase();
+  let score = tool2.deferLoading ? 0 : 2;
+  if (activeProfile && tool2.profiles?.includes(activeProfile)) score += 2;
+  for (const token of queryTokens) {
+    if (tool2.name.toLowerCase() === token) score += 6;
+    else if (tool2.name.toLowerCase().includes(token)) score += 4;
+    else if (haystack.includes(token)) score += 2;
+  }
+  return score;
+}
+function filterToolsByProfile(params) {
+  const available = params.tools.filter((tool2) => tool2.available !== false);
+  const config = params.config;
+  if (!config) return available;
+  const activeProfile = params.activeProfile ?? config.defaultProfile;
+  const includeUnprofiled = config.includeUnprofiled ?? true;
+  const profile = activeProfile ? config.profiles?.[activeProfile] : void 0;
+  let filtered = available;
+  if (profile?.include?.length) {
+    filtered = filtered.filter(
+      (tool2) => profile.include.some(
+        (selector) => matchesSelector(tool2, selector, activeProfile)
+      ) || !!activeProfile && tool2.profiles?.includes(activeProfile)
+    );
+  } else if (activeProfile) {
+    filtered = filtered.filter((tool2) => {
+      if (tool2.profiles?.length) return tool2.profiles.includes(activeProfile);
+      return includeUnprofiled;
+    });
+  }
+  if (profile?.exclude?.length) {
+    filtered = filtered.filter(
+      (tool2) => !profile.exclude.some(
+        (selector) => matchesSelector(tool2, selector, activeProfile)
+      )
+    );
+  }
+  return filtered;
+}
+function calculateBM25Score(tool2, queryTerms, idf, avgDocLength, activeProfile) {
+  const text = buildSearchText(tool2);
+  const tokens = tokenize(text);
+  const docLength = Math.max(1, tokens.length);
+  let score = 0;
+  for (const term of queryTerms) {
+    const termFreq = tokens.filter((t) => t === term).length;
+    if (termFreq === 0) continue;
+    const termIDF = idf.get(term) ?? 0;
+    const numerator = termFreq * (BM25_K1 + 1);
+    const denominator = termFreq + BM25_K1 * (1 - BM25_B + BM25_B * (docLength / avgDocLength));
+    score += termIDF * (numerator / denominator);
+  }
+  const nameLower = tool2.name.toLowerCase();
+  for (const term of queryTerms) {
+    if (nameLower === term) score += 3;
+    else if (nameLower.includes(term)) score += 1.5;
+  }
+  if (activeProfile && tool2.profiles?.includes(activeProfile)) score += 0.75;
+  return score;
+}
+function selectTools(params) {
+  const config = params.config;
+  const available = filterToolsByProfile({
+    tools: params.tools,
+    config,
+    activeProfile: params.activeProfile
+  });
+  if (!config) return available;
+  const activeProfile = params.activeProfile ?? config.defaultProfile;
+  const forceIncludeNames = new Set(params.forceIncludeNames ?? []);
+  let filtered = available.filter(
+    (tool2) => !tool2.deferLoading || forceIncludeNames.has(tool2.name)
+  );
+  if (filtered.length === 0) return filtered;
+  const maxTools = Math.max(1, Math.min(config.maxEagerTools, filtered.length));
+  const queryTokens = unique(tokenize(buildToolQuery(params.messages)));
+  const ranked = [...filtered].sort((a, b) => {
+    const diff = scoreTool(b, queryTokens, activeProfile) - scoreTool(a, queryTokens, activeProfile);
+    return diff !== 0 ? diff : a.name.localeCompare(b.name);
+  });
+  if (forceIncludeNames.size === 0) return ranked.slice(0, maxTools);
+  const forced = ranked.filter((t) => forceIncludeNames.has(t.name));
+  const others = ranked.filter((t) => !forceIncludeNames.has(t.name));
+  const remaining = Math.max(0, maxTools - forced.length);
+  return [...forced, ...others.slice(0, remaining)];
+}
+function searchTools(params) {
+  const queryTerms = unique(tokenize(params.query));
+  if (queryTerms.length === 0) return [];
+  const candidates = filterToolsByProfile({
+    tools: params.tools,
+    config: params.config,
+    activeProfile: params.activeProfile
+  }).filter((tool2) => {
+    if ((params.excludeNames ?? []).includes(tool2.name)) return false;
+    if (params.includeSelected) return true;
+    return tool2.deferLoading === true;
+  });
+  if (candidates.length === 0) return [];
+  const docs = candidates.map((tool2) => tokenize(buildSearchText(tool2)));
+  const avgDocLength = docs.reduce((sum, tokens) => sum + Math.max(1, tokens.length), 0) / docs.length;
+  const idf = /* @__PURE__ */ new Map();
+  for (const term of queryTerms) {
+    const docFreq = docs.reduce(
+      (count, tokens) => count + (tokens.includes(term) ? 1 : 0),
+      0
+    );
+    idf.set(
+      term,
+      Math.log((docs.length - docFreq + 0.5) / (docFreq + 0.5) + 1)
+    );
+  }
+  const limit = Math.max(1, params.limit ?? params.config?.maxResults ?? 8);
+  const activeProfile = params.activeProfile ?? params.config?.defaultProfile;
+  return candidates.map((tool2) => ({
+    tool: tool2,
+    score: calculateBM25Score(
+      tool2,
+      queryTerms,
+      idf,
+      avgDocLength,
+      activeProfile
+    )
+  })).filter((entry) => entry.score >= MIN_SCORE).sort((a, b) => {
+    const diff = b.score - a.score;
+    return diff !== 0 ? diff : a.tool.name.localeCompare(b.tool.name);
+  }).slice(0, limit).map(({ tool: tool2, score }) => ({
+    name: tool2.name,
+    description: tool2.description,
+    location: tool2.location,
+    category: tool2.category,
+    group: tool2.group,
+    profiles: tool2.profiles,
+    searchKeywords: tool2.searchKeywords,
+    score: Number(score.toFixed(4))
+  }));
+}
+function normalizeModelName(modelName) {
+  return (modelName ?? "").trim().toLowerCase();
+}
+function supportsAnthropicNativeToolSearch(modelName) {
+  const model = normalizeModelName(modelName);
+  if (!model || model.includes("haiku")) return false;
+  return /(?:^|[-_ ])(?:sonnet|opus)[-_ ]?4(?:$|[-_. ])/.test(model) || /claude[-_ ](?:sonnet|opus)[-_ ]?4/.test(model) || /claude[-_ ]?4[-_ ](?:sonnet|opus)/.test(model);
+}
+function supportsOpenAINativeToolSearch(modelName) {
+  const model = normalizeModelName(modelName);
+  if (!model) return false;
+  const match = model.match(/^gpt-5(?:[._-](\d+))?(?:$|[._-])/);
+  if (!match) return false;
+  const minorVersion = match[1] ? Number.parseInt(match[1], 10) : Number.NaN;
+  if (!Number.isFinite(minorVersion)) return false;
+  return minorVersion >= 4;
+}
+function resolveNativeToolSearch(params) {
+  if (!params.config) return null;
+  if (params.providerName === "anthropic" && supportsAnthropicNativeToolSearch(params.modelName)) {
+    return { provider: "anthropic", variant: "bm25" };
+  }
+  if (params.providerName === "openai" && supportsOpenAINativeToolSearch(params.modelName)) {
+    return { provider: "openai", useResponsesApi: true };
+  }
+  return null;
+}
+function shouldExposeToolSearch(params) {
+  if (!params.config) return false;
+  const deferredCount = params.tools.filter((t) => t.deferLoading).length;
+  if (deferredCount === 0) return false;
+  return params.tools.length >= params.config.exposeWhenExceeds;
+}
+function buildProviderToolOptions(params) {
+  const { toolChoice, parallelCalls } = params.config ?? {};
+  const resolvedNativeSearch = resolveNativeToolSearch({
+    providerName: params.providerName,
+    modelName: params.modelName,
+    config: params.config
+  });
+  if (params.providerName === "openai") {
+    if (toolChoice === void 0 && parallelCalls === void 0 && !resolvedNativeSearch) {
+      return void 0;
+    }
+    let oaiToolChoice;
+    if (toolChoice === "required") oaiToolChoice = "required";
+    else if (toolChoice === "auto") oaiToolChoice = "auto";
+    return {
+      openai: {
+        toolChoice: oaiToolChoice,
+        parallelToolCalls: parallelCalls,
+        nativeToolSearch: resolvedNativeSearch?.provider === "openai" ? {
+          enabled: true,
+          useResponsesApi: resolvedNativeSearch.useResponsesApi
+        } : void 0
+      }
+    };
+  }
+  if (params.providerName === "anthropic") {
+    if (toolChoice === void 0 && parallelCalls === void 0 && !resolvedNativeSearch) {
+      return void 0;
+    }
+    let anthropicToolChoice;
+    if (toolChoice === "required") anthropicToolChoice = "any";
+    else if (toolChoice === "auto") anthropicToolChoice = "auto";
+    return {
+      anthropic: {
+        toolChoice: anthropicToolChoice,
+        // parallelCalls: false → disableParallelToolUse: true
+        disableParallelToolUse: parallelCalls === false ? true : void 0,
+        nativeToolSearch: resolvedNativeSearch?.provider === "anthropic" ? { enabled: true, variant: resolvedNativeSearch.variant ?? "bm25" } : void 0
+      }
+    };
+  }
+  return void 0;
+}
+
 // src/server/runtime.ts
 function buildToolResultForAI(tool2, result, args) {
   const typedResult = result;
@@ -1271,7 +1544,8 @@ var Runtime = class {
       systemPrompt: request.systemPrompt || this.config.systemPrompt,
       config: request.config,
       signal,
-      webSearch: this.getWebSearchConfig()
+      webSearch: this.getWebSearchConfig(),
+      debug: this.config.debug
     };
     const stream = this.adapter.stream(completionRequest);
     for await (const event of stream) {
@@ -1328,11 +1602,18 @@ var Runtime = class {
     try {
       const body = await request.json();
       if (this.config.debug) {
-        console.log("[Copilot SDK] Request:", JSON.stringify(body, null, 2));
+        console.log("[Copilot SDK] Request:", {
+          messageCount: body.messages?.length ?? 0,
+          toolCount: body.tools?.length ?? 0,
+          hasSystemPrompt: Boolean(body.systemPrompt),
+          threadId: body.threadId,
+          streaming: body.streaming !== false,
+          toolProfile: body.toolProfile
+        });
       }
       const signal = request.signal;
       const hasTools = body.tools && body.tools.length > 0 || this.tools.size > 0;
-      const useAgentLoop = hasTools || this.config.agentLoop?.enabled;
+      const useAgentLoop = hasTools;
       if (body.streaming === false) {
         return this.handleNonStreamingRequest(
           body,
@@ -1588,6 +1869,170 @@ var Runtime = class {
     }
     return void 0;
   }
+  /**
+   * Resolve effective tool selection config for a request.
+   */
+  resolveEffectiveToolSelectionConfig(request) {
+    const toolSearch = "toolSearch" in this.config ? this.config.toolSearch : void 0;
+    const hasDeferredServerTool = [...this.tools.values()].some(
+      (t) => t.deferLoading
+    );
+    const hasDeferredInRequest = request.tools?.some((t) => t.deferLoading);
+    if (!hasDeferredServerTool && !hasDeferredInRequest && !toolSearch) {
+      return void 0;
+    }
+    return {
+      maxEagerTools: toolSearch?.maxEagerTools ?? 20,
+      maxResults: toolSearch?.maxResults ?? 8,
+      exposeWhenExceeds: toolSearch?.exposeWhenExceeds ?? 8,
+      toolChoice: toolSearch?.toolChoice,
+      parallelCalls: toolSearch?.parallelCalls,
+      defaultProfile: toolSearch?.defaultProfile,
+      profiles: toolSearch?.profiles,
+      includeUnprofiled: toolSearch?.includeUnprofiled
+    };
+  }
+  collectToolsForRequest(request) {
+    const allTools = [...this.tools.values()];
+    if (request.tools) {
+      for (const tool2 of request.tools) {
+        allTools.push({
+          name: tool2.name,
+          description: tool2.description,
+          location: "client",
+          category: tool2.category,
+          group: tool2.group,
+          deferLoading: tool2.deferLoading,
+          profiles: tool2.profiles,
+          searchKeywords: tool2.searchKeywords,
+          inputSchema: tool2.inputSchema
+        });
+      }
+    }
+    return allTools;
+  }
+  selectToolsForRequest(request, allTools, toolSearchState) {
+    return selectTools({
+      tools: allTools,
+      messages: request.messages,
+      config: this.resolveEffectiveToolSelectionConfig(request),
+      activeProfile: request.toolProfile,
+      forceIncludeNames: toolSearchState?.loadedToolNames
+    });
+  }
+  resolveNativeToolSearchForRequest(request) {
+    return resolveNativeToolSearch({
+      providerName: this.adapter.provider,
+      modelName: this.getModel(),
+      config: this.resolveEffectiveToolSelectionConfig(request)
+    });
+  }
+  buildNativeToolCatalogForRequest(request, allTools) {
+    return filterToolsByProfile({
+      tools: allTools,
+      config: this.resolveEffectiveToolSelectionConfig(request),
+      activeProfile: request.toolProfile
+    });
+  }
+  buildProviderToolOptionsForRequest(selectedTools, request) {
+    return buildProviderToolOptions({
+      providerName: this.adapter.provider,
+      modelName: this.getModel(),
+      config: this.resolveEffectiveToolSelectionConfig(request),
+      metaToolName: this.getToolSearchMetaToolName()
+    });
+  }
+  getToolSearchMetaToolName() {
+    const toolSearch = "toolSearch" in this.config ? this.config.toolSearch : void 0;
+    return toolSearch?.name ?? "search_tools";
+  }
+  createToolSearchTool(request, allTools, selectedTools) {
+    if (!shouldExposeToolSearch({
+      tools: allTools,
+      config: this.resolveEffectiveToolSelectionConfig(request)
+    })) {
+      return null;
+    }
+    const toolName = this.getToolSearchMetaToolName();
+    const excludedNames = selectedTools.map((tool2) => tool2.name);
+    return {
+      name: toolName,
+      description: "toolSearch" in this.config && this.config.toolSearch?.description || "Search available deferred tools and load the most relevant ones for the next step when the right tool is not currently exposed.",
+      location: "server",
+      hidden: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Describe the tool capability you need to find."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of matching tools to load."
+          }
+        },
+        required: ["query"]
+      },
+      handler: async (params) => {
+        const args = params;
+        const results = searchTools({
+          tools: allTools,
+          query: args.query,
+          config: this.resolveEffectiveToolSelectionConfig(request),
+          activeProfile: request.toolProfile,
+          limit: args.limit,
+          excludeNames: excludedNames
+        });
+        if (this.config.debug) {
+          console.log("[Copilot SDK] search_tools result:", {
+            query: args.query,
+            activeProfile: request.toolProfile,
+            selectedToolCount: selectedTools.length,
+            catalogCount: allTools.length,
+            loadedTools: results.map((result) => result.name),
+            results: results.map((result) => ({
+              name: result.name,
+              location: result.location,
+              category: result.category,
+              group: result.group,
+              score: result.score
+            }))
+          });
+        }
+        return {
+          success: true,
+          query: args.query,
+          loadedTools: results.map((result) => result.name),
+          results
+        };
+      }
+    };
+  }
+  extendLoadedToolNames(current, results) {
+    const loaded = new Set(current?.loadedToolNames ?? []);
+    const searchToolName = this.getToolSearchMetaToolName();
+    for (const result of results) {
+      if (result.name !== searchToolName) {
+        continue;
+      }
+      const typedResult = result.result;
+      if (!Array.isArray(typedResult?.loadedTools)) {
+        continue;
+      }
+      for (const toolName of typedResult.loadedTools) {
+        if (typeof toolName === "string" && toolName) {
+          loaded.add(toolName);
+        }
+      }
+    }
+    if (loaded.size === 0) {
+      return current;
+    }
+    return {
+      loadedToolNames: [...loaded]
+    };
+  }
   /**
    * Process a chat request with tool support (Vercel AI SDK pattern)
    *
@@ -1599,8 +2044,8 @@ var Runtime = class {
    * 5. Loop continues until no more tool calls or max iterations reached
    * 6. Returns all new messages in the done event for client to append
    */
-  async *processChatWithLoop(request, signal, _accumulatedMessages, _isRecursive, _httpRequest) {
-    const debug = this.config.debug || this.config.agentLoop?.debug;
+  async *processChatWithLoop(request, signal, _accumulatedMessages, _isRecursive, _httpRequest, _toolSearchState) {
+    const debug = this.config.debug;
     if (request.streaming === false) {
       if (debug) {
         console.log("[Copilot SDK] Using non-streaming mode");
@@ -1610,29 +2055,41 @@ var Runtime = class {
         signal,
         _accumulatedMessages,
         _isRecursive,
-        _httpRequest
+        _httpRequest,
+        _toolSearchState
       )) {
         yield event;
       }
       return;
     }
     const newMessages = _accumulatedMessages || [];
-    this.config.agentLoop?.maxIterations || 20;
-    const allTools = [...this.tools.values()];
-    if (request.tools) {
-      for (const tool2 of request.tools) {
-        allTools.push({
-          name: tool2.name,
-          description: tool2.description,
-          location: "client",
-          inputSchema: tool2.inputSchema
-        });
-      }
-    }
+    this.config.maxIterations ?? 20;
+    const allTools = this.collectToolsForRequest(request);
+    const nativeToolSearch = this.resolveNativeToolSearchForRequest(request);
+    const nativeToolCatalog = nativeToolSearch ? this.buildNativeToolCatalogForRequest(request, allTools) : null;
+    const selectedTools = nativeToolCatalog ?? this.selectToolsForRequest(request, allTools, _toolSearchState);
+    const toolSearchTool = nativeToolSearch ? null : this.createToolSearchTool(request, allTools, selectedTools);
+    const effectiveSelectedTools = nativeToolCatalog ? nativeToolCatalog : toolSearchTool ? [...selectedTools, toolSearchTool] : selectedTools;
+    const providerToolOptions = this.buildProviderToolOptionsForRequest(
+      effectiveSelectedTools,
+      request
+    );
+    const selectedToolMap = new Map(
+      effectiveSelectedTools.map((tool2) => [tool2.name, tool2])
+    );
     if (debug) {
       console.log(
         `[Copilot SDK] Processing chat with ${allTools.length} tools`
       );
+      if (effectiveSelectedTools.length !== allTools.length) {
+        console.log(
+          `[Copilot SDK] Tool selection active: ${effectiveSelectedTools.length}/${allTools.length} tools`,
+          {
+            activeProfile: request.toolProfile,
+            nativeSearch: nativeToolSearch?.provider ?? null
+          }
+        );
+      }
       for (let i = 0; i < request.messages.length; i++) {
         const msg = request.messages[i];
         const hasAttachments = msg.attachments && msg.attachments.length > 0;
@@ -1657,11 +2114,14 @@ var Runtime = class {
       messages: [],
       // Not used when rawMessages is provided
       rawMessages: request.messages,
-      actions: this.convertToolsToActions(allTools),
+      actions: nativeToolSearch ? void 0 : this.convertToolsToActions(effectiveSelectedTools),
+      toolDefinitions: nativeToolSearch ? effectiveSelectedTools : void 0,
       systemPrompt,
       config: request.config,
       signal,
-      webSearch: this.getWebSearchConfig()
+      webSearch: this.getWebSearchConfig(),
+      providerToolOptions,
+      debug
     };
     const stream = this.adapter.stream(completionRequest);
     for await (const event of stream) {
@@ -1738,7 +2198,7 @@ var Runtime = class {
       const serverToolCalls = [];
       const clientToolCalls = [];
       for (const tc of toolCalls) {
-        const tool2 = allTools.find((t) => t.name === tc.name);
+        const tool2 = selectedToolMap.get(tc.name);
         if (tool2?.location === "server" && tool2.handler) {
           serverToolCalls.push(tc);
         } else {
@@ -1748,7 +2208,7 @@ var Runtime = class {
       const serverToolResults = [];
       const toolContextData = "toolContext" in this.config ? this.config.toolContext : void 0;
       for (const tc of serverToolCalls) {
-        const tool2 = allTools.find((t) => t.name === tc.name);
+        const tool2 = selectedToolMap.get(tc.name);
         if (tool2?.handler) {
           if (debug) {
             console.log(`[Copilot SDK] Executing server-side tool: ${tc.name}`);
@@ -1772,6 +2232,7 @@ var Runtime = class {
             yield {
               type: "action:end",
               id: tc.id,
+              name: tc.name,
               result
             };
           } catch (error) {
@@ -1789,6 +2250,7 @@ var Runtime = class {
             yield {
               type: "action:end",
               id: tc.id,
+              name: tc.name,
               error: error instanceof Error ? error.message : "Tool execution failed"
             };
           }
@@ -1834,6 +2296,13 @@ var Runtime = class {
           ...request,
           messages: messagesWithResults
         };
+        const nextToolSearchState = this.extendLoadedToolNames(
+          _toolSearchState,
+          serverToolResults.map((result) => ({
+            name: result.name,
+            result: result.result
+          }))
+        );
         yield { type: "message:end" };
         for await (const event of this.processChatWithLoop(
           nextRequest,
@@ -1841,7 +2310,8 @@ var Runtime = class {
           newMessages,
           true,
           // Mark as recursive
-          _httpRequest
+          _httpRequest,
+          nextToolSearchState
         )) {
           yield event;
         }
@@ -1900,22 +2370,14 @@ var Runtime = class {
    * - Easier debugging (full response at once)
    * - More predictable retry behavior
    */
-  async *processChatWithLoopNonStreaming(request, signal, _accumulatedMessages, _isRecursive, _httpRequest) {
+  async *processChatWithLoopNonStreaming(request, signal, _accumulatedMessages, _isRecursive, _httpRequest, _toolSearchState) {
     const newMessages = _accumulatedMessages || [];
-    const debug = this.config.debug || this.config.agentLoop?.debug;
-    const maxIterations = this.config.agentLoop?.maxIterations || 20;
+    const debug = this.config.debug;
+    const maxIterations = this.config.maxIterations ?? 20;
     let accumulatedUsage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-    const allTools = [...this.tools.values()];
-    if (request.tools) {
-      for (const tool2 of request.tools) {
-        allTools.push({
-          name: tool2.name,
-          description: tool2.description,
-          location: "client",
-          inputSchema: tool2.inputSchema
-        });
-      }
-    }
+    const allTools = this.collectToolsForRequest(request);
+    const nativeToolSearch = this.resolveNativeToolSearchForRequest(request);
+    let toolSearchState = _toolSearchState;
     const systemPrompt = request.systemPrompt || this.config.systemPrompt || "";
     let iteration = 0;
     let conversationMessages = request.messages;
@@ -1944,20 +2406,35 @@ var Runtime = class {
           signal,
           _accumulatedMessages,
           _isRecursive,
-          _httpRequest
+          _httpRequest,
+          toolSearchState
         )) {
           yield event;
         }
         return;
       }
+      const nativeToolCatalog = nativeToolSearch ? this.buildNativeToolCatalogForRequest(request, allTools) : null;
+      const selectedTools = nativeToolCatalog ?? this.selectToolsForRequest(request, allTools, toolSearchState);
+      const toolSearchTool = nativeToolSearch ? null : this.createToolSearchTool(request, allTools, selectedTools);
+      const effectiveSelectedTools = nativeToolCatalog ? nativeToolCatalog : toolSearchTool ? [...selectedTools, toolSearchTool] : selectedTools;
+      const providerToolOptions = this.buildProviderToolOptionsForRequest(
+        effectiveSelectedTools,
+        request
+      );
+      const selectedToolMap = new Map(
+        effectiveSelectedTools.map((tool2) => [tool2.name, tool2])
+      );
       const completionRequest = {
         messages: [],
         rawMessages: conversationMessages,
-        actions: this.convertToolsToActions(allTools),
+        actions: nativeToolSearch ? void 0 : this.convertToolsToActions(effectiveSelectedTools),
+        toolDefinitions: nativeToolSearch ? effectiveSelectedTools : void 0,
         systemPrompt,
         config: request.config,
         signal,
-        webSearch: this.getWebSearchConfig()
+        webSearch: this.getWebSearchConfig(),
+        providerToolOptions,
+        debug
       };
       try {
         const result = await this.adapter.complete(completionRequest);
@@ -1983,7 +2460,7 @@ var Runtime = class {
           const serverToolCalls = [];
           const clientToolCalls = [];
           for (const tc of result.toolCalls) {
-            const tool2 = allTools.find((t) => t.name === tc.name);
+            const tool2 = selectedToolMap.get(tc.name);
             if (tool2?.location === "server" && tool2.handler) {
               serverToolCalls.push(tc);
             } else {
@@ -1995,7 +2472,7 @@ var Runtime = class {
             }
           }
           for (const tc of result.toolCalls) {
-            const tool2 = allTools.find((t) => t.name === tc.name);
+            const tool2 = selectedToolMap.get(tc.name);
             yield {
               type: "action:start",
               id: tc.id,
@@ -2011,7 +2488,7 @@ var Runtime = class {
           const serverToolResults = [];
           const toolContextData = "toolContext" in this.config ? this.config.toolContext : void 0;
           for (const tc of serverToolCalls) {
-            const tool2 = allTools.find((t) => t.name === tc.name);
+            const tool2 = selectedToolMap.get(tc.name);
             if (tool2?.handler) {
               if (debug) {
                 console.log(`[Copilot SDK] Executing tool: ${tc.name}`);
@@ -2035,6 +2512,7 @@ var Runtime = class {
                 yield {
                   type: "action:end",
                   id: tc.id,
+                  name: tc.name,
                   result: toolResult
                 };
               } catch (error) {
@@ -2052,6 +2530,7 @@ var Runtime = class {
                 yield {
                   type: "action:end",
                   id: tc.id,
+                  name: tc.name,
                   error: error instanceof Error ? error.message : "Tool execution failed"
                 };
               }
@@ -2090,6 +2569,13 @@ var Runtime = class {
               assistantWithToolCalls,
               ...toolResultMessages
             ];
+            toolSearchState = this.extendLoadedToolNames(
+              toolSearchState,
+              serverToolResults.map((toolResult) => ({
+                name: toolResult.name,
+                result: toolResult.result
+              }))
+            );
             continue;
           }
           if (clientToolCalls.length > 0) {
@@ -2552,7 +3038,11 @@ function transformTools(tools) {
     function: {
       name: tool2.name,
       description: tool2.description,
-      parameters: tool2.inputSchema
+      parameters: tool2.inputSchema ? {
+        type: "object",
+        properties: tool2.inputSchema.properties ?? {},
+        required: tool2.inputSchema.required
+      } : { type: "object", properties: {} }
     }
   }));
 }
@@ -2641,7 +3131,11 @@ function transformTools2(tools) {
   return tools.map((tool2) => ({
     name: tool2.name,
     description: tool2.description,
-    input_schema: tool2.inputSchema
+    input_schema: tool2.inputSchema ? {
+      type: "object",
+      properties: tool2.inputSchema.properties ?? {},
+      required: tool2.inputSchema.required
+    } : { type: "object", properties: {} }
   }));
 }
 function parseToolCalls2(response) {
@@ -2722,7 +3216,11 @@ function transformTools3(tools) {
       functionDeclarations: tools.map((tool2) => ({
         name: tool2.name,
         description: tool2.description,
-        parameters: tool2.inputSchema
+        parameters: tool2.inputSchema ? {
+          type: "object",
+          properties: tool2.inputSchema.properties ?? {},
+          required: tool2.inputSchema.required
+        } : { type: "object", properties: {} }
       }))
     }
   ];
@@ -2871,29 +3369,34 @@ async function* runAgentLoop(options) {
     systemPrompt,
     provider,
     signal,
-    config,
+    maxIterations: optMaxIterations,
+    debug: optDebug,
+    toolSelectionConfig,
+    toolProfile,
     callLLM,
     executeServerTool,
     waitForClientToolResult
   } = options;
-  const maxIterations = config?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-  const debug = config?.debug ?? false;
+  const maxIterations = optMaxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const debug = optDebug ?? false;
   const formatter = getFormatter(provider.name);
+  const toolSearchMetaToolName = "search_tools";
   const serverTools = tools.filter((t) => t.location === "server");
   const clientTools = tools.filter((t) => t.location === "client");
   const allTools = [...serverTools, ...clientTools];
-  const providerTools = formatter.transformTools(allTools);
   const conversation = buildConversation(
     messages,
     systemPrompt
   );
   let iteration = 0;
+  let loadedToolNames = /* @__PURE__ */ new Set();
   if (debug) {
     console.log("[AgentLoop] Starting with", {
       messageCount: messages.length,
-      toolCount: allTools.length,
+      availableToolCount: allTools.length,
       serverToolCount: serverTools.length,
       clientToolCount: clientTools.length,
+      activeProfile: toolProfile ?? toolSelectionConfig?.defaultProfile,
       maxIterations
     });
   }
@@ -2912,11 +3415,71 @@ async function* runAgentLoop(options) {
       iteration,
       maxIterations
     };
+    const selectedTools = selectTools({
+      tools: allTools,
+      messages,
+      config: toolSelectionConfig,
+      activeProfile: toolProfile,
+      forceIncludeNames: [...loadedToolNames]
+    });
+    const toolSearchTool = shouldExposeToolSearch({
+      tools: allTools,
+      config: toolSelectionConfig
+    }) ? {
+      name: toolSearchMetaToolName,
+      description: "Search available deferred tools and load the most relevant ones for the next step when the required tool is not currently exposed.",
+      location: "server",
+      hidden: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Describe the tool capability you need to find."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of matching tools to load."
+          }
+        },
+        required: ["query"]
+      },
+      handler: async (params) => {
+        const query = typeof params.query === "string" ? params.query : "";
+        const limit = typeof params.limit === "number" ? params.limit : void 0;
+        const results = searchTools({
+          tools: allTools,
+          query,
+          config: toolSelectionConfig,
+          activeProfile: toolProfile,
+          limit,
+          excludeNames: selectedTools.map((tool2) => tool2.name)
+        });
+        return {
+          success: true,
+          query,
+          loadedTools: results.map((result) => result.name),
+          results
+        };
+      }
+    } : null;
+    const effectiveSelectedTools = toolSearchTool ? [...selectedTools, toolSearchTool] : selectedTools;
+    const providerToolOptions = buildProviderToolOptions({
+      providerName: provider.name,
+      config: toolSelectionConfig});
+    const providerTools = formatter.transformTools(effectiveSelectedTools);
     if (debug) {
-      console.log(`[AgentLoop] Iteration ${iteration}/${maxIterations}`);
+      console.log(`[AgentLoop] Iteration ${iteration}/${maxIterations}`, {
+        selectedToolCount: effectiveSelectedTools.length,
+        loadedDeferredTools: [...loadedToolNames]
+      });
     }
     try {
-      const response = await callLLM(conversation, providerTools);
+      const response = await callLLM(
+        conversation,
+        providerTools,
+        providerToolOptions
+      );
       const toolCalls = formatter.parseToolCalls(response);
       const textContent = formatter.extractTextContent(response);
       if (textContent) {
@@ -2934,7 +3497,7 @@ async function* runAgentLoop(options) {
         }
         const results = await executeToolCalls(
           toolCalls,
-          tools,
+          effectiveSelectedTools,
           executeServerTool,
           waitForClientToolResult,
           function* (event) {
@@ -2953,6 +3516,23 @@ async function* runAgentLoop(options) {
             };
           }
         }
+        for (const result of results) {
+          const toolCall = toolCalls.find((tc) => tc.id === result.toolCallId);
+          if (!toolCall || toolCall.name !== toolSearchMetaToolName) {
+            continue;
+          }
+          try {
+            const parsed = JSON.parse(result.content);
+            if (Array.isArray(parsed.loadedTools)) {
+              for (const toolName of parsed.loadedTools) {
+                if (typeof toolName === "string" && toolName) {
+                  loadedToolNames.add(toolName);
+                }
+              }
+            }
+          } catch {
+          }
+        }
         const assistantMessage = formatter.buildAssistantToolMessage(
           toolCalls,
           textContent
@@ -3103,6 +3683,6 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
   return results;
 }
 
-export { DEFAULT_CAPABILITIES, DEFAULT_MAX_ITERATIONS, GenerateResult, Runtime, StreamResult, createEventStream, createExpressHandler, createExpressMiddleware, createHonoApp, createNextHandler, createNodeHandler, createRuntime, createSSEHeaders, createSSEResponse, createStreamResult, createTextStreamHeaders, createTextStreamResponse, formatSSEData, formatToolsForAnthropic, formatToolsForGoogle, formatToolsForOpenAI, generateMessageId, generateText, generateThreadId, generateToolCallId, pipeSSEToResponse, pipeTextToResponse, runAgentLoop, streamText, tool };
+export { DEFAULT_CAPABILITIES, DEFAULT_MAX_ITERATIONS, GenerateResult, Runtime, StreamResult, buildProviderToolOptions, createEventStream, createExpressHandler, createExpressMiddleware, createHonoApp, createNextHandler, createNodeHandler, createRuntime, createSSEHeaders, createSSEResponse, createStreamResult, createTextStreamHeaders, createTextStreamResponse, formatSSEData, formatToolsForAnthropic, formatToolsForGoogle, formatToolsForOpenAI, generateMessageId, generateText, generateThreadId, generateToolCallId, pipeSSEToResponse, pipeTextToResponse, runAgentLoop, searchTools, selectTools, shouldExposeToolSearch, streamText, tool };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map