@visual-z/xeno 0.1.3 → 0.2.0

package/src/core/action-defaults.ts

@@ -0,0 +1,306 @@
+/** Adapted from Pi keybindings at 02eed88 (MIT). Platform-neutral defaults; overrides share scoped ownership. */
+export const ACTION_DEFAULTS = {
+  "editor.cursorUp": [
+    "up"
+  ],
+  "editor.cursorDown": [
+    "down"
+  ],
+  "tui.editor.historyPrevious": [],
+  "tui.editor.historyNext": [],
+  "editor.cursorLeft": [
+    "left",
+    "ctrl+b"
+  ],
+  "editor.cursorRight": [
+    "right",
+    "ctrl+f"
+  ],
+  "editor.cursorWordLeft": [
+    "alt+left",
+    "ctrl+left",
+    "alt+b"
+  ],
+  "editor.cursorWordRight": [
+    "alt+right",
+    "ctrl+right",
+    "alt+f"
+  ],
+  "editor.cursorLineStart": [
+    "home",
+    "ctrl+home",
+    "ctrl+a"
+  ],
+  "editor.cursorLineEnd": [
+    "end",
+    "ctrl+end",
+    "ctrl+e"
+  ],
+  "tui.editor.jumpForward": [
+    "ctrl+]"
+  ],
+  "tui.editor.jumpBackward": [
+    "ctrl+alt+]"
+  ],
+  "tui.editor.pageUp": [
+    "pageUp",
+    "ctrl+pageUp"
+  ],
+  "tui.editor.pageDown": [
+    "pageDown",
+    "ctrl+pageDown"
+  ],
+  "editor.deleteCharBackward": [
+    "backspace"
+  ],
+  "editor.deleteCharForward": [
+    "delete",
+    "ctrl+d"
+  ],
+  "editor.deleteWordBackward": [
+    "ctrl+w",
+    "alt+backspace"
+  ],
+  "editor.deleteWordForward": [
+    "alt+d",
+    "alt+delete"
+  ],
+  "editor.deleteToLineStart": [
+    "ctrl+u"
+  ],
+  "editor.deleteToLineEnd": [
+    "ctrl+k"
+  ],
+  "editor.yank": [
+    "ctrl+y"
+  ],
+  "tui.editor.yankPop": [
+    "alt+y"
+  ],
+  "editor.undo": [
+    "ctrl+-",
+    "ctrl+_"
+  ],
+  "editor.newLine": [
+    "shift+enter",
+    "ctrl+j"
+  ],
+  "editor.submit": [
+    "enter"
+  ],
+  "editor.complete": [
+    "tab"
+  ],
+  "tui.input.copy": [
+    "ctrl+c"
+  ],
+  "tui.select.up": [
+    "up"
+  ],
+  "tui.select.down": [
+    "down"
+  ],
+  "tui.select.pageUp": [
+    "pageUp"
+  ],
+  "tui.select.pageDown": [
+    "pageDown"
+  ],
+  "tui.select.confirm": [
+    "enter"
+  ],
+  "tui.select.cancel": [
+    "escape",
+    "ctrl+c"
+  ],
+  "tui.altScreen.pageUp": [
+    "pageUp"
+  ],
+  "tui.altScreen.pageDown": [
+    "pageDown"
+  ],
+  "tui.altScreen.halfPageUp": [],
+  "tui.altScreen.halfPageDown": [],
+  "tui.altScreen.lineUp": [],
+  "tui.altScreen.lineDown": [],
+  "tui.altScreen.previousPrompt": [
+    "ctrl+shift+up",
+    "ctrl+up"
+  ],
+  "tui.altScreen.nextPrompt": [
+    "ctrl+shift+down",
+    "ctrl+down"
+  ],
+  "tui.altScreen.search": [
+    "ctrl+shift+f"
+  ],
+  "tui.altScreen.searchNext": [
+    "enter",
+    "ctrl+g"
+  ],
+  "tui.altScreen.searchPrevious": [
+    "shift+enter",
+    "ctrl+shift+g"
+  ],
+  "tui.altScreen.searchClose": [
+    "escape"
+  ],
+  "tui.altScreen.top": [
+    "home"
+  ],
+  "tui.altScreen.bottom": [
+    "end"
+  ],
+  "app.interrupt": [
+    "escape"
+  ],
+  "app.clear": [
+    "ctrl+c"
+  ],
+  "app.exit": [
+    "ctrl+d"
+  ],
+  "app.suspend": [
+    "ctrl+z"
+  ],
+  "app.cycleThinking": [
+    "shift+tab"
+  ],
+  "app.saveDefault": [
+    "ctrl+s"
+  ],
+  "app.cycleModel": [
+    "ctrl+p"
+  ],
+  "app.cycleModelReverse": [
+    "shift+ctrl+p"
+  ],
+  "app.model": [
+    "ctrl+l"
+  ],
+  "app.toggleTools": [
+    "ctrl+o"
+  ],
+  "app.toggleThinking": [
+    "ctrl+t"
+  ],
+  "app.session.toggleNamedFilter": [
+    "ctrl+n"
+  ],
+  "app.externalEditor": [
+    "ctrl+g"
+  ],
+  "app.message.copy": [
+    "ctrl+x"
+  ],
+  "app.message.followUp": [
+    "alt+enter"
+  ],
+  "app.message.dequeue": [
+    "alt+up"
+  ],
+  "app.clipboard.pasteImage": [
+    "ctrl+v"
+  ],
+  "app.session.new": [],
+  "app.session.tree": [],
+  "app.session.fork": [],
+  "app.session.resume": [],
+  "app.tree.foldOrUp": [
+    "alt+left",
+    "ctrl+left"
+  ],
+  "app.tree.unfoldOrDown": [
+    "alt+right",
+    "ctrl+right"
+  ],
+  "app.tree.editLabel": [
+    "shift+l"
+  ],
+  "app.tree.toggleLabelTimestamp": [
+    "shift+t"
+  ],
+  "app.session.togglePath": [
+    "ctrl+p"
+  ],
+  "app.session.toggleSort": [
+    "ctrl+s"
+  ],
+  "app.session.rename": [
+    "ctrl+r"
+  ],
+  "app.session.delete": [
+    "ctrl+d"
+  ],
+  "app.session.deleteNoninvasive": [
+    "ctrl+backspace"
+  ],
+  "app.models.save": [
+    "ctrl+s"
+  ],
+  "app.models.enableAll": [
+    "ctrl+a"
+  ],
+  "app.models.clearAll": [
+    "ctrl+x"
+  ],
+  "app.models.toggleProvider": [
+    "ctrl+p"
+  ],
+  "app.models.reorderUp": [
+    "alt+up"
+  ],
+  "app.models.reorderDown": [
+    "alt+down"
+  ],
+  "app.tree.filter.default": [
+    "ctrl+d"
+  ],
+  "app.tree.filter.noTools": [
+    "ctrl+t"
+  ],
+  "app.tree.filter.userOnly": [
+    "ctrl+u"
+  ],
+  "app.tree.filter.labeledOnly": [
+    "ctrl+l"
+  ],
+  "app.tree.filter.all": [
+    "ctrl+a"
+  ],
+  "app.tree.filter.cycleForward": [
+    "ctrl+o"
+  ],
+  "app.tree.filter.cycleBackward": [
+    "shift+ctrl+o"
+  ]
+} as const;
+export const ACTION_ALIASES: Readonly<Record<string,string>> = {
+  "tui.input.submit": "editor.submit",
+  "tui.input.newLine": "editor.newLine",
+  "tui.input.tab": "editor.complete",
+  "app.model.select": "app.model",
+  "app.model.cycleForward": "app.cycleModel",
+  "app.model.cycleBackward": "app.cycleModelReverse",
+  "app.thinking.cycle": "app.cycleThinking",
+  "app.thinking.toggle": "app.toggleThinking",
+  "app.tools.expand": "app.toggleTools",
+  "app.editor.external": "app.externalEditor",
+  "app.thinking.save": "app.saveDefault",
+  "tui.editor.cursorUp": "editor.cursorUp",
+  "tui.editor.cursorDown": "editor.cursorDown",
+  "tui.editor.cursorLeft": "editor.cursorLeft",
+  "tui.editor.cursorRight": "editor.cursorRight",
+  "tui.editor.cursorWordLeft": "editor.cursorWordLeft",
+  "tui.editor.cursorWordRight": "editor.cursorWordRight",
+  "tui.editor.cursorLineStart": "editor.cursorLineStart",
+  "tui.editor.cursorLineEnd": "editor.cursorLineEnd",
+  "tui.editor.deleteCharBackward": "editor.deleteCharBackward",
+  "tui.editor.deleteCharForward": "editor.deleteCharForward",
+  "tui.editor.deleteWordBackward": "editor.deleteWordBackward",
+  "tui.editor.deleteWordForward": "editor.deleteWordForward",
+  "tui.editor.deleteToLineStart": "editor.deleteToLineStart",
+  "tui.editor.deleteToLineEnd": "editor.deleteToLineEnd",
+  "tui.editor.yank": "editor.yank",
+  "tui.editor.undo": "editor.undo"
+};

