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

package/dist/chunks/{bash-description-yyd9jznf.js → bash-description-94km1hm2.js}

@@ -4,7 +4,7 @@ import {
   initializeResult2,
   renderNotification2,
   clampCanvasHeight2
-} from "./bash-description-dnvgk30y.js";
+} from "./bash-description-4rfavmha.js";
 
 // src/canvas/canvas-preview.ts
 import { Type } from "typebox";

package/dist/chunks/{bash-description-svrhh5a5.js → bash-description-99k8z2r7.js}

@@ -1,10 +1,11 @@
 import {
   MIRROR_TOOL2,
+  agentUsage2,
   emptyMessage2,
   mirrorClass2,
   toolText2,
   Translator2
-} from "./bash-description-9nn3yp18.js";
+} from "./bash-description-q2v8wbn8.js";
 
 // src/acp/thread.ts
 import { posix } from "node:path";
@@ -168,7 +169,7 @@ class AcpThread2 {
             reason = "toolUse";
           } else {
             translator.end();
-            if (event.response.usage !== undefined && event.response.usage !== null)
+            if (Value.Check(agentUsage2, event.response.usage))
               translator.usage(event.response.usage);
             output.rawStopReason = event.response.stopReason;
             const mapped = stopReason(event.response);

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-h13r0byk.js → bash-description-axnga0jz.js}

@@ -5,13 +5,13 @@ var policy = standard(Type.Union([Type.Literal("ask"), Type.Literal("auto-edit")
 var PERMISSIONS2 = "permissions";
 var approvalPolicy2 = policy;
 var APPROVAL_POLICIES2 = [
-  { value: "ask", label: "Ask first", description: "Asks before every command and file change" },
+  { value: "ask", label: "Ask first", badge: "Asks before commands, file edits and other tools" },
   {
     value: "auto-edit",
     label: "Auto-edit",
-    description: "Edits workspace files, asks before commands and anything outside"
+    badge: "Edits workspace files, asks before commands and other tools"
   },
-  { value: "full", label: "Full access", description: "Runs every tool without asking" }
+  { value: "full", label: "Full access", badge: "Runs every tool without asking" }
 ];
 var reasonType = Type.Union([
   Type.Literal("shell"),

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-ye3wk5r3.js → bash-description-bas41ptb.js}

@@ -1,8 +1,6 @@
 // src/claude-code-sdk/translate.ts
 import { calculateCost, parseStreamingJson } from "@nyte-ai/ai";
 var CLAUDE_CODE_PROVIDER2 = "claude-code";
-var MIRROR_TOOL3 = "claude_code";
-var BACKGROUND_TOOL2 = "BackgroundTasks";
 var NYTE_SERVER2 = "nyte";
 var NYTE_TOOL_PREFIX2 = `mcp__${NYTE_SERVER2}__`;
 function emptyMessage3(model) {
@@ -24,9 +22,6 @@ function emptyMessage3(model) {
     timestamp: Date.now()
   };
 }
-function mirrorCall2(id, name, input) {
-  return { type: "toolCall", id, name: MIRROR_TOOL3, arguments: { id, name, input } };
-}
 function stopReason(reason) {
   if (reason === "tool_use")
     return "toolUse";
@@ -85,16 +80,6 @@ class Translator3 {
         return;
     }
   }
-  append(call) {
-    const contentIndex = this.#output.content.push(call) - 1;
-    this.#stream.push({ type: "toolcall_start", contentIndex, partial: this.#output });
-    this.#stream.push({
-      type: "toolcall_end",
-      contentIndex,
-      toolCall: call,
-      partial: this.#output
-    });
-  }
   #usage(usage) {
     const usageOutput = this.#output.usage;
     if (this.#started) {
@@ -113,12 +98,12 @@ class Translator3 {
       thinking: "[Reasoning redacted]",
       thinkingSignature: block.data,
       redacted: true
-    } : block.type === "tool_use" ? block.name.startsWith(NYTE_TOOL_PREFIX2) ? {
+    } : block.type === "tool_use" && block.name.startsWith(NYTE_TOOL_PREFIX2) ? {
       type: "toolCall",
       id: block.id,
       name: block.name.slice(NYTE_TOOL_PREFIX2.length),
       arguments: {}
-    } : mirrorCall2(block.id, block.name, {}) : undefined;
+    } : undefined;
     if (content === undefined)
       return;
     const index = this.#output.content.push(content) - 1;
@@ -155,8 +140,7 @@ class Translator3 {
       content.thinkingSignature = (content.thinkingSignature ?? "") + delta.signature;
     } else if (delta.type === "input_json_delta" && content?.type === "toolCall") {
       slot.json += delta.partial_json;
-      const input = parseStreamingJson(slot.json);
-      content.arguments = content.name === MIRROR_TOOL3 ? { ...content.arguments, input } : input;
+      content.arguments = parseStreamingJson(slot.json);
       this.#stream.push({
         type: "toolcall_delta",
         contentIndex,
@@ -193,13 +177,11 @@ class Translator3 {
         toolCall: content,
         partial: this.#output
       });
-      if (content.name !== MIRROR_TOOL3) {
-        this.#output.stopReason = "toolUse";
-        return "tool_use";
-      }
+      this.#output.stopReason = "toolUse";
+      return "tool_use";
     }
     return;
   }
 }
 
