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

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<{
@@ -73,7 +58,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;

package/dist/src/rename.js

@@ -1,28 +1,93 @@
 // src/rename.ts
 import { dev, isPart, text } from "@nyte-ai/core";
-var TITLE_PROMPT = `You write the title of a conversation so the user can find it later.
-Answer with one line of at most 50 characters and nothing else, in the language of the user's request.
-Name the topic or task, keep technical terms, numbers and file names exact, and never answer the request itself.`;
-var NAME_LIMIT = 100;
+import { asId, standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var TITLE_PROMPT = `You name conversations so the user can find them later in a list of past sessions.
+
+You 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:".
+
+Aim 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".
+
+The 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.
+
+Use 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.
+
+The 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".
+
+Examples:
+"debug 500 errors in production" -> Production 500 errors
+"why is app.js failing" -> app.js failure
+"what does the retry logic in fetch.ts do" -> fetch.ts retry logic
+"@src/credential.ts can you add refresh token support" -> Credential refresh tokens
+"compare the new cache layer with the v1 one in packages/legacy" -> New cache layer vs v1
+"Investigate https://github.com/acme/app/issues/412, don't make edits" -> Issue #412
+"hey" -> Greeting`;
+var MAX_LENGTH = 100;
+var MAX_CONTEXT_LENGTH = 8000;
+var MAX_FIRST_MESSAGE_LENGTH = 2000;
+var messagePrompt = (value) => `Here is the first message of the conversation:
+
+<message>
+${value}
+</message>
+
+Reply with only the title.`;
+var conversationPrompt = (value) => `Here is the conversation so far:
+
+<conversation>
+${value}
+</conversation>
+
+Reply with only the title.`;
 var renameCommand = {
   name: "rename",
   title: "Rename chat",
   description: "Names the chat; with no name, the chat's model titles it again.",
   takesText: true,
   async run(given, { api, signal }) {
-    const name = given === "" ? await requestTitle(api, signal) : given.slice(0, NAME_LIMIT);
-    await api.session.update({ name });
-    return `Renamed to ${name}.`;
+    const name = given.trim();
+    if (name !== "") {
+      await api.session.update({ name });
+      return `Renamed to ${name}.`;
+    }
+    const title = await generateTitle(api, signal);
+    return title === null ? "The chat's model gave no title." : `Renamed to ${title}.`;
+  }
+};
+var renameParameters = standard(Type.Object({
+  session: Type.Optional(Type.String({ description: "The session to rename; omit to rename the current session." })),
+  title: Type.String({ minLength: 1, description: "The new session title." })
+}));
+var renameTool = {
+  name: "session_rename",
+  description: "Rename a session, or omit session to rename the current session. Use a short, specific title that summarizes the work being done.",
+  parameters: renameParameters,
+  class: (args) => ({ kind: "custom", label: `Renaming to ${args.title.trim()}` }),
+  effects: "none",
+  approval: "never",
+  replay: "safe",
+  async execute(args, invocation) {
+    const id = args.session ?? invocation.session.id;
+    const title = args.title.trim();
+    if (title === "")
+      throw new Error("Session title must not be empty.");
+    const outcome = await invocation.sdk.session(asId(id)).update({ name: title });
+    if (outcome.kind !== "updated")
+      throw new Error(`Unable to rename session ${id}: ${outcome.kind}.`);
+    return { content: [{ kind: "text", text: `Renamed session ${id} to ${title}.` }] };
   }
 };
 var rename_default = {
   id: "rename",
-  contribute: { commands: [renameCommand] },
+  contribute: { commands: [renameCommand], tools: [renameTool] },
   hooks: {
-    run_started: (run, { api }) => {
+    run_started: async (run, { api }) => {
       if (run.origin.kind !== "input")
         return;
-      nameUnnamed(api).catch((error) => api.report({
+      const info = await api.session.info();
+      if (info.name !== null || info.parent !== null)
+        return;
+      generateTitle(api, api.signal).catch((error) => api.report({
         severity: "warning",
         path: ["run_started"],
         message: `Naming the session failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -31,56 +96,58 @@ var rename_default = {
     }
   }
 };
-async function nameUnnamed(api) {
-  const info = await api.session.info();
-  if (info.name !== null || info.parent !== null)
-    return;
-  const view = await api.session.view();
-  const words = view.messages.flatMap((message) => message.kind === "user" ? [userWords(message.content)] : [])[0];
-  const firstLine = words?.split(`
-`).find((line) => line.trim() !== "")?.trim().slice(0, NAME_LIMIT);
-  if (firstLine === undefined)
-    return;
-  await api.session.update({ name: firstLine });
-  const title = await requestTitle(api, api.signal);
-  if ((await api.session.info()).name !== firstLine)
-    return;
-  await api.session.update({ name: title });
-}
-async function requestTitle(api, signal) {
+async function generateTitle(api, signal) {
+  const before = (await api.session.info()).name;
   const view = await api.session.view();
   const model = view.configuration.effective?.model;
-  const conversation = transcript(view.messages);
-  if (model === undefined)
-    throw new Error("The chat has no model to title it.");
-  if (conversation === "")
-    throw new Error("Send a message before titling the chat.");
+  const first = view.messages.find((message) => message.kind === "user");
+  if (model === undefined || first === undefined)
+    return null;
   const outcome = await api.request({
     model,
     system: TITLE_PROMPT,
-    messages: [{ role: "user", content: conversation, timestamp: Date.now() }],
+    messages: [
+      {
+        role: "user",
+        content: before === null ? messagePrompt(userWords(first.content)) : historyPrompt(first, view.messages),
+        timestamp: Date.now()
+      }
+    ],
     maxOutput: 64,
     signal
   });
   dev("rename", "title", { session: api.session.id, outcome: outcome.kind });
-  if (outcome.kind === "refused")
-    throw new Error(outcome.reason);
-  if (outcome.kind === "failed")
-    throw new Error(outcome.failure.message);
-  const name = outcome.value.split(`
-`).find((line) => line.trim() !== "")?.trim().slice(0, NAME_LIMIT);
-  if (name === undefined)
-    throw new Error("The model answered with no title.");
-  return name;
+  if (outcome.kind !== "ok")
+    return null;
+  const line = outcome.value.split(`
+`).map((candidate) => candidate.trim()).find((candidate) => candidate.length > 0);
+  if (line === undefined)
+    return null;
+  const title = line.length <= MAX_LENGTH ? line : `${line.slice(0, MAX_LENGTH - 3)}...`;
+  const current = (await api.session.info()).name;
+  if (current !== before || current === title)
+    return title;
+  await api.session.update({ name: title });
+  return title;
 }
-function transcript(messages) {
-  return messages.flatMap((message) => {
-    if (message.kind === "user")
-      return [`User: ${userWords(message.content)}`];
-    return isPart(message, text) ? [`Assistant: ${message.state.markdown}`] : [];
+function historyPrompt(first, messages) {
+  const original = `Original request:
+${userWords(first.content).slice(0, MAX_FIRST_MESSAGE_LENGTH)}`;
+  const recent = messages.flatMap((message) => {
+    if (message.kind === "user" && message !== first)
+      return [`User: ${userWords(message.content).trim()}`];
+    return isPart(message, text) && message.state.markdown.trim() !== "" ? [`Assistant: ${message.state.markdown.trim()}`] : [];
   }).join(`
 
-`).slice(0, 4000);
+`);
+  if (recent === "")
+    return conversationPrompt(original);
+  const prefix = `${original}
+
+Recent conversation:
+`;
+  const budget = MAX_CONTEXT_LENGTH - conversationPrompt("").length - prefix.length;
+  return conversationPrompt(`${prefix}${recent.slice(-budget)}`);
 }
 function userWords(content) {
   return typeof content === "string" ? content : content.flatMap((block) => block.kind === "text" ? [block.text] : []).join(" ");

package/dist/src/subagents.d.ts

@@ -0,0 +1,30 @@
+import type { Session } from "@nyte-ai/core";
+/**
+ * Contributes the subagent tools to top-level sessions: `task`, `create`,
+ * `send`, `await`, `read_agent` and `stop`, built on child sessions and
+ * durable waits.
+ *
+ * @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: 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>;
+    }): Promise<void>;
+};
+export default _default;

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/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
+};