@inflexa-ai/harness 0.41.2 → 0.42.0

package/dist/loop/run-agent.js

@@ -8,8 +8,8 @@ import { ATTR_INFLEXA_TOOL_USE_ID, passThroughSpan, stableSpan } from "../lib/ot
 import { ResultError, unwrapOrThrow } from "../lib/result.js";
 import { describeZodIssueShapes } from "../lib/zod-issue-shape.js";
 import { hintForZodIssue, repairToolInput } from "../lib/zod-issues.js";
-import { dropMarkerMessage, markCompactionExchange, markInterruptedMessage, summaryMarkerMessage, syntheticUserMessage, } from "../memory/ai-sdk-message-storage.js";
-import { conversationView, keptTurnsForDrop, viewTokens } from "../memory/conversation-view.js";
+import { contextRecordOf, markCompactionExchange, markInterruptedMessage, summaryMarkerMessage, syntheticUserMessage, withRequestInputTokens, } from "../memory/ai-sdk-message-storage.js";
+import { conversationView, lastRequestInputTokens } from "../memory/conversation-view.js";
 import { answerUnansweredToolCalls } from "../memory/tool-call-integrity.js";
 import { classifyProviderError, extractStatus } from "../providers/errors.js";
 import { DEFAULT_PROMPT_CACHE, withPromptCacheBreakpoint, withSystemPromptBreakpoint } from "../providers/prompt-cache.js";
@@ -42,6 +42,11 @@ export const WRAP_UP_MAX_REQUESTS = 2;
 async function runAgentLoop(agent, initial, session, opts) {
     const formatStepName = opts.formatStepName ?? DEFAULT_STEP_NAME_FORMATTER;
     const loop = openLoop(agent, initial, session, opts, agent.id);
+    if (opts.turnInput !== undefined) {
+        const ended = await loop.startTurn(opts.turnInput);
+        if (ended !== undefined)
+            return ended;
+    }
     const task = await loop.runSegment({ mask: opts.toolMask, maxRequests: agent.maxIterations, stepNames: formatStepName, firstIndex: 0, checksBudget: true });
     if (task !== "capped")
         return task;
@@ -100,6 +105,8 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
     let continuesTruncation = false;
     let compactionStopped = false;
     let compactions = 0;
+    // The first request after a summary shows if the summary brought the conversation under the budget.
+    let summarizedLast = false;
     // Bound from the same `source` the emitted events carry: one derivation feeding
     // both sinks, so a record and an event cannot disagree about who produced them.
     // `callPath` rides as an array rather than a joined string — the queryable form;
@@ -224,7 +231,7 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
         if (!endsOnRequestRefusal) {
             const reply = await resultStep(callStep)(stepName, chat);
             accountForChatCall(reply, { ...accounting, stepName });
-            return reply;
+            return withRequestAnchor(reply);
         }
         // The step gives the `Result` as its value, thus a refusal ends the segment and no step throws for it.
         const result = await callStep(stepName, async () => await chat());
@@ -233,7 +240,7 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
             return { refusal };
         const reply = unwrapOrThrow(result);
         accountForChatCall(reply, { ...accounting, stepName });
-        return reply;
+        return withRequestAnchor(reply);
     };
     // The user said no. A subsequent model call would only let the agent argue
     // with the decision, or spend a call acknowledging it; the denial tool result
@@ -327,13 +334,13 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
         return { messages, finish: { reason: "error", cappedOut: false, truncationRecoveries, ...finishUsage() }, refusal };
     };
     /** The result of the run when an abort ends the exchange, or `undefined` when the run continues. */
