@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/web-ui/app/components/config-workspace/workspace-mutations.js

@@ -29,6 +29,8 @@ export function createConfigWorkspaceMutations({
   setWorkspaceStatus,
   syncDirtyPresentation,
 }) {
+  let discardRequest = 0;
+
   function mutateConfigFile(kind, id, mutator, options = {}) {
     const file = findConfigFile(kind, id);
     if (!file) return;
@@ -79,7 +81,8 @@ export function createConfigWorkspaceMutations({
     renderConfigDashboard();
   }
 
-  function prepareDiscardChanges(reason = "leave configuration") {
+  async function prepareDiscardChanges(reason = "leave configuration") {
+    discardRequest += 1;
     if (state.externalRuntimeMutationInFlight) {
       setWorkspaceStatus(
         `Wait for the current Runtime update before you ${reason}.`,
@@ -97,13 +100,14 @@ export function createConfigWorkspaceMutations({
     const changed = dirtyFiles();
     if (!changed.length) return prepareConfigDiscardCommit(false);
     const count = changed.length;
-    const confirmed = confirmDiscard(
+    const discard = prepareConfigDiscardCommit(true);
+    const confirmed = await confirmDiscard(
       `Discard unsaved changes in ${count} config ${
         count === 1 ? "file" : "files"
       } and ${reason}?`,
     );
-    if (!confirmed) return null;
-    return prepareConfigDiscardCommit(true);
+    if (!confirmed || !discard.canCommit()) return null;
+    return discard;
   }
 
   function configDraftFingerprint() {
@@ -114,10 +118,16 @@ export function createConfigWorkspaceMutations({
   }
 
   function prepareConfigDiscardCommit(hasChanges) {
+    const request = discardRequest;
     const dashboard = state.configDashboard;
     const fingerprint = configDraftFingerprint();
-    const commit = () => { if (hasChanges) discardAllChanges(); };
+    const commit = () => {
+      if (!commit.canCommit()) return false;
+      if (hasChanges) discardAllChanges();
+      return true;
+    };
     commit.canCommit = () => {
+      if (request !== discardRequest) return false;
       if (state.externalRuntimeMutationInFlight) return false;
       if (state.savingKeys.size > 0) return false;
       if (state.configDashboard !== dashboard) return false;
@@ -126,9 +136,9 @@ export function createConfigWorkspaceMutations({
     return commit;
   }
 
-  function confirmDiscardChanges(reason = "leave configuration") {
-    const discardChanges = prepareDiscardChanges(reason);
-    if (!discardChanges) return false;
+  async function confirmDiscardChanges(reason = "leave configuration") {
+    const discardChanges = await prepareDiscardChanges(reason);
+    if (!discardChanges || !discardChanges.canCommit()) return false;
     discardChanges();
     return true;
   }
@@ -197,13 +207,16 @@ export function createConfigWorkspaceMutations({
     }
   }
 
-  function keepOrDiscardCurrentRawDraft(currentFile, select) {
+  async function keepOrDiscardCurrentRawDraft(currentFile, select) {
+    discardRequest += 1;
     if (!currentFile || !hasRawDraftChanges(currentFile)) return true;
-    const confirmed = confirmDiscard(
+    const original = prepareConfigDiscardCommit(false);
+    const confirmed = await confirmDiscard(
       `Discard the unapplied raw draft for ${textOf(
         currentFile.label || currentFile.id,
       )}?`,
     );
+    if (!original.canCommit()) return false;
     if (!confirmed) {
       select.value = state.selectedRawConfigKey;
       return false;
@@ -217,9 +230,16 @@ export function createConfigWorkspaceMutations({
     return true;
   }
 
-  function changeRawFile(nextKey, select) {
+  async function changeRawFile(nextKey, select) {
     const currentFile = selectedRawConfigFile();
-    if (!keepOrDiscardCurrentRawDraft(currentFile, select)) return;
+    const dashboard = state.configDashboard;
+    const currentKey = state.selectedRawConfigKey;
+    const pending = keepOrDiscardCurrentRawDraft(currentFile, select);
+    const request = discardRequest;
+    if (!await pending) return;
+    if (request !== discardRequest) return;
+    if (dashboard !== state.configDashboard) return;
+    if (currentKey !== state.selectedRawConfigKey) return;
     state.selectedRawConfigKey = nextKey;
     syncDirtyPresentation({ syncRawEditor: true });
   }

package/dist/src/web-ui/app/components/config-workspace/workspace-persistence.js

@@ -78,7 +78,7 @@ export function createConfigWorkspacePersistence({
 
   async function loadRuntimeConfig(options = {}) {
     const protectUnsaved = options.protectUnsaved !== false;
-    if (protectUnsaved && !confirmDiscardChanges("refresh configuration")) {
+    if (protectUnsaved && !await confirmDiscardChanges("refresh configuration")) {
       return false;
     }
     if (options.clearBeforeLoad === true) {

package/dist/src/web-ui/app/components/config-workspace.js

@@ -1,3 +1,4 @@
+import { confirmDialog } from "./confirmation-dialog.js";
 import { createModelPluginViewState } from "./config-workspace/model-plugin-view-state.js";
 import { createConfigCalibrationDisclosure } from "./config-workspace/calibration-disclosure.js";
 import { createConfigDashboardRendering } from "./config-workspace/dashboard-rendering.js";
@@ -33,7 +34,7 @@ export function createConfigWorkspace({
   onRemoveModel,
   onNavigationChange = () => {},
   recordControlEvent,
-  confirmDiscard = (message) => window.confirm(message),
+  confirmDiscard = (message) => confirmDialog(message, { title: "Discard configuration changes", confirmLabel: "Discard changes", tone: "danger" }),
   eventTarget = window,
 }) {
   const workspaceModel = createConfigWorkspaceModel();

package/dist/src/web-ui/app/components/confirmation-dialog.js

@@ -0,0 +1,88 @@
+const dialogs = new WeakMap();
+let nextDialogId = 0;
+
+/** Shared, non-blocking confirmation. Overlapping requests fail closed. */
+export function createConfirmationDialog({ documentRoot = globalThis.document } = {}) {
+  const dialog = documentRoot.createElement("dialog");
+  const id = `confirmation-${++nextDialogId}`;
+  dialog.className = "confirmation-dialog";
+  dialog.setAttribute("aria-labelledby", `${id}-title`);
+  dialog.setAttribute("aria-describedby", `${id}-description`);
+  dialog.innerHTML = `<div class="confirmation-content">
+    <header class="confirmation-heading"><h2 id="${id}-title"></h2>
+      <button type="button" class="confirmation-close" aria-label="Close confirmation">×</button></header>
+    <p id="${id}-description" class="confirmation-description"></p>
+    <footer class="confirmation-actions"><button type="button" data-confirmation-cancel>Cancel</button>
+      <button type="button" data-confirmation-accept>Continue</button></footer>
+  </div>`;
+  documentRoot.body.append(dialog);
+  const heading = dialog.querySelector("h2");
+  const description = dialog.querySelector(".confirmation-description");
+  const cancel = dialog.querySelector("[data-confirmation-cancel]");
+  const accept = dialog.querySelector("[data-confirmation-accept]");
+  let pending;
+  let returnFocus;
+  let destroyed = false;
+
+  function finish(approved) {
+    if (!pending) return;
+    const resolve = pending;
+    pending = undefined;
+    if (dialog.open) dialog.close();
+    if (returnFocus?.isConnected && !returnFocus.closest("[hidden], [inert]")) returnFocus.focus();
+    returnFocus = undefined;
+    resolve(approved);
+  }
+  cancel.addEventListener("click", () => finish(false));
+  dialog.querySelector(".confirmation-close").addEventListener("click", () => finish(false));
+  accept.addEventListener("click", () => finish(true));
+  dialog.addEventListener("keydown", (event) => {
+    if (event.key !== "Escape" || event.isComposing) return;
+    event.preventDefault();
+    event.stopPropagation();
+    finish(false);
+  });
+  dialog.addEventListener("cancel", (event) => { event.preventDefault(); finish(false); });
+  // A delayed close event from the previous request must not cancel a newly opened one.
+  dialog.addEventListener("close", () => { if (!dialog.open) finish(false); });
+  const onPageHide = () => finish(false);
+  documentRoot.defaultView?.addEventListener("pagehide", onPageHide);
+
+  return {
+    confirm(message, { title = "Confirm action", confirmLabel = "Continue", tone = "default" } = {}) {
+      if (pending || destroyed) return Promise.resolve(false);
+      heading.textContent = title;
+      description.textContent = message;
+      accept.textContent = confirmLabel;
+      dialog.dataset.tone = tone === "danger" ? "danger" : "default";
+      returnFocus = documentRoot.activeElement;
+      return new Promise((resolve) => {
+        pending = resolve;
+        try {
+          dialog.showModal();
+          cancel.focus();
+        } catch {
+          finish(false);
+        }
+      });
+    },
+    cancel() { finish(false); },
+    destroy() {
+      destroyed = true;
+      finish(false);
+      documentRoot.defaultView?.removeEventListener("pagehide", onPageHide);
+      dialog.remove();
+    },
+  };
+}
+
+export function confirmDialog(message, options) {
+  const documentRoot = globalThis.document;
+  if (!documentRoot?.body) return Promise.resolve(false);
+  let instance = dialogs.get(documentRoot);
+  if (!instance) {
+    instance = createConfirmationDialog({ documentRoot });
+    dialogs.set(documentRoot, instance);
+  }
+  return instance.confirm(message, options);
+}

package/dist/src/web-ui/app/components/conversation-activity.d.ts

@@ -1,3 +1,4 @@
+import type { MemoryActivity } from "../lib/memory-activity-model.js";
 import type { ContextWindowDisplay } from "../lib/context-window-state.js";
 import type { ConversationFileReference } from "../lib/conversation-file-reference.js";
 import type { buildConversationRoleCards } from "../lib/conversation-role-model.js";
@@ -25,6 +26,7 @@ export declare function buildConversationActivityModel(
 ): {
   requestId: string;
   events: ConversationActivityEvent[];
+  memoryActivities: MemoryActivity[];
   roleCards: ReturnType<typeof buildConversationRoleCards>;
   sources: ConversationSourcesGroup[];
   toolActions: ConversationToolAction[];

package/dist/src/web-ui/app/components/conversation-activity.js

@@ -16,6 +16,8 @@ import {
   summarizeConversationTools,
 } from "../lib/tool-activity-model.js";
 import { isNonToolTimelineEvent } from "../lib/tool-timeline.js";
+import { buildMemoryActivities, isMemoryRetrievalEvent } from "../lib/memory-activity-model.js";
+import { createConversationMemoryActivity } from "./conversation-memory-activity.js";
 
 function textOf(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
@@ -113,6 +115,7 @@ export function buildConversationActivityModel({
     return {
       requestId: "",
       events: [],
+      memoryActivities: [],
       roleCards: [],
       sources: [],
       toolActions: [],
@@ -134,7 +137,12 @@ export function buildConversationActivityModel({
         .map(presentEvent)
     : [];
   const toolCount = countToolInvocations(scopedEvents);
-  const timeline = buildEventTimelineEntries(scopedEvents);
+  const memoryActivities = buildMemoryActivities({
+    requestId: normalizedRequestId, events: scopedEvents, streaming,
+  });
+  const timeline = buildEventTimelineEntries(scopedEvents.filter(
+    (event) => !isMemoryRetrievalEvent(event),
+  ));
   const progress = normalizeProgress(taskProgress, normalizedRequestId);
   const contextWindowModel = projectContextWindowDisplay(
     contextWindow,
@@ -155,6 +163,7 @@ export function buildConversationActivityModel({
   return {
     requestId: normalizedRequestId,
     events: timeline,
+    memoryActivities,
     roleCards: buildConversationRoleCards({
       requestId: normalizedRequestId,
       events: scopedEvents,
@@ -179,7 +188,7 @@ export function buildConversationActivityModel({
         "Working"
       : "",
     openByDefault: Boolean(streaming),
-    hasContent: Boolean(progress || timeline.length > 0),
+    hasContent: Boolean(progress || timeline.length > 0 || memoryActivities.length > 0),
   };
 }
 
@@ -263,6 +272,25 @@ export function createConversationActivity({
   function createNode(input = {}) {
     const model = buildConversationActivityModel(input);
     if (!model.hasContent) return null;
+    if (model.roleCards.length > 0) return createActivityNode(model);
+    const memory = createConversationMemoryActivity({
+      documentRoot, activities: model.memoryActivities,
+    });
+    const bubble = documentRoot.createElement("div");
+    bubble.className = "conversation-role-message conversation-memory-bubble";
+    bubble.dataset.requestId = model.requestId;
+    if (memory) bubble.appendChild(memory);
+    if (!model.events.length && !model.progress) return bubble;
+    const activity = createActivityNode(model);
+    if (!memory) return activity;
+    const group = documentRoot.createElement("div");
+    group.className = "conversation-activity-group";
+    group.dataset.requestId = model.requestId;
+    group.append(bubble, activity);
+    return group;
+  }
+
+  function createActivityNode(model) {
     const hasFailures = model.failureCount > 0;
     const hasRoleCards = model.roleCards.length > 0;
 
@@ -352,12 +380,13 @@ export function createConversationActivity({
 
     const body = documentRoot.createElement("div");
     body.className = "conversation-activity-body";
-    if (model.events.length > 0) {
+    if (model.events.length > 0 || hasRoleCards) {
       const timelineEvents = model.events.filter(isNonToolTimelineEvent);
       body.appendChild(
         roleCards.createNode({
           requestId: model.requestId,
           cards: model.roleCards,
+          memoryActivities: model.memoryActivities,
           heading: summary,
           timeline: renderTimeline(documentRoot, timelineEvents),
           hasTimeline: timelineEvents.length > 0,

package/dist/src/web-ui/app/components/conversation-memory-activity.js

@@ -0,0 +1,31 @@
+export function createConversationMemoryActivity({
+  documentRoot = document,
+  activities = [],
+} = {}) {
+  if (activities.length === 0) return null;
+  const section = documentRoot.createElement("section");
+  section.className = "conversation-memory-activity";
+  section.setAttribute("aria-label", "Memory activity");
+  for (const activity of activities) {
+    const row = documentRoot.createElement("div");
+    row.className = "conversation-memory-row";
+    row.dataset.state = activity.state;
+    const icon = documentRoot.createElement("span");
+    icon.className = "conversation-memory-icon";
+    icon.setAttribute("aria-hidden", "true");
+    icon.innerHTML = '<svg viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="1.35" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="10" cy="4.5" rx="6" ry="2.5"/><path d="M4 4.5v10c0 1.4 2.7 2.5 6 2.5s6-1.1 6-2.5v-10M4 9.5c0 1.4 2.7 2.5 6 2.5s6-1.1 6-2.5"/></svg>';
+    const label = documentRoot.createElement("span");
+    label.className = "conversation-memory-label";
+    label.textContent = activity.label;
+    row.append(icon, label);
+    if (activity.detail) {
+      const detail = documentRoot.createElement("span");
+      detail.className = "conversation-memory-detail";
+      detail.setAttribute("dir", "auto");
+      detail.textContent = activity.detail;
+      row.appendChild(detail);
+    }
+    section.appendChild(row);
+  }
+  return section;
+}

package/dist/src/web-ui/app/components/conversation-role-cards.d.ts

@@ -1,5 +1,6 @@
 import type { ConversationFileReference } from "../lib/conversation-file-reference.js";
 import type { buildConversationRoleCards } from "../lib/conversation-role-model.js";
+import type { MemoryActivity } from "../lib/memory-activity-model.js";
 
 export declare function createConversationRoleCards(options?: {
   documentRoot?: Document;
@@ -12,6 +13,7 @@ export declare function createConversationRoleCards(options?: {
   createNode(input: {
     requestId: string;
     cards: ReturnType<typeof buildConversationRoleCards>;
+    memoryActivities?: MemoryActivity[];
     heading?: HTMLElement;
     timeline: HTMLElement;
     hasTimeline: boolean;

package/dist/src/web-ui/app/components/conversation-role-cards.js

@@ -1,4 +1,8 @@
+import { createConversationSkillActivity } from "./conversation-skill-activity.js";
+import { createConversationMemoryActivity } from "./conversation-memory-activity.js";
 import { createConversationTools } from "./conversation-tools.js";
+import { createConversationRoleDelegations } from "./conversation-role-delegations.js";
+import { createConversationRoleReturns } from "./conversation-role-returns.js";
 
 const ROLE_INITIALS = {
   supervisor: "S",
@@ -16,6 +20,8 @@ export function createConversationRoleCards({
   const timelineRequests = new Set();
   const timelineToggles = new Map();
   const toolsByRequest = new Map();
+  const delegations = createConversationRoleDelegations({ documentRoot });
+  const returns = createConversationRoleReturns({ documentRoot });
   let panelSequence = 0;
 
   function element(tag, className, text = "") {
@@ -66,7 +72,7 @@ export function createConversationRoleCards({
     }
   }
 
-  function renderCard(requestId, card) {
+  function renderCard(requestId, card, memoryActivities = []) {
     const row = element("li", `conversation-role-card is-${card.tone}`);
     row.dataset.role = card.role;
     row.dataset.cardId = card.id;
@@ -97,6 +103,22 @@ export function createConversationRoleCards({
     }
     content.appendChild(header);
     const message = element("div", "conversation-role-message");
+    const memory = createConversationMemoryActivity({ documentRoot, activities: memoryActivities });
+    if (memory) message.appendChild(memory);
+    const skillActivity = createConversationSkillActivity({
+      documentRoot, activities: card.skillActivities,
+    });
+    if (skillActivity) message.appendChild(skillActivity);
+    if (card.role === "supervisor") {
+      const history = delegations.createNode({
+        requestId, delegations: card.delegations || [],
+      });
+      if (history) message.appendChild(history);
+    }
+    if (card.role === "planner") {
+      const history = returns.createNode({ requestId, returns: card.returns || [] });
+      if (history) message.appendChild(history);
+    }
     if (card.summary) {
       const summary = element("p", "conversation-role-summary");
       summary.append(
@@ -133,6 +155,7 @@ export function createConversationRoleCards({
   function createNode({
     requestId,
     cards,
+    memoryActivities = [],
     heading,
     timeline,
     hasTimeline,
@@ -161,7 +184,10 @@ export function createConversationRoleCards({
     toggle.setAttribute("aria-controls", panel.id);
     const list = element("ol", "conversation-role-list");
     list.setAttribute("aria-label", "Request agents");
-    for (const card of cards) list.appendChild(renderCard(requestId, card));
+    for (const card of cards) {
+      const requestMemory = card === cards[0] ? memoryActivities : [];
+      list.appendChild(renderCard(requestId, card, requestMemory));
+    }
     panel.append(list, timeline);
     section.append(panel, toolbar);
 
@@ -187,6 +213,8 @@ export function createConversationRoleCards({
   }
 
   function forget(requestId) {
+    delegations.forget(requestId);
+    returns.forget(requestId);
     timelineRequests.delete(requestId);
     timelineToggles.delete(requestId);
     const tools = toolsByRequest.get(requestId);
@@ -195,6 +223,8 @@ export function createConversationRoleCards({
   }
 
   function reset() {
+    delegations.reset();
+    returns.reset();
     timelineRequests.clear();
     timelineToggles.clear();
     for (const tools of toolsByRequest.values()) {

package/dist/src/web-ui/app/components/conversation-role-delegations.d.ts

@@ -0,0 +1,12 @@
+import type { RoleDelegation } from "../lib/role-delegation-event.js";
+
+export declare function createConversationRoleDelegations(options?: {
+  documentRoot?: Document;
+}): {
+  createNode(input: {
+    requestId: string;
+    delegations?: RoleDelegation[];
+  }): HTMLElement | null;
+  forget(requestId: string): void;
+  reset(): void;
+};

package/dist/src/web-ui/app/components/conversation-role-delegations.js

@@ -0,0 +1,24 @@
+import { titleCaseEventValue } from "../lib/event-presentation.js";
+import { createConversationRoleHistory } from "./conversation-role-history.js";
+
+export function createConversationRoleDelegations({ documentRoot = document } = {}) {
+  const history = createConversationRoleHistory({
+    documentRoot,
+    kind: "delegation",
+    textClassName: "conversation-role-delegation-objective",
+    ariaLabel: "Delegated work",
+  });
+
+  function createNode({ requestId, delegations = [] }) {
+    return history.createNode({
+      requestId,
+      items: delegations.map((delegation) => ({
+        id: delegation.id,
+        label: `Delegated to ${titleCaseEventValue(delegation.childRole)}`,
+        text: delegation.objective,
+      })),
+    });
+  }
+
+  return { createNode, forget: history.forget, reset: history.reset };
+}

package/dist/src/web-ui/app/components/conversation-role-history.d.ts

@@ -0,0 +1,13 @@
+export declare function createConversationRoleHistory(options: {
+  documentRoot?: Document;
+  kind: "delegation" | "return";
+  textClassName: string;
+  ariaLabel: string;
+}): {
+  createNode(input: {
+    requestId: string;
+    items?: { id: string; label: string; text: string }[];
+  }): HTMLElement | null;
+  forget(requestId: string): void;
+  reset(): void;
+};

package/dist/src/web-ui/app/components/conversation-role-history.js

@@ -0,0 +1,81 @@
+export function createConversationRoleHistory({
+  documentRoot = document,
+  kind,
+  textClassName,
+  ariaLabel,
+}) {
+  const requests = new Map();
+  const prefix = `conversation-role-${kind}`;
+
+  function element(tag, className, text = "") {
+    const node = documentRoot.createElement(tag);
+    node.className = className;
+    node.textContent = text;
+    return node;
+  }
+
+  function requestState(requestId) {
+    const existing = requests.get(requestId);
+    if (existing) return existing;
+    const state = { expanded: new Set(), nodes: new Map() };
+    requests.set(requestId, state);
+    return state;
+  }
+
+  function isCurrentDisclosure(requestId, state, id, node) {
+    if (requests.get(requestId) !== state) return false;
+    return state.nodes.get(id) === node;
+  }
+
+  function historyRow(requestId, state, item) {
+    const row = element("li", `${prefix}-row`);
+    const details = element("details", `conversation-role-history-item ${prefix}`);
+    details.dataset[`${kind}Id`] = item.id;
+    details.open = state.expanded.has(item.id);
+    state.nodes.set(item.id, details);
+    const summary = element("summary", `conversation-role-history-toggle ${prefix}-toggle`);
+    const label = element("span", `conversation-role-history-label ${prefix}-label`, item.label);
+    const chevron = element("span", `conversation-role-history-chevron ${prefix}-chevron`, "⌄");
+    chevron.setAttribute("aria-hidden", "true");
+    const text = element("span", `conversation-role-history-text ${textClassName}`, item.text);
+    text.setAttribute("dir", "auto");
+    summary.append(label, chevron, text);
+    details.appendChild(summary);
+    details.addEventListener("toggle", () => {
+      if (!isCurrentDisclosure(requestId, state, item.id, details)) return;
+      if (details.open) {
+        state.expanded.add(item.id);
+        return;
+      }
+      state.expanded.delete(item.id);
+    });
+    row.appendChild(details);
+    return row;
+  }
+
+  function createNode({ requestId, items = [] }) {
+    requests.get(requestId)?.nodes.clear();
+    if (items.length === 0) return null;
+    const state = requestState(requestId);
+    const identities = new Set(items.map((item) => item.id));
+    for (const id of state.expanded) {
+      if (!identities.has(id)) state.expanded.delete(id);
+    }
+    const list = element("ol", `conversation-role-history ${prefix}s`);
+    list.setAttribute("aria-label", ariaLabel);
+    for (const item of items) {
+      list.appendChild(historyRow(requestId, state, item));
+    }
+    return list;
+  }
+
+  function forget(requestId) {
+    requests.delete(requestId);
+  }
+
+  function reset() {
+    requests.clear();
+  }
+
+  return { createNode, forget, reset };
+}

package/dist/src/web-ui/app/components/conversation-role-returns.d.ts

@@ -0,0 +1,12 @@
+import type { RoleReturn } from "../lib/role-return-event.js";
+
+export declare function createConversationRoleReturns(options?: {
+  documentRoot?: Document;
+}): {
+  createNode(input: {
+    requestId: string;
+    returns?: RoleReturn[];
+  }): HTMLElement | null;
+  forget(requestId: string): void;
+  reset(): void;
+};

package/dist/src/web-ui/app/components/conversation-role-returns.js

@@ -0,0 +1,23 @@
+import { createConversationRoleHistory } from "./conversation-role-history.js";
+
+export function createConversationRoleReturns({ documentRoot = document } = {}) {
+  const history = createConversationRoleHistory({
+    documentRoot,
+    kind: "return",
+    textClassName: "conversation-role-return-summary",
+    ariaLabel: "Planner results",
+  });
+
+  function createNode({ requestId, returns = [] }) {
+    return history.createNode({
+      requestId,
+      items: returns.map((receipt) => ({
+        id: receipt.id,
+        label: receipt.outcome === "failed" ? "Planner failed" : "Returned result",
+        text: receipt.summary,
+      })),
+    });
+  }
+
+  return { createNode, forget: history.forget, reset: history.reset };
+}