@nyte-ai/plugin 0.0.25-beta.1 → 0.0.25-nightly.20261025.2

package/dist/chunks/bash-description-9gw9ets8.js

@@ -0,0 +1,162 @@
+import {
+  readCapped2
+} from "./bash-description-0ah30s12.js";
+
+// src/web/providers.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var PROVIDERS2 = [
+  { id: "exa", name: "Exa" },
+  { id: "tavily", name: "Tavily" },
+  { id: "firecrawl", name: "Firecrawl" },
+  { id: "parallel", name: "Parallel" }
+];
+var MAX_RESPONSE_BYTES = 256 * 1024;
+var textBlocks = Type.Object({
+  content: Type.Array(Type.Object({ type: Type.String(), text: Type.Optional(Type.String()) }))
+});
+var tavilyResponse = Type.Object({
+  results: Type.Array(Type.Object({ url: Type.String(), title: Type.String(), content: Type.String() }))
+});
+var firecrawlResponse = Type.Object({
+  data: Type.Object({
+    web: Type.Array(Type.Object({
+      url: Type.String(),
+      title: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+      description: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+    }))
+  })
+});
+var parallelResponse = Type.Object({
+  structuredContent: Type.Object({
+    results: Type.Array(Type.Object({
+      url: Type.String(),
+      title: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+      publish_date: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+      excerpts: Type.Array(Type.String())
+    }))
+  })
+});
+var adapters2 = {
+  async tavily({ query, key, fetch, signal }) {
+    const response = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...key === undefined ? { "X-Tavily-Access-Mode": "keyless" } : { Authorization: `Bearer ${key}` }
+      },
+      body: JSON.stringify({ query, search_depth: "basic", max_results: 8 }),
+      signal
+    });
+    const body = parse(await answered(response, "tavily"));
+    return Value.Check(tavilyResponse, body) ? body.results.map((hit) => ({ url: hit.url, title: hit.title, content: hit.content })) : [];
+  },
+  async exa({ query, key, fetch, signal }) {
+    const endpoint = new URL("https://mcp.exa.ai/mcp");
+    if (key !== undefined)
+      endpoint.searchParams.set("exaApiKey", key);
+    const result = await callTool(fetch, endpoint, "exa", undefined, "web_search_exa", {
+      query,
+      numResults: 8
+    }, signal);
+    const text = Value.Check(textBlocks, result) ? result.content.find((block) => block.text !== undefined)?.text ?? "" : "";
+    return text.split(/\n\n---\n\n/).flatMap((block) => {
+      const url = field(block, "URL");
+      const published = field(block, "Published");
+      return url === undefined ? [] : [
+        {
+          url,
+          title: field(block, "Title"),
+          content: block.match(/^(?:Highlights|Text):\s*\n?([\s\S]*)$/m)?.[1]?.trim(),
+          published: published === undefined ? undefined : Date.parse(published)
+        }
+      ];
+    });
+  },
+  async firecrawl({ query, key, fetch, signal }) {
+    const result = await callTool(fetch, new URL("https://mcp.firecrawl.dev/v2/mcp"), "firecrawl", key, "firecrawl_search", { query, limit: 8 }, signal);
+    const text = Value.Check(textBlocks, result) ? result.content.find((block) => block.text !== undefined)?.text ?? "" : "";
+    const body = parse(text);
+    return Value.Check(firecrawlResponse, body) ? body.data.web.map((hit) => ({
+      url: hit.url,
+      title: hit.title ?? undefined,
+      content: hit.description ?? undefined
+    })) : [];
+  },
+  async parallel({ query, key, fetch, signal }) {
+    const result = await callTool(fetch, new URL("https://search.parallel.ai/mcp"), "parallel", key, "web_search", { objective: query, search_queries: [query] }, signal);
+    return Value.Check(parallelResponse, result) ? result.structuredContent.results.map((hit) => ({
+      url: hit.url,
+      title: hit.title ?? undefined,
+      content: hit.excerpts.length === 0 ? undefined : hit.excerpts.join(`
+
+`),
+      published: hit.publish_date === undefined || hit.publish_date === null ? undefined : Date.parse(hit.publish_date)
+    })) : [];
+  }
+};
+function shippedProviders2(fetch, key) {
+  return PROVIDERS2.map((provider) => ({
+    id: provider.id,
+    name: provider.name,
+    search: async (input) => adapters2[provider.id]({
+      query: input.query,
+      key: await key(provider.id),
+      fetch,
+      signal: input.signal
+    })
+  }));
+}
+async function callTool(fetch, url, provider, key, tool, args, signal) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Accept: "application/json, text/event-stream",
+      "Content-Type": "application/json",
+      ...key === undefined ? {} : { Authorization: `Bearer ${key}` }
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: tool, arguments: args }
+    }),
+    signal
+  });
+  const body = await answered(response, provider);
+  const frames = [
+    body,
+    ...body.split(`
+`).flatMap((line) => line.startsWith("data: ") ? [line.slice(6)] : [])
+  ];
+  for (const frame of frames) {
+    const message = parse(frame);
+    if (typeof message === "object" && message !== null && "result" in message)
+      return message.result;
+  }
+  return;
+}
+async function answered(response, provider) {
+  const body = new TextDecoder().decode(await readCapped2(response, MAX_RESPONSE_BYTES));
+  const name = PROVIDERS2.find((known) => known.id === provider)?.name ?? provider;
+  if (response.status === 401)
+    throw new Error(`${name} refused the search (HTTP 401). Set a key with /websearch-key ${provider} <key>.`);
+  if (response.status === 429)
+    throw new Error(`${name} is rate limiting searches (HTTP 429). Try again later, or set a key with /websearch-key ${provider} <key>.`);
+  if (!response.ok)
+    throw new Error(`HTTP ${response.status}: ${body.trim().slice(0, 200) || response.statusText}`);
+  return body;
+}
+function parse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+function field(block, name) {
+  const value = block.match(new RegExp(`^${name}:\\s*(.+)$`, "m"))?.[1]?.trim();
+  return value === undefined || value === "" || value === "N/A" ? undefined : value;
+}
+
+export { PROVIDERS2, adapters2, shippedProviders2 };