-    const compact = async (active, tokensBefore, index) => {
+    const compact = async (active, tokensBefore, index, trigger) => {
         const id = randomUUID();
         const stepNamespace = `compaction-${compactions++}`;
         const startedAt = performance.now();
-        const emitPart = (data) => emit({ type: "data-compaction", source, data });
+        const emitPart = (data) => emit({ type: "data-compaction", source, data: { ...data, trigger } });
         await emitPart({ id, status: "running", tokensBefore });
-        const { onRound: _onRound, compaction: _compaction, ...conversationOptions } = opts;
+        const { onRound: _onRound, compaction: _compaction, turnInput: _turnInput, ...conversationOptions } = opts;
         let settled = false;
         try {
             const exchange = await continueAgent(agent, viewOf(), {
@@ -357,36 +364,25 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
                 return { messages, finish: { reason: "aborted", cappedOut: false, truncationRecoveries, ...finishUsage() } };
             }
             const summary = summaryOf(exchange);
-            const keptTurns = summary === undefined ? keptTurnsForDrop(messages, viewOptions, active.budget) : 0;
-            const markerOf = (tokensAfter, durationMs) => summary === undefined
-                ? dropMarkerMessage({ kind: "drop", id, tokensBefore, tokensAfter, durationMs, keptTurns })
-                : summaryMarkerMessage(summary, { kind: "summary", id, tokensBefore, tokensAfter, durationMs });
+            if (summary === undefined) {
+                settled = true;
+                const durationMs = Math.round(performance.now() - startedAt);
+                await emitPart({ id, status: "failed", tokensBefore, durationMs });
+                const refusal = exchange.refusal === undefined ? {} : { status: exchange.refusal.status, providerError: exchange.refusal.message };
+                log.error("compaction gave no summary, thus the run compacts no more", { compactionId: id, trigger, tokensBefore, durationMs, ...refusal });
+                compactionStopped = true;
+                return undefined;
+            }
+            const markerOf = (durationMs) => summaryMarkerMessage(summary, { kind: "summary", id, tokensBefore, durationMs, trigger });
             // The figures of a marker do not change the view, thus a draft marker gives the view of the real one.
-            const view = conversationView([...messages, markerOf(0, 0)], viewOptions).messages;
-            const records = await active.recordsAfter(view);
-            const tokensAfter = viewTokens([...view, ...records]);
+            const records = await active.recordsAfter(conversationView([...messages, markerOf(0)], viewOptions).messages);
             const durationMs = Math.round(performance.now() - startedAt);
-            messages.push(markerOf(tokensAfter, durationMs), ...records);
+            messages.push(markerOf(durationMs), ...records);
             await giveRound();
             settled = true;
-            await emitPart({ id, status: summary === undefined ? "failed" : "done", tokensBefore, tokensAfter, durationMs });
-            const fields = { compactionId: id, tokensBefore, tokensAfter, durationMs };
-            if (summary === undefined) {
-                const refusal = exchange.refusal === undefined ? {} : { status: exchange.refusal.status, providerError: exchange.refusal.message };
-                log.warn("compaction gave no summary, thus the oldest turns left the view", { ...fields, keptTurns, ...refusal });
-            }
-            else {
-                log.info("conversation compacted", fields);
-            }
-            if (summary !== undefined && tokensAfter > active.budget) {
-                log.warn("the compacted view still exceeds the budget, thus the run compacts no more", {
-                    compactionId: id,
-                    tokensAfter,
-                    budget: active.budget,
-                });
-            }
-            if (summary === undefined || tokensAfter > active.budget)
-                compactionStopped = true;
+            await emitPart({ id, status: "done", tokensBefore, durationMs });
+            log.info("conversation compacted", { compactionId: id, trigger, tokensBefore, durationMs });
+            summarizedLast = true;
             return undefined;
         }
         finally {
@@ -394,11 +390,36 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
                 await emitPart({ id, status: "failed", tokensBefore, durationMs: Math.round(performance.now() - startedAt) });
         }
     };
+    const startTurn = async (input) => {
+        const budget = policy?.turnStartBudget;
+        const tokens = lastRequestInputTokens(messages);
+        if (policy === undefined || budget === undefined || tokens === undefined || tokens <= budget) {
+            messages.push(...input);
+            return undefined;
+        }
+        const ended = await compact(policy, tokens, 0, "turn-start");
+        if (ended !== undefined)
+            return ended;
+        // The records after a summary give the current context, thus a record of the input would only repeat one.
+        messages.push(...(summarizedLast ? input.filter((message) => contextRecordOf(message) === undefined) : input));
+        return undefined;
+    };
     const compactOverBudget = async (index) => {
         if (policy === undefined || continuesTruncation || compactionStopped)
             return undefined;
-        const tokensBefore = viewTokens(viewOf());
-        return tokensBefore > policy.budget ? compact(policy, tokensBefore, index) : undefined;
+        const tokens = lastRequestInputTokens(messages);
+        if (tokens === undefined)
+            return undefined;
+        const afterSummary = summarizedLast;
+        summarizedLast = false;
+        if (tokens <= policy.budget)
+            return undefined;
+        if (afterSummary) {
+            log.warn("the first request after the summary still exceeds the budget, thus the run compacts no more", { tokens, budget: policy.budget });
+            compactionStopped = true;
+            return undefined;
+        }
+        return compact(policy, tokens, index, "mid-turn");
     };
     const runSegment = async (segment) => {
         const names = segment.stepNames;
@@ -558,6 +579,7 @@ export function openLoop(agent, initial, session, opts, metricAgentId) {
         }
     };
     return {
+        startTurn: (input) => giveRoundBeforeThrow(() => startTurn(input)),
         runSegment: (segment) => giveRoundBeforeThrow(() => runSegment(segment)),
         endCapped: () => giveRoundBeforeThrow(endCapped),
     };
@@ -577,6 +599,11 @@ function summaryOf(exchange) {
     const text = finalText(exchange.messages).trim();
     return text.length > 0 ? text : undefined;
 }
+/** The reply whose message holds the input tokens of its request, which the budget checks read. */
+function withRequestAnchor(reply) {
+    const tokens = reply.usage?.inputTokens;
+    return tokens === undefined ? reply : { ...reply, message: withRequestInputTokens(reply.message, tokens) };
+}
 /**
  * Called at the fold point, before any run-ending branch, so an aborted or
  * dead run is still accounted. Token counters grow inside the call's step

package/dist/loop/types.d.ts

@@ -11,6 +11,7 @@ import type { ModelMessage } from "ai";
 import type { ToolCallDetail, ToolOutcome } from "../contracts/chat-events.js";
 import type { ChatStreamEvent } from "../providers/types.js";
 import type { Tool } from "../tools/define-tool.js";
+import type { CompactionRules } from "./compaction.js";
 /**
  * A loop message. The harness's working message array is AI SDK-shaped
  * `ModelMessage`.
@@ -28,6 +29,8 @@ export interface AgentDefinition {
     readonly tools: readonly Tool[];
     /** Runaway guard: at the cap the loop runs up to two masked wrap-up requests, until it gets a text answer. */
     readonly maxIterations: number;
+    /** The compaction rules of an agent that a chat thread runs. Absent: the conversation never compacts. */
+    readonly compaction?: CompactionRules;
 }
 /**
  * The durability seam. `passthroughStep` (`(_, fn) => fn()`) in the chat

package/dist/memory/ai-sdk-message-storage.d.ts

@@ -1,4 +1,4 @@
-import { type ModelMessage, type UserContent } from "ai";
+import { type AssistantModelMessage, type ModelMessage, type UserContent } from "ai";
 import { z } from "zod";
 export declare const SUPPORTED_AI_SDK_MAJOR = 7;
 export declare const StoredMessageEnvelopeSchema: z.ZodObject<{
@@ -110,21 +110,36 @@ export declare function isSyntheticRecordMessage(message: ModelMessage): boolean
 export declare const COMPACTION_EXCHANGE_KEY = "compactionExchange";
 /** The {@link HARNESS_PROVIDER_NAMESPACE} key that holds the figures of a compaction marker, which the view rule reads. */
 export declare const COMPACTION_MARKER_KEY = "compactionMarker";
+declare const COMPACTION_TRIGGERS: readonly ["turn-start", "mid-turn"];
+/** Where a compaction started: before the user message of a turn, or before a later request. */
+export type CompactionTrigger = (typeof COMPACTION_TRIGGERS)[number];
 declare const CompactionMarkerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     tokensBefore: z.ZodNumber;
-    tokensAfter: z.ZodNumber;
     durationMs: z.ZodNumber;
+    trigger: z.ZodOptional<z.ZodEnum<{
+        "turn-start": "turn-start";
+        "mid-turn": "mid-turn";
+    }>>;
     kind: z.ZodLiteral<"summary">;
 }, z.core.$strip>, z.ZodObject<{
     keptTurns: z.ZodNumber;
     id: z.ZodString;
     tokensBefore: z.ZodNumber;
-    tokensAfter: z.ZodNumber;
     durationMs: z.ZodNumber;
+    trigger: z.ZodOptional<z.ZodEnum<{
+        "turn-start": "turn-start";
+        "mid-turn": "mid-turn";
+    }>>;
     kind: z.ZodLiteral<"drop">;
 }, z.core.$strip>], "kind">;
 export type CompactionMarker = z.infer<typeof CompactionMarkerSchema>;
