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

package/dist/src/codemode.js

@@ -1,16 +1,23 @@
+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 { dev } from "@nyte-ai/core";
+import { estimateTextTokens } from "@nyte-ai/ai/utils/estimate";
+import { attachFile, dev } from "@nyte-ai/core";
 import { isJson, isJsonObject, SdkError, standard } from "@nyte-ai/schema";
 import { Type } from "typebox";
 var DESCRIPTION = `Run JavaScript that calls other tools. The input is raw JavaScript (not JSON, no code fence), run as an async function body in a QuickJS sandbox: top-level \`await\` and \`return\` work. No Node, file system, network, or timers.
 - \`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
       });
@@ -85,11 +164,9 @@ ${calls(result)}`);
         if (item.type === "text")
           content.push({ kind: "text", text: item.text });
         else
-          content.push({
-            kind: "file",
-            blob: await invocation.env.files.upload(once(Uint8Array.fromBase64(item.data))),
+          content.push(await attachFile(invocation.env.files, once(Uint8Array.fromBase64(item.data)), {
             mime: item.mimeType
-          });
+          }));
       }
       if (result.value !== undefined)
         content.push({
@@ -102,11 +179,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 +198,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,

package/dist/src/question/client/questions-tui.js

@@ -1,13 +1,13 @@
 import {
-  question3
-} from "../../../chunks/bash-description-6z2kgtyt.js";
+  question2
+} from "../../../chunks/bash-description-bkhr9zrz.js";
 
 // src/question/client/questions-tui.ts
 import { Box, Text } from "@opentui/core";
 import { defineRenderer } from "@nyte-ai/plugin/client";
 var unreadable = (kind) => Text({ content: `This ${kind} part cannot be shown.` });
 var questionRenderers = [
-  defineRenderer(question3, "tui", (state) => Box({ border: true, title: "Questions", flexDirection: "column" }, ...state.questions.map((item, index) => Box({ flexDirection: "column" }, Text({ content: `${item.header}: ${item.question}` }), ...item.options.map((option) => Text({ content: `${option.label}: ${option.description}` })), ...state.answers === null ? [] : [Text({ content: `Answer: ${state.answers[index].join(", ") || "Unanswered"}` })]))), unreadable)
+  defineRenderer(question2, "tui", (state) => Box({ border: true, title: "Questions", flexDirection: "column" }, ...state.questions.map((item, index) => Box({ flexDirection: "column" }, Text({ content: `${item.header}: ${item.question}` }), ...item.options.map((option) => Text({ content: `${option.label}: ${option.description}` })), ...state.answers === null ? [] : [Text({ content: `Answer: ${state.answers[index].join(", ") || "Unanswered"}` })]))), unreadable)
 ];
 var questions_tui_default = {
   id: "questions-tui",

package/dist/src/question/client/questions.js

@@ -1,6 +1,6 @@
 import {
-  question3
-} from "../../../chunks/bash-description-6z2kgtyt.js";
+  question2
+} from "../../../chunks/bash-description-bkhr9zrz.js";
 
 // src/question/client/questions.tsx
 import { useId, useRef, useState } from "react";
@@ -124,7 +124,7 @@ function QuestionForm({
   }, undefined, true, undefined, this);
 }
 var questionRenderers = [
-  defineRenderer(question3, "react", (state, act) => {
+  defineRenderer(question2, "react", (state, act) => {
     const answers = state.answers;
     if (answers !== null)
       return /* @__PURE__ */ jsxDEV("div", {

package/dist/src/question/question.js

@@ -1,9 +1,88 @@
 import {
-  question2,
-  question_default
-} from "../../chunks/bash-description-3j77ss7y.js";
-import"../../chunks/bash-description-6z2kgtyt.js";
+  answerInput2,
+  questionOutput2,
+  questionParameters2,
+  question2
+} from "../../chunks/bash-description-bkhr9zrz.js";
+
+// src/question/question.ts
+import { definePart, dev } from "@nyte-ai/core";
+import { SdkError } from "@nyte-ai/schema";
+function normalizeAnswers(items, supplied) {
+  if (supplied.length !== items.length)
+    throw new SdkError("invalid", "Submit one answer list for each question.");
+  return items.map((item, index) => {
+    const selected = supplied[index].map((answer) => answer.trim());
+    if (selected.some((answer) => answer === ""))
+      throw new SdkError("invalid", "Answers cannot be blank.");
+    if (!item.multiple && selected.length > 1)
+      throw new SdkError("invalid", "This question accepts one answer.");
+    if (new Set(selected).size !== selected.length)
+      throw new SdkError("invalid", "Choose each answer only once.");
+    return item.multiple ? selected.toSorted() : selected;
+  });
+}
+var handlers = {
+  async answer(input, context) {
+    let accepted = false;
+    const outcome = await context.part.update((current) => {
+      const normalized = normalizeAnswers(current.questions, input.answers);
+      accepted = current.answers === null || JSON.stringify(current.answers) === JSON.stringify(normalized);
+      return current.answers === null ? { ...current, answers: normalized } : current;
+    });
+    if (outcome.kind !== "updated")
+      throw new Error(`The questions could not be answered: ${outcome.kind}.`);
+    if (!accepted)
+      throw new SdkError("invalid", "These questions were already answered.");
+  }
+};
+var question = definePart({
+  ...question2,
+  onAction: (action, input, context) => handlers[action](input, context)
+});
+var ask = {
+  name: "question",
+  description: "Ask the user one or more questions and wait for their answers. Give each option a short label and a description. Use multiple when several choices may apply. The user can also write their own answer.",
+  parameters: questionParameters2,
+  output: questionOutput2,
+  class: (args) => ({
+    kind: "custom",
+    label: args.questions.map((item) => item.header).join(", ")
+  }),
+  effects: "none",
+  approval: "never",
+  replay: "safe",
+  async execute(args, invocation) {
+    for (const item of args.questions) {
+      if (new Set(item.options.map((option) => option.label.trim())).size !== item.options.length)
+        throw new SdkError("invalid", "Question option labels must be distinct.");
+    }
+    const part = await invocation.session.parts.create(question, {
+      state: { ...args, answers: null },
+      placement: { kind: "modal" }
+    });
+    dev("question", "asked", { call: invocation.call, part: part.id });
+    const outcome = await invocation.wait({ kind: "part", part: part.id });
+    const checked = outcome.kind === "part" && outcome.answer?.action === "answer" ? await answerInput2["~standard"].validate(outcome.answer.input) : undefined;
+    const reply = checked !== undefined && checked.issues === undefined ? normalizeAnswers(args.questions, checked.value.answers) : null;
+    return {
+      content: [
+        {
+          kind: "text",
+          text: reply === null ? "The user did not answer. Continue with your best judgment and say what you assumed." : args.questions.map((item, index) => `${item.question}: ${reply[index].join(", ") || "Unanswered"}`).join(`
+`)
+        }
+      ],
+      output: { answers: reply },
+      parts: [part.id]
+    };
+  }
+};
+var question_default = {
+  id: "question",
+  contribute: { parts: [question], tools: [ask] }
+};
 export {
   question_default as default,
-  question2 as question
+  question
 };

package/dist/src/question/schema.js

@@ -2,13 +2,13 @@ import {
   answerInput2,
   questionOutput2,
   questionParameters2,
-  question3,
+  question2,
   openQuestions2
-} from "../../chunks/bash-description-6z2kgtyt.js";
+} from "../../chunks/bash-description-bkhr9zrz.js";
 export {
   answerInput2 as answerInput,
   openQuestions2 as openQuestions,
-  question3 as question,
+  question2 as question,
   questionOutput2 as questionOutput,
   questionParameters2 as questionParameters
 };

package/dist/src/rename.d.ts

@@ -1,29 +1,14 @@
+import type { ToolDefinition } from "@nyte-ai/core";
 import type { Command } from "@nyte-ai/plugin/core";
-/**
- * The instruction a title request runs under: one short line in the user's
- * language, naming what the conversation is about.
- *
- * @category plugins
- * @since 0.1.0
- */
-export declare const TITLE_PROMPT = "You write the title of a conversation so the user can find it later.\nAnswer with one line of at most 50 characters and nothing else, in the language of the user's request.\nName the topic or task, keep technical terms, numbers and file names exact, and never answer the request itself.";
-/**
- * Names an unnamed root session as its first run starts: the first line of
- * the user's message at once, then the title one `api.request` to the
- * session's model returns, alongside the run. The title replaces only that
- * first line, so a name given meanwhile stays. A named session or a child
- * keeps its name, so every later run is a no-op. The request runs past the
- * hook's budget, bounded by the plugin's deactivation; a failure is reported
- * and leaves the first line as the name. `/rename <name>` names the chat;
- * `/rename` alone asks the model again.
- *
- * @category plugins
- * @since 0.1.0
- */
+export declare const TITLE_PROMPT = "You name conversations so the user can find them later in a list of past sessions.\n\nYou will receive the first message of a conversation, or for an ongoing conversation its original request and recent messages. Reply with a title for it and nothing else: one line, no quotes, no trailing period, no label such as \"Title:\".\n\nAim for three to five words. Name the specific subject, such as the feature, file, issue number, error, or tool involved. Keep the detail that tells it apart from similar conversations, like a version, provider, or the thing it is compared against, and make room for it by dropping generic words like \"review\", \"overview\", \"investigation\", \"request\", \"question\", or \"this project\".\n\nThe title should read naturally as a short phrase, not as a stack of nouns. Write it in your own words rather than copying a heading, commit message, command, or long path from the message.\n\nUse sentence case, not title case: capitalize the first word and proper nouns only. Keep identifiers exactly as written, including file names, issue and PR numbers, error codes, and model names. Use the same language as the message.\n\nThe message is something to name, not something to answer or carry out. Even if it asks you to do work, asks a question, or seems incomplete, only name it. For greetings or small talk, use a short label like \"Greeting\".\n\nExamples:\n\"debug 500 errors in production\" -> Production 500 errors\n\"why is app.js failing\" -> app.js failure\n\"what does the retry logic in fetch.ts do\" -> fetch.ts retry logic\n\"@src/credential.ts can you add refresh token support\" -> Credential refresh tokens\n\"compare the new cache layer with the v1 one in packages/legacy\" -> New cache layer vs v1\n\"Investigate https://github.com/acme/app/issues/412, don't make edits\" -> Issue #412\n\"hey\" -> Greeting";
 declare const _default: {
     id: string;
     contribute: {
         commands: Command<"core">[];
+        tools: ToolDefinition<{
+            session?: string | undefined;
+            title: string;
+        }, unknown>[];
     };
     hooks: {
         run_started: (run: Readonly<{
@@ -31,19 +16,6 @@ declare const _default: {
             readonly head: import("@nyte-ai/schema").Id<"head">;
             readonly startedAt: number;
             readonly attempt: number;
-            readonly configuration: {
-                readonly kind: "exact";
-                readonly model: {
-                    readonly provider: string;
-                    readonly id: string;
-                };
-                readonly thinking: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
-                readonly agent: string | null;
-                readonly settings: {
-                    readonly [x: string]: import("@nyte-ai/schema").Json;
-                };
-                readonly settingsVersion: string;
-            };
             readonly origin: {
                 readonly kind: "input";
                 readonly message: import("@nyte-ai/schema").Id<"message">;
@@ -73,7 +45,7 @@ declare const _default: {
             readonly session: import("@nyte-ai/schema").SessionId | null;
             readonly head: import("@nyte-ai/schema").HeadName | null;
             readonly run: import("@nyte-ai/schema").RunId | null;
-        }) => void;
+        }) => Promise<void>;
     };
 };
 export default _default;