package/dist/chunks/bash-description-b78pre8c.js

@@ -0,0 +1,147 @@
+// src/tool-search.ts
+import { isJsonObject, standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var DEFAULT_SEARCH_LIMIT2 = 8;
+var STOP_WORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "with"
+]);
+var K1 = 1.2;
+var B = 0.75;
+var DESCRIPTION = `Searches over deferred tool metadata with BM25 and exposes matching tools for the next model call.
+
+Some of the tools, such as tools of MCP servers, may not have been provided to you upfront, and you should use this tool (\`tool_search\`) to search for the required tools. For MCP tool discovery, always use \`tool_search\`.`;
+var parameters = standard(Type.Object({
+  query: Type.String({ description: "Search query for deferred tools." }),
+  limit: Type.Optional(Type.Integer({
+    minimum: 1,
+    description: `Maximum number of tools to return. Defaults to ${DEFAULT_SEARCH_LIMIT2}.`
+  }))
+}));
+var output = standard(Type.Object({ loaded: Type.Array(Type.String()) }));
+var tool_search_default = {
+  id: "tool-search",
+  activate(api) {
+    const namespaces = () => new Map(api.contribute.tools.list().flatMap((definition) => definition.namespace === undefined ? [] : [[definition.name, definition.namespace]]));
+    const search = {
+      name: "tool_search",
+      description: DESCRIPTION,
+      parameters,
+      output,
+      exposure: "model-only",
+      class: () => ({ kind: "custom", label: "Searching tools" }),
+      effects: "none",
+      approval: "never",
+      replay: "safe",
+      loads: (result) => result.loaded,
+      async execute(args, invocation) {
+        if (args.query.trim() === "")
+          throw new Error("query must not be empty");
+        const loaded = new Set(await invocation.tools.loaded());
+        const found = namespaces();
+        const candidates = invocation.tools.list().filter((info) => (info.exposure === "code" || info.exposure === "deferred") && !loaded.has(info.name));
+        const names = rankTools2(args.query, candidates.map((info) => createToolSearchDocument2(info, found.get(info.name))), args.limit ?? DEFAULT_SEARCH_LIMIT2);
+        const lines = names.map((name) => {
+          const [line = ""] = (candidates.find((info) => info.name === name)?.description ?? "").trim().split(/\r?\n/);
+          return `- ${name}: ${line}`;
+        });
+        return {
+          content: [
+            {
+              kind: "text",
+              text: names.length === 0 ? "No matching tools found." : `Loaded ${names.length} tool${names.length === 1 ? "" : "s"}. They are available from your next call:
+${lines.join(`
+`)}`
+            }
+          ],
+          output: { loaded: [...names] }
+        };
+      }
+    };
+    api.contribute.tools.add(search);
+    api.hook("transform_transcript", (transcript) => {
+      const declared = new Set(transcript.tools.map((info) => info.name));
+      const pending = api.contribute.tools.list().some((definition) => definition.exposure === "deferred" && !declared.has(definition.name));
+      return pending ? transcript : { ...transcript, tools: transcript.tools.filter((info) => info.name !== search.name) };
+    });
+  }
+};
+function tokenize2(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 0 && !STOP_WORDS.has(term)).map(stem);
+}
+function stem(term) {
+  if (term.length > 4 && term.endsWith("ies"))
+    return `${term.slice(0, -3)}y`;
+  if (term.length > 4 && /(ches|shes|sses|xes|zes)$/.test(term))
+    return term.slice(0, -2);
+  if (term.length > 3 && term.endsWith("s") && !term.endsWith("ss"))
+    return term.slice(0, -1);
+  return term;
+}
+function createToolSearchDocument2(tool, namespace) {
+  const parts = [
+    tool.name,
+    tool.name.replaceAll("_", " "),
+    tool.description,
+    ...describeSchema(tool.parameters),
+    ...namespace === undefined ? [] : [namespace.name, namespace.description ?? "", namespace.instructions ?? ""]
+  ];
+  return { name: tool.name, text: parts.filter((part) => part.trim() !== "").join(" ") };
+}
+function describeSchema(schema) {
+  if (schema === undefined || !isJsonObject(schema))
+    return [];
+  const properties = isJsonObject(schema.properties) ? Object.entries(schema.properties) : [];
+  return [
+    ...typeof schema.description === "string" ? [schema.description] : [],
+    ...properties.flatMap(([name, property]) => [name, ...describeSchema(property)]),
+    ...describeSchema(schema.items),
+    ...["anyOf", "oneOf", "allOf"].flatMap((key) => {
+      const variants = schema[key];
+      return Array.isArray(variants) ? variants.flatMap(describeSchema) : [];
+    })
+  ];
+}
+function rankTools2(query, documents, limit) {
+  const terms = [...new Set(tokenize2(query))];
+  if (terms.length === 0 || documents.length === 0)
+    return [];
+  const indexed = documents.map((document) => {
+    const tokens = tokenize2(document.text);
+    return { name: document.name, length: tokens.length, counts: Map.groupBy(tokens, (t) => t) };
+  });
+  const average = indexed.reduce((sum, entry) => sum + entry.length, 0) / indexed.length || 1;
+  const idf = new Map(terms.map((term) => {
+    const frequency = indexed.filter((entry) => entry.counts.has(term)).length;
+    return [term, Math.log(1 + (indexed.length - frequency + 0.5) / (frequency + 0.5))];
+  }));
+  return indexed.map((entry) => ({
+    name: entry.name,
+    score: terms.reduce((score, term) => {
+      const count = entry.counts.get(term)?.length ?? 0;
+      const norm = K1 * (1 - B + B * entry.length / average);
+      return score + (idf.get(term) ?? 0) * (count * (K1 + 1)) / (count + norm);
+    }, 0)
+  })).filter((match) => match.score > 0).toSorted((left, right) => right.score - left.score).slice(0, limit).map((match) => match.name);
+}
+
+export { DEFAULT_SEARCH_LIMIT2, tool_search_default, tokenize2, createToolSearchDocument2, rankTools2 };

