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

package/dist/src/client/presentation.d.ts

@@ -1,6 +1,7 @@
 import { text, thinking } from "@nyte-ai/core";
 import type { PartState } from "@nyte-ai/core";
-import type { Execution, Failure, HeadInfo, Message, MessageSource, SessionInfo, ToolClass, ToolPartState, UserContent } from "@nyte-ai/schema";
+import type { Execution, Failure, HeadInfo, Message, MessageSource, RunEnd, RunId, SessionInfo, ToolClass, ToolPartState, UserContent } from "@nyte-ai/schema";
+export { jobTaskState } from "@nyte-ai/schema";
 /**
  * A message the user sent, or one a child, job or action delivered for them.
  *
@@ -142,17 +143,135 @@ export declare function toolStatus(message: Pick<ToolMessage, "state" | "status"
  */
 export declare function toolOutput(state: ToolPartState): string;
 /**
- * The mark a session list draws for a head's execution.
+ * A chat's, subagent's or job's state, each with one mark and one word ({@link taskLabel}). A
+ * stopped run or job is done, never failed.
  *
  * @category presentation
  */
-export type SessionMark = "waiting" | "retry" | "working" | "failed" | "idle";
+export type TaskState = "waiting" | "retrying" | "working" | "background" | "failed" | "done";
 /**
- * The mark for an execution; a session without one is idle.
+ * Screen readers hear the same word sighted users see.
  *
  * @category presentation
  */
-export declare function executionMark(execution: Execution | undefined): SessionMark;
+export declare function taskLabel(state: TaskState): string;
+/**
+ * A delegate call's state as a task, for a child no client knows yet.
+ *
+ * @category presentation
+ */
+export declare function callTaskState(status: ToolStatus): TaskState;
+/**
+ * Whether a task has finished, either done or failed.
+ *
+ * @category presentation
+ */
+export declare function taskEnded(state: TaskState): boolean;
+/**
+ * The heading over a group of agents: how many still run, else how many finished and failed.
+ *
+ * @category presentation
+ */
+export declare function agentGroupSummary(states: readonly TaskState[]): {
+    readonly title: string;
+    readonly detail: string | undefined;
+};
+/**
+ * A chat's own run; background work never changes it. The active kinds carry the run a Stop
+ * targets.
+ *
+ * @category presentation
+ */
+export type RunStatus = {
+    readonly kind: "idle";
+} | {
+    readonly kind: "completed";
+} | {
+    readonly kind: "stopped";
+} | {
+    readonly kind: "failed";
+    readonly failure: Failure;
+} | {
+    readonly kind: "working";
+    readonly run: RunId;
+    readonly stopping: boolean;
+} | {
+    readonly kind: "retrying";
+    readonly run: RunId;
+} | {
+    readonly kind: "waiting-for-approval";
+    readonly run: RunId;
+};
+/**
+ * How many of a head's background items are still working and how many wait on the user.
+ *
+ * @category presentation
+ */
+export type BackgroundWork = HeadInfo["background"];
+/**
+ * A head's execution as a run status; none reads as idle, and a run waiting on a child, job or
+ * timer reads as working.
+ *
+ * @category presentation
+ */
+export declare function runStatus(execution: Execution | undefined): RunStatus;
+/**
+ * The status a run leaves when it ends; a stopped run is never a failure.
+ *
+ * @category presentation
+ */
+export declare function endedStatus(end: RunEnd): RunStatus;
+/**
+ * A chat's own run as a task state; a run that ended is done unless it failed.
+ *
+ * @category presentation
+ */
+export declare function runMark(status: RunStatus): TaskState;
+/**
+ * The state a list row shows, taking the first that applies: the chat's own active run,
+ * background work waiting on the user, the chat's own failure, background work still running,
+ * then how the chat's last run ended.
+ *
+ * @category presentation
+ */
+export declare function rowMark(status: RunStatus, background: BackgroundWork): TaskState;
+/**
+ * Words for a chat's background work, or `undefined` while none is working or waiting.
+ *
+ * @category presentation
+ */
+export declare function backgroundLabel(background: BackgroundWork): string | undefined;
+/**
+ * The live row's words after `planningMs` without progress. None at first, so a quick gap doesn't
+ * flash.
+ *
+ * @category presentation
+ */
+export declare function planningLabel(planningMs: number): string | undefined;
+/**
+ * Also holds the live row's place before {@link planningLabel} shows it.
+ *
+ * @category presentation
+ */
+export declare const PLANNING_LABEL = "Planning next moves";
+/**
+ * How long without progress before the live row says a run is planning.
+ *
+ * @category presentation
+ */
+export declare const PLANNING_DELAY_MS = 200;
+/**
+ * How long without progress before the live row says a run is taking longer than expected.
+ *
+ * @category presentation
+ */
+export declare const SLOW_PLANNING_MS = 15000;
+/**
+ * An execution's own run as a task; a session without one is done.
+ *
+ * @category presentation
+ */
+export declare function executionMark(execution: Execution | undefined): TaskState;
 /**
  * The head a session row speaks for: `main`, else the first.
  *
@@ -160,11 +279,23 @@ export declare function executionMark(execution: Execution | undefined): Session
  */
 export declare function mainHead(session: Pick<SessionInfo, "heads">): HeadInfo | undefined;
 /**
- * The mark for a session's main head.
+ * A session's state, the same in a list row, a tab and a parent's task list.
+ *
+ * @category presentation
+ */
+export declare function sessionMark(session: Pick<SessionInfo, "heads">): TaskState;
+/**
+ * A session's title: its name, else "New chat" for a top-level chat or {@link SUBAGENT_TITLE}.
+ *
+ * @category presentation
+ */
+export declare function sessionTitle(session: Pick<SessionInfo, "name" | "parent">): string;
+/**
+ * A child session's title while it has no name or a client doesn't know it yet.
  *
  * @category presentation
  */