+/** The {@link HARNESS_PROVIDER_NAMESPACE} key that holds the input tokens that the provider reported for the request of an assistant message. */
+export declare const REQUEST_INPUT_TOKENS_KEY = "requestInputTokens";
+/** A copy of `message` whose harness namespace holds the input tokens of its request. The mark keeps each other namespace. */
+export declare function withRequestInputTokens(message: AssistantModelMessage, tokens: number): AssistantModelMessage;
+/** The input tokens of the request of an assistant message, or `undefined` when the provider reported none. */
+export declare function requestInputTokensOf(message: ModelMessage): number | undefined;
 /** A copy of `message` whose harness namespace, which no provider reads, holds the compaction id. */
 export declare function markCompactionExchange(message: ModelMessage, id: string): ModelMessage;
 export declare function compactionExchangeOf(message: ModelMessage): string | undefined;

package/dist/memory/ai-sdk-message-storage.js

@@ -162,11 +162,33 @@ export function isSyntheticRecordMessage(message) {
 export const COMPACTION_EXCHANGE_KEY = "compactionExchange";
 /** The {@link HARNESS_PROVIDER_NAMESPACE} key that holds the figures of a compaction marker, which the view rule reads. */
 export const COMPACTION_MARKER_KEY = "compactionMarker";
-const compactionFigures = { id: z.string(), tokensBefore: z.number(), tokensAfter: z.number(), durationMs: z.number() };
+const COMPACTION_TRIGGERS = ["turn-start", "mid-turn"];
+// A row from before the trigger has none.
+const compactionFigures = { id: z.string(), tokensBefore: z.number(), durationMs: z.number(), trigger: z.enum(COMPACTION_TRIGGERS).optional() };
 const CompactionMarkerSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("summary"), ...compactionFigures }),
     z.object({ kind: z.literal("drop"), ...compactionFigures, keptTurns: z.number() }),
 ]);
