@nyte-ai/plugin 0.0.24 → 0.0.25-nightly.20261025.2

package/dist/src/subagents.js

@@ -0,0 +1,323 @@
+// src/subagents.ts
+import { Type } from "typebox";
+import { asId, standard } from "@nyte-ai/schema";
+import { isPart, text, tool } from "@nyte-ai/core";
+var ANSWER_LIMIT = 16000;
+var TRANSCRIPT_LIMIT = 16000;
+var SCHEDULED = {
+  joined: "it joins the work in progress",
+  "next-turn": "it runs once its current work ends",
+  attached: "it rides with its next turn",
+  deciding: "its plugins are deciding it"
+};
+var selectionParameters = {
+  agent: Type.Optional(Type.String({ description: "A registered agent to run as; the default agent otherwise." })),
+  model: Type.Optional(Type.String({
+    description: "A model from /model, as provider/id or its id alone; a fast variant is its own id. The default model otherwise."
+  })),
+  thinking: Type.Optional(Type.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"], {
+    description: "A thinking level the model accepts; its default otherwise."
+  }))
+};
+var isolationParameter = {
+  isolation: Type.Optional(Type.Literal("worktree", {
+    description: "Run the subagent in a git worktree on a new branch from HEAD, with your uncommitted changes copied in, so its edits stay out of this workspace. The reply names the folder and branch. Without it, the subagent works in this workspace."
+  }))
+};
+var taskParameters = standard(Type.Object({
+  prompt: Type.String({
+    description: "The task for the subagent, with everything it needs to know."
+  }),
+  title: Type.Optional(Type.String({ description: "A short name for the subagent's session." })),
+  ...selectionParameters,
+  ...isolationParameter
+}));
+var createParameters = standard(Type.Object({
+  prompt: Type.String({
+    description: "The subagent's first message; it starts working on it at once."
+  }),
+  title: Type.Optional(Type.String({ description: "A short name for the subagent's session." })),
+  ...selectionParameters,
+  ...isolationParameter,
+  role: Type.Optional(Type.String({
+    description: "Instructions the subagent keeps for every message, added to its prompt."
+  }))
+}));
+var sendParameters = standard(Type.Object({
+  session: Type.String({ description: "The subagent's session id, from task or create." }),
+  prompt: Type.String({ description: "The message for the subagent." })
+}));
+var awaitParameters = standard(Type.Object({
+  session: Type.String({ description: "The subagent's session id, from task or create." }),
+  timeout: Type.Optional(Type.Integer({
+    minimum: 1,
+    description: "Seconds to wait before returning while it still works."
+  }))
+}));
+var readParameters = standard(Type.Object({
+  session: Type.String({ description: "The subagent's session id, from task or create." })
+}));
+var stopParameters = standard(Type.Object({
+  session: Type.String({ description: "The subagent's session id, from task or create." })
+}));
+var task = {
+  name: "task",
+  description: "Run a subagent on a task and wait for its answer. Give it everything it needs; it does not see this conversation.",
+  parameters: taskParameters,
+  class: (args) => ({ kind: "delegate", child: null, role: "task", title: args.title ?? null }),
+  replay: "safe",
+  async execute(args, invocation) {
+    const { session: child, receipt } = await invocation.sdk.sessions.start({
+      parent: invocation.session.id,
+      name: args.title,
+      configuration: await childConfiguration(invocation, args),
+      isolation: args.isolation,
+      content: args.prompt
+    });
+    const run = await invocation.memo("run", async () => {
+      const landing = await receipt.landed();
+      return landing.kind === "landed" ? landing.run : null;
+    });
+    if (run === null)
+      return reply(`Subagent ${child.id} did not start the task.`);
+    const outcome = await invocation.wait({
+      kind: "any",
+      targets: [{ kind: "run", session: child.id, run }],
+      untilInput: true
+    });
+    const answer = await readSubagentReply(child, run, outcome);
+    const worktree = await describeWorktree(invocation, child);
+    return reply(worktree === null ? answer : `${worktree}
+
+${answer}`);
+  }
+};
+var create = {
+  name: "create",
+  description: "Start a subagent on a first message and return its id, to send it more messages and await it later.",
+  parameters: createParameters,
+  class: (args) => ({ kind: "delegate", child: null, role: "create", title: args.title ?? null }),
+  effects: "none",
+  replay: "safe",
+  async execute(args, invocation) {
+    const { session: child } = await invocation.sdk.sessions.start({
+      parent: invocation.session.id,
+      name: args.title,
+      configuration: await childConfiguration(invocation, args),
+      prompt: args.role === undefined ? undefined : { kind: "layer", text: args.role },
+      isolation: args.isolation,
+      content: args.prompt
+    });
+    const worktree = await describeWorktree(invocation, child);
+    return reply(worktree === null ? `Started subagent ${child.id}.` : `Started subagent ${child.id}. ${worktree}`);
+  }
+};
+var send = {
+  name: "send",
+  description: "Send a message to a subagent; it works in the background. Use await for its answer.",
+  parameters: sendParameters,
+  class: (args) => ({
+    kind: "delegate",
+    child: asId(args.session),
+    role: "send",
+    title: null
+  }),
+  effects: "none",
+  replay: "safe",
+  async execute(args, invocation) {
+    const child = await requireChildSession(invocation, args.session);
+    const receipt = await child.send(args.prompt, {
+      id: asId(`${invocation.call}:${child.id}`)
+    });
+    const view = await child.view();
+    const message = [...view.messages, ...view.queue].find((entry) => entry.id === receipt.message);
+    return reply(`Sent to subagent ${child.id}; ${scheduled(message)}.`);
+  }
+};
+var awaitChild = {
+  name: "await",
+  description: "Wait for a subagent to finish its current work and return its answer.",
+  parameters: awaitParameters,
+  class: (args) => ({
+    kind: "delegate",
+    child: asId(args.session),
+    role: "await",
+    title: null
+  }),
+  replay: "safe",
+  async execute(args, invocation) {
+    const child = await requireChildSession(invocation, args.session);
+    const run = await invocation.memo("run", async () => {
+      const { execution } = await child.view();
+      return execution.kind === "idle" ? null : execution.run.id;
+    });
+    if (run === null) {
+      const execution = (await child.view()).execution;
+      const last = execution.kind === "idle" ? execution.lastRun : null;
+      if (last === null)
+        return reply(`Subagent ${child.id} has not worked on anything yet.`);
+      return reply(await readSubagentReply(child, last.id, {
+        kind: "run",
+        session: child.id,
+        run: last.id,
+        end: last.end
+      }));
+    }
+    const targets = [{ kind: "run", session: child.id, run }];
+    const outcome = await invocation.wait(args.timeout === undefined ? { kind: "any", targets, untilInput: true } : {
+      kind: "any",
+      targets,
+      untilInput: true,
+      deadline: invocation.now() + args.timeout * 1000
+    });
+    return reply(await readSubagentReply(child, run, outcome));
+  }
+};
+var readAgent = {
+  name: "read_agent",
+  description: "Read a subagent's conversation so far, newest last.",
+  parameters: readParameters,
+  class: (args) => ({
+    kind: "delegate",
+    child: asId(args.session),
+    role: "read",
+    title: null
+  }),
+  effects: "none",
+  replay: "safe",
+  async execute(args, invocation) {
+    const child = await requireChildSession(invocation, args.session);
+    const view = await child.view();
+    const execution = view.execution.kind;
+    const state = execution === "idle" ? "idle" : execution === "waiting" ? "waiting" : "working";
+    const transcript = fromEnd([...view.messages, ...view.queue].flatMap(renderTranscriptMessage).join(`
+
+`), TRANSCRIPT_LIMIT);
+    return reply(transcript === "" ? `Subagent ${child.id} is ${state} and has no messages yet.` : `Subagent ${child.id} is ${state}.
+
+${transcript}`);
+  }
+};
+var stop = {
+  name: "stop",
+  description: "Stop a subagent's current work.",
+  parameters: stopParameters,
+  class: (args) => ({
+    kind: "delegate",
+    child: asId(args.session),
+    role: "stop",
+    title: null
+  }),
+  effects: "none",
+  replay: "safe",
+  async execute(args, invocation) {
+    const child = await requireChildSession(invocation, args.session);
+    const { stopped, withdrawn } = await child.stop();
+    return reply(`Stopped ${stopped.length} run${stopped.length === 1 ? "" : "s"} of subagent ${child.id} and withdrew ${withdrawn.length} pending message${withdrawn.length === 1 ? "" : "s"}.`);
+  }
+};
+var subagents_default = {
+  id: "subagents",
+  async activate(api) {
+    if ((await api.session.info()).parent !== null)
+      return;
+    for (const definition of [task, create, send, awaitChild, readAgent, stop])
+      api.contribute.tools.add(definition);
+  }
+};
+async function childConfiguration(invocation, { agent, model, thinking }) {
+  if (agent === undefined && model === undefined && thinking === undefined)
+    return;
+  return {
+    agent,
+    model: model === undefined ? undefined : await findModel(invocation, model),
+    thinking
+  };
+}
+async function findModel(invocation, name) {
+  const models = (await invocation.sdk.models.list()).providers.flatMap((provider) => provider.credential === "unknown" || provider.credential === "configured" || provider.credential === "verified" ? provider.models : []);
+  const refs = models.flatMap((info) => info.fast === null ? [info.ref] : [info.ref, info.fast]);
+  const exact = refs.filter((ref) => `${ref.provider}/${ref.id}` === name);
+  const matches = exact.length > 0 ? exact : refs.filter((ref) => ref.id === name);
+  const [only, ...others] = matches;
+  if (only !== undefined && others.length === 0)
+    return only;
+  if (only !== undefined)
+    throw new Error(`${name} names more than one model; pass one of ${matches.map((ref) => `${ref.provider}/${ref.id}`).join(", ")}.`);
+  if (models.length === 0)
+    throw new Error("No model is available; sign in to a provider first.");
+  throw new Error(`/model has no ${name}. Choose one of:
+${models.map((info) => `- ${info.ref.provider}/${info.ref.id} (thinking: ${info.thinking.join(", ")})${info.fast === null ? "" : `, fast: ${info.fast.provider}/${info.fast.id}`}`).join(`
+`)}`);
+}
+async function describeWorktree(invocation, child) {
+  const workspace = await invocation.sdk.workspace((await child.info()).workspace).info();
+  if (workspace.isolation === null)
+    return null;
+  const folder = "path" in workspace.target ? workspace.target.path : workspace.id;
+  return `It works in the worktree ${folder} on branch ${workspace.isolation.branch}.`;
+}
+function reply(content) {
+  return { content: [{ kind: "text", text: content }] };
+}
+async function requireChildSession(invocation, id) {
+  const child = invocation.sdk.session(asId(id));
+  if ((await child.info()).parent !== invocation.session.id)
+    throw new Error(`Session ${id} is not a subagent of this session.`);
+  return child;
+}
+async function readSubagentReply(child, run, outcome) {
+  const header = `Subagent ${child.id} ${describeSubagentOutcome(outcome)}.`;
+  const view = await child.view();
+  const turn = view.turns.find((entry) => entry.run === run)?.id;
+  const answer = view.messages.flatMap((message) => message.turn === turn && isPart(message, text) && message.state.markdown !== "" ? [message.state.markdown] : []).at(-1) ?? "";
+  return answer === "" ? header : `${header}
+
+${fromStart(answer, ANSWER_LIMIT)}`;
+}
+function describeSubagentOutcome(outcome) {
+  if (outcome.kind === "run")
+    return endedAs(outcome.end);
+  return outcome.kind === "stopped" ? "is still working; this call was stopped before it ended" : "is still working";
+}
+function endedAs(end) {
+  if (end.kind === "failed")
+    return `failed: ${end.failure.message}`;
+  return end.kind === "completed" ? "finished" : "was stopped";
+}
+function scheduled(message) {
+  if (message?.kind !== "user")
+    return "it was admitted";
+  if (message.status.kind === "landed")
+    return "it started working on it";
+  if (message.status.kind !== "pending")
+    return "it was admitted";
+  return SCHEDULED[message.status.schedule.kind];
+}
+function renderTranscriptMessage(message) {
+  if (message.kind === "user")
+    return [
+      `User: ${typeof message.content === "string" ? message.content : message.content.flatMap((item) => item.kind === "text" ? [item.text] : []).join(" ")}`
+    ];
+  if (isPart(message, text))
+    return message.state.markdown === "" ? [] : [`Assistant: ${message.state.markdown}`];
+  if (isPart(message, tool)) {
+    const state = message.state;
+    const status = state.phase === "settled" ? state.outcome.kind : state.phase;
+    return [`Tool ${state.name}(${JSON.stringify(state.args)}): ${status}`];
+  }
+  return [];
+}
+function fromStart(content, limit) {
+  return content.length > limit ? `${content.slice(0, limit)}
+
+[… cut at ${limit} characters]` : content;
+}
+function fromEnd(content, limit) {
+  return content.length > limit ? `[… earlier messages cut]
+
+${content.slice(-limit)}` : content;
+}
+export {
+  subagents_default as default
+};