package/dist/chunks/{bash-description-eqp7ap2w.js → bash-description-vg0xecwm.js}

@@ -15,7 +15,7 @@ import { processEnvironment } from "@nyte-ai/core";
 // package.json
 var package_default = {
   name: "@nyte-ai/plugin",
-  version: "0.0.25-beta.1",
+  version: "0.0.25-nightly.20261025.2",
   private: false,
   license: "MIT",
   repository: {
@@ -46,8 +46,10 @@ var package_default = {
     "./core/openai-compaction": "./src/openai-compaction.ts",
     "./core/question": "./src/question/question.ts",
     "./core/rename": "./src/rename.ts",
+    "./core/subagents": "./src/subagents.ts",
     "./core/telemetry": "./src/telemetry.ts",
-    "./core/web-search": "./src/web-search.ts",
+    "./core/tool-search": "./src/tool-search.ts",
+    "./core/web": "./src/web/index.ts",
     "./client": "./src/client.ts",
     "./client/mount": "./src/client/mount.ts",
     "./client/notifications": "./src/client/notifications.ts",
@@ -127,13 +129,21 @@ var package_default = {
         types: "./dist/src/rename.d.ts",
         import: "./dist/src/rename.js"
       },
+      "./core/subagents": {
+        types: "./dist/src/subagents.d.ts",
+        import: "./dist/src/subagents.js"
+      },
       "./core/telemetry": {
         types: "./dist/src/telemetry.d.ts",
         import: "./dist/src/telemetry.js"
       },
-      "./core/web-search": {
-        types: "./dist/src/web-search.d.ts",
-        import: "./dist/src/web-search.js"
+      "./core/tool-search": {
+        types: "./dist/src/tool-search.d.ts",
+        import: "./dist/src/tool-search.js"
+      },
+      "./core/web": {
+        types: "./dist/src/web/index.d.ts",
+        import: "./dist/src/web/index.js"
       },
       "./client": {
         types: "./dist/src/client.d.ts",
@@ -206,6 +216,7 @@ var package_default = {
     "@opentelemetry/sdk-trace": "^3.0.0",
     "@opentelemetry/semantic-conventions": "^1.43.0",
     "es-module-lexer": "^3.0.4",
+    htmlparser2: "^8.0.2",
     sucrase: "^3.35.1",
     typebox: "^1.4.2",
     zod: "^4.6.7"

package/dist/src/acp/connection.js

@@ -1,6 +1,6 @@
 import {
   AcpProcess2
-} from "../../chunks/bash-description-eqp7ap2w.js";
+} from "../../chunks/bash-description-vg0xecwm.js";
 import"../../chunks/bash-description-svrhh5a5.js";
 import"../../chunks/bash-description-9nn3yp18.js";
 export {

package/dist/src/acp/index.js

@@ -8,7 +8,7 @@ import {
 import"../../chunks/bash-description-svrhh5a5.js";
 import {
   AcpProcess2
-} from "../../chunks/bash-description-eqp7ap2w.js";
+} from "../../chunks/bash-description-vg0xecwm.js";
 import"../../chunks/bash-description-4vz9pxyx.js";
 import {
   registryEntries2,

package/dist/src/claude-code-sdk/index.js

@@ -54,6 +54,7 @@ var CLAUDE_CODE_HAS_ITS_OWN = new Set([
   "edit",
   "list",
   "web_search",
+  "web_fetch",
   "question"
 ]);
 var ultracodeSetting = {

package/dist/src/codemode.js

@@ -1,7 +1,14 @@
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  createToolSearchDocument2,
+  rankTools2
+} from "../chunks/bash-description-b78pre8c.js";
+
 // src/codemode.ts
 import { CodemodeSandbox } from "@earendil-works/pi-codemode";
-import { renderToolSample } from "@earendil-works/pi-codemode/declarations";
+import { renderToolSample, toCodemodeIdentifier } from "@earendil-works/pi-codemode/declarations";
 import { CODEMODE_SOURCE_GRAMMAR, parseCodemodeSource } from "@earendil-works/pi-codemode/source";
+import { estimateTextTokens } from "@nyte-ai/ai/utils/estimate";
 import { dev } from "@nyte-ai/core";
 import { isJson, isJsonObject, SdkError, standard } from "@nyte-ai/schema";
 import { Type } from "typebox";
@@ -9,8 +16,8 @@ var DESCRIPTION = `Run JavaScript that calls other tools. The input is raw JavaS
 - \`await tools.<name>({ ...args })\` resolves to the tool's output, or its text, and rejects with an Error on failure.
 - Optional first line: \`// @options: {"timeout_ms": 60000}\`
 - \`text(value)\`, \`console.log(...)\` and \`return\` add output; \`store(key, value)\` and \`load(key)\` keep JSON values across codemode calls in this session.
-- \`ALL_TOOLS\`, \`searchTools(query, { limit?, namespace? })\` and \`describeTool(name)\` find tools and their declarations.`;
-var SUMMARY_CHARS = 160;
+- \`ALL_TOOLS\`, \`await searchTools(query, { limit?, namespace? })\`, \`await describeTool(name)\` and \`await describeNamespace(name)\` find unlisted tools, such as MCP tools, and their declarations.`;
+var LISTING_TOKENS = 3000;
 var parameters = standard(Type.Object({ code: Type.String({ description: "Raw JavaScript source." }) }));
 function codemodePlugin(runtime) {
   return {
@@ -18,32 +25,94 @@ function codemodePlugin(runtime) {
     activate(api) {
       api.contribute.tools.add(codemode(api, runtime));
       api.contribute.prompt.add((draft, siblings) => {
-        const reachable = siblings.tools.list().flatMap((tool) => tool.exposure === "code" || tool.exposure === "deferred" ? [`- ${tool.name}: ${summarize(tool.description)}`] : []).toSorted();
-        if (reachable.length === 0)
-          return;
-        draft.set("codemode", {
-          id: "codemode",
-          order: 96,
-          text: [
-            "Tools you reach only from a codemode script, as `await tools.<name>(args)`; `describeTool(name)` inside a script returns a tool's arguments:",
-            ...reachable
-          ].join(`
-`)
-        });
+        const text = listTools(siblings.tools.list());
+        if (text !== null)
+          draft.set("codemode", { id: "codemode", order: 96, text });
       });
     }
   };
 }
-function summarize(description) {
-  const [line = ""] = description.trim().split(`
+function listTools(definitions) {
+  const sections = definitions.flatMap((definition) => {
+    if (definition.exposure !== "code")
+      return [];
+    const inputSchema = toJsonSchema(definition.parameters, "input");
+    const outputSchema = definition.output === undefined ? { type: "string" } : toJsonSchema(definition.output, "output");
+    if (inputSchema === null || outputSchema === null)
+      return [];
+    const id = toCodemodeIdentifier(definition.name);
+    const sample = renderToolSample({
+      name: definition.name,
+      description: definition.description,
+      inputSchema,
+      outputSchema
+    }).trim();
+    const section = `### \`${id}\`${id === definition.name ? "" : ` (\`${definition.name}\`)`}
+${sample}`;
+    return [
+      {
+        namespace: definition.namespace,
+        name: definition.name,
+        section,
+        cost: estimateTextTokens(section)
+      }
+    ];
+  });
+  if (sections.length === 0)
+    return null;
+  const groups = [
+    ...Map.groupBy(sections, (entry) => entry.namespace?.name ?? "").entries()
+  ].toSorted((left, right) => left[0].localeCompare(right[0])).map((pair) => ({ namespace: pair[1][0]?.namespace, entries: pair[1] }));
+  const shown = selectListed(groups, LISTING_TOKENS);
+  return [
+    "Tools you reach only from a codemode script, as `await tools.<name>(args)`:",
+    ...groups.flatMap((group) => {
+      const visible = group.entries.filter((entry) => shown.has(entry.name));
+      if (group.namespace === undefined)
+        return visible.map((entry) => entry.section);
+      const listing = visible.length === group.entries.length ? "" : visible.length === 0 ? " (tools not listed)" : " (some tools not listed)";
+      const description = group.namespace.description?.trim() ?? "";
+      return [
+        `## ${group.namespace.name}${listing}${description === "" ? "" : `
+${description}`}`,
+        ...visible.map((entry) => entry.section)
+      ];
+    })
+  ].join(`
+
 `);
-  return line.length > SUMMARY_CHARS ? `${line.slice(0, SUMMARY_CHARS)}…` : line;
+}
+function selectListed(groups, budget) {
+  const queues = groups.map((group) => group.entries.toSorted((a, b) => a.cost - b.cost));
+  const shown = new Set;
+  let remaining = budget;
+  let active = queues.filter((queue) => queue.length > 0);
+  while (active.length > 0)
+    active = active.filter((queue) => {
+      const next = queue[0];
+      if (next === undefined || next.cost > remaining)
+        return false;
+      remaining -= next.cost;
+      shown.add(next.name);
+      queue.shift();
+      return queue.length > 0;
+    });
+  return shown;
+}
+function toJsonSchema(schema, direction) {
+  try {
+    const converted = schema["~standard"].jsonSchema[direction]({ target: "draft-2020-12" });
+    return isJson(converted) && isJsonObject(converted) ? converted : null;
+  } catch {
+    return null;
+  }
 }
 function codemode(api, runtime) {
   return {
     name: "codemode",
     description: DESCRIPTION,
     parameters,
+    exposure: "model-only",
     grammar: { kind: "lark", source: CODEMODE_SOURCE_GRAMMAR },
     class: () => ({ kind: "custom", label: "Running a script" }),
     effects: "none",
@@ -51,14 +120,24 @@ function codemode(api, runtime) {
     replay: "never",
     async execute(args, invocation) {
       const { code, options } = parseCodemodeSource(args.code);
-      const callable = invocation.tools.list().filter((info) => info.name !== "codemode" && info.exposure !== "hidden");
+      const callable = invocation.tools.list().filter((info) => info.exposure !== "model-only" && info.exposure !== "hidden");
       const stored = await api.storage.get("store");
       if (stored !== undefined && !isJsonObject(stored))
         throw new SdkError("internal", "Codemode's stored values are not a JSON object.");
+      const namespaces = new Map(api.contribute.tools.list().flatMap((definition) => definition.namespace === undefined ? [] : [[definition.name, definition.namespace]]));
+      const samples = new Map(callable.map((info) => [
+        info.name,
+        renderToolSample({
+          name: info.name,
+          description: info.description,
+          inputSchema: info.parameters,
+          outputSchema: info.output ?? { type: "string" }
+        })
+      ]));
       const sandbox = new CodemodeSandbox({
         ...runtime,
-        tools: callable.map((info) => bridge(info, invocation)),
-        globals: discovery(callable),
+        tools: callable.map((info) => bridge(info, samples.get(info.name) ?? "", invocation)),
+        globals: discovery(callable, samples, namespaces),
         timeoutMs: options.timeoutMs ?? 300000,
         memoryLimitBytes: 256 * 1024 * 1024
       });
@@ -102,11 +181,11 @@ ${calls(result)}`);
     }
   };
 }
-function bridge(info, invocation) {
+function bridge(info, sample, invocation) {
   let sequence = 0;
   return {
     name: info.name,
-    description: info.description,
+    description: sample,
     inputSchema: info.parameters,
     outputSchema: info.output ?? { type: "string" },
     async execute(args, { signal }) {
@@ -121,42 +200,70 @@ function unwrapToolOutcome(outcome) {
 `);
   throw new Error(outcome.kind === "failed" ? outcome.message : outcome.kind === "rejected" ? `Rejected: ${outcome.reason}` : `The call was ${outcome.kind}.`);
 }
-function discovery(tools) {
+function discovery(tools, samples, namespaces) {
   return [
     {
       name: "searchTools",
       spread: true,
       execute(args) {
         const [query, options] = Array.isArray(args) ? args : [];
-        const words = new Set(String(query).toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 1));
-        const limit = typeof options === "object" && options !== null && "limit" in options && typeof options.limit === "number" ? options.limit : 8;
-        const namespace = typeof options === "object" && options !== null && "namespace" in options && typeof options.namespace === "string" ? options.namespace : null;
-        return tools.filter((info) => namespace === null || info.namespace === namespace).map((info) => ({
-          info,
-          score: `${info.name} ${info.description}`.toLowerCase().split(/[^a-z0-9]+/).filter((word) => words.has(word)).length
-        })).filter((entry) => entry.score > 0).toSorted((left, right) => right.score - left.score).slice(0, limit).map(({ info }) => ({
-          name: info.name,
-          namespace: info.namespace,
-          description: info.description
+        if (typeof query !== "string")
+          throw new Error("searchTools() expects a query string");
+        const limit = isJsonObject(options) ? options.limit ?? null : null;
+        const namespace = isJsonObject(options) ? options.namespace ?? null : null;
+        if (limit !== null && (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0))
+          throw new Error("searchTools() limit must be a positive integer");
+        if (namespace !== null && typeof namespace !== "string")
+          throw new Error("searchTools() namespace must be a string");
+        const documents = tools.flatMap((info) => {
+          const found = namespaces.get(info.name);
+          if (namespace !== null && (found === undefined || !matchesNamespace(found, namespace)))
+            return [];
+          return [createToolSearchDocument2(info, found)];
+        });
+        return rankTools2(query, documents, limit ?? DEFAULT_SEARCH_LIMIT2).map((name) => ({
+          name: toCodemodeIdentifier(name),
+          description: samples.get(name) ?? ""
         }));
       }
     },
     {
       name: "describeTool",
       execute(name) {
-        const info = tools.find((candidate) => candidate.name === name);
+        if (typeof name !== "string")
+          throw new Error("describeTool() expects a tool name");
+        const info = tools.find((candidate) => candidate.name === name || toCodemodeIdentifier(candidate.name) === name);
         if (info === undefined)
-          throw new Error(`No tool is named ${String(name)}.`);
-        return renderToolSample({
-          name: info.name,
-          description: info.description,
-          inputSchema: info.parameters,
-          outputSchema: info.output ?? { type: "string" }
+          throw new Error(`No tool is named ${name}.`);
+        return samples.get(info.name) ?? "";
+      }
+    },
+    {
+      name: "describeNamespace",
+      execute(name) {
+        if (typeof name !== "string")
+          throw new Error("describeNamespace() expects a namespace name");
+        const members = tools.filter((info) => {
+          const found = namespaces.get(info.name);
+          return found !== undefined && matchesNamespace(found, name);
         });
+        const namespace = members[0] === undefined ? undefined : namespaces.get(members[0].name);
+        if (namespace === undefined)
+          throw new Error(`No namespace is named ${name}.`);
+        return {
+          name: namespace.name,
+          ...namespace.description === undefined ? {} : { description: namespace.description },
+          ...namespace.instructions === undefined ? {} : { instructions: namespace.instructions },
+          tools: members.map((info) => toCodemodeIdentifier(info.name))
+        };
       }
     }
   ];
 }
+function matchesNamespace(namespace, query) {
+  const id = toCodemodeIdentifier(query);
+  return [namespace.name, ...namespace.aliases ?? []].some((name) => name === query || toCodemodeIdentifier(name) === id);
+}
 function calls(result) {
   return result.calls.length === 0 ? "No tool calls were made." : `Tool calls made before the failure (not undone): ${result.calls.map((call) => `${call.name} (${call.status})`).join(", ")}`;
 }

package/dist/src/core.d.ts

@@ -1,6 +1,6 @@
 import type { HookEntry as SideHookEntry, HookHandler as SideHookHandler, HookName as SideHookName, Plugin as CorePlugin, PluginApi as CorePluginApi } from "@nyte-ai/core";
 export { branchSummary, compaction, definePart, isPart, text, thinking, tool } from "@nyte-ai/core";
-export type { ActionContext, Agent, Command, Durable, HookTable, ModelContextPolicy, Part, PartDefinition, PartState, PromptSection, Setting, SettingDefinition, Skill, ToolDefinition, ToolInvocation, } from "@nyte-ai/core";
+export type { ActionContext, Agent, Command, Durable, HookTable, ModelContextPolicy, Part, PartDefinition, PartState, PromptSection, SearchProvider, SearchResult, Setting, SettingDefinition, Skill, ToolDefinition, ToolInvocation, } from "@nyte-ai/core";
 export type { CompactionPlan, Decision, ModelRequest, Submission, ToolCall, Transcript, } from "@nyte-ai/schema";
 /**
  * A core plugin: per session on the host, with tools, prompt sections,