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

package/THIRD-PARTY-NOTICES.md

@@ -55,6 +55,11 @@ SOFTWARE.
   `@earendil-works/pi-codemode` 1.0.0 supply the MCP client and QuickJS
   executor. Tool discovery and code-mode integration are adapted from commit
   `86dfceec402ad77e563bf4feab5f26c42d5f5db6`.
+- BM25 tool search (`tool_search`, `searchTools()`), tool namespaces with
+  `describeNamespace()`, the budgeted codemode listing and the one-line MCP
+  server summary (`packages/plugin/src/tool-search.ts`,
+  `packages/plugin/src/codemode.ts`, `packages/core/src/builtins/mcp.ts`) are
+  ported from commit `d5b3de22d0e24a3e9c38a9410d3329b099717283`.
 - Transcript reconciliation, checkpoint instruction snapshots, provider system
   updates, and cache warming are ported from the 1.0.0 release commit
   `a13d35a742c6ef8462812a28fbe1d8c8b7431c32`.
@@ -312,11 +317,14 @@ Copyright 2025 OpenAI
   front of the queue (`packages/tui/src/model/interactions.ts`) is its
   `onEmptySubmit`. The rename
   plugin's context construction, prompt, model fallback, and output cleanup
-  (`packages/plugin/src/rename.ts`) port OpenCode v2. The web-search
-  plugin set (`packages/plugin/src/web-search.ts`) ports its Exa, Firecrawl,
-  Parallel, and Tavily adapters, its stateless MCP `tools/call` transport and
-  response bounds, its result and error vocabulary, and its arrangement of one
-  plugin per provider from OpenCode v2.
+  (`packages/plugin/src/rename.ts`) port OpenCode v2. The web plugin
+  (`packages/plugin/src/web/`) ports OpenCode v2's web search and fetch tools:
+  the search provider registry any plugin can add to (`searchProviders` in
+  `packages/core/src/contract/plugin.ts`), its Exa, Firecrawl, Parallel, and
+  Tavily adapters, their stateless MCP `tools/call` transport and response
+  bounds, the result and error vocabulary, `web_fetch`'s Accept headers,
+  Cloudflare-challenge retry and size limits, and the streaming HTML-to-Markdown
+  and HTML-to-text converters (`packages/plugin/src/web/html-markdown.ts`).
 - Core's ripgrep resolver and search adapter (`packages/core/src/ripgrep.ts`,
   `packages/core/src/ripgrep/binary.ts`) and filename search
   (`packages/core/src/file-search.ts`) adapt OpenCode v2's core implementation.

package/dist/chunks/bash-description-0ah30s12.js