package/dist/src/telemetry.d.ts

@@ -21,7 +21,7 @@ declare const _default: {
         readonly contribute: import("@nyte-ai/core").Registries<"core">;
         readonly storage: import("@nyte-ai/core").PluginStorage;
         readonly signal: AbortSignal;
-        hook<N extends "session_activated" | "before_send" | "run_started" | "transform_transcript" | "before_compaction" | "before_request" | "before_tool" | "after_tool" | "after_request" | "run_ended">(name: N, entry: import("@nyte-ai/core").HookEntry<"core", N>): import("@nyte-ai/schema").Disposer;
+        hook<N extends import("@nyte-ai/core").HookName<"core">>(name: N, entry: import("@nyte-ai/core").HookEntry<"core", N>): import("@nyte-ai/schema").Disposer;
         report(issue: import("@nyte-ai/schema").ValidationIssue): void;
         reload(): void;
     } & {

package/dist/src/tool-search.d.ts

@@ -0,0 +1,49 @@
+import type { ToolNamespace } from "@nyte-ai/core";
+import type { ToolInfo } from "@nyte-ai/schema";
+export declare const DEFAULT_SEARCH_LIMIT = 8;
+/** A tool as the ranker sees it: its name and the text {@link createToolSearchDocument} builds. */
+export type ToolSearchDocument = {
+    readonly name: string;
+    readonly text: string;
+};
+/**
+ * The `tool_search` tool: ranks the `code` and `deferred` tools the head
+ * has not loaded yet and loads the matches, so the model sees them declared
+ * from its next request on. Loads live in the call's output, so they follow
+ * the head's history through restarts, branches and compaction. The tool is
+ * declared only while some `deferred` tool is not.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    activate(api: {
+        readonly side: "core";
+        readonly sdk: import("@nyte-ai/core").Connection;
+        readonly contribute: import("@nyte-ai/core").Registries<"core">;
+        readonly storage: import("@nyte-ai/core").PluginStorage;
+        readonly signal: AbortSignal;
+        hook<N extends import("@nyte-ai/core").HookName<"core">>(name: N, entry: import("@nyte-ai/core").HookEntry<"core", N>): import("@nyte-ai/schema").Disposer;
+        report(issue: import("@nyte-ai/schema").ValidationIssue): void;
+        reload(): void;
+    } & {
+        readonly session: import("@nyte-ai/core").Session;
+        readonly env: import("@nyte-ai/core").ExecutionEnv;
+        wrapEnv(wrap: import("@nyte-ai/core").EnvironmentWrap): import("@nyte-ai/schema").Disposer;
+        readonly inputs: import("@nyte-ai/core").Resources;
+        request<T = string>(input: import("@nyte-ai/schema").ModelRequestInput<T>): Promise<import("@nyte-ai/schema").ModelRequestOutcome<T>>;
+        approve(call: import("@nyte-ai/core").RuntimeCall, signal: AbortSignal): Promise<import("@nyte-ai/core").RuntimeVerdict>;
+    }): void;
+};
+export default _default;
+/** Lowercase terms split at camelCase boundaries and non-alphanumerics, without stop words, naively singular. */
+export declare function tokenize(text: string): readonly string[];
+/**
+ * A tool's search text: its name, the name with `_` as spaces, its
+ * description, every parameter's name and description, and its namespace's
+ * name, description and instructions.
+ */
+export declare function createToolSearchDocument(tool: Pick<ToolInfo, "name" | "description" | "parameters">, namespace: ToolNamespace | undefined): ToolSearchDocument;
+/** The names of the `limit` best documents for `query` by Okapi BM25; ties keep document order. */
+export declare function rankTools(query: string, documents: readonly ToolSearchDocument[], limit: number): readonly string[];

package/dist/src/tool-search.js

@@ -0,0 +1,14 @@
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  tool_search_default,
+  tokenize2,
+  createToolSearchDocument2,
+  rankTools2
+} from "../chunks/bash-description-b78pre8c.js";
+export {
+  DEFAULT_SEARCH_LIMIT2 as DEFAULT_SEARCH_LIMIT,
+  createToolSearchDocument2 as createToolSearchDocument,
+  tool_search_default as default,
+  rankTools2 as rankTools,
+  tokenize2 as tokenize
+};

