@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-I6PKJ7XQ.js

@@ -0,0 +1,292 @@
+// src/models/types.ts
+var SourcePriority = /* @__PURE__ */ ((SourcePriority2) => {
+  SourcePriority2[SourcePriority2["UserConfig"] = 0] = "UserConfig";
+  SourcePriority2[SourcePriority2["LocalCache"] = 1] = "LocalCache";
+  SourcePriority2[SourcePriority2["BundledData"] = 2] = "BundledData";
+  SourcePriority2[SourcePriority2["PatternMatch"] = 3] = "PatternMatch";
+  SourcePriority2[SourcePriority2["RemoteAPI"] = 4] = "RemoteAPI";
+  return SourcePriority2;
+})(SourcePriority || {});
+var DEFAULT_RESOLVER_OPTIONS = {
+  enableRemoteFetch: false,
+  remoteApiUrl: "https://models.dev",
+  cachePath: ".agent-core/cache",
+  cacheTtlMs: 60 * 60 * 1e3,
+  // 1 hour
+  networkTimeoutMs: 10 * 1e3,
+  // 10 seconds
+  modelOverrides: {}
+};
+
+// src/models/profiles.ts
+var REASONING_PATTERNS = [
+  // OpenAI o-series
+  {
+    pattern: /^o[134]-?(mini|pro|preview)?$/i,
+    provider: "openai",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
+    confidence: 0.95
+  },
+  // OpenAI GPT-5.x
+  {
+    pattern: /gpt-?5(\.\d)?/i,
+    provider: "openai",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { supportsReasoningEffort: true, thinkingFormat: "openai" },
+    confidence: 0.9
+  },
+  // DeepSeek R1 variants
+  {
+    pattern: /deepseek[_-]?r1|r1[_-]distill/i,
+    capabilities: { reasoning: true, toolCalling: false },
+    confidence: 0.95
+  },
+  // Anthropic Claude with thinking
+  {
+    pattern: /claude.*thinking|thinking.*claude/i,
+    provider: "anthropic",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "anthropic" },
+    confidence: 0.9
+  },
+  // Claude 4.x series (reasoning capable)
+  {
+    pattern: /claude[_-]?(opus|sonnet)[_-]?4/i,
+    provider: "anthropic",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "anthropic" },
+    confidence: 0.85
+  },
+  // Gemini thinking models
+  {
+    pattern: /gemini.*thinking|gemini[_-]?2\.5[_-]?pro/i,
+    provider: "google",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "google" },
+    confidence: 0.85
+  },
+  // Gemini 3.x (future-proofing)
+  {
+    pattern: /gemini[_-]?3/i,
+    provider: "google",
+    capabilities: { reasoning: true, toolCalling: true },
+    compatibility: { thinkingFormat: "google" },
+    confidence: 0.8
+  },
+  // Grok reasoning models
+  {
+    pattern: /grok[_-]?\d[_-]?(mini|reasoning)/i,
+    provider: "xai",
+    capabilities: { reasoning: true, toolCalling: true },
+    confidence: 0.85
+  },
+  // Qwen thinking models
+  {
+    pattern: /qwen.*thinking|qwen3/i,
+    capabilities: { reasoning: true, toolCalling: true },
+    confidence: 0.8
+  },
+  // Generic reasoning/thinking in name
+  {
+    pattern: /reasoning|thinking/i,
+    capabilities: { reasoning: true },
+    confidence: 0.7
+  }
+];
+var PROVIDER_PATTERNS = [
+  { pattern: /^(gpt|o[134]|chatgpt|davinci)/i, provider: "openai" },
+  { pattern: /^claude/i, provider: "anthropic" },
+  { pattern: /^gemini|^palm/i, provider: "google" },
+  { pattern: /^grok/i, provider: "xai" },
+  { pattern: /^deepseek/i, provider: "deepseek" },
+  { pattern: /^mistral|^mixtral|codestral/i, provider: "mistral" },
+  { pattern: /^llama/i, provider: "meta" },
+  { pattern: /^qwen/i, provider: "alibaba" },
+  { pattern: /^command/i, provider: "cohere" }
+];
+var CONTEXT_WINDOW_PROFILES = [
+  // Anthropic Claude 4.x — 200k
+  { pattern: /claude[_-]?(opus|sonnet)[_-]?4/i, tokens: 2e5 },
+  // Anthropic Claude 3.5 — 200k
+  { pattern: /claude[_-]?3[._-]?5/i, tokens: 2e5 },
+  // Anthropic Claude 3 Opus/Sonnet/Haiku — 200k
+  { pattern: /claude[_-]?3/i, tokens: 2e5 },
+  // Anthropic Claude 2 — 100k
+  { pattern: /claude[_-]?2/i, tokens: 1e5 },
+  // OpenAI o-series (o1, o3, o4) — 200k
+  { pattern: /^o[134]-?(mini|pro|preview)?$/i, tokens: 2e5 },
+  // OpenAI GPT-5.x — 1M
+  { pattern: /gpt-?5/i, tokens: 1e6 },
+  // OpenAI GPT-4o — 128k
+  { pattern: /gpt-?4o/i, tokens: 128e3 },
+  // OpenAI GPT-4 turbo — 128k
+  { pattern: /gpt-?4[_-]?turbo/i, tokens: 128e3 },
+  // OpenAI GPT-4 — 8k (original)
+  { pattern: /gpt-?4(?!o|[_-]?turbo)/i, tokens: 8192 },
+  // OpenAI GPT-3.5 turbo — 16k
+  { pattern: /gpt-?3[._-]?5/i, tokens: 16384 },
+  // Google Gemini 2.5 Pro — 1M
+  { pattern: /gemini[_-]?2[._-]?5[_-]?pro/i, tokens: 1e6 },
+  // Google Gemini 2.x Flash — 1M
+  { pattern: /gemini[_-]?2.*flash/i, tokens: 1e6 },
+  // Google Gemini 2.x Pro — 1M
+  { pattern: /gemini[_-]?2[._-]?\d?[_-]?pro/i, tokens: 1e6 },
+  // Google Gemini 1.5 Pro/Flash — 1M
+  { pattern: /gemini[_-]?1[._-]?5/i, tokens: 1e6 },
+  // xAI Grok 3+ — 128k
+  { pattern: /grok[_-]?\d/i, tokens: 128e3 },
+  // Mistral Large — 128k
+  { pattern: /mistral[_-]?large/i, tokens: 128e3 },
+  // Mistral Medium — 32k
+  { pattern: /mistral[_-]?medium/i, tokens: 32768 },
+  // Codestral — 256k
+  { pattern: /codestral/i, tokens: 256e3 },
+  // Mistral generic — 32k
+  { pattern: /mistral|mixtral/i, tokens: 32768 },
+  // DeepSeek R1/V3 — 128k
+  { pattern: /deepseek/i, tokens: 128e3 },
+  // Qwen 3 — 128k
+  { pattern: /qwen/i, tokens: 128e3 },
+  // Meta Llama 3 — 128k
+  { pattern: /llama[_-]?3/i, tokens: 128e3 },
+  // Cohere Command R+ — 128k
+  { pattern: /command[_-]?r/i, tokens: 128e3 }
+];
+function inferContextWindow(modelId) {
+  const normalized = modelId.toLowerCase();
+  for (const { pattern, tokens } of CONTEXT_WINDOW_PROFILES) {
+    if (pattern.test(normalized)) {
+      return tokens;
+    }
+  }
+  return void 0;
+}
+function inferProvider(modelId) {
+  const normalized = modelId.toLowerCase();
+  for (const { pattern, provider } of PROVIDER_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return provider;
+    }
+  }
+  if (modelId.includes("/")) {
+    return modelId.split("/")[0];
+  }
+  return void 0;
+}
+function matchPatterns(modelId, providerHint) {
+  const normalized = modelId.toLowerCase();
+  for (const rule of REASONING_PATTERNS) {
+    if (rule.provider && providerHint && rule.provider !== providerHint) {
+      continue;
+    }
+    const matches = typeof rule.pattern === "string" ? normalized.includes(rule.pattern.toLowerCase()) : rule.pattern.test(normalized);
+    if (matches) {
+      return { rule, confidence: rule.confidence };
+    }
+  }
+  return void 0;
+}
+function createDefaultCapabilities() {
+  return {
+    reasoning: false,
+    toolCalling: true,
+    temperature: true,
+    attachments: false,
+    streaming: true,
+    inputModalities: ["text"],
+    outputModalities: ["text"]
+  };
+}
+var PatternCapabilitySource = class {
+  priority = 3 /* PatternMatch */;
+  name = "Pattern Matching";
+  async lookup(modelId, providerHint) {
+    const provider = providerHint || inferProvider(modelId);
+    const match = matchPatterns(modelId, provider);
+    const baseCapabilities = createDefaultCapabilities();
+    if (match) {
+      const entry = {
+        id: modelId,
+        name: modelId,
+        provider: match.rule.provider || provider || "unknown",
+        capabilities: {
+          ...baseCapabilities,
+          ...match.rule.capabilities,
+          contextWindow: inferContextWindow(modelId)
+        },
+        compatibility: match.rule.compatibility
+      };
+      return {
+        entry,
+        source: this.priority,
+        confident: match.confidence > 0.8
+      };
+    }
+    return {
+      entry: {
+        id: modelId,
+        name: modelId,
+        provider: provider || "unknown",
+        capabilities: {
+          ...baseCapabilities,
+          contextWindow: inferContextWindow(modelId)
+        }
+      },
+      source: this.priority,
+      confident: false
+    };
+  }
+  async isAvailable() {
+    return true;
+  }
+};
+function likelySupportsReasoning(modelId) {
+  const match = matchPatterns(modelId);
+  return match !== void 0 && match.rule.capabilities.reasoning === true;
+}
+function getProviderCompatibility(modelId, provider) {
+  const match = matchPatterns(modelId, provider);
+  return match?.rule.compatibility;
+}
+
+// src/models/identifiers.ts
+function getModelId(model) {
+  if (typeof model === "string") return model;
+  if (typeof model === "object" && model !== null && "modelId" in model) {
+    return String(model.modelId);
+  }
+  return String(model);
+}
+function getProviderId(model) {
+  if (typeof model === "string") {
+    if (model.includes("/")) {
+      return model.split("/")[0];
+    }
+    return void 0;
+  }
+  if (typeof model === "object" && model !== null && "provider" in model) {
+    const provider = String(model.provider);
+    return provider.split(".")[0];
+  }
+  return void 0;
+}
+var extractModelId = getModelId;
+function extractProvider(model) {
+  const provider = getProviderId(model);
+  return provider ?? inferProvider(getModelId(model));
+}
+
+export {
+  SourcePriority,
+  DEFAULT_RESOLVER_OPTIONS,
+  inferContextWindow,
+  inferProvider,
+  PatternCapabilitySource,
+  likelySupportsReasoning,
+  getProviderCompatibility,
+  getModelId,
+  getProviderId,
+  extractModelId,
+  extractProvider
+};

