@athenaintel/react 0.28.0 → 0.30.0

package/dist/workbench/session-workbench-model.cjs

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const messageTime = require("../chat/message-time.cjs");
+const athenaUrls = require("../lib/athena-urls.cjs");
+const utils = require("../lib/utils.cjs");
+const writeTodosToolUi = require("../tools/write-todos-tool-ui.cjs");
+const toolNames = require("../agent-runtime/src/tool-names.cjs");
+const executeOutput = require("../agent-runtime/src/execute-output.cjs");
+const messageWindow = require("../agent-runtime/src/message-window.cjs");
+function readToolCallPart(part) {
+  if (!utils.isRecord(part) || part.type !== "tool-call") return null;
+  const { toolCallId, toolName, args, argsText, result, isError, artifact } = part;
+  if (typeof toolName !== "string" || typeof toolCallId !== "string") return null;
+  return {
+    toolCallId,
+    toolName,
+    args: utils.isRecord(args) ? args : {},
+    argsText: typeof argsText === "string" ? argsText : void 0,
+    result,
+    isError: isError === true,
+    artifact
+  };
+}
+function toolResultText(result) {
+  if (result === void 0 || result === null) return null;
+  if (typeof result === "string") return result;
+  if (Array.isArray(result)) {
+    const texts = result.flatMap(
+      (part) => utils.isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []
+    );
+    return texts.length > 0 ? texts.join("\n") : JSON.stringify(result);
+  }
+  if (utils.isRecord(result) && typeof result.content === "string") return result.content;
+  return JSON.stringify(result);
+}
+const SHELL_OUTPUT_PREVIEW_CHARS = 4e3;
+const SESSION_SANDBOX_LABEL = "Session sandbox";
+function shellMachine({
+  sandboxAssetId,
+  workspace
+}) {
+  const targetId = sandboxAssetId ?? (workspace == null ? void 0 : workspace.sessionComputerAssetId) ?? null;
+  if (targetId === null) return { assetId: null, label: SESSION_SANDBOX_LABEL };
+  const computer = workspace == null ? void 0 : workspace.computers.find((entry) => entry.assetId === targetId);
+  return { assetId: targetId, label: (computer == null ? void 0 : computer.title) ?? targetId };
+}
+function shellStatus({
+  result,
+  exitCode,
+  isError
+}) {
+  if (result === void 0) return "running";
+  if (exitCode !== null) return exitCode === 0 ? "succeeded" : "failed";
+  return isError ? "failed" : "unknown";
+}
+function deriveShellRows({
+  messages,
+  workspace
+}) {
+  var _a;
+  const rows = [];
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    const createdAt = messageTime.readMessageCreatedAt((_a = message.metadata) == null ? void 0 : _a.custom);
+    for (const raw of message.content) {
+      const part = readToolCallPart(raw);
+      if (!part || part.toolName !== toolNames.EXECUTE_TOOL_NAME) continue;
+      const command = typeof part.args.command === "string" ? part.args.command : "";
+      const sandboxAssetId = typeof part.args.sandbox_asset_id === "string" && part.args.sandbox_asset_id ? part.args.sandbox_asset_id : null;
+      const text = toolResultText(part.result);
+      const parsed = text === null ? null : executeOutput.parseExecuteOutput(text);
+      const body = (parsed == null ? void 0 : parsed.body) ?? "";
+      const clipped = body.length > SHELL_OUTPUT_PREVIEW_CHARS;
+      const { firstLine, extraLines } = executeOutput.summarizeShellCommand(command);
+      rows.push({
+        id: part.toolCallId,
+        command,
+        firstLine,
+        extraLines,
+        machine: shellMachine({ sandboxAssetId, workspace }),
+        status: shellStatus({
+          result: part.result,
+          exitCode: (parsed == null ? void 0 : parsed.exitCode) ?? null,
+          isError: part.isError
+        }),
+        exitCode: (parsed == null ? void 0 : parsed.exitCode) ?? null,
+        output: clipped ? body.slice(0, SHELL_OUTPUT_PREVIEW_CHARS) : body,
+        outputPartial: clipped || (parsed == null ? void 0 : parsed.truncated) === true || messageWindow.readTruncatedToolOutputArtifact(part.artifact) !== null,
+        createdAt
+      });
+    }
+  }
+  return rows.reverse();
+}
+function filterShellRows(rows, query) {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [...rows];
+  return rows.filter((row) => {
+    const haystack = `${row.command}
+${row.machine.label}
+${row.output}`.toLowerCase();
+    return words.every((word) => haystack.includes(word));
+  });
+}
+function taskProgress(steps) {
+  return {
+    steps: [...steps],
+    done: steps.filter((step) => step.status === "completed").length,
+    total: steps.length
+  };
+}
+function deriveTaskSteps({
+  stateTodos,
+  messages
+}) {
+  if (Array.isArray(stateTodos)) {
+    return writeTodosToolUi.parseTodoPlan({ args: { todos: stateTodos } }).steps;
+  }
+  for (let m = messages.length - 1; m >= 0; m -= 1) {
+    const message = messages[m];
+    if (!message || message.role !== "assistant") continue;
+    for (let p = message.content.length - 1; p >= 0; p -= 1) {
+      const part = readToolCallPart(message.content[p]);
+      if (!part || part.toolName !== "write_todos") continue;
+      const steps = writeTodosToolUi.parseTodoPlan({
+        args: part.args,
+        argsText: part.argsText,
+        result: part.result
+      }).steps;
+      if (steps.length > 0) return steps;
+    }
+  }
+  return [];
+}
+function workspaceComputers(workspace) {
+  const computers = (workspace == null ? void 0 : workspace.computers) ?? [];
+  const primary = computers.find((computer) => computer.role === "session_computer") ?? computers[0] ?? null;
+  return {
+    primary,
+    others: computers.filter((computer) => computer !== primary)
+  };
+}
+const COMPUTER_STATE_BADGES = {
+  started: { label: "Running", tone: "running" },
+  running: { label: "Running", tone: "running" },
+  ready: { label: "Running", tone: "running" },
+  starting: { label: "Starting", tone: "transition" },
+  pending: { label: "Starting", tone: "transition" },
+  restoring: { label: "Restoring", tone: "transition" },
+  resuming: { label: "Waking", tone: "transition" },
+  stopping: { label: "Stopping", tone: "transition" },
+  pausing: { label: "Pausing", tone: "transition" },
+  stopped: { label: "Stopped", tone: "stopped" },
+  paused: { label: "Paused", tone: "stopped" },
+  suspended: { label: "Sleeping", tone: "stopped" },
+  archived: { label: "Archived", tone: "stopped" },
+  error: { label: "Error", tone: "error" },
+  failed: { label: "Error", tone: "error" },
+  errored: { label: "Error", tone: "error" }
+};
+function computerStateBadge(status) {
+  if (status.explicitStop === "stopping") return { label: "Stopping", tone: "transition" };
+  const state = status.state.toLowerCase();
+  if (state === "" || state === "unknown") return null;
+  return COMPUTER_STATE_BADGES[state] ?? {
+    label: state.charAt(0).toUpperCase() + state.slice(1).replace(/_/g, " "),
+    tone: "stopped"
+  };
+}
+const ASSET_TYPE_LABELS = {
+  presentation_pptx_studio: "Presentation",
+  pptx: "PowerPoint file",
+  pdf: "PDF",
+  txt: "Text file",
+  json: "JSON",
+  yaml: "YAML",
+  query_snippet: "Query",
+  web_page: "Web page",
+  browse_session: "Browser session",
+  agent_config: "Agent",
+  collab_agent: "Agent"
+};
+function assetTypeLabel(assetType) {
+  const known = ASSET_TYPE_LABELS[assetType];
+  if (known) return known;
+  if (!assetType) return "Asset";
+  const words = assetType.replace(/_/g, " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+const ASSET_PANEL_TYPES = {
+  presentation: "presentation",
+  presentation_pptx_studio: "presentation",
+  spreadsheet: "spreadsheet",
+  document: "document",
+  notebook: "notebook"
+};
+function assetPanelTypeOf(assetType) {
+  return ASSET_PANEL_TYPES[assetType] ?? null;
+}
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function athenaLinkAppUrl({
+  appUrl,
+  backendUrl,
+  pageOrigin
+}) {
+  const deployed = athenaUrls.deriveAthenaAppUrl({ backendUrl });
+  if (deployed && pageOrigin !== null && originOf(appUrl) === pageOrigin) return deployed;
+  return appUrl;
+}
+const REVIEW_DECISION_LABELS = {
+  APPROVED: "approved",
+  CHANGES_REQUESTED: "changes requested",
+  REVIEW_REQUIRED: "review required"
+};
+function reviewDecisionLabel(reviewDecision) {
+  if (!reviewDecision) return "";
+  return REVIEW_DECISION_LABELS[reviewDecision] ?? reviewDecision.toLowerCase().replace(/_/g, " ");
+}
+function threadTabs(state, threadKey, defaults) {
+  return state[threadKey] ?? defaults;
+}
+function workbenchTabsReducer(state, action) {
+  const current = threadTabs(state, action.threadKey, action.defaults);
+  let next;
+  switch (action.type) {
+    case "open":
+      next = {
+        open: current.open.includes(action.paneId) ? current.open : [...current.open, action.paneId],
+        active: action.paneId
+      };
+      break;
+    case "activate":
+      if (!current.open.includes(action.paneId) || current.active === action.paneId) return state;
+      next = { open: current.open, active: action.paneId };
+      break;
+    case "close": {
+      const index = current.open.indexOf(action.paneId);
+      if (index < 0) return state;
+      const open = current.open.filter((id) => id !== action.paneId);
+      next = {
+        open,
+        active: current.active === action.paneId ? open[index] ?? open[index - 1] ?? null : current.active
+      };
+      break;
+    }
+  }
+  return { ...state, [action.threadKey]: next };
+}
+function visibleThreadTabs(tabs, paneIds) {
+  const open = tabs.open.filter((id) => paneIds.has(id));
+  const active = tabs.active !== null && open.includes(tabs.active) ? tabs.active : open[0] ?? null;
+  return { open, active };
+}
+function filterWorkbenchPanes(panes, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return panes;
+  return panes.filter(
+    (pane) => {
+      var _a;
+      return pane.title.toLowerCase().includes(needle) || (((_a = pane.description) == null ? void 0 : _a.toLowerCase().includes(needle)) ?? false);
+    }
+  );
+}
+exports.SESSION_SANDBOX_LABEL = SESSION_SANDBOX_LABEL;
+exports.SHELL_OUTPUT_PREVIEW_CHARS = SHELL_OUTPUT_PREVIEW_CHARS;
+exports.assetPanelTypeOf = assetPanelTypeOf;
+exports.assetTypeLabel = assetTypeLabel;
+exports.athenaLinkAppUrl = athenaLinkAppUrl;
+exports.computerStateBadge = computerStateBadge;
+exports.deriveShellRows = deriveShellRows;
+exports.deriveTaskSteps = deriveTaskSteps;
+exports.filterShellRows = filterShellRows;
+exports.filterWorkbenchPanes = filterWorkbenchPanes;
+exports.reviewDecisionLabel = reviewDecisionLabel;
+exports.shellMachine = shellMachine;
+exports.taskProgress = taskProgress;
+exports.threadTabs = threadTabs;
+exports.toolResultText = toolResultText;
+exports.visibleThreadTabs = visibleThreadTabs;
+exports.workbenchTabsReducer = workbenchTabsReducer;
+exports.workspaceComputers = workspaceComputers;
+//# sourceMappingURL=session-workbench-model.cjs.map

package/dist/workbench/session-workbench-model.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-workbench-model.cjs","sources":["../../src/workbench/session-workbench-model.ts"],"sourcesContent":["/**\n * Pure derivations behind `SessionWorkbench`: the Shell pane's rows from the\n * transcript's `execute` calls, the Tasks pane's plan from the thread's\n * `write_todos` state, the Computer pane's choice of machine, and the tab\n * strip's per-thread open/active state. React-free so the panes stay thin and\n * hosts building their own panes reuse the same rules.\n */\nimport {\n  EXECUTE_TOOL_NAME,\n  parseExecuteOutput,\n  readTruncatedToolOutputArtifact,\n  summarizeShellCommand,\n} from '@athenaintel/agent-runtime';\nimport { readMessageCreatedAt } from '../chat/message-time';\nimport { deriveAthenaAppUrl } from '../lib/athena-urls';\nimport { isRecord } from '../lib/utils';\nimport { type PlanStep, parseTodoPlan } from '../tools/write-todos-tool-ui';\nimport type { SessionWorkspace, SessionWorkspaceAsset } from './session-workspace-api';\n\n// ─── Transcript shape ────────────────────────────────────────────────\n\n/**\n * The slice of an assistant-ui thread message the workbench reads — a\n * structural subset of `ThreadMessage`, so tests and hosts can hand plain\n * objects.\n */\nexport interface WorkbenchMessage {\n  readonly id: string;\n  readonly role: string;\n  readonly content: readonly unknown[];\n  readonly metadata?: { readonly custom?: Record<string, unknown> } | undefined;\n}\n\ninterface ToolCallPart {\n  toolCallId: string;\n  toolName: string;\n  args: Record<string, unknown>;\n  argsText: string | undefined;\n  result: unknown;\n  isError: boolean;\n  artifact: unknown;\n}\n\nfunction readToolCallPart(part: unknown): ToolCallPart | null {\n  if (!isRecord(part) || part.type !== 'tool-call') return null;\n  const { toolCallId, toolName, args, argsText, result, isError, artifact } = part;\n  if (typeof toolName !== 'string' || typeof toolCallId !== 'string') return null;\n  return {\n    toolCallId,\n    toolName,\n    args: isRecord(args) ? args : {},\n    argsText: typeof argsText === 'string' ? argsText : undefined,\n    result,\n    isError: isError === true,\n    artifact,\n  };\n}\n\n/** A tool result as text: a string as is, text parts joined, `{content}` unwrapped. */\nexport function toolResultText(result: unknown): string | null {\n  if (result === undefined || result === null) return null;\n  if (typeof result === 'string') return result;\n  if (Array.isArray(result)) {\n    const texts = result.flatMap((part) =>\n      isRecord(part) && part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    );\n    return texts.length > 0 ? texts.join('\\n') : JSON.stringify(result);\n  }\n  if (isRecord(result) && typeof result.content === 'string') return result.content;\n  return JSON.stringify(result);\n}\n\n// ─── Shell ───────────────────────────────────────────────────────────\n\n/** How a shell command ended, as far as the transcript says. */\nexport type ShellRowStatus = 'running' | 'succeeded' | 'failed' | 'unknown';\n\n/** Where a command ran: a computer (by asset id) or the session's own sandbox. */\nexport interface ShellMachine {\n  /** `null` for the session sandbox (an `execute` without `sandbox_asset_id`). */\n  assetId: string | null;\n  label: string;\n}\n\nexport interface ShellRow {\n  /** The tool call id — stable across renders. */\n  id: string;\n  command: string;\n  /** The command's first non-blank line. */\n  firstLine: string;\n  /** Lines after the first. */\n  extraLines: number;\n  machine: ShellMachine;\n  status: ShellRowStatus;\n  exitCode: number | null;\n  /** The output without its status notes, clipped to {@link SHELL_OUTPUT_PREVIEW_CHARS}. */\n  output: string;\n  /** The output shown is not all of it (clipped here, cut by the backend, or not loaded). */\n  outputPartial: boolean;\n  /** ISO time of the turn that ran it, when the runtime stamped one. */\n  createdAt: string | null;\n}\n\n/** Characters of output a row keeps for its expanded view. */\nexport const SHELL_OUTPUT_PREVIEW_CHARS = 4000;\n\n/** The label for the session's own sandbox. */\nexport const SESSION_SANDBOX_LABEL = 'Session sandbox';\n\n/**\n * Name a machine: a computer the workspace lists by its title, a bare\n * `sandbox_asset_id` the caller cannot see by its id, the session sandbox by\n * {@link SESSION_SANDBOX_LABEL} (or by the session computer, when the session\n * is bound to one).\n */\nexport function shellMachine({\n  sandboxAssetId,\n  workspace,\n}: {\n  sandboxAssetId: string | null;\n  workspace: SessionWorkspace | null | undefined;\n}): ShellMachine {\n  const targetId = sandboxAssetId ?? workspace?.sessionComputerAssetId ?? null;\n  if (targetId === null) return { assetId: null, label: SESSION_SANDBOX_LABEL };\n  const computer = workspace?.computers.find((entry) => entry.assetId === targetId);\n  return { assetId: targetId, label: computer?.title ?? targetId };\n}\n\nfunction shellStatus({\n  result,\n  exitCode,\n  isError,\n}: {\n  result: unknown;\n  exitCode: number | null;\n  isError: boolean;\n}): ShellRowStatus {\n  if (result === undefined) return 'running';\n  if (exitCode !== null) return exitCode === 0 ? 'succeeded' : 'failed';\n  return isError ? 'failed' : 'unknown';\n}\n\n/**\n * Every `execute` call in the transcript, newest first. Commands still\n * running read `running`; one whose output the live window cut reads its exit\n * note only when the loaded text still carries it (`unknown` otherwise).\n */\nexport function deriveShellRows({\n  messages,\n  workspace,\n}: {\n  messages: readonly WorkbenchMessage[];\n  workspace?: SessionWorkspace | null;\n}): ShellRow[] {\n  const rows: ShellRow[] = [];\n  for (const message of messages) {\n    if (message.role !== 'assistant') continue;\n    const createdAt = readMessageCreatedAt(message.metadata?.custom);\n    for (const raw of message.content) {\n      const part = readToolCallPart(raw);\n      if (!part || part.toolName !== EXECUTE_TOOL_NAME) continue;\n      const command = typeof part.args.command === 'string' ? part.args.command : '';\n      const sandboxAssetId =\n        typeof part.args.sandbox_asset_id === 'string' && part.args.sandbox_asset_id\n          ? part.args.sandbox_asset_id\n          : null;\n      const text = toolResultText(part.result);\n      const parsed = text === null ? null : parseExecuteOutput(text);\n      const body = parsed?.body ?? '';\n      const clipped = body.length > SHELL_OUTPUT_PREVIEW_CHARS;\n      const { firstLine, extraLines } = summarizeShellCommand(command);\n      rows.push({\n        id: part.toolCallId,\n        command,\n        firstLine,\n        extraLines,\n        machine: shellMachine({ sandboxAssetId, workspace }),\n        status: shellStatus({\n          result: part.result,\n          exitCode: parsed?.exitCode ?? null,\n          isError: part.isError,\n        }),\n        exitCode: parsed?.exitCode ?? null,\n        output: clipped ? body.slice(0, SHELL_OUTPUT_PREVIEW_CHARS) : body,\n        outputPartial:\n          clipped ||\n          parsed?.truncated === true ||\n          readTruncatedToolOutputArtifact(part.artifact) !== null,\n        createdAt,\n      });\n    }\n  }\n  return rows.reverse();\n}\n\n/** Rows whose command, machine or output contains every word of `query` (case-insensitive). */\nexport function filterShellRows(rows: readonly ShellRow[], query: string): ShellRow[] {\n  const words = query.toLowerCase().split(/\\s+/).filter(Boolean);\n  if (words.length === 0) return [...rows];\n  return rows.filter((row) => {\n    const haystack = `${row.command}\\n${row.machine.label}\\n${row.output}`.toLowerCase();\n    return words.every((word) => haystack.includes(word));\n  });\n}\n\n// ─── Tasks ───────────────────────────────────────────────────────────\n\nexport interface TaskProgress {\n  steps: PlanStep[];\n  /** Steps completed. */\n  done: number;\n  total: number;\n}\n\n/** The plan with its \"N/M done\" counts. */\nexport function taskProgress(steps: readonly PlanStep[]): TaskProgress {\n  return {\n    steps: [...steps],\n    done: steps.filter((step) => step.status === 'completed').length,\n    total: steps.length,\n  };\n}\n\n/**\n * The session's current plan: the thread state's `todos` channel (the\n * deepagents plan the backend keeps — authoritative whenever it is an array,\n * an empty one included: a cleared plan stays cleared), else the newest\n * `write_todos` call in the loaded transcript, else empty. The transcript\n * fallback covers a host whose wire does not carry the channel.\n */\nexport function deriveTaskSteps({\n  stateTodos,\n  messages,\n}: {\n  stateTodos: unknown;\n  messages: readonly WorkbenchMessage[];\n}): PlanStep[] {\n  if (Array.isArray(stateTodos)) {\n    return parseTodoPlan({ args: { todos: stateTodos } }).steps;\n  }\n  for (let m = messages.length - 1; m >= 0; m -= 1) {\n    const message = messages[m];\n    if (!message || message.role !== 'assistant') continue;\n    for (let p = message.content.length - 1; p >= 0; p -= 1) {\n      const part = readToolCallPart(message.content[p]);\n      if (!part || part.toolName !== 'write_todos') continue;\n      const steps = parseTodoPlan({\n        args: part.args,\n        argsText: part.argsText,\n        result: part.result,\n      }).steps;\n      if (steps.length > 0) return steps;\n    }\n  }\n  return [];\n}\n\n// ─── Computers ───────────────────────────────────────────────────────\n\n/**\n * The computer the Computer pane leads with: the session's bound computer,\n * else the computer the session touched most recently. The rest follow.\n */\nexport function workspaceComputers(workspace: SessionWorkspace | null | undefined): {\n  primary: SessionWorkspaceAsset | null;\n  others: SessionWorkspaceAsset[];\n} {\n  const computers = workspace?.computers ?? [];\n  const primary =\n    computers.find((computer) => computer.role === 'session_computer') ?? computers[0] ?? null;\n  return {\n    primary,\n    others: computers.filter((computer) => computer !== primary),\n  };\n}\n\nexport type ComputerStateTone = 'running' | 'transition' | 'stopped' | 'error';\n\nconst COMPUTER_STATE_BADGES: Record<string, { label: string; tone: ComputerStateTone }> = {\n  started: { label: 'Running', tone: 'running' },\n  running: { label: 'Running', tone: 'running' },\n  ready: { label: 'Running', tone: 'running' },\n  starting: { label: 'Starting', tone: 'transition' },\n  pending: { label: 'Starting', tone: 'transition' },\n  restoring: { label: 'Restoring', tone: 'transition' },\n  resuming: { label: 'Waking', tone: 'transition' },\n  stopping: { label: 'Stopping', tone: 'transition' },\n  pausing: { label: 'Pausing', tone: 'transition' },\n  stopped: { label: 'Stopped', tone: 'stopped' },\n  paused: { label: 'Paused', tone: 'stopped' },\n  suspended: { label: 'Sleeping', tone: 'stopped' },\n  archived: { label: 'Archived', tone: 'stopped' },\n  error: { label: 'Error', tone: 'error' },\n  failed: { label: 'Error', tone: 'error' },\n  errored: { label: 'Error', tone: 'error' },\n};\n\n/**\n * The badge for a computer's runtime state, or `null` when the state says\n * nothing a person can act on (`unknown`). A stop someone asked for wins over\n * a runtime that has not caught up yet.\n */\nexport function computerStateBadge(status: {\n  state: string;\n  explicitStop: string | null;\n}): { label: string; tone: ComputerStateTone } | null {\n  if (status.explicitStop === 'stopping') return { label: 'Stopping', tone: 'transition' };\n  const state = status.state.toLowerCase();\n  if (state === '' || state === 'unknown') return null;\n  return (\n    COMPUTER_STATE_BADGES[state] ?? {\n      label: state.charAt(0).toUpperCase() + state.slice(1).replace(/_/g, ' '),\n      tone: 'stopped',\n    }\n  );\n}\n\n// ─── Assets ──────────────────────────────────────────────────────────\n\nconst ASSET_TYPE_LABELS: Record<string, string> = {\n  presentation_pptx_studio: 'Presentation',\n  pptx: 'PowerPoint file',\n  pdf: 'PDF',\n  txt: 'Text file',\n  json: 'JSON',\n  yaml: 'YAML',\n  query_snippet: 'Query',\n  web_page: 'Web page',\n  browse_session: 'Browser session',\n  agent_config: 'Agent',\n  collab_agent: 'Agent',\n};\n\n/** A person's word for an Athena asset type (`spreadsheet` → \"Spreadsheet\"). */\nexport function assetTypeLabel(assetType: string): string {\n  const known = ASSET_TYPE_LABELS[assetType];\n  if (known) return known;\n  if (!assetType) return 'Asset';\n  const words = assetType.replace(/_/g, ' ');\n  return words.charAt(0).toUpperCase() + words.slice(1);\n}\n\nconst ASSET_PANEL_TYPES: Record<string, 'presentation' | 'spreadsheet' | 'document' | 'notebook'> = {\n  presentation: 'presentation',\n  presentation_pptx_studio: 'presentation',\n  spreadsheet: 'spreadsheet',\n  document: 'document',\n  notebook: 'notebook',\n};\n\n/** The asset panel's viewer for an asset type, or `null` when the panel has none. */\nexport function assetPanelTypeOf(\n  assetType: string,\n): 'presentation' | 'spreadsheet' | 'document' | 'notebook' | null {\n  return ASSET_PANEL_TYPES[assetType] ?? null;\n}\n\nfunction originOf(url: string): string | null {\n  try {\n    return new URL(url).origin;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The Athena frontend an \"Open in Athena\" link points at. The provider's\n * `appUrl` is that frontend, except in an app a computer serves: Marathon's\n * `/_athena/auth` mints `appUrl` as the app's OWN origin, so a link built on\n * it opens the app instead of Athena. When `appUrl` is the page's own origin\n * and the Agora base belongs to a known Athena deployment, the deployment's\n * frontend wins (on Olympus itself the two are the same origin anyway).\n */\nexport function athenaLinkAppUrl({\n  appUrl,\n  backendUrl,\n  pageOrigin,\n}: {\n  appUrl: string;\n  backendUrl: string;\n  pageOrigin: string | null;\n}): string {\n  const deployed = deriveAthenaAppUrl({ backendUrl });\n  if (deployed && pageOrigin !== null && originOf(appUrl) === pageOrigin) return deployed;\n  return appUrl;\n}\n\n// ─── Pull requests ───────────────────────────────────────────────────\n\nconst REVIEW_DECISION_LABELS: Record<string, string> = {\n  APPROVED: 'approved',\n  CHANGES_REQUESTED: 'changes requested',\n  REVIEW_REQUIRED: 'review required',\n};\n\n/** GitHub's review decision in words, or `''` when there is none. */\nexport function reviewDecisionLabel(reviewDecision: string | null): string {\n  if (!reviewDecision) return '';\n  return REVIEW_DECISION_LABELS[reviewDecision] ?? reviewDecision.toLowerCase().replace(/_/g, ' ');\n}\n\n// ─── Tabs ────────────────────────────────────────────────────────────\n\n/** One thread's open tabs (in strip order) and its active tab. */\nexport interface WorkbenchThreadTabs {\n  open: string[];\n  active: string | null;\n}\n\n/** Every thread's tabs this workbench has seen, in memory only. */\nexport type WorkbenchTabsState = Readonly<Record<string, WorkbenchThreadTabs>>;\n\nexport type WorkbenchTabsAction =\n  | { type: 'open'; threadKey: string; paneId: string; defaults: WorkbenchThreadTabs }\n  | { type: 'close'; threadKey: string; paneId: string; defaults: WorkbenchThreadTabs }\n  | { type: 'activate'; threadKey: string; paneId: string; defaults: WorkbenchThreadTabs };\n\n/** A thread's tabs, or the defaults for a thread the workbench has not changed yet. */\nexport function threadTabs(\n  state: WorkbenchTabsState,\n  threadKey: string,\n  defaults: WorkbenchThreadTabs,\n): WorkbenchThreadTabs {\n  return state[threadKey] ?? defaults;\n}\n\n/**\n * The tab strip's transitions. Opening a tab that is already open activates\n * it; closing the active tab activates its right neighbour (else its left);\n * the first change to a thread starts from the defaults.\n */\nexport function workbenchTabsReducer(\n  state: WorkbenchTabsState,\n  action: WorkbenchTabsAction,\n): WorkbenchTabsState {\n  const current = threadTabs(state, action.threadKey, action.defaults);\n  let next: WorkbenchThreadTabs;\n  switch (action.type) {\n    case 'open':\n      next = {\n        open: current.open.includes(action.paneId)\n          ? current.open\n          : [...current.open, action.paneId],\n        active: action.paneId,\n      };\n      break;\n    case 'activate':\n      if (!current.open.includes(action.paneId) || current.active === action.paneId) return state;\n      next = { open: current.open, active: action.paneId };\n      break;\n    case 'close': {\n      const index = current.open.indexOf(action.paneId);\n      if (index < 0) return state;\n      const open = current.open.filter((id) => id !== action.paneId);\n      next = {\n        open,\n        active:\n          current.active === action.paneId\n            ? (open[index] ?? open[index - 1] ?? null)\n            : current.active,\n      };\n      break;\n    }\n  }\n  return { ...state, [action.threadKey]: next };\n}\n\n/**\n * The tabs as the strip renders them: only panes the registry still has, and\n * an active tab that is one of them (the first, when the stored one is gone).\n */\nexport function visibleThreadTabs(\n  tabs: WorkbenchThreadTabs,\n  paneIds: ReadonlySet<string>,\n): WorkbenchThreadTabs {\n  const open = tabs.open.filter((id) => paneIds.has(id));\n  const active =\n    tabs.active !== null && open.includes(tabs.active) ? tabs.active : (open[0] ?? null);\n  return { open, active };\n}\n\n/** The \"+\" menu's search: panes whose title or description holds the query, any case. */\nexport function filterWorkbenchPanes<P extends { title: string; description?: string }>(\n  panes: readonly P[],\n  query: string,\n): readonly P[] {\n  const needle = query.trim().toLowerCase();\n  if (!needle) return panes;\n  return panes.filter(\n    (pane) =>\n      pane.title.toLowerCase().includes(needle) ||\n      (pane.description?.toLowerCase().includes(needle) ?? false),\n  );\n}\n"],"names":["isRecord","readMessageCreatedAt","EXECUTE_TOOL_NAME","parseExecuteOutput","summarizeShellCommand","readTruncatedToolOutputArtifact","parseTodoPlan","deriveAthenaAppUrl"],"mappings":"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"}

package/dist/workbench/session-workbench-model.d.ts

@@ -0,0 +1,168 @@
+import { type PlanStep } from '../tools/write-todos-tool-ui';
+import type { SessionWorkspace, SessionWorkspaceAsset } from './session-workspace-api';
+/**
+ * The slice of an assistant-ui thread message the workbench reads — a
+ * structural subset of `ThreadMessage`, so tests and hosts can hand plain
+ * objects.
+ */
+export interface WorkbenchMessage {
+    readonly id: string;
+    readonly role: string;
+    readonly content: readonly unknown[];
+    readonly metadata?: {
+        readonly custom?: Record<string, unknown>;
+    } | undefined;
+}
+/** A tool result as text: a string as is, text parts joined, `{content}` unwrapped. */
+export declare function toolResultText(result: unknown): string | null;
+/** How a shell command ended, as far as the transcript says. */
+export type ShellRowStatus = 'running' | 'succeeded' | 'failed' | 'unknown';
+/** Where a command ran: a computer (by asset id) or the session's own sandbox. */
+export interface ShellMachine {
+    /** `null` for the session sandbox (an `execute` without `sandbox_asset_id`). */
+    assetId: string | null;
+    label: string;
+}
+export interface ShellRow {
+    /** The tool call id — stable across renders. */
+    id: string;
+    command: string;
+    /** The command's first non-blank line. */
+    firstLine: string;
+    /** Lines after the first. */
+    extraLines: number;
+    machine: ShellMachine;
+    status: ShellRowStatus;
+    exitCode: number | null;
+    /** The output without its status notes, clipped to {@link SHELL_OUTPUT_PREVIEW_CHARS}. */
+    output: string;
+    /** The output shown is not all of it (clipped here, cut by the backend, or not loaded). */
+    outputPartial: boolean;
+    /** ISO time of the turn that ran it, when the runtime stamped one. */
+    createdAt: string | null;
+}
+/** Characters of output a row keeps for its expanded view. */
+export declare const SHELL_OUTPUT_PREVIEW_CHARS = 4000;
+/** The label for the session's own sandbox. */
+export declare const SESSION_SANDBOX_LABEL = "Session sandbox";
+/**
+ * Name a machine: a computer the workspace lists by its title, a bare
+ * `sandbox_asset_id` the caller cannot see by its id, the session sandbox by
+ * {@link SESSION_SANDBOX_LABEL} (or by the session computer, when the session
+ * is bound to one).
+ */
+export declare function shellMachine({ sandboxAssetId, workspace, }: {
+    sandboxAssetId: string | null;
+    workspace: SessionWorkspace | null | undefined;
+}): ShellMachine;
+/**
+ * Every `execute` call in the transcript, newest first. Commands still
+ * running read `running`; one whose output the live window cut reads its exit
+ * note only when the loaded text still carries it (`unknown` otherwise).
+ */
+export declare function deriveShellRows({ messages, workspace, }: {
+    messages: readonly WorkbenchMessage[];
+    workspace?: SessionWorkspace | null;
+}): ShellRow[];
+/** Rows whose command, machine or output contains every word of `query` (case-insensitive). */
+export declare function filterShellRows(rows: readonly ShellRow[], query: string): ShellRow[];
+export interface TaskProgress {
+    steps: PlanStep[];
+    /** Steps completed. */
+    done: number;
+    total: number;
+}
+/** The plan with its "N/M done" counts. */
+export declare function taskProgress(steps: readonly PlanStep[]): TaskProgress;
+/**
+ * The session's current plan: the thread state's `todos` channel (the
+ * deepagents plan the backend keeps — authoritative whenever it is an array,
+ * an empty one included: a cleared plan stays cleared), else the newest
+ * `write_todos` call in the loaded transcript, else empty. The transcript
+ * fallback covers a host whose wire does not carry the channel.
+ */
+export declare function deriveTaskSteps({ stateTodos, messages, }: {
+    stateTodos: unknown;
+    messages: readonly WorkbenchMessage[];
+}): PlanStep[];
+/**
+ * The computer the Computer pane leads with: the session's bound computer,
+ * else the computer the session touched most recently. The rest follow.
+ */
+export declare function workspaceComputers(workspace: SessionWorkspace | null | undefined): {
+    primary: SessionWorkspaceAsset | null;
+    others: SessionWorkspaceAsset[];
+};
+export type ComputerStateTone = 'running' | 'transition' | 'stopped' | 'error';
+/**
+ * The badge for a computer's runtime state, or `null` when the state says
+ * nothing a person can act on (`unknown`). A stop someone asked for wins over
+ * a runtime that has not caught up yet.
+ */
+export declare function computerStateBadge(status: {
+    state: string;
+    explicitStop: string | null;
+}): {
+    label: string;
+    tone: ComputerStateTone;
+} | null;
+/** A person's word for an Athena asset type (`spreadsheet` → "Spreadsheet"). */
+export declare function assetTypeLabel(assetType: string): string;
+/** The asset panel's viewer for an asset type, or `null` when the panel has none. */
+export declare function assetPanelTypeOf(assetType: string): 'presentation' | 'spreadsheet' | 'document' | 'notebook' | null;
+/**
+ * The Athena frontend an "Open in Athena" link points at. The provider's
+ * `appUrl` is that frontend, except in an app a computer serves: Marathon's
+ * `/_athena/auth` mints `appUrl` as the app's OWN origin, so a link built on
+ * it opens the app instead of Athena. When `appUrl` is the page's own origin
+ * and the Agora base belongs to a known Athena deployment, the deployment's
+ * frontend wins (on Olympus itself the two are the same origin anyway).
+ */
+export declare function athenaLinkAppUrl({ appUrl, backendUrl, pageOrigin, }: {
+    appUrl: string;
+    backendUrl: string;
+    pageOrigin: string | null;
+}): string;
+/** GitHub's review decision in words, or `''` when there is none. */
+export declare function reviewDecisionLabel(reviewDecision: string | null): string;
+/** One thread's open tabs (in strip order) and its active tab. */
+export interface WorkbenchThreadTabs {
+    open: string[];
+    active: string | null;
+}
+/** Every thread's tabs this workbench has seen, in memory only. */
+export type WorkbenchTabsState = Readonly<Record<string, WorkbenchThreadTabs>>;
+export type WorkbenchTabsAction = {
+    type: 'open';
+    threadKey: string;
+    paneId: string;
+    defaults: WorkbenchThreadTabs;
+} | {
+    type: 'close';
+    threadKey: string;
+    paneId: string;
+    defaults: WorkbenchThreadTabs;
+} | {
+    type: 'activate';
+    threadKey: string;
+    paneId: string;
+    defaults: WorkbenchThreadTabs;
+};
+/** A thread's tabs, or the defaults for a thread the workbench has not changed yet. */
+export declare function threadTabs(state: WorkbenchTabsState, threadKey: string, defaults: WorkbenchThreadTabs): WorkbenchThreadTabs;
+/**
+ * The tab strip's transitions. Opening a tab that is already open activates
+ * it; closing the active tab activates its right neighbour (else its left);
+ * the first change to a thread starts from the defaults.
+ */
+export declare function workbenchTabsReducer(state: WorkbenchTabsState, action: WorkbenchTabsAction): WorkbenchTabsState;
+/**
+ * The tabs as the strip renders them: only panes the registry still has, and
+ * an active tab that is one of them (the first, when the stored one is gone).
+ */
+export declare function visibleThreadTabs(tabs: WorkbenchThreadTabs, paneIds: ReadonlySet<string>): WorkbenchThreadTabs;
+/** The "+" menu's search: panes whose title or description holds the query, any case. */
+export declare function filterWorkbenchPanes<P extends {
+    title: string;
+    description?: string;
+}>(panes: readonly P[], query: string): readonly P[];