package/dist/src/web/body.d.ts

@@ -0,0 +1,3 @@
+export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** Reads a response body, throwing once its declared or streamed size passes `limit` bytes. */
+export declare function readCapped(response: Response, limit: number): Promise<Uint8Array>;

package/dist/src/web/body.js

@@ -0,0 +1,6 @@
+import {
+  readCapped2
+} from "../../chunks/bash-description-0ah30s12.js";
+export {
+  readCapped2 as readCapped
+};

package/dist/src/web/fetch.d.ts

@@ -0,0 +1,16 @@
+import { Type } from "typebox";
+import type { Static } from "typebox";
+import type { ToolDefinition } from "@nyte-ai/plugin/core";
+import type { Fetch } from "./body.ts";
+declare const fetchParameters: Type.TObject<{
+    url: Type.TString;
+    format: Type.TOptional<Type.TUnion<[Type.TLiteral<"markdown">, Type.TLiteral<"text">, Type.TLiteral<"html">]>>;
+    timeout: Type.TOptional<Type.TNumber>;
+}>;
+/**
+ * The `web_fetch` tool: GETs an http(s) URL through `fetch`, following at most ten
+ * redirects that stay on http(s), and returns HTML as markdown, text or itself, other
+ * text as is, and an image as a file. Bodies stop at 5 MiB; text shown inline at 50 KiB.
+ */
+export declare function webFetch(fetch: Fetch): ToolDefinition<Static<typeof fetchParameters>>;
+export {};