@@ -0,0 +1,33 @@
+// src/web/body.ts
+async function readCapped2(response, limit) {
+  const declared = Number(response.headers.get("content-length") ?? Number.NaN);
+  if (Number.isSafeInteger(declared) && declared > limit) {
+    await response.body?.cancel();
+    throw tooLarge(limit);
+  }
+  if (response.body === null)
+    return new Uint8Array;
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (let next = await reader.read();!next.done; next = await reader.read()) {
+    size += next.value.byteLength;
+    if (size > limit) {
+      await reader.cancel();
+      throw tooLarge(limit);
+    }
+    chunks.push(next.value);
+  }
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+function tooLarge(limit) {
+  return new Error(`The response is larger than ${limit >= 1024 * 1024 ? `${limit / 1024 / 1024} MiB` : `${limit / 1024} KiB`}.`);
+}
+
+export { readCapped2 };

package/dist/chunks/bash-description-4cdbmar0.js

@@ -0,0 +1,124 @@
+import {
+  readCapped2
+} from "./bash-description-0ah30s12.js";
+import {
+  htmlToMarkdown2,
+  htmlToText2
+} from "./bash-description-5dpf5hpt.js";
+
+// src/web/fetch.ts
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var INLINE_CHARS = 50 * 1024;
+var MAX_REDIRECTS = 10;
+var DEFAULT_TIMEOUT_SECONDS = 30;
+var MAX_TIMEOUT_SECONDS = 120;
+var USER_AGENT = "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; Nyte/1.0; +https://nyte.sh";
+var fetchParameters = Type.Object({
+  url: Type.String({ minLength: 1, description: "The http:// or https:// URL to fetch." }),
+  format: Type.Optional(Type.Union([Type.Literal("markdown"), Type.Literal("text"), Type.Literal("html")], {
+    description: "What to return the page as. Defaults to markdown."
+  })),
+  timeout: Type.Optional(Type.Number({
+    exclusiveMinimum: 0,
+    maximum: MAX_TIMEOUT_SECONDS,
+    description: `Seconds to wait, at most ${MAX_TIMEOUT_SECONDS}. Defaults to ${DEFAULT_TIMEOUT_SECONDS}.`
+  }))
+});
+var ACCEPT = {
+  markdown: "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1",
+  text: "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1",
+  html: "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1"
+};
+function webFetch2(fetch) {
+  return {
+    name: "web_fetch",
+    description: "Fetch an http(s) URL and return it as markdown (the default), text or HTML; an image comes back as a file. Read-only. Prefer a more specific tool when one fits.",
+    parameters: standard(fetchParameters),
+    class: (args) => ({ kind: "custom", label: `Fetching ${args.url}` }),
+    effects: "none",
+    approval: "never",
+    replay: "safe",
+    async execute(args, invocation) {
+      const url = URL.parse(args.url);
+      if (url === null || url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error(`Fetch an http:// or https:// URL; ${args.url} isn't one.`);
+      const format = args.format ?? "markdown";
+      const seconds = args.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+      const page = await invocation.memo("page", async () => {
+        const deadline = AbortSignal.timeout(seconds * 1000);
+        const signal = AbortSignal.any([invocation.signal, deadline]);
+        try {
+          const response = await follow(fetch, url, format, signal);
+          const mime = (response.headers.get("content-type") ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
+          if (mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet") {
+            const bytes = await readCapped2(response, MAX_RESPONSE_BYTES);
+            const blob = await invocation.env.files.upload(async function* () {
+              yield bytes;
+            }());
+            return { kind: "image", blob, mime };
+          }
+          if (mime !== "" && !mime.startsWith("text/") && mime !== "application/json" && !mime.endsWith("+json") && mime !== "application/xml" && !mime.endsWith("+xml") && mime !== "application/javascript" && mime !== "application/x-javascript") {
+            await response.body?.cancel();
+            throw new Error(`${url.href} is ${mime}; web_fetch reads text, HTML and images.`);
+          }
+          const body = new TextDecoder().decode(await readCapped2(response, MAX_RESPONSE_BYTES));
+          const text = mime !== "text/html" || format === "html" ? body : format === "markdown" ? htmlToMarkdown2(body) : htmlToText2(body);
+          return {
+            kind: "text",
+            text: text.length > INLINE_CHARS ? `${text.slice(0, INLINE_CHARS)}
+
+… Cut at ${INLINE_CHARS} of ${text.length} characters.` : text
+          };
+        } catch (error) {
+          if (deadline.aborted && !invocation.signal.aborted)
+            throw new Error(`${url.href} didn't answer within ${seconds} s.`, { cause: error });
+          throw error;
+        }
+      });
+      if (page.kind === "image")
+        return { content: [{ kind: "file", blob: page.blob, mime: page.mime }] };
+      return {
+        content: [{ kind: "text", text: page.text === "" ? "The page is empty." : page.text }]
+      };
+    }
+  };
+}
+async function follow(fetch, start, format, signal) {
+  let url = start;
+  for (let hop = 0;hop <= MAX_REDIRECTS; hop += 1) {
+    const response = await get(fetch, url, format, signal);
+    const location = response.headers.get("location");
+    if (response.status < 300 || response.status >= 400 || location === null) {
+      if (response.ok)
+        return response;
+      await response.body?.cancel();
+      throw new Error(`${url.href} answered HTTP ${response.status}${response.statusText === "" ? "" : ` ${response.statusText}`}.`);
+    }
+    await response.body?.cancel();
+    const next = new URL(location, url);
+    if (next.protocol !== "http:" && next.protocol !== "https:")
+      throw new Error(`${url.href} redirects to ${next.href}, which isn't http(s).`);
+    url = next;
+  }
+  throw new Error(`${start.href} redirects more than ${MAX_REDIRECTS} times.`);
+}
+async function get(fetch, url, format, signal) {
+  const send = (agent) => fetch(url, {
+    headers: {
+      "User-Agent": agent,
+      Accept: ACCEPT[format],
+      "Accept-Language": "en-US,en;q=0.9"
+    },
+    redirect: "manual",
+    signal
+  });
+  const response = await send(USER_AGENT);
+  if (response.status !== 403 || response.headers.get("cf-mitigated") !== "challenge")
+    return response;
+  await response.body?.cancel();
+  return send("nyte");
+}
+
+export { webFetch2 };

package/dist/chunks/bash-description-4h0hnsv4.js

@@ -0,0 +1,68 @@
+// src/web/search.ts
+import { dev } from "@nyte-ai/core";
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var TIMEOUT_MS = 25000;
+var parameters = standard(Type.Object({ query: Type.String({ minLength: 1, description: "What to search the web for." }) }));
+var searchOutput = Type.Object({
+  provider: Type.String(),
+  results: Type.Array(Type.Object({
+    url: Type.String(),
+    title: Type.Optional(Type.String()),
+    content: Type.Optional(Type.String()),
+    published: Type.Optional(Type.Number({ description: "Milliseconds since the Unix epoch." }))
+  }))
+});
+function webSearch2(api, setting) {
+  return {
+    name: "web_search",
+    description: `Search the web using the user's selected search provider. Use this for current information beyond your knowledge cutoff. The current year is ${new Date().getFullYear()}.`,
+    parameters,
+    output: standard(searchOutput),
+    class: (args) => ({ kind: "custom", label: `Searching ${args.query}` }),
+    effects: "none",
+    approval: "never",
+    replay: "safe",
+    async execute(args, invocation) {
+      const output = await invocation.memo("results", async () => {
+        const chosen = await api.contribute.settings.value(setting);
+        const providers = api.contribute.searchProviders.list();
+        const provider = providers.find((candidate) => candidate.id === chosen) ?? providers.find((candidate) => candidate.id === "exa") ?? providers[0];
+        if (provider === undefined)
+          throw new Error("No web search provider is installed.");
+        dev("web", "search", { call: invocation.call, provider: provider.id });
+        const deadline = AbortSignal.timeout(TIMEOUT_MS);
+        const hits = await provider.search({ query: args.query, signal: AbortSignal.any([invocation.signal, deadline]) }).catch((error) => {
+          if (deadline.aborted && !invocation.signal.aborted)
+            throw new Error(`${provider.name} didn't answer within ${TIMEOUT_MS / 1000} s.`, {
+              cause: error
+            });
+          throw error;
+        });
+        return { provider: provider.id, results: hits.map(clean) };
+      });
+      const text = output.results.length === 0 ? "No search results found. Try a different query." : output.results.map((hit) => {
+        const published = hit.published === undefined ? "" : `
+Published: ${new Date(hit.published).toISOString()}`;
+        return `## [${hit.title ?? hit.url}](${hit.url})${published}${hit.content === undefined ? "" : `
+
+${hit.content}`}`;
+      }).join(`
+
+`);
+      return { content: [{ kind: "text", text }], output };
+    }
+  };
+}
+function clean(hit) {
+  const kept = { url: hit.url };
+  if (hit.title !== undefined && hit.title !== "")
+    kept.title = hit.title;
+  if (hit.content !== undefined && hit.content !== "")
+    kept.content = hit.content;
+  if (hit.published !== undefined && Number.isFinite(hit.published))
+    kept.published = hit.published;
+  return kept;
+}
+
+export { webSearch2 };