@abot-ai/runtime 1.9.0 → 2.0.0

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

@@ -0,0 +1,113 @@
+import {
+  effectiveReasoningBudgetEffort,
+  isTokenBudgetModel,
+  reasoningBudgetStatusText,
+} from "./reasoning-budget.js";
+
+function isReasoningGenerationPath(path) {
+  if (!Array.isArray(path)) return false;
+  if (path.length === 1) return path[0] === "generation";
+  if (path.length !== 3) return false;
+  return path[0] === "calibration" && typeof path[1] === "string" &&
+    path[2] === "generation";
+}
+
+function budgetEditGenerationPath(path) {
+  const budgetIndex = path.lastIndexOf("reasoningBudget");
+  if (budgetIndex < 0) return undefined;
+  const generation = path.slice(0, budgetIndex);
+  return isReasoningGenerationPath(generation) ? generation : undefined;
+}
+
+function reasoningStatusGenerationPath(element) {
+  try {
+    const path = JSON.parse(element.dataset.reasoningGenerationPath);
+    return isReasoningGenerationPath(path) ? path : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function generationCalibration(file, path) {
+  if (path[0] !== "calibration") return undefined;
+  return file.config.calibration?.[path[1]];
+}
+
+function hasPositiveReasoningTokenLimit(value) {
+  if (!Number.isInteger(value)) return false;
+  if (value <= 0) return false;
+  return value <= 2147483647;
+}
+
+function budgetModeEnablesThinking(value) {
+  if (value?.mode === "server-default") return true;
+  if (value?.mode !== "tokens") return false;
+  return hasPositiveReasoningTokenLimit(value.tokens);
+}
+
+function explicitlyEnablesBudget(path, value) {
+  if (path.at(-1) === "reasoningBudget")
+    return budgetModeEnablesThinking(value);
+  if (path.at(-1) !== "tokens" || path.at(-2) !== "reasoningBudget")
+    return false;
+  return hasPositiveReasoningTokenLimit(value);
+}
+
+/** A form budget action enables only the edited generation scope. */
+export function activateEditedReasoningBudget(
+  file,
+  dashboard,
+  path,
+  value,
+  setConfigPathValue,
+) {
+  if (file.kind !== "model" || !explicitlyEnablesBudget(path, value))
+    return undefined;
+  const generationPath = budgetEditGenerationPath(path);
+  if (!generationPath) return undefined;
+  const calibration = generationCalibration(file, generationPath);
+  if (!isTokenBudgetModel(file, dashboard, calibration)) return undefined;
+  const effort = effectiveReasoningBudgetEffort(
+    file,
+    dashboard,
+    generationPath,
+  );
+  if (effort !== undefined && effort !== "none") return undefined;
+  setConfigPathValue(
+    file.config,
+    [...generationPath, "reasoningEffort"],
+    "medium",
+  );
+  return generationPath;
+}
+
+function matchesReasoningControl(element, file) {
+  return element.dataset.kind === file.kind && element.dataset.id === file.id;
+}
+
+/** Numeric input keeps focus while the coupled select and status update. */
+export function syncActivatedReasoningBudget(
+  root,
+  file,
+  dashboard,
+  generationPath,
+) {
+  const effortPath = JSON.stringify([...generationPath, "reasoningEffort"]);
+  for (const element of root.querySelectorAll(
+    'select[data-config-action="field"]',
+  )) {
+    if (!matchesReasoningControl(element, file)) continue;
+    if (element.dataset.path !== effortPath) continue;
+    element.value = "medium";
+  }
+  for (const element of root.querySelectorAll(
+    "[data-reasoning-generation-path]",
+  )) {
+    if (!matchesReasoningControl(element, file)) continue;
+    const statusPath = reasoningStatusGenerationPath(element);
+    if (!statusPath) continue;
+    const calibration = generationCalibration(file, statusPath);
+    if (!isTokenBudgetModel(file, dashboard, calibration)) continue;
+    element.textContent = reasoningBudgetStatusText(file, dashboard, statusPath);
+  }
+}

package/dist/src/web-ui/app/components/config-workspace/reasoning-budget.d.ts

@@ -0,0 +1,16 @@
+export declare function isTokenBudgetModel(file: { id?: string; config?: Record<string, unknown> }, dashboard: unknown, calibration?: { profileId?: string }): boolean;
+export declare function shouldRefreshReasoningBudgetFields(
+  file: { kind: string },
+  path: string[],
+  valueType?: string,
+): boolean;
+export declare function parseReasoningBudgetMode(value: string, previous?: { mode: string; tokens?: number }): { mode: string; tokens?: number } | undefined;
+export declare function renderReasoningBudget(
+  file: { kind: string; id: string; config: Record<string, unknown> },
+  generationPath: string[],
+  renderConfigInput: (...args: unknown[]) => string,
+  options?: { supported?: boolean; dashboard?: unknown },
+): string;
+export declare function effectiveReasoningBudgetEffort(file: { config: Record<string, any> }, dashboard: unknown, generationPath: string[]): string | undefined;
+export declare function reasoningBudgetStatusText(file: { config: Record<string, any> }, dashboard: unknown, generationPath: string[]): string;
+export declare function renderReasoningEffort(file: { config: Record<string, any> }, generationPath: string[], renderConfigInput: (...args: unknown[]) => string): string;

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

@@ -0,0 +1,67 @@
+import { escapeAttribute } from "../../lib/text-format.js";
+
+function reasoningBudgetTarget(file, dashboard, calibration) {
+  const targetId = calibration?.profileId;
+  return targetId && targetId !== file.id
+    ? dashboard?.files?.models?.find((model) => model.id === targetId)
+    : file;
+}
+
+export function isTokenBudgetModel(file, dashboard, calibration) {
+  const target = reasoningBudgetTarget(file, dashboard, calibration);
+  if (target?.config?.supportsThinking !== true) return false;
+  const providerId = target.config.provider;
+  return dashboard?.files?.runtime?.config?.models?.providers?.[providerId]?.type === "llamacpp";
+}
+
+export function shouldRefreshReasoningBudgetFields(file, path, valueType) {
+  if (valueType === "reasoning-budget-mode") return true;
+  if (valueType === "reasoning-mode-budgets") return true;
+  if (file.kind !== "model") return false;
+  if (path.at(-1) === "reasoningEffort") return true;
+  if (path.length !== 1) return false;
+  return path[0] === "supportsThinking" || path[0] === "provider";
+}
+
+export function parseReasoningBudgetMode(value, previous) {
+  if (value === "inherit") return undefined;
+  if (value === "server-default") return { mode: "server-default" };
+  return { mode: "tokens", tokens: previous?.mode === "tokens" ? previous.tokens : 0 };
+}
+
+export function effectiveReasoningBudgetEffort(file, dashboard, generationPath) {
+  const generation = generationPath.reduce((value, key) => value?.[key], file.config);
+  if (generation?.reasoningEffort !== undefined) return generation.reasoningEffort;
+  if (generationPath[0] !== "calibration") return undefined;
+  const calibration = file.config?.calibration?.[generationPath[1]];
+  return reasoningBudgetTarget(file, dashboard, calibration)?.config?.generation?.reasoningEffort;
+}
+
+export function reasoningBudgetStatusText(file, dashboard, generationPath) {
+  const budget = generationPath.reduce((value, key) => value?.[key], file.config)?.reasoningBudget;
+  const savedBudgetIsOff = budget !== undefined &&
+    effectiveReasoningBudgetEffort(file, dashboard, generationPath) === "none";
+  if (savedBudgetIsOff)
+    return "Inactive while reasoning is Off. Choose a positive token limit or Server default to enable thinking.";
+  return "Per reasoning segment. Zero disables thinking; a positive budget enables it. Off keeps the saved budget inactive.";
+}
+
+export function renderReasoningEffort(file, generationPath, renderConfigInput) {
+  return `<label><span>Reasoning effort</span>${renderConfigInput(file, [...generationPath, "reasoningEffort"], {
+    type: "select", values: ["", "none", "minimal", "low", "medium", "high", "xhigh"],
+  })}<small>Default inherits the profile or request mode. None disables thinking unless a mode token limit or request setting enables it.</small></label>`;
+}
+
+export function renderReasoningBudget(file, generationPath, renderConfigInput, { supported = true, dashboard } = {}) {
+  const budget = generationPath.reduce((value, key) => value?.[key], file.config)?.reasoningBudget;
+  if (!supported && budget === undefined) return "";
+  const path = [...generationPath, "reasoningBudget"];
+  const mode = budget?.mode || "inherit";
+  const attributes = `data-config-action="field" data-kind="${escapeAttribute(file.kind)}" data-id="${escapeAttribute(file.id)}" data-path="${escapeAttribute(JSON.stringify(path))}" data-value-type="reasoning-budget-mode"`;
+  return `<label><span>Thinking budget</span><select ${attributes}>
+    <option value="inherit" ${mode === "inherit" ? "selected" : ""}>Inherit (no override)</option>
+    ${supported ? `<option value="server-default" ${mode === "server-default" ? "selected" : ""}>Server default</option>
+    <option value="tokens" ${mode === "tokens" ? "selected" : ""}>Token limit</option>` : `<option value="${escapeAttribute(mode)}" selected disabled>Saved override (unsupported target)</option>`}
+  </select><small data-reasoning-generation-path="${escapeAttribute(JSON.stringify(generationPath))}" data-kind="${escapeAttribute(file.kind)}" data-id="${escapeAttribute(file.id)}">${supported ? reasoningBudgetStatusText(file, dashboard, generationPath) : "This target does not support token budgets. Choose Inherit to remove this override."}</small></label>
+  ${supported && mode === "tokens" ? `<label><span>Thinking tokens</span>${renderConfigInput(file, [...path, "tokens"], { type: "number", min: "0", step: "1" })}<small>Enter a non-negative whole number; 0 disables thinking. The answer also needs capacity within the total output limit.</small></label>` : ""}`;
+}

package/dist/src/web-ui/app/components/config-workspace/reasoning-mode-budgets.d.ts

@@ -0,0 +1,7 @@
+export declare function parseReasoningModeBudgets(value: string, previous?: Record<string, number>): Record<string, number> | undefined;
+export declare function renderReasoningModeBudgets(
+  file: { kind: string; id: string; config: Record<string, any> },
+  generationPath: string[],
+  renderConfigInput: (...args: any[]) => string,
+  options?: { supported?: boolean },
+): string;

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

@@ -0,0 +1,25 @@
+import { escapeAttribute } from "../../lib/text-format.js";
+
+const REASONING_MODES = [["fast", "Low"], ["reasoning", "Reasoning"], ["deep", "Deep"]];
+
+export function parseReasoningModeBudgets(value, previous) {
+  if (value === "inherit") return undefined;
+  return previous ?? {};
+}
+
+export function renderReasoningModeBudgets(file, generationPath, renderConfigInput, { supported = true } = {}) {
+  const generation = generationPath.reduce((value, key) => value?.[key], file.config);
+  const budgets = generation?.reasoningBudgetByMode;
+  if (!supported && budgets === undefined) return "";
+  const path = [...generationPath, "reasoningBudgetByMode"];
+  const custom = budgets !== undefined;
+  const attributes = `data-config-action="field" data-kind="${escapeAttribute(file.kind)}" data-id="${escapeAttribute(file.id)}" data-path="${escapeAttribute(JSON.stringify(path))}" data-value-type="reasoning-mode-budgets"`;
+  const selector = `<label><span>Mode token overrides</span><select ${attributes}>
+    <option value="inherit" ${custom ? "" : "selected"}>Inherit (no override)</option>
+    ${supported ? `<option value="custom" ${custom ? "selected" : ""}>Custom limits by mode</option>` : '<option value="custom" selected disabled>Saved override (unsupported target)</option>'}
+  </select><small>${supported
+    ? "Optional limits for main model steps. A custom map replaces inherited mode limits; blank entries use the ordinary effort and budget settings."
+    : "This target does not support token budgets. Choose Inherit to remove this override."}</small></label>`;
+  if (!supported || !custom) return selector;
+  return selector + REASONING_MODES.map(([mode, label]) => `<label><span>${label} thinking tokens</span>${renderConfigInput(file, [...path, mode], { type: "number", min: "0", step: "1" })}<small>Optional non-negative integer. Zero disables thinking; positive values enable it for this mode, including Low. Explicit request or invocation Off still wins.</small></label>`).join("");
+}

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

@@ -1,3 +1,5 @@
+import { activateEditedReasoningBudget, syncActivatedReasoningBudget } from "./reasoning-budget-edit.js";
+import { shouldRefreshReasoningBudgetFields } from "./reasoning-budget.js";
 import { rememberCalibrationDisclosure } from "./calibration-disclosure.js";
 import { textOf } from "../../lib/text-format.js";
 import { resolveModelExecutionRoute } from "./config-model.js";
@@ -72,10 +74,17 @@ export function createConfigWorkspaceEvents({
       action === "step-value"
         ? element.value
         : parseConfigInputValue(element, file, path);
-    mutateConfigFile(element.dataset.kind, element.dataset.id, (config) =>
-      applyConfigFieldValue(config, element, path, value),
-    );
+    let activatedGeneration;
+    mutateConfigFile(element.dataset.kind, element.dataset.id, (config) => {
+      applyConfigFieldValue(config, element, path, value);
+      activatedGeneration = activateEditedReasoningBudget(
+        file, state.configDashboard, path, value, setConfigPathValue,
+      );
+    });
+    if (activatedGeneration)
+      syncActivatedReasoningBudget(dom.configDashboard, file, state.configDashboard, activatedGeneration);
     syncExecutionRouteDescription(element);
+    if (shouldRefreshReasoningBudgetFields(file, path, element.dataset.valueType)) renderConfigDashboard();
   }
 
   function handleDashboardInput(event) {
@@ -90,8 +99,7 @@ export function createConfigWorkspaceEvents({
     if (dashboardIsBusy()) return;
     const element = event.target;
     if (element?.id === "configRawFileSelect") {
-      changeRawFile(element.value, element);
-      return;
+      return changeRawFile(element.value, element);
     }
     const actionElement = element?.closest?.("[data-config-action]");
     if (!actionElement) return;
@@ -273,9 +281,9 @@ export function createConfigWorkspaceEvents({
   function bind() {
     if (state.bound) return;
     state.bound = true;
-    dom.refreshConfigButton.addEventListener("click", () => {
+    dom.refreshConfigButton.addEventListener("click", async () => {
       if (dashboardIsBusy()) return;
-      if (!confirmDiscardChanges("refresh configuration")) return;
+      if (!await confirmDiscardChanges("refresh configuration")) return;
       void loadRuntimeConfig({ protectUnsaved: false });
     });
     dom.configDashboard.addEventListener("click", handleDashboardClick);

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;