package/dist/src/web/fetch.js

@@ -0,0 +1,8 @@
+import {
+  webFetch2
+} from "../../chunks/bash-description-4cdbmar0.js";
+import"../../chunks/bash-description-5dpf5hpt.js";
+import"../../chunks/bash-description-0ah30s12.js";
+export {
+  webFetch2 as webFetch
+};

package/dist/src/web/html-markdown.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_MARKDOWN_BYTES: number;
+/**
+ * Converts HTML to Markdown in one streaming pass: drops scripts, styles, the head and
+ * hidden elements; keeps headings, lists, GFM tables, fenced code, links and images;
+ * stops nesting past 10,000 levels and caps the result at `MAX_MARKDOWN_BYTES`.
+ */
+export declare function htmlToMarkdown(html: string): string;
+/** Returns an HTML document's text outside scripts, styles and embeds, trimmed. */
+export declare function htmlToText(html: string): string;

package/dist/src/web/html-markdown.js

@@ -0,0 +1,10 @@
+import {
+  MAX_MARKDOWN_BYTES2,
+  htmlToMarkdown2,
+  htmlToText2
+} from "../../chunks/bash-description-5dpf5hpt.js";
+export {
+  MAX_MARKDOWN_BYTES2 as MAX_MARKDOWN_BYTES,
+  htmlToMarkdown2 as htmlToMarkdown,
+  htmlToText2 as htmlToText
+};