package/src/core/attachment-input.ts

@@ -0,0 +1,17 @@
+/** Only an entire list of image paths is a drop; ordinary prose and shell syntax remain literal. */
+export function droppedImagePaths(text: string): string[] | null {
+  const paths: string[] = [];
+  let token = "", quote = "", escaped = false;
+  for (const char of text.trim()) {
+    if (escaped) { token += char; escaped = false; }
+    else if (char === "\\" && quote !== "'") escaped = true;
+    else if (quote) { if (char === quote) quote = ""; else token += char; }
+    else if (char === "'" || char === '"') quote = char;
+    else if (/\s/.test(char)) { if (token) { paths.push(token); token = ""; } }
+    else token += char;
+  }
+  if (escaped || quote) return null;
+  if (token) paths.push(token);
+  return paths.length > 0 && paths.every(path => !/[\x00-\x1f]/.test(path) && !path.startsWith("@") &&
+    /\.(png|jpe?g|gif|webp|bmp)$/i.test(path) && !/[;$|<>`]/.test(path)) ? paths : null;
+}

package/src/core/catalog-merge.ts

@@ -0,0 +1,19 @@
+import { modelKey } from "./session-position.ts";
+
+/** D13: identity and selection are independent of provider SDKs and source order. */
+export function mergeCatalogs<T extends { provider: string; id: string }>(...layers: readonly (readonly T[])[]): T[] {
+  const models = new Map<string, T>();
+  for (const layer of layers) for (const model of layer) models.set(modelKey(model), model);
+  return [...models.values()];
+}
+
+/** Provider-local allow/deny patterns use literal characters plus '*' and '?'. */
+export function matchesModelPattern(id: string, pattern: string): boolean {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "u").test(id);
+}
+
+export function modelEnabled(id: string, allow?: readonly string[], deny?: readonly string[]): boolean {
+  return (allow === undefined || allow.some(pattern => matchesModelPattern(id, pattern)))
+    && !(deny?.some(pattern => matchesModelPattern(id, pattern)) ?? false);
+}

package/src/core/event-validation.ts

@@ -2,6 +2,7 @@
 import type { LogEvent, NodeRef } from "./events.ts";
 import { isExecutionOutcome } from "./outcome.ts";
 import { isJsonValue, isToolDiagnostic } from "./tool-contract.ts";
+import { validImageRef } from "./images.ts";
 
 export function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -23,11 +24,27 @@ export function isLogEvent(value: unknown): value is LogEvent {
   const carried = value["carried_from"];
   if (carried !== undefined && !(isRecord(carried) && natural(carried["node"]) && typeof carried["event"] === "string")) return false;
   const has = (...keys: string[]): boolean => keys.every((key) => typeof value[key] === "string");
+  const images = value["images"];
+  if (images !== undefined && (!Array.isArray(images) || !images.every(validImageRef))) return false;
   switch (value["t"]) {
+    case "extension": return has("customType", "content") && typeof value["display"] === "boolean" && typeof value["inContext"] === "boolean" && (value["data"] === undefined || isJsonValue(value["data"]));
     case "user": return has("text");
+    case "outcome": return has("reason") && isExecutionOutcome(value["outcome"]);
+    case "user_bash": {
+      const ref = value["content_ref"];
+      const outcome = value["outcome"];
+      if (!isExecutionOutcome(outcome) || !["tool_completed", "tool_failed", "cancelled", "timeout"].includes(outcome.reason)) return false;
+      if (outcome.reason === "tool_completed" && value["exit"] !== 0) return false;
+      if (outcome.reason === "tool_failed" && value["exit"] === 0) return false;
+      return has("command", "content") && Number.isInteger(value["exit"]) && typeof value["excludeFromContext"] === "boolean" &&
+        isRecord(ref) && typeof ref["sha256"] === "string" &&
+        typeof ref["path"] === "string" && natural(ref["bytes"]);
+    }
     case "guidance": return has("text") && ["continuation", "repetition", "budget", "boundary", "stall", "output_recovery", "completion_review", "churn", "deadline"].includes(String(value["reason"])) && strings(value["sources"]);
     case "interrupt": return has("user_id");
-    case "assistant": return (value["stop_reason"] === null || optionalString(value["stop_reason"])) && Array.isArray(value["blocks"]) && value["blocks"].every((b: unknown) => {
+    case "assistant": return (value["stop_reason"] === null || optionalString(value["stop_reason"])) &&
+      (value["replay_key"] === undefined || typeof value["replay_key"] === "string" && /^[a-f0-9]{64}$/.test(value["replay_key"])) &&
+      Array.isArray(value["blocks"]) && value["blocks"].every((b: unknown) => {
       if (!isRecord(b)) return false;
       if (b["type"] === "text") return typeof b["text"] === "string";
       if (b["type"] === "thinking") return typeof b["text"] === "string" && "raw" in b;
@@ -54,7 +71,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
         (effect["sha256_before"] === null || typeof effect["sha256_before"] === "string");
     }
     case "cut": return has("handoff_ref") && ["trigger", "hard_limit", "model_checkpoint"].includes(String(value["reason"])) &&
-      optionalString(value["retained_from"]) &&
+      optionalString(value["retained_from"]) && optionalString(value["next_context_ref"]) &&
       (value["next_node"] === undefined || natural(value["next_node"])) && optionalString(value["next_model"]) &&
       (value["handoff_tokens"] === undefined || (typeof value["handoff_tokens"] === "number" && Number.isFinite(value["handoff_tokens"]) && value["handoff_tokens"] > 0)) &&
       (value["predecessor"] === null || validNodeRef(value["predecessor"]));

package/src/core/events.ts

@@ -19,6 +19,7 @@
  */
 
 import type { ExecutionOutcome } from "./outcome.ts";
+import type { ImageRef } from "./images.ts";
 import type { JsonValue, ToolDiagnostic } from "./tool-contract.ts";
 
 export type EventId = string;
@@ -78,6 +79,29 @@ export interface UserEvent {
   id: EventId;
   at: IsoTime;
   text: string;
+  images?: readonly ImageRef[];
+}
+
+/** User-authorized shell execution is distinct from a model tool invocation (Pi !/!!). */
+export interface UserBashEvent {
+  t: "user_bash";
+  id: EventId;
+  at: IsoTime;
+  command: string;
+  content: string;
+  exit: number;
+  excludeFromContext: boolean;
+  outcome: ExecutionOutcome;
+  content_ref: ArtifactRef;
+}
+
+/** A terminal execution fact; human history must not turn a truncated answer into success. */
+export interface OutcomeEvent {
+  t: "outcome";
+  id: EventId;
+  at: IsoTime;
+  reason: string;
+  outcome: ExecutionOutcome;
 }
 
 /** A factual harness notice, appended once rather than rewriting the prompt (N.1). */
@@ -119,7 +143,7 @@ export interface InterruptEvent {
  * what a UI renders.
  */
 export type AssistantBlock =
-  | { type: "text"; text: string }
+  | { type: "text"; text: string; wire?: unknown }
   | { type: "thinking"; text: string; raw: unknown }
   /**
    * `wire` is the provider's own per-call data beyond id, name and arguments
@@ -134,6 +158,8 @@ export interface AssistantEvent {
   blocks: readonly AssistantBlock[];
   /** N.12: provider-observed termination, never a claim of task completion. Legacy logs omit it. */
   stop_reason?: string | null;
+  /** D8: opaque digest of the wire profile that produced signed blocks; no credentials. */
+  replay_key?: string;
 }
 
 export interface ToolResultEvent {
@@ -144,6 +170,7 @@ export interface ToolResultEvent {
   ok: boolean;
   /** What the model sees. Large payloads belong on disk, referenced by effect. */
   content: string;
+  images?: readonly ImageRef[];
   /** Digest of the complete observation, even when it fits inline in the log. */
   content_sha256?: Sha256;
   /** O.3: semantic observation digest excludes presentation metadata. */
@@ -170,6 +197,12 @@ export interface CutEvent {
   /** Durable transition intent; recovery opens this exact successor. */
   next_node?: number;
   next_model?: string;
+  /** Paired with next_model so crash recovery preserves the selected provider. */
+  next_provider?: string;
+  /** The successor request effort is durable even if the adapter has not been installed. */
+  next_thinking?: string;
+  /** D6: resource reload activates this frozen context only in the successor. */
+  next_context_ref?: Sha256;
   /** V2 carried-state budget, fixed in the log for identical replay. */
   handoff_tokens?: number;
   /** N.8: first retained event on the effective ancestry; no copied transcript. */
@@ -439,8 +472,18 @@ export interface EvidenceLinkEvent {
   carried_from?: CarriedFrom;
 }
 
+/** Extension state is append-only data; only explicit messages enter either projection (D1). */
+export interface ExtensionEvent {
+  t: "extension"; id: string; at: string; customType: string;
+  content: string; display: boolean; inContext: boolean;
+  data?: import("./tool-contract.ts").JsonValue;
+}
+
 export type LogEvent =
+  | ExtensionEvent
   | UserEvent
+  | UserBashEvent
+  | OutcomeEvent
   | GuidanceEvent
   | InterruptEvent
   | AssistantEvent
@@ -462,7 +505,7 @@ export type LogEvent =
   | WorkStatusEvent;
 
 export const HARNESS_EVENTS = [
-  "user", "guidance", "interrupt", "assistant", "tool_result", "cut", "snapshot", "rewind",
+  "user", "user_bash", "outcome", "guidance", "interrupt", "assistant", "tool_result", "cut", "snapshot", "rewind", "extension",
 ] as const;
 export const MODEL_EVENTS = [
   "claim", "decision", "pitfall", "blocked", "question", "next_action", "work_status", "evidence_link",

package/src/core/export.ts

@@ -13,6 +13,7 @@
 
 import type { AssistantBlock, LogEvent } from "./events.ts";
 import { assertNever } from "./exhaustive.ts";
+import { imageDescription } from "./images.ts";
 
 export interface HtmlMeta {
   title: string;
@@ -90,8 +91,11 @@ function escapeHtml(s: string): string {
 
 function eventHtml(e: LogEvent): string {
   switch (e.t) {
+    case "extension": return e.display ? wrap("event", e.customType, e.at, e.content || JSON.stringify(e.data)) : "";
     case "user":
-      return wrap("user", "user", e.at, e.text);
+      return wrap("user", "user", e.at, [e.text, ...(e.images ?? []).map(imageDescription)].join("\n"));
+    case "user_bash": return wrap("tool", e.excludeFromContext ? "user bash (excluded)" : "user bash", e.at, `$ ${e.command}\n${e.content}`);
+    case "outcome": return wrap("event", e.outcome.status, e.at, `${e.outcome.reason}: ${e.reason}`);
     case "guidance":
       return wrap("event", `harness ${e.reason}`, e.at, e.text);
     case "assistant":
@@ -99,7 +103,7 @@ function eventHtml(e: LogEvent): string {
     case "interrupt":
       return wrap("event", "interrupt", e.at, `cancelled ${e.user_id}`);
     case "tool_result":
-      return wrap("tool", `tool_result ${e.ok ? "ok" : "fail"}`, e.at, e.content);
+      return wrap("tool", `tool_result ${e.ok ? "ok" : "fail"}`, e.at, [e.content, ...(e.images ?? []).map(imageDescription)].join("\n"));
     case "cut":
       return wrap("event", "cut", e.at, `${e.reason} → ${e.handoff_ref}`);
     case "snapshot":

package/src/core/extension-flags.ts

@@ -0,0 +1,14 @@
+/** Typed extension flags are data; factories and the final CLI pass share their interpretation. */
+export interface ExtensionFlag { type: "string" | "boolean"; description?: string; default?: string | boolean }
+export interface FlagInput { value?: string; inline: boolean }
+export function extensionFlagValue(name: string, definition: ExtensionFlag, input?: FlagInput): string | boolean | undefined {
+  if (!input) return definition.default;
+  if (definition.type === "string") {
+    if (input.value === undefined) throw new Error(`--${name} requires a string value`);
+    return input.value;
+  }
+  if (input.value === "true") return true;
+  if (input.value === "false") return false;
+  if (input.inline) throw new Error(`--${name} requires true or false`);
+  return true;
+}

package/src/core/images.ts

@@ -0,0 +1,46 @@
+/** Immutable attachment metadata; D8 stores bytes once and projects references without I/O. */
+export interface ImageRef {
+  readonly sha256: string;
+  readonly mimeType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+  readonly width: number;
+  readonly height: number;
+  readonly bytes: number;
+  readonly name: string;
+  /** Submission-time policy; enabling images later cannot rewrite an earlier request prefix. */
+  readonly blocked?: true;
+  readonly original?: { readonly sha256: string; readonly width: number; readonly height: number };
+}
+export interface ImageContent { readonly type: "image"; readonly image: ImageRef; readonly data?: string }
+export type UserInput = string | { readonly text: string; readonly images?: readonly ImageRef[] };
+export function validImageRef(value: unknown): value is ImageRef {
+  if (!value || typeof value !== "object") return false;
+  const v = value as Record<string, unknown>;
+  const digest = (s: unknown) => typeof s === "string" && /^[a-f0-9]{64}$/.test(s);
+  const positive = (n: unknown) => typeof n === "number" && Number.isSafeInteger(n) && n > 0;
+  if (v["blocked"] !== undefined && v["blocked"] !== true) return false;
+  if (!digest(v["sha256"]) || !positive(v["width"]) || !positive(v["height"]) || !positive(v["bytes"]) ||
+      typeof v["name"] !== "string" || !["image/png", "image/jpeg", "image/gif", "image/webp"].includes(String(v["mimeType"]))) return false;
+  if (v["original"] === undefined) return true;
+  if (!v["original"] || typeof v["original"] !== "object") return false;
+  const o = v["original"] as Record<string, unknown>;
+  return digest(o["sha256"]) && positive(o["width"]) && positive(o["height"]);
+}
+export function submissionImages(images: readonly ImageRef[], blocked: boolean): ImageRef[] {
+  return images.map(image => {
+    if (!validImageRef(image)) throw new Error("Invalid image reference");
+    const { sha256, mimeType, width, height, bytes, name, original } = image;
+    return { sha256, mimeType, width, height, bytes, name, ...(original ? { original } : {}), ...(blocked ? { blocked: true as const } : {}) };
+  });
+}
+export function userInputData(input: UserInput, blocked?: boolean): { text: string; images?: readonly ImageRef[] } {
+  return typeof input === "string" ? { text: input } : { text: input.text,
+    ...(input.images?.length ? { images: blocked === undefined ? input.images : submissionImages(input.images, blocked) } : {}) };
+}
+export function imageDescription(image: ImageRef): string {
+  const original = image.original;
+  return `[Image: ${image.name}, ${image.width}x${image.height}${original ? `; original ${original.width}x${original.height}, coordinate scale ${(original.width / image.width).toFixed(2)}` : ""}]`;
+}
+/** Assumption, not provider billing: 32px patches plus framing; anchors replace this after the response. */
+export function estimateImageTokens(image: Pick<ImageRef, "width" | "height">): number {
+  return 256 + Math.ceil(image.width / 32) * Math.ceil(image.height / 32) * 2;
+}

package/src/core/json-event.ts

@@ -22,6 +22,7 @@ export type JsonLoopKind =
   | "text_delta"
   | "thinking_delta"
   | "discard"
+  | "progress"
   | "tool_call"
   | "tool_result"
   | "usage"
@@ -67,6 +68,7 @@ export function toJsonEvent(e: JsonLoopEvent, at: string): Record<string, unknow
     case "text_delta":
     case "thinking_delta":
     case "discard":
+    case "progress":
       return null;
     case "assistant_text":
       return { type: "assistant_text", text: e.text ?? "", at };