-export { CLAUDE_CODE_PROVIDER2, MIRROR_TOOL3, BACKGROUND_TOOL2, NYTE_SERVER2, NYTE_TOOL_PREFIX2, emptyMessage3, mirrorCall2, Translator3 };
+export { CLAUDE_CODE_PROVIDER2, NYTE_SERVER2, NYTE_TOOL_PREFIX2, emptyMessage3, Translator3 };

package/dist/chunks/{bash-description-2v3g7rd9.js → bash-description-bj5yh7tr.js}

@@ -1,24 +1,13 @@
 import {
   CLAUDE_CODE_PROVIDER2,
-  MIRROR_TOOL3,
-  BACKGROUND_TOOL2,
   NYTE_TOOL_PREFIX2
-} from "./bash-description-ye3wk5r3.js";
+} from "./bash-description-bas41ptb.js";
 
 // src/claude-code-sdk/transcript.ts
 import { randomUUID } from "node:crypto";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
 var IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
-var mirrorArguments3 = Type.Object({
-  id: Type.String(),
-  name: Type.String(),
-  input: Type.Record(Type.String(), Type.Unknown())
-});
-function readMirrorCall(call) {
-  if (call.name !== MIRROR_TOOL3 || !Value.Check(mirrorArguments3, call.arguments))
-    return;
-  return call.arguments;
+function toolUseId(id) {
+  return id.replaceAll(/[^a-zA-Z0-9_-]/g, "_");
 }
 function mediaBlock(content) {
   if (content.type === "text")
@@ -43,9 +32,7 @@ function messageKey3(message) {
 }
 function toParams(messages, model) {
   const params = [];
-  const claude = new Map;
-  const foreign = new Map;
-  const skipped = new Set;
+  const open = new Set;
   const push = (role, content) => {
     if (content.length === 0)
       return;
@@ -56,38 +43,27 @@ function toParams(messages, model) {
       params.push({ role, content: [...content] });
   };
   const closeCalls = () => {
-    push("user", [...claude.values()].map((id) => ({
+    push("user", [...open].map((id) => ({
       type: "tool_result",
-      tool_use_id: id,
+      tool_use_id: toolUseId(id),
       content: "No result provided",
       is_error: true
     })));
-    claude.clear();
+    open.clear();
   };
   for (const message of messages) {
     if (message.role === "system")
       continue;
     if (message.role === "toolResult") {
-      const id = claude.get(message.toolCallId);
-      const name = foreign.get(message.toolCallId);
-      if (skipped.has(message.toolCallId))
-        continue;
-      if (id !== undefined) {
-        claude.delete(message.toolCallId);
-        push("user", [
-          {
-            type: "tool_result",
-            tool_use_id: id,
-            content: message.content.map(mediaBlock),
-            is_error: message.isError
-          }
-        ]);
-      } else {
-        push("user", [
-          { type: "text", text: `[${name ?? message.toolName} result]
-${text(message.content)}` }
-        ]);
-      }
+      push("user", open.delete(message.toolCallId) ? [
+        {
+          type: "tool_result",
+          tool_use_id: toolUseId(message.toolCallId),
+          content: message.content.map(mediaBlock),
+          is_error: message.isError
+        }
+      ] : [{ type: "text", text: `[${message.toolName} result]
+${text(message.content)}` }]);
       continue;
     }
     closeCalls();
@@ -106,29 +82,15 @@ ${text(message.content)}` }
           return [];
         return block.redacted === true ? [{ type: "redacted_thinking", data: block.thinkingSignature }] : [{ type: "thinking", thinking: block.thinking, signature: block.thinkingSignature }];
       }
-      const call = readMirrorCall(block);
-      if (call?.name === BACKGROUND_TOOL2) {
-        skipped.add(block.id);
-        return [];
-      }
-      if (call !== undefined) {
-        claude.set(block.id, call.id);
-        return [{ type: "tool_use", id: call.id, name: call.name, input: call.input }];
-      }
-      if (message.provider === CLAUDE_CODE_PROVIDER2) {
-        claude.set(block.id, block.id);
-        return [
-          {
-            type: "tool_use",
-            id: block.id,
-            name: `${NYTE_TOOL_PREFIX2}${block.name}`,
-            input: block.arguments
-          }
-        ];
-      }
-      foreign.set(block.id, block.name);
-      return [{ type: "text", text: `[${block.name}]
-${JSON.stringify(block.arguments)}` }];
+      open.add(block.id);
+      return [
+        {
+          type: "tool_use",
+          id: toolUseId(block.id),
+          name: `${NYTE_TOOL_PREFIX2}${block.name}`,
+          input: block.arguments
+        }
+      ];
     }));
   }
   closeCalls();
@@ -187,4 +149,4 @@ ${text(message.content)}` : "";
 `);
 }
 
-export { mirrorArguments3, userBlocks3, messageKey3, sessionEntries2, flatPrompt2 };
+export { userBlocks3, messageKey3, sessionEntries2, flatPrompt2 };

package/dist/chunks/{bash-description-6z2kgtyt.js → bash-description-bkhr9zrz.js}

@@ -25,7 +25,7 @@ var questionOutput2 = standard(Type.Object({ answers: Type.Union([answers, Type.
 var state = standard(Type.Object({ questions, answers: Type.Union([answers, Type.Null()]) }));
 var questionParameters2 = standard(Type.Object({ questions }));
 var actions = { answer: { input: answerInput2 } };
-var question3 = {
+var question2 = {
   kind: "ask/question",
   state,
   actions,
@@ -39,13 +39,13 @@ Answered: ${current.answers[index].join(", ") || "Unanswered"}`}`).join(`
 };
 function openQuestions2(view) {
   return (view?.parts ?? []).flatMap((part) => {
-    if (part.partKind !== question3.kind || part.status.kind !== "live")
+    if (part.partKind !== question2.kind || part.status.kind !== "live")
       return [];
-    const checked = question3.state["~standard"].validate(part.state);
+    const checked = question2.state["~standard"].validate(part.state);
     if (checked instanceof Promise || checked.issues !== undefined || checked.value.answers !== null)
       return [];
     return [{ part: part.id, questions: checked.value.questions }];
   });
 }
 
-export { answerInput2, questionOutput2, questionParameters2, question3, openQuestions2 };
+export { answerInput2, questionOutput2, questionParameters2, question2, openQuestions2 };

package/dist/chunks/{bash-description-hg64tqf1.js → bash-description-f754ge33.js}

@@ -12,15 +12,26 @@ var launch = {
   args: Type.Optional(Type.Array(Type.String())),
   env: Type.Optional(Type.Record(Type.String(), Type.String()))
 };
+var mode = Type.Optional(Type.String({ minLength: 1 }));
 var registryAgent = Type.Object({
   id: Type.String({ minLength: 1 }),
   name: Type.String({ minLength: 1 }),
+  mode,
   distribution: Type.Object({
     binary: Type.Optional(Type.Record(Type.String(), Type.Object({ cmd: Type.String({ minLength: 1 }), ...launch }))),
     npx: Type.Optional(Type.Object({ package: Type.String({ minLength: 1 }), ...launch }))
   })
 });
 var registry = Type.Object({ agents: Type.Array(Type.Unknown()) });
+var userAgentsFile = Type.Object({
+  agents: Type.Array(Type.Object({
+    id: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1 }),
+    command: Type.String({ minLength: 1 }),
+    mode,
+    ...launch
+  }))
+});
 var packageBin = Type.Object({
   bin: Type.Union([Type.String(), Type.Record(Type.String(), Type.String())])
 });
@@ -79,19 +90,54 @@ async function installed(agent, path) {
         name: agent.name,
         command,
         args: binary.args ?? [],
-        env: binary.env ?? {}
+        env: binary.env ?? {},
+        mode: agent.mode
       };
   }
   const npx = agent.distribution.npx;
   if (npx === undefined)
     return;
   const command = await globalBin(npx.package, path);
-  return command === undefined ? undefined : { id: agent.id, name: agent.name, command, args: npx.args ?? [], env: npx.env ?? {} };
+  return command === undefined ? undefined : {
+    id: agent.id,
+    name: agent.name,
+    command,
+    args: npx.args ?? [],
+    env: npx.env ?? {},
+    mode: agent.mode
+  };
 }
 async function installedAgents2(entries, path) {
   const agents = entries.filter((entry) => Value.Check(registryAgent, entry));
   const found = await Promise.all(agents.map((agent) => installed(agent, path)));
   return found.filter((agent) => agent !== undefined);
 }
+async function userAgents2(file) {
+  const text = await readFile(file, "utf8").catch((error) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  });
+  if (text === undefined)
+    return [];
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${file} is not valid JSON.`, { cause: error });
+  }
+  if (!Value.Check(userAgentsFile, document)) {
+    const [first] = Value.Errors(userAgentsFile, document);
+    throw new Error(`${file}: ${first?.instancePath || "/"} ${first?.message ?? "is invalid"}.`);
+  }
+  return document.agents.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    command: agent.command,
+    args: agent.args ?? [],
+    env: agent.env ?? {},
+    mode: agent.mode
+  }));
+}
 
-export { registryEntries2, installedAgents2 };
+export { registryEntries2, installedAgents2, userAgents2 };