package/dist/src/web/index.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from "@nyte-ai/plugin/core";
+import type { Fetch } from "./body.ts";
+export { adapters, PROVIDERS } from "./providers.ts";
+export type { SearchInput, ShippedProvider } from "./providers.ts";
+/**
+ * Returns the web plugin sending through `fetch`: `web_fetch`, and `web_search`
+ * routed by the host setting `web_search.provider` to any provider in the
+ * search registry. It adds Exa, Tavily, Firecrawl and Parallel there, each
+ * keyed from the plugin's secrets under its id (set with `/websearch-key`) or
+ * on its keyless route without one. The setting `off`, or an empty registry,
+ * drops `web_search`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function webPlugin(fetch: Fetch): Plugin;
+/**
+ * The web plugin over the global `fetch`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: Plugin;
+export default _default;

package/dist/src/web/index.js

@@ -0,0 +1,93 @@
+import"../../chunks/bash-description-0ah30s12.js";
+import"../../chunks/bash-description-5dpf5hpt.js";
+import {
+  webFetch2
+} from "../../chunks/bash-description-4cdbmar0.js";
+import {
+  PROVIDERS2,
+  adapters2,
+  shippedProviders2
+} from "../../chunks/bash-description-9gw9ets8.js";
+import {
+  webSearch2
+} from "../../chunks/bash-description-4h0hnsv4.js";
+
+// src/web/index.ts
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var OFF = { value: "off", label: "Off" };
+var provider = {
+  id: "web_search.provider",
+  label: "Web search provider",
+  schema: standard(Type.String({ minLength: 1 })),
+  choices: [...PROVIDERS2.map((known) => ({ value: known.id, label: known.name })), OFF],
+  default: "exa",
+  scope: "host"
+};
+var keyCommand = {
+  name: "websearch-key",
+  title: "Set a web search key",
+  description: "Store a web search provider's API key: <provider> <key>; no key removes it.",
+  complete(prefix) {
+    const typed = prefix.trimStart();
+    if (/\s/u.test(typed))
+      return [];
+    return PROVIDERS2.filter((known) => known.id.startsWith(typed.toLowerCase())).map((known) => ({
+      value: `${known.id} `,
+      label: known.id
+    }));
+  },
+  async run(text, { api }) {
+    const [named = "", key = ""] = text.split(/\s+(.*)/su);
+    const chosen = PROVIDERS2.find((known) => known.id === named.toLowerCase());
+    if (chosen === undefined)
+      throw new Error(`Name a provider first: ${PROVIDERS2.map((known) => known.id).join(", ")}.`);
+    if (key === "")
+      await api.storage.secrets.delete(chosen.id);
+    else
+      await api.storage.secrets.set(chosen.id, key);
+    return `Key for ${chosen.id} ${key === "" ? "removed" : "saved"}.`;
+  }
+};
+function webPlugin(fetch) {
+  return {
+    id: "web",
+    contribute: {
+      settings: [provider],
+      commands: [keyCommand],
+      tools: [webFetch2(fetch)]
+    },
+    async activate(api) {
+      for (const shipped of shippedProviders2(fetch, (id) => api.storage.secrets.get(id)))
+        api.contribute.searchProviders.add(shipped);
+      let selected = await api.contribute.settings.value(provider.id);
+      (async () => {
+        for await (const value of api.contribute.settings.watch(provider.id)) {
+          if (value === selected)
+            continue;
+          selected = value;
+          api.reload();
+        }
+      })();
+      api.contribute.settings.add((draft, siblings) => draft.wrap(provider.id, (inner) => ({
+        ...inner,
+        choices: [
+          ...siblings.searchProviders.list().map((known) => ({ value: known.id, label: known.name })),
+          OFF
+        ]
+      })));
+      api.contribute.tools.add((draft, siblings) => {
+        if (selected === OFF.value || siblings.searchProviders.list().length === 0)
+          return;
+        draft.set("web_search", webSearch2(api, provider.id));
+      });
+    }
+  };
+}
+var web_default = webPlugin((input, init) => globalThis.fetch(input, init));
+export {
+  PROVIDERS2 as PROVIDERS,
+  adapters2 as adapters,
+  web_default as default,
+  webPlugin
+};

package/dist/src/web/providers.d.ts

@@ -0,0 +1,60 @@
+import type { SearchProvider, SearchResult } from "@nyte-ai/plugin/core";
+import type { Fetch } from "./body.ts";
+/**
+ * The search providers the web plugin ships, by id and display name.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const PROVIDERS: readonly [{
+    readonly id: "exa";
+    readonly name: "Exa";
+}, {
+    readonly id: "tavily";
+    readonly name: "Tavily";
+}, {
+    readonly id: "firecrawl";
+    readonly name: "Firecrawl";
+}, {
+    readonly id: "parallel";
+    readonly name: "Parallel";
+}];
+/**
+ * Names a search provider the web plugin ships.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type ShippedProvider = (typeof PROVIDERS)[number]["id"];
+/**
+ * Returns what one adapter call needs: the query, the provider's key or
+ * undefined for its keyless route, the fetch to send with, and a signal.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export interface SearchInput {
+    readonly query: string;
+    readonly key: string | undefined;
+    readonly fetch: Fetch;
+    readonly signal: AbortSignal;
+}
+/**
+ * One adapter per provider: Tavily over its REST endpoint, the others over
+ * one stateless MCP `tools/call` to their public route. Each sends through
+ * the given fetch only, reads at most 256 KiB, and returns the hits it recognised.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const adapters: {
+    readonly [P in ShippedProvider]: (input: SearchInput) => Promise<readonly SearchResult[]>;
+};
+/**
+ * Returns the shipped providers for the search registry, each reading its key
+ * through `key` on every search and sending through `fetch`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function shippedProviders(fetch: Fetch, key: (provider: ShippedProvider) => Promise<string | undefined>): readonly SearchProvider[];

package/dist/src/web/providers.js

@@ -0,0 +1,11 @@
+import {
+  PROVIDERS2,
+  adapters2,
+  shippedProviders2
+} from "../../chunks/bash-description-9gw9ets8.js";
+import"../../chunks/bash-description-0ah30s12.js";
+export {
+  PROVIDERS2 as PROVIDERS,
+  adapters2 as adapters,
+  shippedProviders2 as shippedProviders
+};

package/dist/src/web/search.d.ts

@@ -0,0 +1,21 @@
+import { Type } from "typebox";
+import type { Static } from "typebox";
+import type { PluginApi, ToolDefinition } from "@nyte-ai/plugin/core";
+declare const searchOutput: Type.TObject<{
+    provider: Type.TString;
+    results: Type.TArray<Type.TObject<{
+        url: Type.TString;
+        title: Type.TOptional<Type.TString>;
+        content: Type.TOptional<Type.TString>;
+        published: Type.TOptional<Type.TNumber>;
+    }>>;
+}>;
+type SearchOutput = Static<typeof searchOutput>;
+/**
+ * The `web_search` tool: asks the registered provider the setting `setting` names,
+ * falling back to Exa and then to the first one registered.
+ */
+export declare function webSearch(api: PluginApi, setting: string): ToolDefinition<{
+    query: string;
+}, SearchOutput>;
+export {};