-export declare function sessionMark(session: Pick<SessionInfo, "heads">): SessionMark;
+export declare const SUBAGENT_TITLE = "Subagent";
 /**
  * The text after a one-line draft's leading `/name `, while the caret is past
  * it: `start` is where that text begins, `query` runs from there to the caret.
@@ -333,4 +464,3 @@ export interface FailureNotice {
  * @category presentation
  */
 export declare function failureNotice(failure: Failure): FailureNotice;
-export {};

package/dist/src/client/presentation.js

@@ -1,373 +1,88 @@
-// src/client/presentation.ts
-import { isPart, text, thinking, tool } from "@nyte-ai/core";
-function showsTool(message) {
-  return isPart(message, tool);
-}
-function showsText(message) {
-  return isPart(message, text);
-}
-function showsThinking(message) {
-  return isPart(message, thinking);
-}
-function readRawPart(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 showsReport(message) {
-  return message.source.kind === "child" || message.source.kind === "job";
-}
-function shownContent(message) {
-  return message.source.kind === "action" ? message.source.label : message.content;
-}
-var RUNNING = { tense: "running", tone: "running", word: undefined };
-function toolStatus(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 toolOutput(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 executionMark(execution) {
-  switch (execution?.kind) {
-    case undefined:
-      return "idle";
-    case "idle":
-      return execution.lastRun?.end.kind === "failed" ? "failed" : "idle";
-    case "live":
-      return "working";
-    case "waiting":
-      return execution.on.kind === "part" ? "waiting" : "working";
-    case "retrying":
-      return "retry";
-    default: {
-      const _exhaustive = execution;
-      return _exhaustive;
-    }
-  }
-}
-function mainHead(session) {
-  return session.heads.find((head) => head.name === "main") ?? session.heads[0];
-}
-function sessionMark(session) {
-  return executionMark(mainHead(session)?.execution);
-}
-var COMMAND_ARGUMENT = /^[ \t]*\/([a-z0-9][a-z0-9-]*)[ \t]+/u;
-function findCommandArgument(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 completionTrigger(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 customTool(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 toolVerbs(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 customTool(toolClass.label).verbs;
-    default: {
-      const _exhaustive = toolClass;
-      return _exhaustive;
-    }
-  }
-}
-function toolNoun(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 delegateSubject(toolClass) {
-  return toolClass.title ?? "subagent";
-}
-function toolSubject(toolClass) {
-  switch (toolClass.kind) {
-    case "read":
-    case "list":
-    case "edit":
-      return toolClass.path;
-    case "shell":
-      return toolClass.command;
-    case "delegate":
-      return delegateSubject(toolClass);
-    case "custom":
-      return customDetail(customTool(toolClass.label));
-    default: {
-      const _exhaustive = toolClass;
-      return _exhaustive;
-    }
-  }
-}
-function toolTitle(toolClass, tense, subject = toolSubject(toolClass)) {
-  if (tense !== "none") {
-    const verb = toolVerbs(toolClass)[tense];
-    return subject === undefined ? verb : `${verb} ${subject}`;
-  }
-  if (toolClass.kind === "custom" && customTool(toolClass.label).name === undefined)
-    return toolClass.label;
-  return [subject, toolNoun(toolClass)].filter((word) => word !== undefined).join(" ");
-}
-function tidyPath(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 placeName(path, cwd) {
-  const tidy = tidyPath(path, cwd);
-  if (tidy === "." || tidy === "./" || tidy === cwd)
-    return basename(cwd ?? tidy) || tidy;
-  return basename(tidy.replace(/[\\/]+$/u, "")) || tidy;
-}
-function condensedCommand(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 formatDuration(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 formatWholeDuration(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 toolDetail(toolClass, cwd) {
-  switch (toolClass.kind) {
-    case "edit": {
-      const title = tidyPath(toolClass.path, cwd);
-      return { text: basename(title), title };
-    }
-    case "read":
-    case "list":
-      return { text: placeName(toolClass.path, cwd), title: tidyPath(toolClass.path, cwd) };
-    case "shell":
-      return { text: condensedCommand(toolClass.command, cwd) };
-    case "delegate":
-      return { text: delegateSubject(toolClass) };
-    case "custom": {
-      const detail = customDetail(customTool(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 failureNotice(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;
-    }
-  }
-}
+import {
+  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
+} from "../../chunks/bash-description-qwyy182r.js";
 export {
-  completionTrigger,
-  condensedCommand,
-  customTool,
-  delegateSubject,
-  executionMark,
-  failureNotice,
-  findCommandArgument,
-  formatDuration,
-  formatWholeDuration,
-  mainHead,
-  placeName,
-  readRawPart,
-  sessionMark,
-  shownContent,
-  showsReport,
-  showsText,
-  showsThinking,
-  showsTool,
-  tidyPath,
-  toolDetail,
-  toolNoun,
-  toolOutput,
-  toolStatus,
-  toolSubject,
-  toolTitle,
-  toolVerbs
+  PLANNING_DELAY_MS2 as PLANNING_DELAY_MS,
+  PLANNING_LABEL2 as PLANNING_LABEL,
+  SLOW_PLANNING_MS2 as SLOW_PLANNING_MS,
+  SUBAGENT_TITLE2 as SUBAGENT_TITLE,
+  agentGroupSummary2 as agentGroupSummary,
+  backgroundLabel2 as backgroundLabel,
+  callTaskState2 as callTaskState,
+  completionTrigger2 as completionTrigger,
+  condensedCommand2 as condensedCommand,
+  customTool2 as customTool,
+  delegateSubject2 as delegateSubject,
+  endedStatus2 as endedStatus,
+  executionMark2 as executionMark,
+  failureNotice2 as failureNotice,
+  findCommandArgument2 as findCommandArgument,
+  formatDuration2 as formatDuration,
+  formatWholeDuration2 as formatWholeDuration,
+  jobTaskState2 as jobTaskState,
+  mainHead2 as mainHead,
+  placeName2 as placeName,
+  planningLabel2 as planningLabel,
+  readRawPart2 as readRawPart,
+  rowMark2 as rowMark,
+  runMark2 as runMark,
+  runStatus2 as runStatus,
+  sessionMark2 as sessionMark,
+  sessionTitle2 as sessionTitle,
+  shownContent2 as shownContent,
+  showsReport2 as showsReport,
+  showsText2 as showsText,
+  showsThinking2 as showsThinking,
+  showsTool2 as showsTool,
+  taskEnded2 as taskEnded,
+  taskLabel2 as taskLabel,
+  tidyPath2 as tidyPath,
+  toolDetail2 as toolDetail,
+  toolNoun2 as toolNoun,
+  toolOutput2 as toolOutput,
+  toolStatus2 as toolStatus,
+  toolSubject2 as toolSubject,
+  toolTitle2 as toolTitle,
+  toolVerbs2 as toolVerbs
 };