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

package/dist/chunks/{bash-description-zz15raxk.js → bash-description-ff18794t.js}

@@ -10,7 +10,7 @@ import {
   LIBRARY_EXPORTS2,
   canvasFilesComment2,
   KIT_EXPORTS2
-} from "./bash-description-dnvgk30y.js";
+} from "./bash-description-4rfavmha.js";
 
 // src/canvas/canvas-compile.ts
 import { init, parse } from "es-module-lexer/minimal";

package/dist/chunks/{bash-description-wmcbg6fw.js → bash-description-g7gfy7nw.js}

@@ -1,6 +1,6 @@
 import {
   MIRROR_TOOL2
-} from "./bash-description-9nn3yp18.js";
+} from "./bash-description-q2v8wbn8.js";
 
 // src/acp/transcript.ts
 var RESULT_LIMIT = 2000;

package/dist/chunks/{bash-description-1neewp76.js → bash-description-hp4rb8k4.js}

@@ -1,6 +1,6 @@
 import {
   CANVAS_CODE_LIMIT2
-} from "./bash-description-dnvgk30y.js";
+} from "./bash-description-4rfavmha.js";
 
 // src/canvas/schema.ts
 import { definePart } from "@nyte-ai/core";
@@ -11,7 +11,8 @@ var CANVAS_REVISIONS_KEPT2 = 50;
 var drawn = {
   runtime: Type.Integer({ minimum: 1 }),
   title: Type.String({ minLength: 1, maxLength: 120 }),
-  height: Type.Union([Type.Number(), Type.Null()])
+  height: Type.Union([Type.Number(), Type.Null()]),
+  heights: Type.Optional(Type.Array(Type.Object({ width: Type.Integer({ minimum: 1 }), height: Type.Number({ minimum: 0 }) }), { maxItems: 8 }))
 };
 var revision = Type.Object({
   number: Type.Integer({ minimum: 1 }),
@@ -23,7 +24,7 @@ var state = standard(Type.Object({
   ...drawn,
   code: Type.String({ maxLength: CANVAS_CODE_LIMIT2 }),
   error: Type.Union([Type.String(), Type.Null()]),
-  revisions: Type.Optional(Type.Array(revision, { maxItems: CANVAS_REVISIONS_KEPT2 }))
+  revisions: Type.Array(revision, { minItems: 1, maxItems: CANVAS_REVISIONS_KEPT2 })
 }));
 var actions = {
   replace: {

package/dist/chunks/bash-description-myvnmtt2.js

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

package/dist/chunks/{bash-description-9nn3yp18.js → bash-description-q2v8wbn8.js}

@@ -13,6 +13,14 @@ var mirrorArguments2 = Type.Object({
   input: Type.Record(Type.String(), Type.Unknown()),
   paths: Type.Array(Type.String())
 });
+var count = Type.Optional(Type.Union([Type.Number(), Type.Null()]));
+var agentUsage2 = Type.Object({
+  inputTokens: Type.Number(),
+  outputTokens: Type.Number(),
+  totalTokens: Type.Number(),
+  cachedReadTokens: count,
+  cachedWriteTokens: count
+});
 var command = Type.Union([
   Type.String({ minLength: 1 }),
   Type.Array(Type.String(), { minItems: 1 })
@@ -173,4 +181,4 @@ class Translator2 {
   }
 }
 
-export { ACP_PROVIDER2, ACP_API2, MIRROR_TOOL2, mirrorArguments2, emptyMessage2, mirrorClass2, toolText2, Translator2 };
+export { ACP_PROVIDER2, ACP_API2, MIRROR_TOOL2, mirrorArguments2, agentUsage2, emptyMessage2, mirrorClass2, toolText2, Translator2 };

package/dist/chunks/bash-description-qwyy182r.js

@@ -0,0 +1,452 @@
+// src/client/presentation.ts
+import { isPart, text, thinking, tool } from "@nyte-ai/core";
+import { jobTaskState as jobTaskState2 } from "@nyte-ai/schema";
+function showsTool2(message) {
+  return isPart(message, tool);
+}
+function showsText2(message) {
+  return isPart(message, text);
+}
+function showsThinking2(message) {
+  return isPart(message, thinking);
+}
+function readRawPart2(message) {
+  const { state } = message;
+  if (typeof state === "object" && state !== null && !Array.isArray(state)) {
+    const prose = "markdown" in state ? state.markdown : ("text" in state) ? state.text : undefined;
+    if (typeof prose === "string")
+      return { format: "text", body: prose };
+  }
+  return { format: "json", body: state === undefined ? "null" : JSON.stringify(state, null, 2) };
+}
+function showsReport2(message) {
+  return message.source.kind === "child" || message.source.kind === "job";
+}
+function shownContent2(message) {
+  return message.source.kind === "action" ? message.source.label : message.content;
+}
+var RUNNING = { tense: "running", tone: "running", word: undefined };
+function toolStatus2(message) {
+  const { state, status } = message;
+  if (state.phase !== "settled") {
+    if (status.kind === "failed")
+      return status.failure.class === "aborted" ? { tense: "none", tone: "stopped", word: "Stopped" } : { tense: "none", tone: "stopped", word: "Interrupted" };
+    if (status.kind === "waiting" && status.on.kind === "part")
+      return { tense: "running", tone: "attention", word: "Needs input" };
+    return RUNNING;
+  }
+  switch (state.outcome.kind) {
+    case "ok":
+      return { tense: "past", tone: "success", word: undefined };
+    case "failed":
+      return { tense: "none", tone: "failure", word: "Failed" };
+    case "rejected":
+      return { tense: "none", tone: "failure", word: "Blocked" };
+    case "stopped":
+      return { tense: "none", tone: "stopped", word: "Stopped" };
+    case "interrupted":
+      return { tense: "none", tone: "stopped", word: "Interrupted" };
+    default: {
+      const _exhaustive = state.outcome;
+      return _exhaustive;
+    }
+  }
+}
+function toolOutput2(state) {
+  if (state.phase !== "settled")
+    return "";
+  switch (state.outcome.kind) {
+    case "ok":
+      return state.outcome.content.flatMap((content) => content.kind === "text" && content.text !== "" ? [content.text] : []).join(`
+`);
+    case "failed":
+      return state.outcome.message;
+    case "rejected":
+      return state.outcome.reason;
+    case "stopped":
+    case "interrupted":
+      return "";
+    default: {
+      const _exhaustive = state.outcome;
+      return _exhaustive;
+    }
+  }
+}
+function taskLabel2(state) {
+  return TASK_LABELS[state];
+}
+var TASK_LABELS = {
+  waiting: "Needs attention",
+  retrying: "Retrying",
+  working: "Working",
+  background: "Working in the background",
+  failed: "Failed",
+  done: "Done"
+};
+function callTaskState2(status) {
+  return CALL_STATES[status.tone];
+}
+var CALL_STATES = {
+  running: "working",
+  attention: "waiting",
+  failure: "failed",
+  success: "done",
+  stopped: "done"
+};
+function taskEnded2(state) {
+  return state === "done" || state === "failed";
+}
+function agentGroupSummary2(states) {
+  const total = states.length;
+  const going = states.filter((state) => !taskEnded2(state)).length;
+  const done = taskLabel2("done").toLowerCase();
+  if (going > 0)
+    return {
+      title: `Running ${String(total)} agents…`,
+      detail: going === total ? undefined : `(${String(total - going)} ${done})`
+    };
+  const failed = states.filter((state) => state === "failed").length;
+  return {
+    title: `${String(total)} agents ${done}`,
+    detail: failed === 0 ? undefined : `· ${String(failed)} ${taskLabel2("failed").toLowerCase()}`
+  };
+}
+var IDLE = { kind: "idle" };
+function runStatus2(execution) {
+  switch (execution?.kind) {
+    case undefined:
+      return IDLE;
+    case "idle":
+      return execution.lastRun === null ? IDLE : endedStatus2(execution.lastRun.end);
+    case "live":
+      return { kind: "working", run: execution.run.id, stopping: execution.stopping };
+    case "waiting":
+      return execution.on.kind === "part" ? { kind: "waiting-for-approval", run: execution.run.id } : { kind: "working", run: execution.run.id, stopping: false };
+    case "retrying":
+      return { kind: "retrying", run: execution.run.id };
+    default: {
+      const _exhaustive = execution;
+      return _exhaustive;
+    }
+  }
+}
+function endedStatus2(end) {
+  switch (end.kind) {
+    case "completed":
+      return { kind: "completed" };
+    case "stopped":
+      return { kind: "stopped" };
+    case "failed":
+      return { kind: "failed", failure: end.failure };
+    default: {
+      const _exhaustive = end;
+      return _exhaustive;
+    }
+  }
+}
+function runMark2(status) {
+  switch (status.kind) {
+    case "idle":
+    case "completed":
+    case "stopped":
+      return "done";
+    case "failed":
+      return "failed";
+    case "working":
+      return "working";
+    case "retrying":
+      return "retrying";
+    case "waiting-for-approval":
+      return "waiting";
+    default: {
+      const _exhaustive = status;
+      return _exhaustive;
+    }
+  }
+}
+function rowMark2(status, background) {
+  if ("run" in status)
+    return runMark2(status);
+  if (background.waiting > 0)
+    return "waiting";
+  if (status.kind === "failed")
+    return "failed";
+  return background.working > 0 ? "background" : runMark2(status);
+}
+function backgroundLabel2(background) {
+  if (background.waiting > 0)
+    return `${taskLabel2("waiting")} in the background`;
+  return background.working > 0 ? `${String(background.working)} working in the background` : undefined;
+}
+function planningLabel2(planningMs) {
+  if (planningMs < PLANNING_DELAY_MS2)
+    return;
+  return planningMs < SLOW_PLANNING_MS2 ? PLANNING_LABEL2 : "Taking longer than expected…";
+}
+var PLANNING_LABEL2 = "Planning next moves";
+var PLANNING_DELAY_MS2 = 200;
+var SLOW_PLANNING_MS2 = 15000;
+function executionMark2(execution) {
+  return runMark2(runStatus2(execution));
+}
+function mainHead2(session) {
+  return session.heads.find((head) => head.name === "main") ?? session.heads[0];
+}
+function sessionMark2(session) {
+  const head = mainHead2(session);
+  return head === undefined ? "done" : rowMark2(runStatus2(head.execution), head.background);
+}
+function sessionTitle2(session) {
+  return session.name ?? (session.parent === null ? "New chat" : SUBAGENT_TITLE2);
+}
+var SUBAGENT_TITLE2 = "Subagent";
+var COMMAND_ARGUMENT = /^[ \t]*\/([a-z0-9][a-z0-9-]*)[ \t]+/u;
+function findCommandArgument2(value, cursor) {
+  const found = COMMAND_ARGUMENT.exec(value);
+  const command = found?.[1];
+  if (found === null || command === undefined || /[\r\n]/u.test(value))
+    return;
+  const start = found[0].length;
+  return cursor < start ? undefined : { command, start, query: value.slice(start, cursor) };
+}
+function completionTrigger2(value, cursor = value.length) {
+  const caret = Math.max(0, Math.min(cursor, value.length));
+  let start = caret;
+  while (start > 0 && (value[start - 1] ?? "").trim() !== "")
+    start -= 1;
+  const kind = value[start];
+  if (start === caret || kind !== "@" && kind !== "/")
+    return;
+  let end = caret;
+  while (end < value.length && (value[end] ?? "").trim() !== "")
+    end += 1;
+  return { kind, start, end, query: value.slice(start + 1, caret) };
+}
+var RAN = { running: "Running", past: "Ran" };
+var CLASS_VERBS = {
+  read: { running: "Reading", past: "Read" },
+  list: { running: "Listing", past: "Listed" },
+  edit: { running: "Editing", past: "Edited" },
+  shell: RAN
+};
+var DELEGATE_VERBS = {
+  task: { running: "Delegating", past: "Delegated" },
+  create: { running: "Creating", past: "Created" },
+  send: { running: "Messaging", past: "Messaged" },
+  await: { running: "Waiting on", past: "Waited on" },
+  read: { running: "Reading transcript", past: "Read transcript" },
+  stop: { running: "Stopping", past: "Stopped" }
+};
+var DELEGATE_NOUNS = {
+  task: "agent",
+  create: "agent",
+  send: "message",
+  await: "wait",
+  read: "transcript",
+  stop: "stop"
+};
+var NAMED_TOOLS = new Map([
+  ["codemode", { verbs: { running: "Running script", past: "Ran script" } }],
+  ["tool_search", { verbs: { running: "Exploring", past: "Explored" }, detail: "available tools" }],
+  ["websearch", { verbs: { running: "Searching web", past: "Searched web" } }],
+  ["web_search", { verbs: { running: "Searching web", past: "Searched web" } }],
+  ["webfetch", { verbs: { running: "Fetching page", past: "Fetched page" } }],
+  ["web_fetch", { verbs: { running: "Fetching page", past: "Fetched page" } }],
+  ["rename_chat", { verbs: { running: "Renaming chat", past: "Renamed chat" } }],
+  ["browser_open", { verbs: { running: "Opening page", past: "Opened page" } }],
+  ["browser_click", { verbs: { running: "Clicking", past: "Clicked" } }],
+  ["browser_type", { verbs: { running: "Typing", past: "Typed" } }],
+  ["browser_press", { verbs: { running: "Pressing key", past: "Pressed key" } }],
+  ["browser_scroll", { verbs: { running: "Scrolling", past: "Scrolled" } }],
+  ["browser_wait", { verbs: { running: "Waiting", past: "Waited" } }],
+  ["browser_snapshot", { verbs: { running: "Taking snapshot", past: "Took snapshot" } }],
+  [
+    "browser_console",
+    { verbs: { running: "Checking console logs", past: "Checked console logs" } }
+  ],
+  ["browser_evaluate", { verbs: { running: "Executing JS", past: "Executed JS" } }]
+]);
+var MCP_LABEL = /^(?<server>[^:\s]+): (?<name>\S+)$/u;
+var MCP_NAME = /^mcp__(?<server>.+?)__(?<name>.+)$/u;
+function customTool2(label) {
+  const named = NAMED_TOOLS.get(label);
+  if (named !== undefined)
+    return named;
+  const mcp = (MCP_LABEL.exec(label) ?? MCP_NAME.exec(label))?.groups;
+  if (mcp?.server !== undefined && mcp.name !== undefined)
+    return { verbs: RAN, name: mcp.name, server: mcp.server };
+  if (/\s/u.test(label))
+    return { verbs: { running: label, past: label } };
+  return { verbs: RAN, name: label };
+}
+function customDetail(custom) {
+  if (custom.name === undefined)
+    return custom.detail;
+  return custom.server === undefined ? custom.name : `${custom.name} in ${custom.server}`;
+}
+function toolVerbs2(toolClass) {
+  switch (toolClass.kind) {
+    case "read":
+    case "list":
+    case "edit":
+    case "shell":
+      return CLASS_VERBS[toolClass.kind];
+    case "delegate":
+      return DELEGATE_VERBS[toolClass.role];
+    case "custom":
+      return customTool2(toolClass.label).verbs;
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+function toolNoun2(toolClass) {
+  switch (toolClass.kind) {
+    case "read":
+    case "list":
+    case "edit":
+      return toolClass.kind;
+    case "delegate":
+      return DELEGATE_NOUNS[toolClass.role];
+    case "shell":
+    case "custom":
+      return;
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+function delegateSubject2(toolClass) {
+  return toolClass.title ?? "subagent";
+}
+function toolSubject2(toolClass) {
+  switch (toolClass.kind) {
+    case "read":
+    case "list":
+    case "edit":
+      return toolClass.path;
+    case "shell":
+      return toolClass.command;
+    case "delegate":
+      return delegateSubject2(toolClass);
+    case "custom":
+      return customDetail(customTool2(toolClass.label));
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+function toolTitle2(toolClass, tense, subject = toolSubject2(toolClass)) {
+  if (tense !== "none") {
+    const verb = toolVerbs2(toolClass)[tense];
+    return subject === undefined ? verb : `${verb} ${subject}`;
+  }
+  if (toolClass.kind === "custom" && customTool2(toolClass.label).name === undefined)
+    return toolClass.label;
+  return [subject, toolNoun2(toolClass)].filter((word) => word !== undefined).join(" ");
+}
+function tidyPath2(path, cwd) {
+  if (cwd !== undefined && path.startsWith(`${cwd}/`))
+    return path.slice(cwd.length + 1);
+  return path;
+}
+function basename(path) {
+  return path.split(/[\\/]/u).at(-1) ?? path;
+}
+function placeName2(path, cwd) {
+  const tidy = tidyPath2(path, cwd);
+  if (tidy === "." || tidy === "./" || tidy === cwd)
+    return basename(cwd ?? tidy) || tidy;
+  return basename(tidy.replace(/[\\/]+$/u, "")) || tidy;
+}
+function condensedCommand2(command, cwd) {
+  const compact = command.replaceAll(/\s+/gu, " ").trim();
+  if (cwd === undefined)
+    return compact;
+  const prefix = [cwd, `"${cwd}"`, `'${cwd}'`].flatMap((dir) => [`cd ${dir} && `, `cd ${dir}; `]).find((candidate) => compact.startsWith(candidate));
+  return prefix === undefined ? compact : compact.slice(prefix.length);
+}
+function formatDuration2(ms) {
+  const seconds = Math.max(0, ms) / 1000;
+  if (seconds < 10)
+    return `${seconds.toFixed(1)}s`;
+  if (seconds < 60)
+    return `${String(Math.floor(seconds))}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${String(minutes)}m ${String(Math.floor(seconds % 60))}s`;
+  return `${String(Math.floor(minutes / 60))}h ${String(minutes % 60)}m`;
+}
+function formatWholeDuration2(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0)
+    return minutes % 60 === 0 ? `${String(hours)}h` : `${String(hours)}h ${String(minutes % 60)}m`;
+  if (minutes > 0)
+    return seconds % 60 === 0 ? `${String(minutes)}m` : `${String(minutes)}m ${String(seconds % 60)}s`;
+  return `${String(seconds)}s`;
+}
+function toolDetail2(toolClass, cwd) {
+  switch (toolClass.kind) {
+    case "edit": {
+      const title = tidyPath2(toolClass.path, cwd);
+      return { text: basename(title), title };
+    }
+    case "read":
+    case "list":
+      return { text: placeName2(toolClass.path, cwd), title: tidyPath2(toolClass.path, cwd) };
+    case "shell":
+      return { text: condensedCommand2(toolClass.command, cwd) };
+    case "delegate":
+      return { text: delegateSubject2(toolClass) };
+    case "custom": {
+      const detail = customDetail(customTool2(toolClass.label));
+      return detail === undefined ? undefined : { text: detail };
+    }
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+var NOTICE_LIMIT = 180;
+function oneLine(message) {
+  const compact = message.replaceAll(/\s+/gu, " ").trim();
+  if (compact === "")
+    return;
+  return compact.length <= NOTICE_LIMIT ? compact : `${compact.slice(0, NOTICE_LIMIT - 1).trimEnd()}…`;
+}
+function danger(notice, recovery) {
+  return { text: notice, tone: "danger", recovery };
+}
+function failureNotice2(failure) {
+  switch (failure.class) {
+    case "aborted":
+      return { text: "Run stopped.", tone: "neutral", recovery: undefined };
+    case "rate_limit":
+      return danger("Rate limit reached. Try again shortly.");
+    case "context_window":
+      return danger("This chat no longer fits the model's context window.", "compact");
+    case "quota":
+      return danger("Provider quota reached.", "switch-model");
+    case "auth":
+      return danger("The provider rejected the sign-in.", "sign-in");
+    case "overloaded":
+      return danger("The model is temporarily unavailable. Try again shortly.");
+    case "network":
+      return danger("Connection lost. Check your network and try again.");
+    case "provider":
+    case "runner":
+      return danger(oneLine(failure.message) ?? "Request failed.");
+    default: {
+      const _exhaustive = failure.class;
+      return _exhaustive;
+    }
+  }
+}
+
+export { showsTool2, showsText2, showsThinking2, readRawPart2, showsReport2, shownContent2, toolStatus2, toolOutput2, taskLabel2, callTaskState2, taskEnded2, agentGroupSummary2, runStatus2, endedStatus2, runMark2, rowMark2, backgroundLabel2, planningLabel2, PLANNING_LABEL2, PLANNING_DELAY_MS2, SLOW_PLANNING_MS2, executionMark2, mainHead2, sessionMark2, sessionTitle2, SUBAGENT_TITLE2, findCommandArgument2, completionTrigger2, customTool2, toolVerbs2, toolNoun2, delegateSubject2, toolSubject2, toolTitle2, tidyPath2, placeName2, condensedCommand2, formatDuration2, formatWholeDuration2, toolDetail2, failureNotice2, jobTaskState2 };