package/dist/{chunk-BDBZ3SLK.js → chunk-ICZ66572.js}

@@ -9,7 +9,7 @@ function generateEntryId(existingIds) {
   }
   return crypto.randomUUID();
 }
-function parseJSONL(content) {
+function parseJSONL(content, logger) {
   const entries = [];
   const lines = content.split("\n");
   for (const line of lines) {
@@ -18,7 +18,7 @@ function parseJSONL(content) {
     try {
       entries.push(JSON.parse(trimmed));
     } catch {
-      console.warn("[Storage] Skipping malformed JSONL line");
+      logger?.warn("Skipping malformed JSONL line");
     }
   }
   return entries;
@@ -160,7 +160,6 @@ function getLeafId(entries) {
     children.push(e.id);
     childMap.set(e.parentId, children);
   }
-  const _allIds = new Set(entries.slice(1).map((e) => e.id));
   const hasChildren = /* @__PURE__ */ new Set();
   for (const children of childMap.values()) {
     for (const child of children) {
@@ -204,7 +203,8 @@ function buildMessagesFromEntries(entries, leafId) {
   let skipUntilId;
   for (const entry of path) {
     if (entry.type === "compaction") {
-      skipUntilId = entry.firstKeptEntryId;
+      messages.length = 0;
+      skipUntilId = entry.firstKeptEntryId !== entry.id ? entry.firstKeptEntryId : void 0;
       messages.push({
         id: entry.id,
         role: "system",
@@ -291,6 +291,16 @@ async function ensureStorageDirectory(directory) {
 }
 function getSessionFilePath(directory, extension, sessionId) {
   const safeId = sessionId.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const needsHash = safeId !== sessionId;
+  if (needsHash) {
+    let hash = 2166136261;
+    for (let i = 0; i < sessionId.length; i++) {
+      hash ^= sessionId.charCodeAt(i);
+      hash = hash * 16777619 >>> 0;
+    }
+    const suffix = hash.toString(16).padStart(8, "0");
+    return join(directory, `${safeId}_${suffix}${extension}`);
+  }
   return join(directory, `${safeId}${extension}`);
 }
 async function loadEntriesFromDisk(filePath, sessionId) {
@@ -615,6 +625,40 @@ var SessionManager = class {
     this.currentLeafId = entry.id;
     return entry.id;
   }
+  async replaceWithCompaction(options) {
+    if (!this.currentSessionId) {
+      throw new Error("No session loaded");
+    }
+    const compactionId = generateEntryId(this.idsCache);
+    this.idsCache.add(compactionId);
+    let parentId = compactionId;
+    const messageEntries = [];
+    for (const message of options.messages) {
+      const entry = createMessageEntry(message, parentId, this.idsCache);
+      messageEntries.push(entry);
+      this.idsCache.add(entry.id);
+      parentId = entry.id;
+    }
+    const compactionEntry = {
+      type: "compaction",
+      id: compactionId,
+      parentId: this.currentLeafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      summary: options.summary,
+      firstKeptEntryId: messageEntries[0]?.id ?? compactionId,
+      tokensBefore: options.tokensBefore,
+      tokensAfter: options.tokensAfter,
+      ...options.readFiles ? { readFiles: options.readFiles } : {},
+      ...options.modifiedFiles ? { modifiedFiles: options.modifiedFiles } : {}
+    };
+    await this.storage.appendBatch(this.currentSessionId, [
+      compactionEntry,
+      ...messageEntries
+    ]);
+    this.entriesCache.push(compactionEntry, ...messageEntries);
+    this.currentLeafId = messageEntries[messageEntries.length - 1]?.id ?? compactionEntry.id;
+    return compactionEntry.id;
+  }
   async branch(fromEntryId, summary) {
     if (!this.currentSessionId) {
       throw new Error("No session loaded");

package/dist/chunk-KYLPMBHD.js

@@ -0,0 +1,316 @@
+import {
+  Tool
+} from "./chunk-Q742PSH3.js";
+
+// src/tool/registry.ts
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  groups = /* @__PURE__ */ new Map();
+  // --------------------------------------------------------------------------
+  // Tool registration
+  // --------------------------------------------------------------------------
+  /**
+   * Register a tool. Throws if a tool with the same ID is already registered.
+   * Use `set()` for upsert semantics.
+   */
+  register(tool) {
+    if (this.tools.has(tool.id)) {
+      throw new Error(`Tool '${tool.id}' is already registered`);
+    }
+    this.tools.set(tool.id, tool);
+  }
+  /** Register multiple tools (throws on duplicates). */
+  registerAll(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  /** Register or replace a tool (upsert). */
+  set(tool) {
+    this.tools.set(tool.id, tool);
+  }
+  /** Unregister a tool by ID. Returns `true` if it existed. */
+  unregister(id) {
+    return this.tools.delete(id);
+  }
+  /** Get a tool by ID. */
+  get(id) {
+    return this.tools.get(id);
+  }
+  /** Check if a tool is registered. */
+  has(id) {
+    return this.tools.has(id);
+  }
+  /** Get all tool IDs. */
+  ids() {
+    return Array.from(this.tools.keys());
+  }
+  /** Get all tools. */
+  all() {
+    return Array.from(this.tools.values());
+  }
+  /** Clear all tools and groups. */
+  clear() {
+    this.tools.clear();
+    this.groups.clear();
+  }
+  /** Number of registered tools. */
+  get size() {
+    return this.tools.size;
+  }
+  // --------------------------------------------------------------------------
+  // Group management
+  // --------------------------------------------------------------------------
+  /**
+   * Register a named group of tool IDs.
+   * The group name can be used in `resolve()` specs.
+   * Tool IDs don't need to be registered yet — resolution is lazy.
+   */
+  registerGroup(name, toolIds) {
+    this.groups.set(name, toolIds);
+  }
+  /** Get tools in a group (only returns registered tools). */
+  getGroup(name) {
+    const ids = this.groups.get(name);
+    if (!ids) return void 0;
+    return ids.map((id) => this.tools.get(id)).filter((t) => t !== void 0);
+  }
+  /** Check if a group is registered. */
+  hasGroup(name) {
+    return this.groups.has(name);
+  }
+  /** List all group names. */
+  listGroups() {
+    return Array.from(this.groups.keys());
+  }
+  // --------------------------------------------------------------------------
+  // Deferred loading
+  // --------------------------------------------------------------------------
+  /**
+   * Partition registered tools into eager and deferred sets.
+   *
+   * Eager tools have their full schemas sent to the LLM on turn 1.
+   * Deferred tools are held back — the model discovers them via a
+   * search mechanism when needed, saving context window space.
+   *
+   * @returns `{ eager, deferred }` arrays of tool infos.
+   */
+  partition() {
+    const eager = [];
+    const deferred = [];
+    for (const tool of this.tools.values()) {
+      if (tool.deferred) {
+        deferred.push(tool);
+      } else {
+        eager.push(tool);
+      }
+    }
+    return { eager, deferred };
+  }
+  /**
+   * Search deferred tools by keyword with multi-signal weighted scoring.
+   *
+   * Scoring per term:
+   *  - Exact tool ID match: +10
+   *  - Partial tool ID match (substring): +5
+   *  - Keyword word-boundary match: +4
+   *  - Keyword substring match: +2
+   *
+   * @param query - Space-separated search terms
+   * @param maxResults - Maximum results to return (default: 5)
+   * @returns Matching deferred tools sorted by relevance (highest score first)
+   */
+  searchDeferred(query, maxResults = 5) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0) return [];
+    const { deferred } = this.partition();
+    const scored = deferred.map((tool) => {
+      let score = 0;
+      const id = tool.id.toLowerCase();
+      const keywords = (tool.searchKeywords ?? []).join(" ").toLowerCase();
+      for (const term of terms) {
+        if (id === term) {
+          score += 10;
+          continue;
+        }
+        if (id.includes(term)) {
+          score += 5;
+          continue;
+        }
+        const wordBoundary = new RegExp(`\\b${escapeRegExp(term)}\\b`);
+        if (wordBoundary.test(keywords)) {
+          score += 4;
+          continue;
+        }
+        if (keywords.includes(term)) {
+          score += 2;
+        }
+      }
+      return { tool, score };
+    }).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxResults).map(({ tool }) => tool);
+  }
+  // --------------------------------------------------------------------------
+  // Resolution
+  // --------------------------------------------------------------------------
+  /**
+   * Resolve a `ToolSpec` to an array of tools.
+   *
+   * Supports group names, individual tool IDs, comma-separated strings,
+   * exclusions with `-` prefix, booleans, and pass-through arrays.
+   *
+   * @example
+   * ```typescript
+   * registry.resolve("read-only");          // group name
+   * registry.resolve("read,grep,glob");     // comma-separated IDs
+   * registry.resolve("all,-bash");          // all except bash
+   * registry.resolve(["read", "grep"]);     // array of IDs
+   * registry.resolve(true);                 // all registered tools
+   * registry.resolve(false);                // empty array
+   * ```
+   */
+  resolve(spec) {
+    if (spec === true) return this.all();
+    if (spec === false) return [];
+    if (Array.isArray(spec) && spec.length > 0 && typeof spec[0] !== "string") {
+      return spec;
+    }
+    const tokens = Array.isArray(spec) ? spec : spec.split(",").map((s) => s.trim()).filter(Boolean);
+    const includes = [];
+    const excludes = [];
+    for (const token of tokens) {
+      if (token.startsWith("-")) {
+        excludes.push(token.slice(1));
+      } else {
+        includes.push(token);
+      }
+    }
+    const result = /* @__PURE__ */ new Map();
+    if (includes.length === 0 && excludes.length > 0) {
+      for (const [id, tool] of this.tools) {
+        result.set(id, tool);
+      }
+    } else {
+      for (const token of includes) {
+        if (token === "all") {
+          for (const [id, tool] of this.tools) {
+            result.set(id, tool);
+          }
+        } else if (this.groups.has(token)) {
+          const ids = this.groups.get(token);
+          for (const id of ids) {
+            const tool = this.tools.get(id);
+            if (tool) result.set(id, tool);
+          }
+        } else if (this.tools.has(token)) {
+          result.set(token, this.tools.get(token));
+        }
+      }
+    }
+    for (const id of excludes) {
+      if (this.groups.has(id)) {
+        const ids = this.groups.get(id);
+        for (const gid of ids) {
+          result.delete(gid);
+        }
+      } else {
+        result.delete(id);
+      }
+    }
+    return Array.from(result.values());
+  }
+};
+var defaultRegistry = new ToolRegistry();
+
+// src/tool/tool-search.ts
+import { z } from "zod";
+function createToolSearchTool(options) {
+  const { registry, maxResults = 5, onMatch } = options;
+  return Tool.define("tool_search", {
+    description: "Search for additional tools by keyword. Some tools are not loaded by default to save context. Call this when you need a capability that isn't available in your current tool set. Returns matching tool names and descriptions.",
+    parameters: z.object({
+      query: z.string().describe(
+        "Space-separated keywords describing the tool you need (e.g. 'jupyter notebook cells' or 'docker container'). Use 'select:tool_name' to load a specific tool by name, or 'select:foo,bar' for multiple."
+      )
+    }),
+    capabilities: {
+      parallelSafe: true,
+      readOnly: true,
+      riskLevel: "safe"
+    },
+    execute: async ({ query }, ctx) => {
+      if (query.startsWith("select:")) {
+        const ids = query.slice(7).split(",").map((s) => s.trim()).filter(Boolean);
+        const found = [];
+        const missing = [];
+        for (const id of ids) {
+          const tool = registry.get(id);
+          if (tool) {
+            found.push(tool);
+          } else {
+            missing.push(id);
+          }
+        }
+        if (found.length > 0) onMatch(found);
+        const summaries2 = [];
+        for (const t of found) {
+          try {
+            const init = await t.init({ cwd: ctx.cwd });
+            summaries2.push(`- **${t.id}**: ${init.description}`);
+          } catch {
+            summaries2.push(`- **${t.id}**: (description unavailable)`);
+          }
+        }
+        if (missing.length > 0) {
+          summaries2.push(`
+Not found: ${missing.join(", ")}`);
+        }
+        return {
+          title: `Loaded ${found.length} tool(s)`,
+          output: found.length > 0 ? summaries2.join("\n") + "\n\nThese tools are now available for use." : `No tools found: ${missing.join(", ")}`,
+          metadata: {
+            matchCount: found.length,
+            toolIds: found.map((t) => t.id)
+          }
+        };
+      }
+      const matches = registry.searchDeferred(query, maxResults);
+      if (matches.length === 0) {
+        return {
+          title: `No tools found for "${query}"`,
+          output: `No matching tools found for query: "${query}". Try different keywords.`,
+          metadata: { matchCount: 0, toolIds: [] }
+        };
+      }
+      const summaries = [];
+      for (const tool of matches) {
+        try {
+          const init = await tool.init({ cwd: ctx.cwd });
+          summaries.push(`- **${tool.id}**: ${init.description}`);
+        } catch {
+          summaries.push(`- **${tool.id}**: (description unavailable)`);
+        }
+      }
+      onMatch(matches);
+      return {
+        title: `Found ${matches.length} tool(s)`,
+        output: `Found ${matches.length} tool(s) matching "${query}":
+
+` + summaries.join("\n") + "\n\nThese tools are now available for use.",
+        metadata: {
+          matchCount: matches.length,
+          toolIds: matches.map((t) => t.id)
+        }
+      };
+    }
+  });
+}
+
+export {
+  ToolRegistry,
+  defaultRegistry,
+  createToolSearchTool
+};