+/** The {@link HARNESS_PROVIDER_NAMESPACE} key that holds the input tokens that the provider reported for the request of an assistant message. */
+export const REQUEST_INPUT_TOKENS_KEY = "requestInputTokens";
+/** A copy of `message` whose harness namespace holds the input tokens of its request. The mark keeps each other namespace. */
+export function withRequestInputTokens(message, tokens) {
+    const existingOptions = message.providerOptions ?? {};
+    return {
+        ...message,
+        providerOptions: {
+            ...existingOptions,
+            [HARNESS_PROVIDER_NAMESPACE]: { ...existingOptions[HARNESS_PROVIDER_NAMESPACE], [REQUEST_INPUT_TOKENS_KEY]: tokens },
+        },
+    };
+}
+/** The input tokens of the request of an assistant message, or `undefined` when the provider reported none. */
+export function requestInputTokensOf(message) {
+    if (message.role !== "assistant")
+        return undefined;
+    const tokens = message.providerOptions?.[HARNESS_PROVIDER_NAMESPACE]?.[REQUEST_INPUT_TOKENS_KEY];
+    return typeof tokens === "number" && Number.isFinite(tokens) ? tokens : undefined;
+}
 /** A copy of `message` whose harness namespace, which no provider reads, holds the compaction id. */
 export function markCompactionExchange(message, id) {
     const existingOptions = message.providerOptions ?? {};

package/dist/memory/conversation-display-recorder.d.ts

@@ -15,9 +15,15 @@ export interface ConversationDisplayRecorder {
 }
 export interface ConversationDisplayRecorderOptions {
     readonly userText: string;
-    readonly topLevelCallPath: readonly string[];
+    /** The root agent of the turn. Its call path is `[agentId]`, and an event with a longer path is from a sub-agent. */
+    readonly agentId: string;
     readonly sink: EmitFn;
     readonly userMessageId?: string;
     readonly assistantMessageId?: string;
 }
+/**
+ * Record the display of a turn through the same translation path as a live surface: each event becomes a
+ * frame (`toChatFrame`), and the frames build the messages of the round (`applyChatFrame`). Only a part that
+ * the conversation keeps enters the record.
+ */
 export declare function createConversationDisplayRecorder(options: ConversationDisplayRecorderOptions): ConversationDisplayRecorder;

package/dist/memory/conversation-display-recorder.js

@@ -1,33 +1,36 @@
 import { randomUUID } from "node:crypto";
+import { applyChatFrame, checkChatPart, isRootFrame, toChatFrame } from "../contracts/chat-frame.js";
 import { PART_REGISTRY } from "../contracts/part-registry.js";
-import { CortexChatPartSchema } from "../contracts/schemas/chat-parts.js";
 import { compactionExchangeOf, compactionMarkerOf } from "./ai-sdk-message-storage.js";
 import { conversationDisplayPart } from "./conversation-display-storage.js";
 function jsonCopy(value) {
     return JSON.parse(JSON.stringify(value));
 }
-function isSubAgent(event, topLevelCallPath) {
-    if (!("source" in event) || event.source === undefined)
-        return false;
-    const path = event.source.callPath;
-    return path.length > topLevelCallPath.length && topLevelCallPath.every((entry, index) => path[index] === entry);
-}
 function durableConversationType(type) {
     if (!Object.hasOwn(PART_REGISTRY, type))
         return false;
     const descriptor = PART_REGISTRY[type];
     return descriptor.emitter === "conversation" && descriptor.consumer === "conversation" && !descriptor.transient;
 }
-function dataPart(event) {
-    const parsed = CortexChatPartSchema.safeParse({ type: event.type, ...event.data });
-    if (!parsed.success)
-        throw new Error(`Invalid emitted conversation part ${event.type}: ${parsed.error.message}`);
-    const { type, ...data } = parsed.data;
-    return {
-        type,
-        id: "id" in data && typeof data.id === "string" ? data.id : undefined,
-        data: jsonCopy(data),
-    };
+/** The checked part of a data frame, copied at receipt, because the emitter keeps its own reference to the payload. */
+function recordedPart(frame) {
+    const checked = checkChatPart(frame);
+    if (!checked.ok)
+        throw new Error(`Invalid emitted conversation part ${frame.type}: ${checked.error}`);
+    return jsonCopy(checked.frame);
+}
+/**
+ * The stored form of the parts of one round. A round that closes ends each question that it asked, thus a
+ * pending ask is stored `aborted`, and a call with no outcome is stored `incomplete` ({@link conversationDisplayPart}).
+ */
+function displayParts(parts) {
+    return parts.flatMap((part) => {
+        if (part.type === "text")
+            return part.text.length === 0 ? [] : [{ type: "text", text: part.text, state: "done" }];
+        if (part.type === "data-ask" && part.status === "pending")
+            return [conversationDisplayPart({ ...part, status: "aborted" })];
+        return [conversationDisplayPart(part)];
+    });
 }
 /** The text of the assistant messages of a round. The text of an exchange is a summary, and no reply. */
 function assistantText(messages) {
@@ -48,148 +51,85 @@ function compactionDivider(marker) {
         id: marker.id,
         status: marker.kind === "summary" ? "done" : "failed",
         tokensBefore: marker.tokensBefore,
-        tokensAfter: marker.tokensAfter,
         durationMs: marker.durationMs,
+        ...(marker.trigger === undefined ? {} : { trigger: marker.trigger }),
     });
     return { id: marker.id, role: "system", parts: [part] };
 }
+/**
+ * Record the display of a turn through the same translation path as a live surface: each event becomes a
+ * frame (`toChatFrame`), and the frames build the messages of the round (`applyChatFrame`). Only a part that
+ * the conversation keeps enters the record.
+ */
 export function createConversationDisplayRecorder(options) {
     // One id for each message of the turn, thus the rounds of a turn replay as one assistant message.
     const userMessageId = options.userMessageId ?? randomUUID();
     let assistantMessageId = options.assistantMessageId ?? randomUUID();
-    const assistantParts = [];
-    // Where a reconciling part lives, keyed by `type:id`. Type-qualified because a
-    // stable id is only unique within its own family — a plan and a run card may
-    // legitimately share one.
-    const reconcileIndexes = new Map();
+    const rootSource = { agentId: options.agentId, callPath: [options.agentId] };
+    // The messages of the open round. A later update of a part lands in the next round, and the replay replaces the earlier copy.
+    let round = [];
     let finished = false;
-    /**
-     * Place a part, replacing the one it reconciles with when it has a stable id.
-     * A tool call reaching its `finished` state and an `ask` reaching its resolved
-     * status are the same operation: latest-wins, in the position the part first
-     * took, so a later part never jumps the ordering the user saw.
-     */
-    function upsert(part, reconciling) {
-        if (!reconciling || part.id === undefined) {
-            assistantParts.push(part);
-            return;
-        }
-        const key = `${part.type}:${part.id}`;
-        const index = reconcileIndexes.get(key);
-        if (index !== undefined) {
-            assistantParts[index] = part;
-            return;
-        }
-        reconcileIndexes.set(key, assistantParts.length);
-        assistantParts.push(part);
+    function apply(frame) {
+        round = applyChatFrame(round, frame, assistantMessageId).messages;
+    }
+    function roundParts() {
+        return round.find((message) => message.id === assistantMessageId)?.parts ?? [];
     }
-    /**
-     * Place or update a call's recorded state.
-     *
-     * A call is recorded `incomplete` the moment it is dispatched and overwritten with
-     * its real outcome when it finishes. The record is therefore honest at every
-     * instant, and a turn that ends mid-call needs no closing pass — the calls that
-     * never finished are already saying so.
-     */
-    function recordToolCall(toolCallId, toolName, outcome, detail) {
-        upsert(conversationDisplayPart({
-            type: "tool-call",
-            toolCallId,
-            toolName,
-            outcome,
-            ...(detail === undefined ? {} : { detail }),
-        }), true);
+    function hasText() {
+        return roundParts().some((part) => part.type === "text" && part.text.length > 0);
     }
     function appendText(text) {
-        if (text.length === 0)
+        if (text.length > 0)
+            apply({ type: "text-delta", text, source: rootSource });
+    }
+    function record(event) {
+        const frame = toChatFrame(event, rootSource);
+        if (frame === null || !isRootFrame(frame))
             return;
-        const previous = assistantParts.at(-1);
-        if (previous?.type === "text") {
-            previous.text += text;
+        if (frame.type.startsWith("data-")) {
+            // Each chat event type is named without the `data-` prefix, thus a `data-` frame is a part frame.
+            if (durableConversationType(frame.type))
+                apply(recordedPart(frame));
             return;
         }
-        assistantParts.push({ type: "text", text, state: "streaming" });
-    }
-    function recordData(event) {
-        if (!durableConversationType(event.type))
-            return;
-        upsert(dataPart(event), PART_REGISTRY[event.type].reconciling);
+        apply(frame);
     }
     const emit = (event) => {
-        if (finished)
-            return options.sink(event);
-        if (!isSubAgent(event, options.topLevelCallPath)) {
-            switch (event.type) {
-                case "text-delta":
-                    appendText(event.text);
-                    break;
-                // The detail the loop computed at dispatch is recorded as shown. It is
-                // NOT re-derived on reload: doing that would need the tool's schema and
-                // the raw input, which is the tool-name coupling the display projection
-                // exists to remove.
-                case "tool-started":
-                    recordToolCall(event.toolUseId, event.name, "incomplete", event.detail);
-                    break;
-                case "tool-finished":
-                    recordToolCall(event.toolUseId, event.name, event.outcome, event.detail);
-                    break;
-                case "done":
-                case "iteration":
-                    break;
-                default:
-                    recordData(event);
-                    break;
-            }
-        }
+        if (!finished)
+            record(event);
         return options.sink(event);
     };
-    function closeParts() {
-        // Calls need no closing pass: one that never reached `tool-finished` still holds
-        // the `incomplete` it was recorded with at dispatch, which is the whole of what
-        // the harness observed. An approval does need one — `pending` is a question, and
-        // a turn that ends without answering it aborted it.
-        for (const part of assistantParts) {
-            if (part.type === "data-ask" && part.data.status === "pending")
-                part.data.status = "aborted";
-            if (part.type === "text")
-                part.state = "done";
-        }
-    }
     function takeOpening() {
         return [{ id: userMessageId, role: "user", parts: [{ type: "text", text: options.userText, state: "done" }] }];
     }
     function takeRound(messages) {
-        if (!assistantParts.some((part) => part.type === "text"))
+        if (!hasText())
             appendText(assistantText(messages));
-        // Only a round that a throw ends can hold a pending approval.
-        closeParts();
-        const round = assistantParts.length === 0 ? [] : [{ id: assistantMessageId, role: "assistant", parts: jsonCopy(assistantParts) }];
-        // A later update of a part lands in the next round, and the replay replaces the earlier copy.
-        assistantParts.length = 0;
-        reconcileIndexes.clear();
+        const parts = displayParts(roundParts());
+        const taken = parts.length === 0 ? [] : [{ id: assistantMessageId, role: "assistant", parts: jsonCopy(parts) }];
+        round = [];
         const marker = messages.map(compactionMarkerOf).find((found) => found !== undefined);
         if (marker !== undefined) {
-            round.push(compactionDivider(marker));
+            taken.push(compactionDivider(marker));
             // The divider splits the turn into two assistant messages of the replay, and two messages must not share an id.
             assistantMessageId = randomUUID();
         }
-        return round;
+        return taken;
     }
     function finish(finishOptions) {
         if (!finished) {
             finished = true;
-            if (!assistantParts.some((part) => part.type === "text") && finishOptions?.fallbackText) {
+            if (!hasText() && finishOptions?.fallbackText)
                 appendText(finishOptions.fallbackText);
-            }
-            closeParts();
         }
         const messages = takeOpening();
-        if (assistantParts.length > 0) {
+        const parts = displayParts(roundParts());
+        if (parts.length > 0) {
             messages.push({
                 id: assistantMessageId,
                 role: "assistant",
                 ...(finishOptions?.interrupted ? { metadata: { interrupted: true } } : {}),
-                parts: jsonCopy(assistantParts),
+                parts: jsonCopy(parts),
             });
         }
         return messages;

package/dist/memory/conversation-display-replay.d.ts

@@ -1,11 +1,11 @@
 /**
- * The runtime transcript read: stored display projections → `CortexMessage[]`. It walks the rows in
+ * The runtime transcript read: stored display projections → `ChatMessage[]`. It walks the rows in
  * `seq` order, merges the rounds of a turn into one assistant message, and folds the turn record onto
  * that message. It consults no tool name, no card builder, and no workspace or database.
  *
  * A row with no envelope predates the display projection and is skipped. A display rebuilt from the
  * model transcript would let each later change of a tool or a card rewrite history.
  */
-import type { CortexMessage } from "../contracts/message.js";
+import type { ChatMessage } from "../contracts/message.js";
 import type { StoredMessage } from "./thread-history.js";
-export declare function storedMessagesToCortex(messages: readonly StoredMessage[]): CortexMessage[];
+export declare function storedMessagesToChat(messages: readonly StoredMessage[]): ChatMessage[];

package/dist/memory/conversation-display-replay.js

@@ -1,32 +1,18 @@
 /**
- * The runtime transcript read: stored display projections → `CortexMessage[]`. It walks the rows in
+ * The runtime transcript read: stored display projections → `ChatMessage[]`. It walks the rows in
  * `seq` order, merges the rounds of a turn into one assistant message, and folds the turn record onto
  * that message. It consults no tool name, no card builder, and no workspace or database.
  *
  * A row with no envelope predates the display projection and is skipped. A display rebuilt from the
  * model transcript would let each later change of a tool or a card rewrite history.
  */
-import { isReconciling } from "../contracts/part-registry.js";
+import { upsertPart } from "../contracts/chat-frame.js";
 import { isSyntheticUserMessage } from "./ai-sdk-message-storage.js";
-import { conversationUIToCortexMessages } from "./conversation-display-storage.js";
-/** The key that a part reconciles on, or `undefined` for a part that each round adds again. */
-function reconcileKey(part) {
-    if (part.type === "tool-call")
-        return `tool-call:${part.toolCallId}`;
-    if (part.type === "text" || !isReconciling(part.type))
-        return undefined;
-    return "id" in part && typeof part.id === "string" ? `${part.type}:${part.id}` : undefined;
-}
+import { conversationUIToChatMessages } from "./conversation-display-storage.js";
 /** Add the parts of a later round to the assistant message of its turn. */
 function mergeRound(target, round) {
-    for (const part of round.parts) {
-        const key = reconcileKey(part);
-        const earlier = key === undefined ? -1 : target.parts.findIndex((candidate) => reconcileKey(candidate) === key);
-        if (earlier >= 0)
-            target.parts[earlier] = part;
-        else
-            target.parts.push(part);
-    }
+    for (const part of round.parts)
+        target.parts = upsertPart(target.parts, part);
 }
 function foldTurnRecord(message, record) {
     if (message === undefined || record === undefined)
@@ -38,7 +24,7 @@ function foldTurnRecord(message, record) {
     if (record.status === "aborted")
         message.interrupted = true;
 }
-export function storedMessagesToCortex(messages) {
+export function storedMessagesToChat(messages) {
     const out = [];
     // The last message of the group being walked, as `out` holds it.
     let groupLast;
@@ -62,7 +48,7 @@ export function storedMessagesToCortex(messages) {
             const createdAt = row.createdAt === undefined ? {} : { createdAt: row.createdAt.toISOString() };
             const author = row.author === undefined ? {} : { author: row.author };
             groupLast = undefined;
-            for (const message of conversationUIToCortexMessages(row.displayEnvelope.messages)) {
+            for (const message of conversationUIToChatMessages(row.displayEnvelope.messages)) {
                 const stamped = { ...message, ...createdAt, ...(message.role === "user" ? author : {}) };
                 const previous = out.at(-1);
                 // The merged message keeps the creation time of its first round.