The Open Framework for Building Agents
fix(eve): persist text streams as deltas (#2867)
Rui70c8a2eb340b
diff --git a/.changeset/tough-deltas-stream.md b/.changeset/tough-deltas-stream.mdnew file mode 100644index 000000000..f75b07c5d--- /dev/null+++ b/.changeset/tough-deltas-stream.md@@ -0,0 +1,9 @@+---+"eve": minor+---++Store message and reasoning appends as plain deltas instead of repeating cumulative text. Streamed tool-input appends now use the same delta-only shape.++Empty tool-input start markers no longer emit an append event; the first append contains actual input text.++Extensions built against the previous dynamic-tool, channel, schedule, subagent, connection, hook, dynamic-skill, or dynamic-instructions capability contracts must be rebuilt and republished with this release.diff --git a/apps/frameworks/next/app/_chat/trace-reducer.ts b/apps/frameworks/next/app/_chat/trace-reducer.tsindex 1ccdc4d22..00a3e06fb 100644--- a/apps/frameworks/next/app/_chat/trace-reducer.ts+++ b/apps/frameworks/next/app/_chat/trace-reducer.ts@@ -2,7 +2,7 @@ import type { EveAgentReducer, EveAgentReducerEvent } from "eve/react";import type { MessageStreamEvent } from "eve/client";import { buildTraceTurnsFromTranscript } from "./trace";-import type { TraceStep, TraceTurn, TranscriptStreamEvent } from "./types";+import type { TraceStep, TraceTurn } from "./types";export interface TraceProjection {readonly events: readonly MessageStreamEvent[];@@ -71,7 +71,7 @@ function reduceTraceProjection(}function buildTraceTurnsFromEvents(events: readonly MessageStreamEvent[]): readonly TraceTurn[] {- return buildTraceTurnsFromTranscript(events as readonly TranscriptStreamEvent[]);+ return buildTraceTurnsFromTranscript(events);}function clientMessageTurns(turns: readonly TraceTurn[]): readonly TraceTurn[] {diff --git a/apps/frameworks/next/app/_chat/trace.ts b/apps/frameworks/next/app/_chat/trace.tsindex efea4061f..ac5b4e8f9 100644--- a/apps/frameworks/next/app/_chat/trace.ts+++ b/apps/frameworks/next/app/_chat/trace.ts@@ -70,27 +70,27 @@ function readEventTimestamp(event: TranscriptStreamEvent): string | undefined {}function getEventTurnId(event: TranscriptStreamEvent): string | undefined {- if (!isRecord(event.data)) {+ if (!("data" in event) || !isRecord(event.data)) {return undefined;}- return readString(event.data.turnId);+ return readString((event.data as Record<string, unknown>).turnId);}function getEventSequence(event: TranscriptStreamEvent): number | undefined {- if (!isRecord(event.data)) {+ if (!("data" in event) || !isRecord(event.data)) {return undefined;}- return readNumber(event.data.sequence);+ return readNumber((event.data as Record<string, unknown>).sequence);}function getEventStepIndex(event: TranscriptStreamEvent): number | undefined {- if (!isRecord(event.data)) {+ if (!("data" in event) || !isRecord(event.data)) {return undefined;}- return readNumber(event.data.stepIndex);+ return readNumber((event.data as Record<string, unknown>).stepIndex);}function ensureTurn(@@ -420,8 +420,8 @@ export function buildTraceTurnsFromTranscript(continue;}- if (event.type === "reasoning.appended" && step !== undefined && isRecord(event.data)) {- step.reasoningText = readString(event.data.reasoningSoFar);+ if (event.type === "reasoning.appended" && step !== undefined) {+ step.reasoningText = (step.reasoningText ?? "") + event.data.reasoningDelta;continue;}@@ -430,8 +430,8 @@ export function buildTraceTurnsFromTranscript(continue;}- if (event.type === "message.appended" && step !== undefined && isRecord(event.data)) {- step.responseText = readString(event.data.messageSoFar);+ if (event.type === "message.appended" && step !== undefined) {+ step.responseText = (step.responseText ?? "") + event.data.messageDelta;continue;}diff --git a/apps/frameworks/next/app/_chat/types.ts b/apps/frameworks/next/app/_chat/types.tsindex 9a914ca95..8ca2aedc6 100644--- a/apps/frameworks/next/app/_chat/types.ts+++ b/apps/frameworks/next/app/_chat/types.ts@@ -1,40 +1,6 @@-export interface TranscriptMessageReceivedEvent {- readonly data: {- readonly message: string;- };- readonly type: "message.received";-}--export interface TranscriptMessageCompletedEvent {- readonly data: {- readonly finishReason?: string;- readonly message: string | null;- };- readonly type: "message.completed";-}--export interface TranscriptSessionFailedEvent {- readonly data: {- readonly message: string;- };- readonly type: "session.failed";-}--export interface TranscriptEventMeta {- readonly at: string;-}+import type { MessageStreamEvent } from "eve/client";-export type TranscriptStreamEvent = (- | TranscriptMessageCompletedEvent- | TranscriptMessageReceivedEvent- | TranscriptSessionFailedEvent- | {- readonly data?: unknown;- readonly type: string;- }-) & {- readonly meta?: TranscriptEventMeta;-};+export type TranscriptStreamEvent = MessageStreamEvent;/*** Derived status for one trace step in the local trace viewer.diff --git a/docs/concepts/sessions-runs-and-streaming.md b/docs/concepts/sessions-runs-and-streaming.mdindex d2089f304..e35451dbe 100644--- a/docs/concepts/sessions-runs-and-streaming.md+++ b/docs/concepts/sessions-runs-and-streaming.md@@ -51,7 +51,7 @@ The stream is newline-delimited JSON (NDJSON), one event per line:| `turn.started` | A new turn began; carries the active `trace` when the runtime is traced. || `message.received` | An inbound user message was accepted; carries flattened text plus structured text/file parts. || `step.started` | A model step began. |-| `action.input.appended` | A raw tool-input text delta, its character offset, and tool-call identity. |+| `action.input.appended` | A raw tool-input text delta and its tool-call identity. || `actions.requested` | The model requested one or more actions, including tool calls; calls stream before execution. || `action.partial` | A locally executed tool generator yielded a preliminary output snapshot. || `action.result` | A tool call returned. |@@ -59,9 +59,9 @@ The stream is newline-delimited JSON (NDJSON), one event per line:| `input.resolved` | The server accepted terminal human-input outcomes; carries `resolutions` with responses when provided. || `subagent.called` | A subagent was delegated; carries `childSessionId` to attach to. || `subagent.completed` | A delegated subagent finished. |-| `reasoning.appended` | A reasoning delta (incremental, with cumulative text so far). |+| `reasoning.appended` | A reasoning text delta. || `reasoning.completed` | The finalized reasoning block. |-| `message.appended` | An assistant text delta (incremental, with cumulative text so far). |+| `message.appended` | An assistant text delta. || `message.completed` | A finalized assistant text block. || `result.completed` | The finalized structured result for a turn that requested an output schema; carries `result`. || `compaction.requested` | Context-window compaction began; carries `modelId`, `sessionId`, `turnId`, `usageInputTokens`. |@@ -79,9 +79,15 @@ The stream is newline-delimited JSON (NDJSON), one event per line:The optional `data.trace` on session and turn starts contains eve-owned W3C trace coordinates: `traceId`, `spanId`, and `traceFlags`. Use it to correlate stream consumers such as eval reporters with an observability backend. An uninstrumented target omits it.-`reasoning.appended`, `message.appended`, and `action.input.appended` stream incremental output as it arrives. When the durable stream writer is busy, eve may coalesce adjacent deltas for the same text block or tool call; the text remains in source order, and a different event type, tool `callId`, or stream coordinate forms an ordering barrier. Text and reasoning appends carry both the new delta and the cumulative text for the current block. The finalized blocks show up on `message.completed` and `reasoning.completed`, which is the compatibility path for clients that don't render incremental streaming.+`reasoning.appended`, `message.appended`, and `action.input.appended` stream incremental output as it arrives. Each append stores only its new text in `reasoningDelta`, `messageDelta`, or `inputTextDelta`. Accumulate the deltas in stream order when you need the text so far. When the durable stream writer is busy, eve may coalesce adjacent deltas for the same event type, stream coordinates, and tool `callId`. The resulting text and event ordering stay the same.-When a streamed tool input becomes a validated call, its `action.input.appended` events precede the matching `actions.requested` event. Each append carries `callId`, `toolName`, `inputTextDelta`, and `inputTextOffset`; the offset is the zero-based UTF-16 code-unit position where the delta begins. Storing only the delta and offset avoids repeating the cumulative input in every durable event. The default client reducer starts or restarts accumulation at offset `0`, ignores a nonzero offset that is not contiguous, and projects the potentially incomplete JSON as a `dynamic-tool` part with `state: "input-streaming"` and cumulative text in `inputText`. `actions.requested` replaces that part with `state: "input-available"` and the validated `input`. Excluded internal actions never publish their input stream.+The default client reducer accumulates assistant text, reasoning, and streamed tool input. A raw consumer can append each delta to its local accumulator. If it reconnects without that state, it must replay the earlier events or wait for `message.completed` or `reasoning.completed`. Those completed events carry the authoritative value for each finalized block and remain the compatibility path for clients that do not render incremental streaming.++If a model provider fails after partial output and eve retries the call, the durable stream keeps events from both attempts. When the failed attempt emitted only deltas, a later completed event lets replaceable projections converge on the successful attempt. A completed block does not mean the provider attempt itself later succeeded; removing abandoned completed blocks would require attempt identity, which these events do not carry.++The client validates the `x-eve-stream-version` header on every connection. It normalizes v21–v24 cumulative message and reasoning appends, plus v24 offset-based tool-input appends, to the v25 delta-only contract. This lets a reconnect cross deployments without changing the reducer input. A current server performs the same normalization when replaying a session written by an earlier deployment. A missing or unsupported version, or an append whose fields do not match its declared version, fails instead of being interpreted as a current event.++When a streamed tool input becomes a validated call, its `action.input.appended` events precede the matching `actions.requested` event. The default client reducer projects the potentially incomplete JSON as a `dynamic-tool` part with `state: "input-streaming"` and cumulative text in `inputText`. `actions.requested` replaces that part with `state: "input-available"` and the validated `input`. Excluded internal actions never publish their input stream.`action.partial` carries one complete preliminary output snapshot from an authored async-generator tool. A later partial for the same `callId` replaces it, and `action.result` is the final snapshot. When the durable writer is busy, eve may keep only the newest adjacent partial for a call. Treat partials as last-write-wins: a durable step can retry and replay overlapping event runs. Provider-executed tool progress and MCP progress notifications are not projected as `action.partial` events.@@ -116,7 +122,7 @@ Alongside `type` and `data`, every event carries a `meta` envelope:`meta.id` is stable. eve mints it once, when the event is written to the durable stream, and stores it with the event. Reconnecting from a cursor, rewinding to `startIndex=0`, or replaying a finished session all return the same id for the same event.-`meta.at` has always been there; `meta.id` arrived in stream version 20, and `action.input.appended` arrived in version 24. Events written by an earlier version are stored with the envelope but no id inside it, so rewinding into the part of a session that ran before you upgraded yields events whose `meta.id` is absent, even though the type says it is always a string. eve passes those events through rather than dropping them, and they cannot be deduplicated. The exposure ends when the sessions that predate your upgrade do.+`meta.at` has always been there; `meta.id` arrived in stream version 20, `action.input.appended` arrived in version 24, and delta-only message and reasoning appends replaced cumulative snapshots in version 25. Events written by an earlier version are stored with the envelope but no id inside it, so rewinding into the part of a session that ran before you upgraded yields events whose `meta.id` is absent, even though the type says it is always a string. eve passes those events through rather than dropping them, and they cannot be deduplicated. The exposure ends when the sessions that predate your upgrade do.That makes it the key for ingesting a stream into a database without duplicating rows when you re-read it:diff --git a/docs/guides/client/streaming.mdx b/docs/guides/client/streaming.mdxindex edcd8623e..93fb13bc1 100644--- a/docs/guides/client/streaming.mdx+++ b/docs/guides/client/streaming.mdx@@ -75,7 +75,23 @@ for await (const event of response) {}```-`message.appended`, `reasoning.appended`, and `action.input.appended` are incremental delta events. eve may combine adjacent deltas for the same text block or tool call while a durable stream write is in flight, but preserves their text and event ordering. A different event type, tool `callId`, or stream coordinate is a barrier. The completed text forms, `message.completed` and `reasoning.completed`, are the compatibility path for clients that don't render deltas. A streamed tool input is complete when the matching validated call arrives in `actions.requested`.+`message.appended`, `reasoning.appended`, and `action.input.appended` are incremental delta events. Each carries only its new text and existing stream coordinates. eve may combine adjacent deltas for the same event type, stream coordinates, and tool `callId` while a durable stream write is in flight, but preserves their text and event ordering. The completed text forms, `message.completed` and `reasoning.completed`, carry the authoritative value for each finalized block and remain the compatibility path for clients that don't render deltas. A streamed tool input is complete when the matching validated call arrives in `actions.requested`.++The default message reducer accumulates these events for you. A raw stream consumer can apply the same rule directly:++```ts+let message = "";++for await (const event of response) {+ if (event.type !== "message.appended") continue;++ message += event.data.messageDelta;+}+```++After reconnecting without local state, replay the earlier events or wait for the completed event instead of appending a later delta to an empty value. Apply the same rule to `reasoningDelta` and `inputTextDelta`. If a model provider fails after partial output and eve retries the call, the durable stream keeps events from both attempts. A later completed event replaces provisional text only when the failed attempt did not already complete that block; the protocol has no attempt identity with which to retract earlier completed blocks.++The eve client validates the stream version on every connection. It accepts v21–v24 cumulative message and reasoning append events and v24 offset-based tool-input appends, then exposes them through the current delta-only `MessageStreamEvent` contract. This also applies when an automatic reconnect reaches a newer deployment. A missing or unsupported `x-eve-stream-version` header fails the stream instead of treating unknown JSON as the current event type.## Handle event types@@ -116,7 +132,7 @@ The most common UI events are:For the complete event table, see [Sessions, runs & streaming](../../concepts/sessions-runs-and-streaming).-Each `action.input.appended` event stores `inputTextDelta` and its zero-based UTF-16 code-unit `inputTextOffset`, so consumers can reject a gap instead of concatenating corrupt input. The default message reducer starts or restarts at offset `0` and ignores a nonzero offset that is not contiguous. It accumulates accepted deltas into a `dynamic-tool` part with `state: "input-streaming"`; its `inputText` field contains cumulative raw text that may be incomplete JSON. The matching `actions.requested` event upgrades the same `toolCallId` to `state: "input-available"` and puts the validated value in `input`.+For `action.input.appended`, the default message reducer accumulates accepted deltas into a `dynamic-tool` part with `state: "input-streaming"`; its `inputText` field contains cumulative raw text that may be incomplete JSON. The matching `actions.requested` event upgrades the same `toolCallId` to `state: "input-available"` and puts the validated value in `input`.When a submitted message includes attachments, `message.received.data.message` stays theflattened compatibility summary, while `message.received.data.parts` carries renderable text anddiff --git a/packages/eve/extension-contracts/reports/channel/v13.json b/packages/eve/extension-contracts/reports/channel/v13.jsonnew file mode 100644index 000000000..e11405975--- /dev/null+++ b/packages/eve/extension-contracts/reports/channel/v13.json@@ -0,0 +1,21 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "channel",+ "epoch": 13,+ "sha256": "8a3397c349e5ea5d0a9222329b182b1207ff71dd305741f15b8c0769cf980f59",+ "exports": [+ "DELETE",+ "GET",+ "HEAD",+ "OPTIONS",+ "PATCH",+ "POST",+ "PUT",+ "WS",+ "createWebSocketUpgradeServer",+ "defineChannel",+ "disableRoute",+ "isChannel",+ "isDisabledRouteSentinel"+ ]+}diff --git a/packages/eve/extension-contracts/reports/connection/v11.json b/packages/eve/extension-contracts/reports/connection/v11.jsonnew file mode 100644index 000000000..ca2796956--- /dev/null+++ b/packages/eve/extension-contracts/reports/connection/v11.json@@ -0,0 +1,16 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "connection",+ "epoch": 11,+ "sha256": "26af496913b95b123e0190e4e5238085dcc5a938ebf0c0cf82ccd12fb3e93067",+ "exports": [+ "ConnectionAuthorizationFailedError",+ "ConnectionAuthorizationRequiredError",+ "defineDynamic",+ "defineInteractiveAuthorization",+ "defineMcpClientConnection",+ "defineOpenAPIConnection",+ "isConnectionAuthorizationFailedError",+ "isConnectionAuthorizationRequiredError"+ ]+}diff --git a/packages/eve/extension-contracts/reports/dynamicInstructions/v15.json b/packages/eve/extension-contracts/reports/dynamicInstructions/v15.jsonnew file mode 100644index 000000000..d335f75ad--- /dev/null+++ b/packages/eve/extension-contracts/reports/dynamicInstructions/v15.json@@ -0,0 +1,7 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "dynamicInstructions",+ "epoch": 15,+ "sha256": "b04313531ba239dcff5df419ae4ba9f005fbe38f33e05ee9639d0cf1323300cb",+ "exports": ["defineDynamic"]+}diff --git a/packages/eve/extension-contracts/reports/dynamicSkill/v14.json b/packages/eve/extension-contracts/reports/dynamicSkill/v14.jsonnew file mode 100644index 000000000..1ffc201d4--- /dev/null+++ b/packages/eve/extension-contracts/reports/dynamicSkill/v14.json@@ -0,0 +1,7 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "dynamicSkill",+ "epoch": 14,+ "sha256": "e2b2cefd1e6f5e83bb8bcb93de4041cafadc68cf411bbd608a047f8da522eee8",+ "exports": ["defineDynamic"]+}diff --git a/packages/eve/extension-contracts/reports/dynamicTool/v22.json b/packages/eve/extension-contracts/reports/dynamicTool/v22.jsonnew file mode 100644index 000000000..e622783a9--- /dev/null+++ b/packages/eve/extension-contracts/reports/dynamicTool/v22.json@@ -0,0 +1,13 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "dynamicTool",+ "epoch": 22,+ "sha256": "3fb090231de6475807a0c4fea6a2c19f379f0ed03bb970de9c7361c654282df9",+ "exports": [+ "DynamicToolEntry",+ "DynamicToolEvents",+ "DynamicToolResult",+ "DynamicToolSet",+ "defineDynamic"+ ]+}diff --git a/packages/eve/extension-contracts/reports/hook/v17.json b/packages/eve/extension-contracts/reports/hook/v17.jsonnew file mode 100644index 000000000..da8320aa4--- /dev/null+++ b/packages/eve/extension-contracts/reports/hook/v17.json@@ -0,0 +1,7 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "hook",+ "epoch": 17,+ "sha256": "25f6661df92a607a8c00087d6e4b2fe8ab23d8d7bb35fda9a613eeb4f3a5f950",+ "exports": ["defineHook"]+}diff --git a/packages/eve/extension-contracts/reports/schedule/v6.json b/packages/eve/extension-contracts/reports/schedule/v6.jsonnew file mode 100644index 000000000..1803a279e--- /dev/null+++ b/packages/eve/extension-contracts/reports/schedule/v6.json@@ -0,0 +1,14 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "schedule",+ "epoch": 6,+ "sha256": "1fe060add742493d7f5b5ac0a52de07ae170bb0e799d3c199055731bcf674686",+ "exports": [+ "ScheduleDefinition",+ "ScheduleHandlerArgs",+ "ScheduleRunHandler",+ "ScheduleToFn",+ "TypedReceiveTarget",+ "defineSchedule"+ ]+}diff --git a/packages/eve/extension-contracts/reports/subagent/v6.json b/packages/eve/extension-contracts/reports/subagent/v6.jsonnew file mode 100644index 000000000..e47a9db1a--- /dev/null+++ b/packages/eve/extension-contracts/reports/subagent/v6.json@@ -0,0 +1,20 @@+{+ "kind": "eve-extension-capability-contract",+ "capability": "subagent",+ "epoch": 6,+ "sha256": "618e2e7d2c3c1025da0538c27b4452560eaacbc0490e045918bd6731ab850b7e",+ "exports": [+ "AgentCompactionDefinition",+ "AgentDefinition",+ "AgentModelDefinition",+ "AgentStaticModelDefinition",+ "DefinedAgent",+ "DynamicLocalSubagentDefinition",+ "DynamicSubagentDefinition",+ "RemoteAgentDefinition",+ "RemoteAgentDefinitionInput",+ "defineAgent",+ "defineDynamic",+ "defineRemoteAgent"+ ]+}diff --git a/packages/eve/src/acp/adapter.test.ts b/packages/eve/src/acp/adapter.test.tsindex f7cb2fd5c..3d50edf9a 100644--- a/packages/eve/src/acp/adapter.test.ts+++ b/packages/eve/src/acp/adapter.test.ts@@ -137,13 +137,12 @@ describe("EveAcpAdapter", () => {const events: TestStreamEvent[] = [{type: "message.appended",- data: { messageDelta: "Hi", messageSoFar: "Hi", sequence: 1, stepIndex: 0, turnId: "t1" },+ data: { messageDelta: "Hi", sequence: 1, stepIndex: 0, turnId: "t1" },},{type: "reasoning.appended",data: {reasoningDelta: "Think",- reasoningSoFar: "Think",sequence: 2,stepIndex: 0,turnId: "t1",diff --git a/packages/eve/src/cli/dev/tui/runner.test.ts b/packages/eve/src/cli/dev/tui/runner.test.tsindex 6ab3e4eab..87ad07e61 100644--- a/packages/eve/src/cli/dev/tui/runner.test.ts+++ b/packages/eve/src/cli/dev/tui/runner.test.ts@@ -12,7 +12,11 @@ import { getApplicationInfo } from "#internal/application/paths.js";import { stampTestEvent } from "#internal/testing/events.js";import { createTestAgentInfoResult } from "#internal/testing/agent-info-fixture.js";import { resolveTestVercelTarget } from "#internal/testing/verified-vercel-target.js";-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";+import {+ EVE_MESSAGE_STREAM_VERSION,+ EVE_STREAM_VERSION_HEADER,+ type UnstampedMessageStreamEvent,+} from "#protocol/message.js";import { createDevelopmentCredentialGate } from "#services/dev-client/credential-gate.js";import type { VercelDeploymentResolution } from "#setup/vercel-deployment.js";@@ -461,6 +465,9 @@ function messageStreamResponseOf(events: readonly MessageStreamEvent[]): Responscontroller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}@@ -930,7 +937,6 @@ describe("EveTUIRunner idle session follow", () => {type: "message.appended",data: {messageDelta: "Background research finished.",- messageSoFar: "Background research finished.",sequence: 1,stepIndex: 1,turnId: "wake-turn",@@ -974,7 +980,6 @@ describe("EveTUIRunner idle session follow", () => {type: "message.appended",data: {messageDelta: "Follow-up answer.",- messageSoFar: "Follow-up answer.",sequence: 2,stepIndex: 0,turnId: "follow-up-turn",@@ -1320,6 +1325,9 @@ describe("EveTUIRunner development session continuity", () => {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}),);@@ -2172,7 +2180,6 @@ describe("EveTUIRunner reused step indexes", () => {type: "message.appended",data: {messageDelta: "I'll call the subagent.",- messageSoFar: "I'll call the subagent.",sequence: 0,stepIndex: 0,turnId: "t0",@@ -2194,7 +2201,6 @@ describe("EveTUIRunner reused step indexes", () => {type: "message.appended",data: {messageDelta: "The subagent returned TOKEN-123.",- messageSoFar: "The subagent returned TOKEN-123.",sequence: 0,stepIndex: 0,turnId: "t0",@@ -2249,7 +2255,6 @@ describe("EveTUIRunner replay guards", () => {type: "message.appended",data: {messageDelta: "Sunny.",- messageSoFar: "Sunny.",sequence: 0,stepIndex: 0,turnId: "turn_0",@@ -2295,7 +2300,7 @@ describe("EveTUIRunner replay guards", () => {expect(deltas).toEqual([{ type: "assistant-delta", id: "text:turn_0:0", delta: "Sunny." }]);});- it("deduplicates repeated call IDs and divergent text attempts in one turn", async () => {+ it("deduplicates repeated call IDs and replaces retried text with the completed text", async () => {const prompts: Array<string | undefined> = ["weather", undefined];const emitted: AgentTUIStreamEvent[] = [];const session = sessionYielding([@@ -2379,7 +2384,6 @@ describe("EveTUIRunner replay guards", () => {type: "message.appended",data: {messageDelta: "Using",- messageSoFar: "Using",sequence: 0,stepIndex: 1,turnId: "turn_0",@@ -2389,7 +2393,6 @@ describe("EveTUIRunner replay guards", () => {type: "message.appended",data: {messageDelta: " the first",- messageSoFar: "Using the first",sequence: 0,stepIndex: 1,turnId: "turn_0",@@ -2399,27 +2402,25 @@ describe("EveTUIRunner replay guards", () => {type: "message.appended",data: {messageDelta: " the retry",- messageSoFar: "Using the retry",sequence: 0,stepIndex: 1,turnId: "turn_0",},},{- type: "message.completed",+ type: "message.appended",data: {- finishReason: "stop",- message: "Using the first answer.",+ messageDelta: " collision",sequence: 0,stepIndex: 1,turnId: "turn_0",},},{- type: "message.appended",+ type: "message.completed",data: {- messageDelta: " answer.",- messageSoFar: "Using the retry answer.",+ finishReason: "stop",+ message: "Using the first answer.",sequence: 0,stepIndex: 1,turnId: "turn_0",@@ -2473,15 +2474,22 @@ describe("EveTUIRunner replay guards", () => {const toolCalls = emitted.filter((event) => event.type === "tool-call");const toolResults = emitted.filter((event) => event.type === "tool-result");- const assistantText = emitted+ const streamedText = emitted.filter((event) => event.type === "assistant-delta").map((event) => event.delta).join("");+ const assistantCompletes = emitted.filter((event) => event.type === "assistant-complete");expect(toolCalls.map((event) => event.toolCallId)).toEqual(["call-original", "call-replay"]);expect(toolResults.map((event) => event.toolCallId)).toEqual(["call-original", "call-replay"]);- expect(assistantText).toBe("Using the first answer.");- expect(assistantText).not.toContain("retry");+ expect(streamedText).toContain("the retry collision");+ expect(assistantCompletes).toEqual([+ {+ type: "assistant-complete",+ id: "text:turn_0:1",+ text: "Using the first answer.",+ },+ ]);expect(emitted.filter((event) => event.type === "finish")).toHaveLength(1);});@@ -3193,6 +3201,9 @@ describe("EveTUIRunner renderer teardown", () => {signal.addEventListener("abort", () => controller.close(), { once: true });},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);});@@ -4221,6 +4232,9 @@ describe("EveTUIRunner cancelled-turn subagent settling", () => {init?.signal?.addEventListener("abort", () => controller.close(), { once: true });},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },),);diff --git a/packages/eve/src/cli/dev/tui/runner.ts b/packages/eve/src/cli/dev/tui/runner.tsindex fde057acb..65bdf4953 100644--- a/packages/eve/src/cli/dev/tui/runner.ts+++ b/packages/eve/src/cli/dev/tui/runner.ts@@ -2174,7 +2174,6 @@ async function* eveEventsToTUIStream(const appended = event as MessageAppendedStreamEvent;const base = textPartId(appended.data.turnId, appended.data.stepIndex);const state = partStateFor(textParts, base);- const next = appended.data.messageSoFar;if (state.completed) {// No intervening `step.started`: a retry of the same model call.@@ -2187,12 +2186,9 @@ async function* eveEventsToTUIStream(state.completed = false;}- if (!next.startsWith(state.text) || next.length <= state.text.length) {- break;- }-- const delta = next.slice(state.text.length);- state.text = next;+ const delta = appended.data.messageDelta;+ if (delta.length === 0) break;+ state.text += delta;yield { type: "assistant-delta", id: partGenerationId(base, state.generation), delta };break;}@@ -2234,6 +2230,11 @@ async function* eveEventsToTUIStream(state.completed = true;state.completedEpoch = stepEpoch;yield { type: "assistant-complete", id };+ } else {+ state.text = message;+ state.completed = true;+ state.completedEpoch = stepEpoch;+ yield { type: "assistant-complete", id, text: message };}} else if (state.text.length > 0) {state.completed = true;@@ -2247,7 +2248,6 @@ async function* eveEventsToTUIStream(const appended = event as ReasoningAppendedStreamEvent;const base = reasoningPartId(appended.data.turnId, appended.data.stepIndex);const state = partStateFor(reasoningParts, base);- const next = appended.data.reasoningSoFar;if (state.completed) {if (stepEpoch <= state.completedEpoch) break;@@ -2256,12 +2256,9 @@ async function* eveEventsToTUIStream(state.completed = false;}- if (!next.startsWith(state.text) || next.length <= state.text.length) {- break;- }-- const delta = next.slice(state.text.length);- state.text = next;+ const delta = appended.data.reasoningDelta;+ if (delta.length === 0) break;+ state.text += delta;yield { type: "reasoning-delta", id: partGenerationId(base, state.generation), delta };break;}@@ -2288,6 +2285,14 @@ async function* eveEventsToTUIStream(state.text = next;yield { type: "reasoning-delta", id, delta: next };} else if (next.length > 0 && !next.startsWith(state.text)) {+ yield { type: "reasoning-complete", id };+ state.generation += 1;+ state.text = next;+ state.completed = true;+ state.completedEpoch = stepEpoch;+ const replacementId = partGenerationId(base, state.generation);+ yield { type: "reasoning-delta", id: replacementId, delta: next };+ yield { type: "reasoning-complete", id: replacementId };break;}@@ -2580,7 +2585,12 @@ type StreamPartState = {function partStateFor(parts: Map<string, StreamPartState>, base: string): StreamPartState {let state = parts.get(base);if (state === undefined) {- state = { generation: 0, text: "", completed: false, completedEpoch: 0 };+ state = {+ generation: 0,+ text: "",+ completed: false,+ completedEpoch: 0,+ };parts.set(base, state);}return state;diff --git a/packages/eve/src/cli/dev/tui/subagent-pump.test.ts b/packages/eve/src/cli/dev/tui/subagent-pump.test.tsindex bebf34d99..177e043d1 100644--- a/packages/eve/src/cli/dev/tui/subagent-pump.test.ts+++ b/packages/eve/src/cli/dev/tui/subagent-pump.test.ts@@ -2,7 +2,12 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { Client, type MessageStreamEvent } from "#client/index.js";import { stampTestEvent } from "#internal/testing/events.js";-import type { UnstampedMessageStreamEvent, SubagentCalledStreamEvent } from "#protocol/message.js";+import {+ EVE_MESSAGE_STREAM_VERSION,+ EVE_STREAM_VERSION_HEADER,+ type SubagentCalledStreamEvent,+ type UnstampedMessageStreamEvent,+} from "#protocol/message.js";import { SubagentPump, type SubagentView } from "./subagent-pump.js";@@ -51,6 +56,9 @@ function pushableChildStream() {);},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);},get aborted() {@@ -83,6 +91,9 @@ function responseOf(events: readonly MessageStreamEvent[]): Response {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}@@ -92,7 +103,6 @@ function reasoningEvent(delta: string, index = 0): MessageStreamEvent {type: "reasoning.appended",data: {reasoningDelta: delta,- reasoningSoFar: delta,sequence: 2,stepIndex: 0,turnId: "child-turn",diff --git a/packages/eve/src/cli/dev/tui/subagent-pump.ts b/packages/eve/src/cli/dev/tui/subagent-pump.tsindex 2673aa4e5..8eabffeb1 100644--- a/packages/eve/src/cli/dev/tui/subagent-pump.ts+++ b/packages/eve/src/cli/dev/tui/subagent-pump.ts@@ -8,6 +8,7 @@import type { Client } from "#client/index.js";import { readNdjsonStream } from "#client/ndjson.js";+import { readMessageStreamVersion } from "#client/stream-version.js";import { createEventDeduper, type EventDeduper } from "#protocol/event-dedupe.js";import {isCurrentTurnBoundaryEvent,@@ -287,7 +288,9 @@ export class SubagentPump {throw new Error(`Child stream returned ${response.status}.`);}- for await (const event of readNdjsonStream(response.body)) {+ for await (const event of readNdjsonStream(response.body, {+ streamVersion: readMessageStreamVersion(response.headers),+ })) {if (controller.signal.aborted) return;deliveredEvent = true;run.childStreamIndex += 1;diff --git a/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts b/packages/eve/src/cli/dev/tui/terminal-renderer.test.tsindex 260963e5b..cdeb5a727 100644--- a/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts+++ b/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts@@ -249,6 +249,23 @@ describe("TerminalRenderer (inline scrollback)", () => {expect(snapshot).toContain("It's 73°F in SF.");});+ it("replaces discarded retry text with the authoritative completed message", async () => {+ const { screen, renderer } = makeRenderer();+ await renderer.renderStream(+ streamOf([+ { type: "assistant-delta", id: "t1", delta: "Discard this partial response." },+ { type: "assistant-delta", id: "t1", delta: "Recovered answer." },+ { type: "assistant-complete", id: "t1", text: "Recovered answer." },+ { type: "finish" },+ ]),+ { submittedPrompt: "continue", continueSession: false },+ );++ const snapshot = screen.snapshot();+ expect(snapshot).not.toContain("Discard this partial response.");+ expect(snapshot.match(/Recovered answer\./gu)).toHaveLength(1);+ });+it("renders rejected tools as denied", async () => {const { screen, renderer } = makeRenderer();await renderer.renderStream(diff --git a/packages/eve/src/cli/dev/tui/terminal-renderer.ts b/packages/eve/src/cli/dev/tui/terminal-renderer.tsindex 7e27cd077..5a9e41e40 100644--- a/packages/eve/src/cli/dev/tui/terminal-renderer.ts+++ b/packages/eve/src/cli/dev/tui/terminal-renderer.ts@@ -3519,10 +3519,7 @@ export class TerminalRenderer implements AgentTUIRenderer {case "assistant-complete": {const existing = turnState.text.get(event.id) ?? "";- const text =- event.text !== undefined && existing.length === 0- ? stripTerminalControls(event.text ?? "")- : existing;+ const text = typeof event.text === "string" ? stripTerminalControls(event.text) : existing;turnState.text.set(event.id, text);this.#upsertAssistantBlock(event.id, text, false);break;diff --git a/packages/eve/src/cli/invoke/invoke.test.ts b/packages/eve/src/cli/invoke/invoke.test.tsindex 7b12c3568..0e1cb8f13 100644--- a/packages/eve/src/cli/invoke/invoke.test.ts+++ b/packages/eve/src/cli/invoke/invoke.test.ts@@ -1,5 +1,7 @@import { afterEach, describe, expect, it, vi } from "vitest";+import { EVE_MESSAGE_STREAM_VERSION, EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";+import { resolveInvokeOperation, runInvoke, type RunInvokeInput } from "./invoke.js";import { parseInvokeResumeInput } from "./result.js";@@ -320,5 +322,8 @@ function streamResponse(events: readonly unknown[]): Response {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}diff --git a/packages/eve/src/client/client.test.ts b/packages/eve/src/client/client.test.tsindex 70a8069ff..59a8b4d15 100644--- a/packages/eve/src/client/client.test.ts+++ b/packages/eve/src/client/client.test.ts@@ -8,6 +8,7 @@ import { createTestAgentInfoResult } from "#internal/testing/agent-info-fixture.import { resolveTestVercelTarget } from "#internal/testing/verified-vercel-target.js";import { resolveRemoteDevelopmentClientOptions } from "#services/dev-client/client-options.js";import { createDevelopmentCredentialGate } from "#services/dev-client/credential-gate.js";+import { EVE_MESSAGE_STREAM_VERSION, EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";const AGENT_INFO = createTestAgentInfoResult({agentRoot: "/tmp/weather-agent/agent",@@ -58,7 +59,9 @@ describe("Client request policy", () => {Response.json({ sessionId: "session_1", status: "accepted" }, { status: 202 }),).mockResolvedValueOnce(- new Response(`${JSON.stringify({ data: {}, type: "session.completed" })}\n`),+ new Response(`${JSON.stringify({ data: {}, type: "session.completed" })}\n`, {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ }),);const client = new Client({host: "https://eve.test?x-vercel-protection-bypass=secret",@@ -87,7 +90,9 @@ describe("Client request policy", () => {Response.json({ sessionId: "session_1", status: "accepted" }, { status: 202 }),).mockResolvedValueOnce(- new Response(`${JSON.stringify({ data: {}, type: "session.completed" })}\n`),+ new Response(`${JSON.stringify({ data: {}, type: "session.completed" })}\n`, {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ }),);const client = new Client({ host: "https://eve.test", redirect: "manual" });@@ -125,7 +130,9 @@ describe("Client request policy", () => {Response.json({ sessionId: "session_1", status: "accepted" }, { status: 202 }),).mockResolvedValueOnce(- new Response(`${JSON.stringify({ data: {}, type: "session.completed" })}\n`),+ new Response(`${JSON.stringify({ data: {}, type: "session.completed" })}\n`, {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ }),);const client = new Client({host: "https://eve.test",diff --git a/packages/eve/src/client/eve-agent-store.test.ts b/packages/eve/src/client/eve-agent-store.test.tsindex 2c8b16ecc..bfaaf051a 100644--- a/packages/eve/src/client/eve-agent-store.test.ts+++ b/packages/eve/src/client/eve-agent-store.test.ts@@ -4,16 +4,23 @@ import { detachEveAgentStore, EveAgentStore } from "#client/eve-agent-store.js";import { defaultMessageReducer } from "#client/message-reducer.js";import { stampTestEvents } from "#internal/testing/events.js";import {+ createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createSessionFailedEvent,createSessionWaitingEvent,createTurnCancelledEvent,createTurnStartedEvent,+ EVE_MESSAGE_STREAM_VERSION,EVE_SESSION_ID_HEADER,+ EVE_STREAM_VERSION_HEADER,type UnstampedMessageStreamEvent,type MessageStreamEvent,} from "#protocol/message.js";+import type {+ MessageStreamEventForVersion,+ MessageStreamVersion,+} from "#protocol/message-version.js";function turnEvents(): MessageStreamEvent[] {return stampTestEvents([@@ -29,6 +36,33 @@ function turnEvents(): MessageStreamEvent[] {] as UnstampedMessageStreamEvent[]);}+function streamingTurnEvents(): MessageStreamEvent[] {+ return stampTestEvents([+ createMessageReceivedEvent({ message: "Hello", sequence: 0, turnId: "turn_1" }),+ createTurnStartedEvent({ sequence: 1, turnId: "turn_1" }),+ createMessageAppendedEvent({+ messageDelta: "Hel",+ sequence: 2,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createMessageAppendedEvent({+ messageDelta: "lo",+ sequence: 3,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createMessageCompletedEvent({+ finishReason: "stop",+ message: "Hello",+ sequence: 4,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createSessionWaitingEvent(),+ ] as UnstampedMessageStreamEvent[]);+}+function startedResponse(): Response {return new Response(JSON.stringify({ ok: true, sessionId: "session_1", status: "accepted" }), {headers: { "content-type": "application/json", [EVE_SESSION_ID_HEADER]: "session_1" },@@ -36,7 +70,10 @@ function startedResponse(): Response {});}-function streamResponse(events: readonly MessageStreamEvent[]): Response {+function versionedStreamResponse<Version extends MessageStreamVersion>(+ version: Version,+ events: readonly MessageStreamEventForVersion<Version>[],+): Response {const encoder = new TextEncoder();return new Response(new ReadableStream<Uint8Array>({@@ -47,6 +84,41 @@ function streamResponse(events: readonly MessageStreamEvent[]): Response {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: version },+ },+ );+}++function streamResponse(events: readonly MessageStreamEvent[]): Response {+ return versionedStreamResponse(EVE_MESSAGE_STREAM_VERSION, events);+}++function disconnectingStreamResponse(events: readonly MessageStreamEvent[]): Response {+ return versionedDisconnectingStreamResponse(EVE_MESSAGE_STREAM_VERSION, events);+}++function versionedDisconnectingStreamResponse<Version extends MessageStreamVersion>(+ version: Version,+ events: readonly MessageStreamEventForVersion<Version>[],+): Response {+ const encoder = new TextEncoder();+ let index = 0;+ return new Response(+ new ReadableStream<Uint8Array>({+ pull(controller) {+ const event = events[index];+ if (event !== undefined) {+ index += 1;+ controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));+ return;+ }+ controller.error(new TypeError("terminated"));+ },+ }),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: version },+ },);}@@ -68,6 +140,9 @@ function controlledStreamResponse() {controller = nextController;},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);return {@@ -106,6 +181,95 @@ afterEach(() => {});describe("EveAgentStore stream overlap", () => {+ it("reconstructs a split message across an in-memory stream reconnect", async () => {+ const events = streamingTurnEvents();+ const fetchMock = vi+ .spyOn(globalThis, "fetch")+ .mockResolvedValueOnce(startedResponse())+ .mockResolvedValueOnce(disconnectingStreamResponse(events.slice(0, 3)))+ .mockResolvedValueOnce(streamResponse(events.slice(3)));+ const store = new EveAgentStore({ reducer: defaultMessageReducer() });+ const streamingText: string[] = [];+ store.subscribe(() => {+ const part = store.snapshot.data.messages.at(-1)?.parts.at(-1);+ if (part?.type === "text" && part.state === "streaming") streamingText.push(part.text);+ });++ await store.send({ message: "Hello" });++ expect(streamingText).toContain("Hel");+ expect(streamingText).toContain("Hello");+ expect(store.snapshot.data.messages.at(-1)?.parts).toContainEqual({+ state: "done",+ stepIndex: 0,+ text: "Hello",+ type: "text",+ });+ expect(+ fetchMock.mock.calls+ .slice(1)+ .map(([request]) =>+ new URL(request.toString(), "http://localhost").searchParams.get("startIndex"),+ ),+ ).toEqual([null, "3"]);+ });++ it.each(["21", "24"] as const)(+ "reconstructs a split message across a v%s-to-v25 reconnect",+ async (legacyVersion) => {+ const current = streamingTurnEvents();+ const received = current[0]!;+ const started = current[1]!;+ if (received.type !== "message.received" || started.type !== "turn.started") {+ throw new Error("Expected the streaming fixture to begin a turn.");+ }+ const legacyPrefix = [+ received,+ started,+ {+ data: {+ messageDelta: "Hel",+ messageSoFar: "Hel",+ sequence: 2,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: current[2]!.meta,+ type: "message.appended",+ },+ ] satisfies readonly MessageStreamEventForVersion<typeof legacyVersion>[];+ const fetchMock = vi+ .spyOn(globalThis, "fetch")+ .mockResolvedValueOnce(startedResponse())+ .mockResolvedValueOnce(versionedDisconnectingStreamResponse(legacyVersion, legacyPrefix))+ .mockResolvedValueOnce(versionedStreamResponse("25", current.slice(3)));+ const store = new EveAgentStore({ reducer: defaultMessageReducer() });+ const streamingText: string[] = [];+ store.subscribe(() => {+ const part = store.snapshot.data.messages.at(-1)?.parts.at(-1);+ if (part?.type === "text" && part.state === "streaming") streamingText.push(part.text);+ });++ await store.send({ message: "Hello" });++ expect(streamingText).toContain("Hel");+ expect(streamingText).toContain("Hello");+ expect(store.snapshot.data.messages.at(-1)?.parts).toContainEqual({+ state: "done",+ stepIndex: 0,+ text: "Hello",+ type: "text",+ });+ expect(+ fetchMock.mock.calls+ .slice(1)+ .map(([request]) =>+ new URL(request.toString(), "http://localhost").searchParams.get("startIndex"),+ ),+ ).toEqual([null, "3"]);+ },+ );+it("rejects a prepared turn containing both a message and input responses", async () => {const fetchMock = vi.spyOn(globalThis, "fetch");const store = new EveAgentStore({ reducer: defaultMessageReducer() });@@ -213,6 +377,72 @@ describe("EveAgentStore stream overlap", () => {});describe("EveAgentStore session resume", () => {+ it("continues a split message from a complete hydrated prefix", async () => {+ const events = streamingTurnEvents();+ const prefix = events.slice(0, 3);+ const fetchMock = vi+ .spyOn(globalThis, "fetch")+ .mockResolvedValueOnce(boundedStreamResponse([events[3]!], 3))+ .mockResolvedValueOnce(streamResponse(events.slice(4)));+ const store = new EveAgentStore({+ initialEvents: prefix,+ initialSession: { sessionId: "session_1", streamIndex: prefix.length },+ reducer: defaultMessageReducer(),+ });+ const streamingText: string[] = [];+ store.subscribe(() => {+ const part = store.snapshot.data.messages.at(-1)?.parts.at(-1);+ if (part?.type === "text" && part.state === "streaming") streamingText.push(part.text);+ });++ await store.resume();++ expect(+ new URL(fetchMock.mock.calls[0]![0].toString(), "http://localhost").searchParams.get(+ "startIndex",+ ),+ ).toBe(String(prefix.length));+ expect(streamingText).toContain("Hello");+ expect(store.snapshot.data.messages.at(-1)?.parts).toContainEqual({+ state: "done",+ stepIndex: 0,+ text: "Hello",+ type: "text",+ });+ });++ it("replays a split message from index zero when only its cursor was retained", async () => {+ const events = streamingTurnEvents();+ const fetchMock = vi+ .spyOn(globalThis, "fetch")+ .mockResolvedValueOnce(boundedStreamResponse(events.slice(0, 4), 3))+ .mockResolvedValueOnce(streamResponse(events.slice(4)));+ const store = new EveAgentStore({+ initialSession: { sessionId: "session_1", streamIndex: 3 },+ reducer: defaultMessageReducer(),+ });+ const streamingText: string[] = [];+ store.subscribe(() => {+ const part = store.snapshot.data.messages.at(-1)?.parts.at(-1);+ if (part?.type === "text" && part.state === "streaming") streamingText.push(part.text);+ });++ await store.resume();++ expect(+ new URL(fetchMock.mock.calls[0]![0].toString(), "http://localhost").searchParams.get(+ "startIndex",+ ),+ ).toBeNull();+ expect(streamingText).toContain("Hello");+ expect(store.snapshot.data.messages.at(-1)?.parts).toContainEqual({+ state: "done",+ stepIndex: 0,+ text: "Hello",+ type: "text",+ });+ });+it("keeps a settled hydrated snapshot resuming until catch-up returns ready", async () => {const events = turnEvents();const fetchMock = vidiff --git a/packages/eve/src/client/message-reducer-primitives.ts b/packages/eve/src/client/message-reducer-primitives.tsindex 72f312495..d221bb8f7 100644--- a/packages/eve/src/client/message-reducer-primitives.ts+++ b/packages/eve/src/client/message-reducer-primitives.ts@@ -69,13 +69,3 @@ export function removeStreamingToolPartsForTurn(export function optimisticUserMessageId(submissionId: string): string {return `optimistic:${submissionId}:user`;}--export function appendToolInputDelta(- inputText: string | undefined,- offset: number,- delta: string,-): string | undefined {- if (offset === 0) return delta;- if (inputText?.length !== offset) return undefined;- return inputText + delta;-}diff --git a/packages/eve/src/client/message-reducer.test.ts b/packages/eve/src/client/message-reducer.test.tsindex a4a4de8c6..7ac44aa3d 100644--- a/packages/eve/src/client/message-reducer.test.ts+++ b/packages/eve/src/client/message-reducer.test.ts@@ -35,13 +35,95 @@ function reduceServerEvents(}describe("defaultMessageReducer", () => {+ it("accumulates message and reasoning deltas without a start marker", () => {+ const reducer = defaultMessageReducer();+ const data = reduceServerEvents(reducer, reducer.initial(), [+ createReasoningAppendedEvent({+ reasoningDelta: "I",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createReasoningAppendedEvent({+ reasoningDelta: " can",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createMessageAppendedEvent({+ messageDelta: "Hel",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createMessageAppendedEvent({+ messageDelta: "lo",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ ]);++ expect(data.messages[0]?.parts).toEqual([+ { type: "step-start" },+ { state: "streaming", stepIndex: 0, text: "I can", type: "reasoning" },+ { state: "streaming", stepIndex: 0, text: "Hello", type: "text" },+ ]);+ });++ it("uses the canonical completion after an interrupted attempt", () => {+ const reducer = defaultMessageReducer();+ let data = reduceServerEvents(reducer, reducer.initial(), [+ createMessageAppendedEvent({+ messageDelta: "abandoned",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createMessageAppendedEvent({+ messageDelta: "replacement",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ createMessageAppendedEvent({+ messageDelta: " complete",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ ]);++ expect(data.messages[0]?.parts).toContainEqual({+ state: "streaming",+ stepIndex: 0,+ text: "abandonedreplacement complete",+ type: "text",+ });++ data = reduceServerEvents(reducer, data, [+ createMessageCompletedEvent({+ message: "replacement complete",+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_1",+ }),+ ]);++ expect(data.messages[0]?.parts).toContainEqual({+ state: "done",+ stepIndex: 0,+ text: "replacement complete",+ type: "text",+ });+ });+it("projects streamed tool input and upgrades it to the validated request", () => {const reducer = defaultMessageReducer();let data = reduceServerEvents(reducer, reducer.initial(), [createActionInputAppendedEvent({callId: "call_render",inputTextDelta: "",- inputTextOffset: 0,sequence: 1,stepIndex: 0,toolName: "render",@@ -50,7 +132,6 @@ describe("defaultMessageReducer", () => {createActionInputAppendedEvent({callId: "call_render",inputTextDelta: '{"title":"Hel',- inputTextOffset: 0,sequence: 1,stepIndex: 0,toolName: "render",@@ -69,19 +150,19 @@ describe("defaultMessageReducer", () => {type: "dynamic-tool",});- const contiguous = data;data = reduceServerEvents(reducer, data, [createActionInputAppendedEvent({callId: "call_render",- inputTextDelta: "gap",- inputTextOffset: 99,+ inputTextDelta: 'lo"}',sequence: 1,stepIndex: 0,toolName: "render",turnId: "turn_1",}),]);- expect(data).toBe(contiguous);+ expect(data.messages[0]?.parts).toContainEqual(+ expect.objectContaining({ inputText: '{"title":"Hello"}' }),+ );data = reduceServerEvents(reducer, data, [createActionsRequestedEvent({@@ -114,7 +195,6 @@ describe("defaultMessageReducer", () => {createActionInputAppendedEvent({callId: "call_render",inputTextDelta: "late",- inputTextOffset: 0,sequence: 1,stepIndex: 0,toolName: "render",@@ -130,7 +210,6 @@ describe("defaultMessageReducer", () => {createActionInputAppendedEvent({callId: "call_render",inputTextDelta: "{",- inputTextOffset: 0,sequence: 1,stepIndex: 0,toolName: "render",@@ -1028,7 +1107,6 @@ describe("defaultMessageReducer", () => {const data = reduceServerEvents(reducer, reducer.initial(), [createMessageAppendedEvent({messageDelta: "Checking Vienna",- messageSoFar: "Checking Vienna",sequence: 0,stepIndex: 0,turnId: "turn_0",@@ -1055,7 +1133,6 @@ describe("defaultMessageReducer", () => {}),createMessageAppendedEvent({messageDelta: "Now Berlin",- messageSoFar: "Now Berlin",sequence: 3,stepIndex: 0,turnId: "turn_0",@@ -1081,14 +1158,12 @@ describe("defaultMessageReducer", () => {const data = reduceServerEvents(reducer, reducer.initial(), [createReasoningAppendedEvent({reasoningDelta: "Thinking",- reasoningSoFar: "Thinking",sequence: 0,stepIndex: 0,turnId: "turn_1",}),createMessageAppendedEvent({messageDelta: "Partial",- messageSoFar: "Partial",sequence: 1,stepIndex: 0,turnId: "turn_1",@@ -1134,7 +1209,6 @@ describe("defaultMessageReducer", () => {}),createMessageAppendedEvent({messageDelta: "<eve-empty-delivery/>",- messageSoFar: "<eve-empty-delivery/>",sequence: 1,stepIndex: 1,turnId: "turn_1",diff --git a/packages/eve/src/client/message-reducer.ts b/packages/eve/src/client/message-reducer.tsindex 9817d56e8..43979d685 100644--- a/packages/eve/src/client/message-reducer.ts+++ b/packages/eve/src/client/message-reducer.ts@@ -21,13 +21,13 @@ import {toMessageInputRequest,} from "#client/message-action-parts.js";import {- appendToolInputDelta,optimisticUserMessageId,partKey,projectReceivedParts,removeStreamingToolPartsForTurn,upsertMessage,} from "#client/message-reducer-primitives.js";+import { messageRun } from "#client/message-run-parts.js";import type { InputResponse } from "#shared/input.js";import type { AuthorizationCompletedStreamEvent, InputResolution } from "#protocol/message.js";@@ -123,17 +123,16 @@ function reduceMessageData(data: EveMessageData, event: EveAgentReducerEvent): Ecase "reasoning.appended":return updateAssistantMessage(data, event.data.turnId, (message) =>- upsertRun(ensureStepStartPart(message, event.data.stepIndex), {- state: "streaming",+ messageRun.append(ensureStepStartPart(message, event.data.stepIndex), {+ delta: event.data.reasoningDelta,stepIndex: event.data.stepIndex,- text: event.data.reasoningSoFar,type: "reasoning",}),);case "reasoning.completed":return updateAssistantMessage(data, event.data.turnId, (message) =>- upsertRun(ensureStepStartPart(message, event.data.stepIndex), {+ messageRun.upsert(ensureStepStartPart(message, event.data.stepIndex), {state: "done",stepIndex: event.data.stepIndex,text: event.data.reasoning,@@ -145,12 +144,9 @@ function reduceMessageData(data: EveMessageData, event: EveAgentReducerEvent): Econst existing = findToolPart(data, event.data.callId);if (existing !== undefined && existing.state !== "input-streaming") return data;- const inputText = appendToolInputDelta(- existing?.state === "input-streaming" ? existing.inputText : undefined,- event.data.inputTextOffset,- event.data.inputTextDelta,- );- if (inputText === undefined) return data;+ const inputText =+ (existing?.state === "input-streaming" ? existing.inputText : "") ++ event.data.inputTextDelta;const nextPart: EveDynamicToolPart = {input: undefined,@@ -355,10 +351,9 @@ function reduceMessageData(data: EveMessageData, event: EveAgentReducerEvent): Ecase "message.appended":return updateAssistantMessage(data, event.data.turnId, (message) =>- upsertRun(ensureStepStartPart(message, event.data.stepIndex), {- state: "streaming",+ messageRun.append(ensureStepStartPart(message, event.data.stepIndex), {+ delta: event.data.messageDelta,stepIndex: event.data.stepIndex,- text: event.data.messageSoFar,type: "text",}),);@@ -369,7 +364,7 @@ function reduceMessageData(data: EveMessageData, event: EveAgentReducerEvent): Ereturn removeTextPart(message, event.data.stepIndex);}- return upsertRun(ensureStepStartPart(message, event.data.stepIndex), {+ return messageRun.upsert(ensureStepStartPart(message, event.data.stepIndex), {state: "done",stepIndex: event.data.stepIndex,text: event.data.message,@@ -539,41 +534,6 @@ function upsertPart(message: EveAssistantMessage, next: EveMessagePart): EveAssi};}-type EveRunPart = Extract<EveMessagePart, { readonly type: "text" | "reasoning" }>;--// Upserts a text/reasoning part, keeping multiple runs per step distinct: one-// step can produce text, call tools, then produce more text (see-// `MessageCompletedStreamEvent`), so a step-only key would collapse them.-//-// We find the latest same-step run of this type: while it is still streaming,-// its snapshots replace it in place; once it is done (or there is none), `next`-// begins a new run appended in arrival order.-function upsertRun(message: EveAssistantMessage, next: EveRunPart): EveAssistantMessage {- let lastIndex = -1;- for (let index = message.parts.length - 1; index >= 0; index -= 1) {- const part = message.parts[index];- if (part?.type === next.type && part.stepIndex === next.stepIndex) {- lastIndex = index;- break;- }- }-- const openRun =- lastIndex !== -1 && (message.parts[lastIndex] as EveRunPart).state === "streaming";- const parts = openRun- ? [...message.parts.slice(0, lastIndex), next, ...message.parts.slice(lastIndex + 1)]- : [...message.parts, next];-- return {- ...message,- metadata: {- ...message.metadata,- status: next.type === "text" && next.state === "done" ? "complete" : "streaming",- },- parts,- };-}-function removeTextPart(message: EveAssistantMessage, stepIndex: number): EveAssistantMessage {const parts = message.parts.filter((part) => part.type !== "text" || part.stepIndex !== stepIndex,diff --git a/packages/eve/src/client/message-run-parts.ts b/packages/eve/src/client/message-run-parts.tsnew file mode 100644index 000000000..36fdfc772--- /dev/null+++ b/packages/eve/src/client/message-run-parts.ts@@ -0,0 +1,65 @@+import type { EveMessage, EveMessagePart } from "#client/message-reducer-types.js";++type EveAssistantMessage = EveMessage & { readonly role: "assistant" };+type EveRunPart = Extract<EveMessagePart, { readonly type: "text" | "reasoning" }>;++function append(+ message: EveAssistantMessage,+ append: {+ readonly delta: string;+ readonly stepIndex: number;+ readonly type: EveRunPart["type"];+ },+): EveAssistantMessage {+ const current = latestStreamingRun(message, append.type, append.stepIndex);+ return upsert(message, {+ state: "streaming",+ stepIndex: append.stepIndex,+ text: (current?.text ?? "") + append.delta,+ type: append.type,+ });+}++function latestStreamingRun(+ message: EveAssistantMessage,+ type: EveRunPart["type"],+ stepIndex: number,+): EveRunPart | undefined {+ for (let index = message.parts.length - 1; index >= 0; index -= 1) {+ const part = message.parts[index];+ if (part?.type === type && part.stepIndex === stepIndex) {+ return part.state === "streaming" ? part : undefined;+ }+ }+ return undefined;+}++// One step can produce text, call tools, then produce more text. Replace its+// open run in place; after completion, append a new run in arrival order.+function upsert(message: EveAssistantMessage, next: EveRunPart): EveAssistantMessage {+ let lastIndex = -1;+ for (let index = message.parts.length - 1; index >= 0; index -= 1) {+ const part = message.parts[index];+ if (part?.type === next.type && part.stepIndex === next.stepIndex) {+ lastIndex = index;+ break;+ }+ }++ const openRun =+ lastIndex !== -1 && (message.parts[lastIndex] as EveRunPart).state === "streaming";+ const parts = openRun+ ? [...message.parts.slice(0, lastIndex), next, ...message.parts.slice(lastIndex + 1)]+ : [...message.parts, next];++ return {+ ...message,+ metadata: {+ ...message.metadata,+ status: next.type === "text" && next.state === "done" ? "complete" : "streaming",+ },+ parts,+ };+}++export const messageRun = { append, upsert } as const;diff --git a/packages/eve/src/client/ndjson.ts b/packages/eve/src/client/ndjson.tsindex 450fc4ba3..fae025c7f 100644--- a/packages/eve/src/client/ndjson.ts+++ b/packages/eve/src/client/ndjson.ts@@ -1,4 +1,9 @@-import type { MessageStreamEvent } from "#protocol/message.js";+import { type MessageStreamEvent } from "#protocol/message.js";+import {+ normalizeMessageStreamEvent,+ type MessageStreamEventForVersion,+ type MessageStreamVersion,+} from "#protocol/message-version.js";/*** Returns true when an error looks like a stream socket disconnection that@@ -35,7 +40,10 @@ export function isStreamDisconnectError(error: unknown): boolean {*/export async function* readNdjsonStream(body: ReadableStream<Uint8Array>,- options?: { readonly idleTimeoutMs?: number },+ options: {+ readonly idleTimeoutMs?: number;+ readonly streamVersion: MessageStreamVersion;+ },): AsyncGenerator<MessageStreamEvent> {const reader = body.getReader();const decoder = new TextDecoder();@@ -64,7 +72,7 @@ export async function* readNdjsonStream(buffer = buffer.slice(newlineIndex + 1);if (line.length > 0) {- yield JSON.parse(line) as MessageStreamEvent;+ yield parseMessageStreamEvent(line, options.streamVersion);}newlineIndex = buffer.indexOf("\n");@@ -74,7 +82,7 @@ export async function* readNdjsonStream(// Yield any trailing content without a final newline.const trailing = buffer.trim();if (trailing.length > 0) {- yield JSON.parse(trailing) as MessageStreamEvent;+ yield parseMessageStreamEvent(trailing, options.streamVersion);}} finally {if (!reachedEof) {@@ -86,6 +94,14 @@ export async function* readNdjsonStream(}}+function parseMessageStreamEvent<Version extends MessageStreamVersion>(+ line: string,+ version: Version,+): MessageStreamEvent {+ const event = JSON.parse(line) as MessageStreamEventForVersion<Version>;+ return normalizeMessageStreamEvent(version, event);+}+async function readWithIdleTimeout(reader: ReadableStreamDefaultReader<Uint8Array>,idleTimeoutMs: number | undefined,diff --git a/packages/eve/src/client/open-stream.ts b/packages/eve/src/client/open-stream.tsindex 96ce7bee5..cf7096439 100644--- a/packages/eve/src/client/open-stream.ts+++ b/packages/eve/src/client/open-stream.ts@@ -1,8 +1,10 @@import type { MessageStreamEvent } from "#protocol/message.js";import { EVE_STREAM_TAIL_INDEX_HEADER } from "#protocol/message.js";+import type { MessageStreamVersion } from "#protocol/message-version.js";import { createEveSessionStreamRoutePath } from "#protocol/routes.js";import { ClientError } from "#client/client-error.js";import { isStreamDisconnectError, readNdjsonStream } from "#client/ndjson.js";+import { readMessageStreamVersion } from "#client/stream-version.js";import type {ClientRedirectPolicy,ResolvedStreamReconnectPolicy as StreamReconnectPolicyOptions,@@ -163,6 +165,7 @@ export async function* followStreamIterable(try {for await (const event of readNdjsonStream(connection.body, {idleTimeoutMs: input.streamReadIdleTimeoutMs ?? DEFAULT_STREAM_READ_IDLE_TIMEOUT_MS,+ streamVersion: connection.streamVersion,})) {startIndex += 1;deliveredEvent = true;@@ -206,6 +209,7 @@ export async function* followStreamIterable(interface OpenedStream {readonly body: ReadableStream<Uint8Array>;close(): void;+ readonly streamVersion: MessageStreamVersion;readonly tailIndex: number | undefined;}@@ -273,6 +277,7 @@ export async function openStreamBody(return {body: response.body,close: () => connectionController.abort(),+ streamVersion: readMessageStreamVersion(response.headers),tailIndex: parseTailIndexHeader(response.headers),};}diff --git a/packages/eve/src/client/session.test.ts b/packages/eve/src/client/session.test.tsindex 01957420e..14eab08fb 100644--- a/packages/eve/src/client/session.test.ts+++ b/packages/eve/src/client/session.test.ts@@ -3,6 +3,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { ClientError } from "#client/client-error.js";import { ClientSession } from "#client/session.js";import type { ClientSessionState } from "#client/types.js";+import { EVE_MESSAGE_STREAM_VERSION, EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";afterEach(() => {vi.restoreAllMocks();@@ -78,6 +79,9 @@ function createStreamResponse(events: readonly unknown[]) {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}@@ -624,7 +628,9 @@ describe("ClientSession", () => {return createAcceptedResponse();}- return new Response(stream);+ return new Response(stream, {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ });});const session = createSession();@@ -757,6 +763,9 @@ describe("ClientSession", () => {controller.error(new Error("socket disconnected"));},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);});const session = createSession({ sessionId: "session_1", streamIndex: 0 });@@ -876,6 +885,9 @@ describe("ClientSession", () => {controller.error(new Error("socket disconnected"));},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}@@ -1032,6 +1044,9 @@ describe("ClientSession", () => {});},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);});const session = createSession();diff --git a/packages/eve/src/client/sessions.test.ts b/packages/eve/src/client/sessions.test.tsindex d150031fc..91573ce0b 100644--- a/packages/eve/src/client/sessions.test.ts+++ b/packages/eve/src/client/sessions.test.ts@@ -1,6 +1,7 @@import { afterEach, describe, expect, it, vi } from "vitest";import { Client } from "#client/client.js";+import { EVE_MESSAGE_STREAM_VERSION, EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";afterEach(() => {vi.restoreAllMocks();@@ -21,6 +22,9 @@ describe("Client.sessions", () => {requests.push({ url: String(request) });return new Response(`${JSON.stringify({ data: { reason: "completed" }, type: "session.completed" })}\n`,+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);});const client = new Client({ host: "https://eve.test" });diff --git a/packages/eve/src/client/stream-follow.integration.test.ts b/packages/eve/src/client/stream-follow.integration.test.tsindex dfdbc1a21..1519089d8 100644--- a/packages/eve/src/client/stream-follow.integration.test.ts+++ b/packages/eve/src/client/stream-follow.integration.test.ts@@ -4,8 +4,13 @@ import { afterEach, describe, expect, it } from "vitest";import { Client } from "./client.js";import { followStreamIterable } from "./open-stream.js";+import { EVE_MESSAGE_STREAM_VERSION, EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";const servers: Server[] = [];+const streamHeaders = {+ "content-type": "application/x-ndjson",+ [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION,+} as const;afterEach(async () => {await Promise.all(@@ -55,7 +60,7 @@ describe("stream following over real sockets", () => {createServer((req, res) => {connections += 1;const index = startIndexOf(req.url);- res.writeHead(200, { "content-type": "application/x-ndjson" });+ res.writeHead(200, streamHeaders);res.write(`${JSON.stringify(log[index])}\n`);if (index % 2 === 0) {@@ -100,7 +105,7 @@ describe("stream following over real sockets", () => {createServer((req, res) => {connections += 1;const index = startIndexOf(req.url);- res.writeHead(200, { "content-type": "application/x-ndjson" });+ res.writeHead(200, streamHeaders);if (connections === 1) {res.write(`${JSON.stringify(events[0])}\n`);return;@@ -132,7 +137,7 @@ describe("stream following over real sockets", () => {const host = await listen(createServer((_req, res) => {connections += 1;- res.writeHead(200, { "content-type": "application/x-ndjson" });+ res.writeHead(200, streamHeaders);setTimeout(() => res.end(), 10);}),);@@ -166,7 +171,7 @@ describe("stream following over real sockets", () => {);tailRequests.push(tailRequested);res.writeHead(200, {- "content-type": "application/x-ndjson",+ ...streamHeaders,...(tailRequested === "1" ? { "x-eve-stream-tail-index": String(log.length - 1) } : {}),});@@ -202,7 +207,7 @@ describe("stream following over real sockets", () => {createServer((_req, res) => {connections += 1;res.writeHead(200, {- "content-type": "application/x-ndjson",+ ...streamHeaders,"x-eve-stream-tail-index": "-1",});// Send headers without any body: a live follow would idle here@@ -223,7 +228,7 @@ describe("stream following over real sockets", () => {it("fails a follow: false read when the server does not report a tail index", async () => {const host = await listen(createServer((_req, res) => {- res.writeHead(200, { "content-type": "application/x-ndjson" });+ res.writeHead(200, streamHeaders);res.end();}),);@@ -239,7 +244,7 @@ describe("stream following over real sockets", () => {createServer((req, res) => {connections += 1;const index = startIndexOf(req.url);- res.writeHead(200, { "content-type": "application/x-ndjson" });+ res.writeHead(200, streamHeaders);const served = idlesServed.get(index) ?? 0;if (index < events.length && served >= 2) {res.end(`${JSON.stringify({ type: events[index], data: {} })}\n`);diff --git a/packages/eve/src/client/stream-version.test.ts b/packages/eve/src/client/stream-version.test.tsnew file mode 100644index 000000000..201e48a32--- /dev/null+++ b/packages/eve/src/client/stream-version.test.ts@@ -0,0 +1,24 @@+import { describe, expect, it } from "vitest";++import { readMessageStreamVersion } from "#client/stream-version.js";+import { EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";++describe("readMessageStreamVersion", () => {+ it.each(["21", "22", "23", "24", "25"] as const)("accepts stream version %s", (version) => {+ expect(readMessageStreamVersion(new Headers({ [EVE_STREAM_VERSION_HEADER]: version }))).toBe(+ version,+ );+ });++ it("rejects a missing version", () => {+ expect(() => readMessageStreamVersion(new Headers())).toThrow(+ `Missing ${EVE_STREAM_VERSION_HEADER} response header.`,+ );+ });++ it("rejects an unsupported version", () => {+ expect(() =>+ readMessageStreamVersion(new Headers({ [EVE_STREAM_VERSION_HEADER]: "26" })),+ ).toThrow("Unsupported message stream version: 26.");+ });+});diff --git a/packages/eve/src/client/stream-version.ts b/packages/eve/src/client/stream-version.tsnew file mode 100644index 000000000..0cb4fcc27--- /dev/null+++ b/packages/eve/src/client/stream-version.ts@@ -0,0 +1,23 @@+import { EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";+import type { MessageStreamVersion } from "#protocol/message-version.js";++const supportedMessageStreamVersions = {+ "21": true,+ "22": true,+ "23": true,+ "24": true,+ "25": true,+} as const satisfies Record<MessageStreamVersion, true>;++/** Reads and validates the schema version declared by a message stream response. */+export function readMessageStreamVersion(headers: Headers): MessageStreamVersion {+ const version = headers.get(EVE_STREAM_VERSION_HEADER);+ if (version !== null && Object.hasOwn(supportedMessageStreamVersions, version)) {+ return version as MessageStreamVersion;+ }++ if (version === null) {+ throw new TypeError(`Missing ${EVE_STREAM_VERSION_HEADER} response header.`);+ }+ throw new TypeError(`Unsupported message stream version: ${version}.`);+}diff --git a/packages/eve/src/compiler/extension-compatibility.ts b/packages/eve/src/compiler/extension-compatibility.tsindex 3ddf49d83..419876483 100644--- a/packages/eve/src/compiler/extension-compatibility.ts+++ b/packages/eve/src/compiler/extension-compatibility.ts@@ -27,30 +27,46 @@ const EXTENSION_CAPABILITY_CONTRACTS = {dropped: { 15: "TaskExec replaces stageEffect with send" },},dynamicTool: {- current: 21,- supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21],- dropped: {},+ current: 22,+ supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22],+ dropped: {+ 21: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",+ },+ },+ channel: {+ current: 13,+ supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13],+ dropped: {+ 12: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",+ },+ },+ schedule: {+ current: 6,+ supported: [1, 2, 3, 4, 6],+ dropped: {+ 5: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",+ },},- channel: { current: 12, supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dropped: {} },- schedule: { current: 5, supported: [1, 2, 3, 4, 5], dropped: {} },subagent: {- current: 5,- supported: [3, 4, 5],+ current: 6,+ supported: [3, 4, 6],dropped: {1: "Persistent subagent sessions are now the default and the experimental opt-in was removed",2: "Persistent subagent sessions are now the default and the experimental opt-in was removed",+ 5: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",},},connection: {- current: 10,- supported: [1, 2, 3, 4, 5, 6, 7, 8, 10],+ current: 11,+ supported: [1, 2, 3, 4, 5, 6, 7, 8, 11],dropped: {9: "Dynamic connection resolvers no longer receive conversation or channel continuation data",+ 10: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",},},hook: {- current: 16,- supported: [10, 11, 12, 13, 14, 15, 16],+ current: 17,+ supported: [10, 11, 12, 13, 14, 15, 17],dropped: {1: "Model identity moved from session.started runtime metadata to step.started call attribution.",2: "Model identity moved from session.started runtime metadata to step.started call attribution.",@@ -61,19 +77,24 @@ const EXTENSION_CAPABILITY_CONTRACTS = {7: "Model identity moved from session.started runtime metadata to step.started call attribution.",8: "Model identity moved from session.started runtime metadata to step.started call attribution.",9: "Model identity moved from session.started runtime metadata to step.started call attribution.",+ 16: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",},},skill: { current: 1, supported: [1], dropped: {} },dynamicSkill: {- current: 13,- supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],- dropped: {},+ current: 14,+ supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14],+ dropped: {+ 13: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",+ },},instructions: { current: 2, supported: [1, 2], dropped: {} },dynamicInstructions: {- current: 14,- supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],- dropped: {},+ current: 15,+ supported: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15],+ dropped: {+ 14: "Message and reasoning append events now expose deltas instead of cumulative snapshots.",+ },},config: { current: 1, supported: [1], dropped: {} },state: { current: 4, supported: [1, 2, 3, 4], dropped: {} },diff --git a/packages/eve/src/evals/runner/execute-task.test.ts b/packages/eve/src/evals/runner/execute-task.test.tsindex ad7201d10..5e7d8b771 100644--- a/packages/eve/src/evals/runner/execute-task.test.ts+++ b/packages/eve/src/evals/runner/execute-task.test.ts@@ -1,7 +1,11 @@import { afterEach, describe, expect, it, vi } from "vitest";import { Client } from "#client/client.js";-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";+import {+ EVE_MESSAGE_STREAM_VERSION,+ EVE_STREAM_VERSION_HEADER,+ type UnstampedMessageStreamEvent,+} from "#protocol/message.js";import { stampTestEvents } from "#internal/testing/events.js";import { executeTask } from "#evals/runner/execute-task.js";import type { EveEval, EveEvalContext } from "#evals/types.js";@@ -801,6 +805,9 @@ function streamResponse(events: readonly UnstampedMessageStreamEvent[]): Responscontroller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}diff --git a/packages/eve/src/execution/ndjson-stream.test.ts b/packages/eve/src/execution/ndjson-stream.test.tsindex 0496b8ad4..15780fae0 100644--- a/packages/eve/src/execution/ndjson-stream.test.ts+++ b/packages/eve/src/execution/ndjson-stream.test.ts@@ -61,6 +61,24 @@ describe("parseNdjsonStream", () => {expect(values).toEqual([{ i: 0 }]);});+ it("maps parsed values before exposing them", async () => {+ const source = new ReadableStream<Uint8Array>({+ start(controller) {+ controller.enqueue(encoder.encode('{"i":1}\n'));+ controller.close();+ },+ });++ const values = await drain(+ parseNdjsonStream(+ () => source,+ (value) => ({ i: (value as { i: number }).i + 1 }),+ ),+ );++ expect(values).toEqual([{ i: 2 }]);+ });+// Regression guard for the parked-session streaming leak: a parked// (`session.waiting`) durable run never closes its event stream, so the// world-local streamer keeps a filesystem poll alive until its reader isdiff --git a/packages/eve/src/execution/ndjson-stream.ts b/packages/eve/src/execution/ndjson-stream.tsindex b53ad0c85..d8ea2bad5 100644--- a/packages/eve/src/execution/ndjson-stream.ts+++ b/packages/eve/src/execution/ndjson-stream.ts@@ -18,6 +18,7 @@*/export function parseNdjsonStream<T>(createByteStream: () => ReadableStream<Uint8Array>,+ parse: (value: unknown) => T = (value) => value as T,): ReadableStream<T> {const decoder = new TextDecoder();let buffer = "";@@ -44,7 +45,7 @@ export function parseNdjsonStream<T>(buffer = buffer.slice(newlineIndex + 1);if (line.length > 0) {- controller.enqueue(JSON.parse(line) as T);+ controller.enqueue(parse(JSON.parse(line)));}}}@@ -56,7 +57,7 @@ export function parseNdjsonStream<T>(buffer += decoder.decode();const trailing = buffer.trim();if (trailing.length > 0) {- controller.enqueue(JSON.parse(trailing) as T);+ controller.enqueue(parse(JSON.parse(trailing)));}controller.close();} catch (error) {diff --git a/packages/eve/src/execution/session-activity-projection.test.ts b/packages/eve/src/execution/session-activity-projection.test.tsindex 6f63aa1a2..ece32a69b 100644--- a/packages/eve/src/execution/session-activity-projection.test.ts+++ b/packages/eve/src/execution/session-activity-projection.test.ts@@ -191,7 +191,6 @@ describe("observeSessionActivity", () => {const event: MessageStreamEvent = {data: {messageDelta: "hello",- messageSoFar: "hello",sequence: 0,stepIndex: 0,turnId: "turn-1",diff --git a/packages/eve/src/execution/workflow-runtime.test.ts b/packages/eve/src/execution/workflow-runtime.test.tsindex 88ba76034..d18f16b87 100644--- a/packages/eve/src/execution/workflow-runtime.test.ts+++ b/packages/eve/src/execution/workflow-runtime.test.ts@@ -832,6 +832,48 @@ describe("createWorkflowRuntime#createSession", () => {expect(getRunMock).toHaveBeenCalledWith("driver-run");expect(getReadable).toHaveBeenCalledTimes(1);});++ it("normalizes persisted v24 appends before exposing a current event stream", async () => {+ const legacy = {+ data: {+ messageDelta: "lo",+ messageSoFar: "Hello",+ sequence: 2,+ stepIndex: 0,+ turnId: "turn-1",+ },+ meta: { at: "2026-09-02T00:00:00.000Z", id: "evt-v24" },+ type: "message.appended",+ };+ const bytes = new TextEncoder().encode(`${JSON.stringify(legacy)}\n`);+ getRunMock.mockReturnValue({+ getReadable: () =>+ new ReadableStream<Uint8Array>({+ start(controller) {+ controller.enqueue(bytes);+ controller.close();+ },+ }),+ });++ const stream = await buildRuntime({} as RuntimeCompiledArtifactsSource).getEventStream(+ "driver-run",+ );++ await expect(stream.getReader().read()).resolves.toEqual({+ done: false,+ value: {+ data: {+ messageDelta: "lo",+ sequence: 2,+ stepIndex: 0,+ turnId: "turn-1",+ },+ meta: legacy.meta,+ type: "message.appended",+ },+ });+ });});describe("createWorkflowRuntime#createSession trace seed allocation", () => {diff --git a/packages/eve/src/execution/workflow-runtime.ts b/packages/eve/src/execution/workflow-runtime.tsindex a83d56705..9f83b79ff 100644--- a/packages/eve/src/execution/workflow-runtime.ts+++ b/packages/eve/src/execution/workflow-runtime.ts@@ -42,6 +42,11 @@ import {type WorkflowMetadata,} from "#internal/workflow/runtime.js";import type { MessageStreamEvent } from "#protocol/message.js";+import {+ normalizePersistedMessageStreamEvent,+ type MessageStreamEventForVersion,+ type MessageStreamVersion,+} from "#protocol/message-version.js";import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";import { ROOT_RUNTIME_AGENT_NODE_ID } from "#runtime/graph.js";import { normalizeEveAttributes } from "#runtime/attributes/normalize.js";@@ -247,7 +252,10 @@ export function createWorkflowRuntime(config: {let events: ReadableStream<MessageStreamEvent> | undefined;const getEvents = () => {- events ??= parseNdjsonStream<MessageStreamEvent>(() => getRun(run.runId).getReadable());+ events ??= parseNdjsonStream<MessageStreamEvent>(+ () => getRun(run.runId).getReadable(),+ normalizePersistedEvent,+ );return events;};@@ -275,8 +283,9 @@ export function createWorkflowRuntime(config: {sessionId: string,options?: GetEventStreamOptions,): Promise<ReadableStream<MessageStreamEvent>> {- return parseNdjsonStream<MessageStreamEvent>(() =>- getRun(sessionId).getReadable({ startIndex: options?.startIndex }),+ return parseNdjsonStream<MessageStreamEvent>(+ () => getRun(sessionId).getReadable({ startIndex: options?.startIndex }),+ normalizePersistedEvent,);},@@ -309,6 +318,12 @@ export function createWorkflowRuntime(config: {};}+function normalizePersistedEvent(value: unknown): MessageStreamEvent {+ return normalizePersistedMessageStreamEvent(+ value as MessageStreamEventForVersion<MessageStreamVersion>,+ );+}+async function cancelActivityCollector(runId: string | undefined): Promise<void> {if (runId === undefined) return;try {diff --git a/packages/eve/src/harness/emission.test.ts b/packages/eve/src/harness/emission.test.tsindex 526fd367a..becf11a88 100644--- a/packages/eve/src/harness/emission.test.ts+++ b/packages/eve/src/harness/emission.test.ts@@ -191,7 +191,9 @@ describe("emitStreamContent empty delivery", () => {expect(appended.map((event) => event.data.messageDelta.length)).toEqual([1, 64, 64, 64, 64, 64, 47,]);- expect(appended.at(-1)?.data.messageSoFar).toBe("x".repeat(deltaCount));+ expect(appended.reduce((total, event) => total + event.data.messageDelta.length, 0)).toBe(+ deltaCount,+ );expect(events.at(-1)?.type).toBe("message.completed");});@@ -314,26 +316,15 @@ describe("emitStreamContent action requests", () => {const events = vi.mocked(emit).mock.calls.map(([event]) => event);expect(events.map((event) => event.type)).toEqual([- "action.input.appended","action.input.appended","action.input.appended","actions.requested",]);const inputEvents = events.filter((event) => event.type === "action.input.appended");expect(inputEvents.map((event) => event.data)).toEqual([- {- callId: "call-render",- inputTextDelta: "",- inputTextOffset: 0,- sequence: 0,- stepIndex: 0,- toolName: "render",- turnId: "turn_0",- },{callId: "call-render",inputTextDelta: '{"title":"Hel',- inputTextOffset: 0,sequence: 0,stepIndex: 0,toolName: "render",@@ -342,7 +333,6 @@ describe("emitStreamContent action requests", () => {{callId: "call-render",inputTextDelta: 'lo"}',- inputTextOffset: 13,sequence: 0,stepIndex: 0,toolName: "render",@@ -526,7 +516,6 @@ describe("emitStreamContent action requests", () => {"message.appended","message.completed","action.input.appended",- "action.input.appended","actions.requested",]);expect(events[1]).toMatchObject({diff --git a/packages/eve/src/harness/emission.ts b/packages/eve/src/harness/emission.tsindex aa778bfab..dd8c10c0f 100644--- a/packages/eve/src/harness/emission.ts+++ b/packages/eve/src/harness/emission.ts@@ -333,7 +333,7 @@ async function consumeStreamContent(const invalidInputToolCallIds = new Set<string>();const inlineAuthorizationResults: TypedToolResult<ToolSet>[] = [];const trailingInlineToolResultParts: InlineToolResultPart[] = [];- const streamingActionInputs = new Map<string, { offset: number; toolName: string }>();+ const streamingActionInputs = new Map<string, { toolName: string }>();const flushCurrentMessage = async (): Promise<void> => {if (currentMessage.length === 0) {@@ -355,13 +355,11 @@ async function consumeStreamContent(callId: string,toolName: string,inputTextDelta: string,- inputTextOffset: number,): Promise<void> =>emitFn(createActionInputAppendedEvent({callId,inputTextDelta,- inputTextOffset,sequence: state.sequence,stepIndex: state.stepIndex,toolName,@@ -491,7 +489,6 @@ async function consumeStreamContent(await emitFn(createReasoningAppendedEvent({reasoningDelta: part.text,- reasoningSoFar: currentReasoning,sequence: state.sequence,stepIndex: state.stepIndex,turnId: state.turnId,@@ -516,7 +513,6 @@ async function consumeStreamContent(await emitFn(createMessageAppendedEvent({messageDelta: part.text,- messageSoFar: currentMessage,sequence: state.sequence,stepIndex: state.stepIndex,turnId: state.turnId,@@ -536,8 +532,7 @@ async function consumeStreamContent(if (currentMessage.trim().length > 0) {await flushCurrentMessage();}- streamingActionInputs.set(part.id, { offset: 0, toolName: part.toolName });- await emitActionInput(part.id, part.toolName, "", 0);+ streamingActionInputs.set(part.id, { toolName: part.toolName });break;}case "tool-input-delta": {@@ -546,9 +541,7 @@ async function consumeStreamContent(break;}await providerActionBatch.flush();- const inputTextOffset = input.offset;- input.offset += part.delta.length;- await emitActionInput(part.id, input.toolName, part.delta, inputTextOffset);+ await emitActionInput(part.id, input.toolName, part.delta);break;}case "tool-input-end":diff --git a/packages/eve/src/harness/ordered-stream-emitter.test.ts b/packages/eve/src/harness/ordered-stream-emitter.test.tsindex 0c6e457bf..0ddf3d74d 100644--- a/packages/eve/src/harness/ordered-stream-emitter.test.ts+++ b/packages/eve/src/harness/ordered-stream-emitter.test.ts@@ -19,20 +19,18 @@ function deferred(): { readonly promise: Promise<void>; resolve(): void } {return { promise, resolve };}-function message(delta: string, soFar: string, stepIndex = 0) {+function message(delta: string, stepIndex = 0) {return createMessageAppendedEvent({messageDelta: delta,- messageSoFar: soFar,sequence: 1,stepIndex,turnId: "turn_1",});}-function reasoning(delta: string, soFar: string) {+function reasoning(delta: string) {return createReasoningAppendedEvent({reasoningDelta: delta,- reasoningSoFar: soFar,sequence: 1,stepIndex: 0,turnId: "turn_1",@@ -48,11 +46,10 @@ function partial(callId: string, output: string) {});}-function input(callId: string, delta: string, offset: number) {+function input(callId: string, delta: string) {return createActionInputAppendedEvent({callId,inputTextDelta: delta,- inputTextOffset: offset,sequence: 1,stepIndex: 0,toolName: "render",@@ -70,15 +67,35 @@ describe("createOrderedStreamEmitter", () => {});const emitter = createOrderedStreamEmitter(emitFn);- await emitter.emit(message("A", "A"));- await emitter.emit(message("B", "AB"));- await emitter.emit(message("C", "ABC"));+ await emitter.emit(message("A"));+ await emitter.emit(message("B"));+ await emitter.emit(message("C"));expect(emitFn).toHaveBeenCalledTimes(1);firstWrite.resolve();await emitter.closeAndDrain();- expect(events).toEqual([message("A", "A"), message("BC", "ABC")]);+ expect(events).toEqual([message("A"), message("BC")]);+ });++ it("coalesces adjacent deltas without content-level boundaries", async () => {+ const firstWrite = deferred();+ const events: UnstampedMessageStreamEvent[] = [];+ const emitFn = vi.fn(async (event: UnstampedMessageStreamEvent) => {+ events.push(event);+ if (events.length === 1) await firstWrite.promise;+ });+ const emitter = createOrderedStreamEmitter(emitFn);++ await emitter.emit(message("A"));+ await emitter.emit(message(" abandoned"));+ await emitter.emit(message("Replacement"));+ await emitter.emit(message(" complete"));++ firstWrite.resolve();+ await emitter.closeAndDrain();++ expect(events).toEqual([message("A"), message(" abandonedReplacement complete")]);});it("coalesces adjacent input deltas for the same tool call", async () => {@@ -90,19 +107,19 @@ describe("createOrderedStreamEmitter", () => {});const emitter = createOrderedStreamEmitter(emitFn);- await emitter.emit(message("A", "A"));- await emitter.emit(input("call_1", "{", 0));- await emitter.emit(input("call_1", '"title":', 1));- await emitter.emit(input("call_1", '"Hello"}', 9));- await emitter.emit(input("call_2", "{}", 0));+ await emitter.emit(message("A"));+ await emitter.emit(input("call_1", "{"));+ await emitter.emit(input("call_1", '"title":'));+ await emitter.emit(input("call_1", '"Hello"}'));+ await emitter.emit(input("call_2", "{}"));firstWrite.resolve();await emitter.closeAndDrain();expect(events).toEqual([- message("A", "A"),- input("call_1", '{"title":"Hello"}', 0),- input("call_2", "{}", 0),+ message("A"),+ input("call_1", '{"title":"Hello"}'),+ input("call_2", "{}"),]);});@@ -121,22 +138,22 @@ describe("createOrderedStreamEmitter", () => {turnId: "turn_1",});- await emitter.emit(message("A", "A"));- await emitter.emit(message("B", "AB"));- await emitter.emit(message("C", "C", 1));- await emitter.emit(message("D", "CD", 1));- await emitter.emit(reasoning("R", "R"));- await emitter.emit(reasoning("S", "RS"));+ await emitter.emit(message("A"));+ await emitter.emit(message("B"));+ await emitter.emit(message("C", 1));+ await emitter.emit(message("D", 1));+ await emitter.emit(reasoning("R"));+ await emitter.emit(reasoning("S"));await emitter.emit(completed);firstWrite.resolve();await emitter.closeAndDrain();expect(events).toEqual([- message("A", "A"),- message("B", "AB"),- message("CD", "CD", 1),- reasoning("RS", "RS"),+ message("A"),+ message("B"),+ message("CD", 1),+ reasoning("RS"),completed,]);});@@ -181,10 +198,10 @@ describe("createOrderedStreamEmitter", () => {throw writeError;});- await emitter.emit(message("A", "A"));+ await emitter.emit(message("A"));await expect(emitter.closeAndDrain()).rejects.toBe(writeError);- await expect(emitter.emit(message("B", "AB"))).rejects.toBe(writeError);+ await expect(emitter.emit(message("B"))).rejects.toBe(writeError);});it("rejects emissions after closing", async () => {@@ -192,7 +209,7 @@ describe("createOrderedStreamEmitter", () => {await emitter.closeAndDrain();- await expect(emitter.emit(message("A", "A"))).rejects.toThrow(/closed/);+ await expect(emitter.emit(message("A"))).rejects.toThrow(/closed/);});it("counts merged empty deltas toward the pending-event limit", async () => {@@ -206,10 +223,10 @@ describe("createOrderedStreamEmitter", () => {{ maxPendingEvents: 2 },);- await emitter.emit(message("A", "A"));- await emitter.emit(reasoning("", ""));+ await emitter.emit(message("A"));+ await emitter.emit(reasoning(""));let accepted = false;- const limited = emitter.emit(reasoning("", "")).then(() => {+ const limited = emitter.emit(reasoning("")).then(() => {accepted = true;});await Promise.resolve();@@ -218,6 +235,6 @@ describe("createOrderedStreamEmitter", () => {firstWrite.resolve();await limited;await emitter.closeAndDrain();- expect(events).toEqual([message("A", "A"), reasoning("", "")]);+ expect(events).toEqual([message("A"), reasoning("")]);});});diff --git a/packages/eve/src/harness/ordered-stream-emitter.ts b/packages/eve/src/harness/ordered-stream-emitter.tsindex caf5c2271..b022f9afe 100644--- a/packages/eve/src/harness/ordered-stream-emitter.ts+++ b/packages/eve/src/harness/ordered-stream-emitter.ts@@ -187,16 +187,7 @@ function mergeAdjacentEmissions(}left.deltaParts ??= [appendDelta(left.event)];left.deltaParts.push(appendDelta(right));- left.event =- left.event.type === "action.input.appended" && right.type === "action.input.appended"- ? {- ...right,- data: {- ...right.data,- inputTextOffset: left.event.data.inputTextOffset,- },- }- : right;+ left.event = right;left.messages = messages;return true;}diff --git a/packages/eve/src/harness/tool-loop-stream-retry.integration.test.ts b/packages/eve/src/harness/tool-loop-stream-retry.integration.test.tsindex f4adbe30a..61ac87646 100644--- a/packages/eve/src/harness/tool-loop-stream-retry.integration.test.ts+++ b/packages/eve/src/harness/tool-loop-stream-retry.integration.test.ts@@ -128,6 +128,16 @@ describe("tool loop streamed provider retries", () => {});expect(JSON.stringify(result.session.history)).toContain("Recovered answer.");expect(JSON.stringify(result.session.history)).not.toContain("Discard this partial response.");+ expect(+ events+ .filter((event) => event.type === "message.appended")+ .map((event) => event.data.messageDelta),+ ).toEqual(["Discard this partial response.", "Recovered answer."]);+ expect(+ events+ .filter((event) => event.type === "message.completed")+ .map((event) => event.data.message),+ ).toEqual(["Recovered answer."]);expect(events.filter((event) => event.type === "step.started")).toHaveLength(1);expect(events.filter((event) => event.type === "step.completed")).toHaveLength(1);expect(events.filter((event) => event.type === "step.failed")).toHaveLength(0);diff --git a/packages/eve/src/harness/tool-loop.test.ts b/packages/eve/src/harness/tool-loop.test.tsindex eaec6e15c..d9278970d 100644--- a/packages/eve/src/harness/tool-loop.test.ts+++ b/packages/eve/src/harness/tool-loop.test.ts@@ -10010,7 +10010,6 @@ describe("createToolLoopHarness", () => {]);expect(events.find((event) => event.type === "reasoning.appended")?.data).toEqual({reasoningDelta: "Need to check the known constraints first.",- reasoningSoFar: "Need to check the known constraints first.",sequence: 0,stepIndex: 0,turnId: "turn_0",@@ -10023,7 +10022,6 @@ describe("createToolLoopHarness", () => {});expect(events.find((event) => event.type === "message.appended")?.data).toEqual({messageDelta: "Answer ready.",- messageSoFar: "Answer ready.",sequence: 0,stepIndex: 0,turnId: "turn_0",@@ -10068,14 +10066,12 @@ describe("createToolLoopHarness", () => {).toEqual([{messageDelta: "Hello",- messageSoFar: "Hello",sequence: 0,stepIndex: 0,turnId: "turn_0",},{messageDelta: " there.",- messageSoFar: "Hello there.",sequence: 0,stepIndex: 0,turnId: "turn_0",diff --git a/packages/eve/src/protocol/message-version.ts b/packages/eve/src/protocol/message-version.tsnew file mode 100644index 000000000..5ff6cbaa2--- /dev/null+++ b/packages/eve/src/protocol/message-version.ts@@ -0,0 +1,249 @@+import {+ EVE_MESSAGE_STREAM_VERSION,+ type ActionInputAppendedStreamEvent,+ type MessageAppendedStreamEvent,+ type MessageStreamEvent,+ type MessageStreamEventMeta,+ type ReasoningAppendedStreamEvent,+ type UnstampedMessageStreamEvent,+} from "#protocol/message.js";++interface MessageAppendedStreamEventV24 {+ data: {+ messageDelta: string;+ messageSoFar: string;+ sequence: number;+ stepIndex: number;+ turnId: string;+ };+ type: "message.appended";+}++interface ReasoningAppendedStreamEventV24 {+ data: {+ reasoningDelta: string;+ reasoningSoFar: string;+ sequence: number;+ stepIndex: number;+ turnId: string;+ };+ type: "reasoning.appended";+}++interface ActionInputAppendedStreamEventV24 {+ data: {+ callId: string;+ inputTextDelta: string;+ inputTextOffset: number;+ sequence: number;+ stepIndex: number;+ toolName: string;+ turnId: string;+ };+ type: "action.input.appended";+}++interface MessageStreamAppendEventsByVersion {+ "21": MessageAppendedStreamEventV24 | ReasoningAppendedStreamEventV24;+ "22": MessageAppendedStreamEventV24 | ReasoningAppendedStreamEventV24;+ "23": MessageAppendedStreamEventV24 | ReasoningAppendedStreamEventV24;+ "24":+ | ActionInputAppendedStreamEventV24+ | MessageAppendedStreamEventV24+ | ReasoningAppendedStreamEventV24;+ "25": ActionInputAppendedStreamEvent | MessageAppendedStreamEvent | ReasoningAppendedStreamEvent;+}++export type MessageStreamVersion = keyof MessageStreamAppendEventsByVersion;+type LegacyMessageStreamVersion = Exclude<MessageStreamVersion, "25">;++type VersionIndependentMessageStreamEvent = Exclude<+ UnstampedMessageStreamEvent,+ ActionInputAppendedStreamEvent | MessageAppendedStreamEvent | ReasoningAppendedStreamEvent+>;++type UnstampedMessageStreamEventForVersion<Version extends MessageStreamVersion> =+ | VersionIndependentMessageStreamEvent+ | MessageStreamAppendEventsByVersion[Version];++export type MessageStreamEventForVersion<Version extends MessageStreamVersion> =+ UnstampedMessageStreamEventForVersion<Version> & {+ readonly meta: MessageStreamEventMeta;+ };++type SupportedMessageStreamEvent = MessageStreamEventForVersion<MessageStreamVersion>;++const currentMessageStreamVersion = EVE_MESSAGE_STREAM_VERSION satisfies MessageStreamVersion;++/** Normalizes one event from a declared wire version into the current event contract. */+export function normalizeMessageStreamEvent<Version extends MessageStreamVersion>(+ version: Version,+ event: MessageStreamEventForVersion<Version>,+): MessageStreamEvent;+export function normalizeMessageStreamEvent(+ version: MessageStreamVersion,+ event: SupportedMessageStreamEvent,+): MessageStreamEvent {+ switch (version) {+ case "21":+ case "22":+ case "23":+ case "24":+ return normalizeLegacyMessageStreamEvent(+ version,+ event as MessageStreamEventForVersion<LegacyMessageStreamVersion>,+ );+ case "25":+ return validateCurrentMessageStreamEvent(event as MessageStreamEventForVersion<"25">);+ default:+ return assertNever(version);+ }+}++/** Normalizes a persisted stream that may contain events written before v25. */+export function normalizePersistedMessageStreamEvent(+ event: SupportedMessageStreamEvent,+): MessageStreamEvent {+ if (+ (event.type === "message.appended" && "messageSoFar" in event.data) ||+ (event.type === "reasoning.appended" && "reasoningSoFar" in event.data) ||+ (event.type === "action.input.appended" && "inputTextOffset" in event.data)+ ) {+ return normalizeLegacyMessageStreamEvent(+ undefined,+ event as MessageStreamEventForVersion<LegacyMessageStreamVersion>,+ );+ }+ return normalizeMessageStreamEvent(+ currentMessageStreamVersion,+ event as MessageStreamEventForVersion<typeof currentMessageStreamVersion>,+ );+}++function normalizeLegacyMessageStreamEvent(+ version: LegacyMessageStreamVersion | undefined,+ event: MessageStreamEventForVersion<LegacyMessageStreamVersion>,+): MessageStreamEvent {+ if (event.type === "message.appended") {+ assertLegacyAppendSnapshot(+ event.data.messageSoFar,+ event.data.messageDelta,+ "message",+ version,+ );+ return {+ data: {+ messageDelta: event.data.messageDelta,+ sequence: event.data.sequence,+ stepIndex: event.data.stepIndex,+ turnId: event.data.turnId,+ },+ meta: event.meta,+ type: "message.appended",+ };+ }++ if (event.type === "reasoning.appended") {+ assertLegacyAppendSnapshot(+ event.data.reasoningSoFar,+ event.data.reasoningDelta,+ "reasoning",+ version,+ );+ return {+ data: {+ reasoningDelta: event.data.reasoningDelta,+ sequence: event.data.sequence,+ stepIndex: event.data.stepIndex,+ turnId: event.data.turnId,+ },+ meta: event.meta,+ type: "reasoning.appended",+ };+ }++ if (event.type === "action.input.appended") {+ if (version !== undefined && version !== "24") {+ throw new TypeError(`Invalid action input append for stream version ${version}.`);+ }+ assertLegacyActionInputOffset(event.data.inputTextOffset, version);+ return {+ data: {+ callId: event.data.callId,+ inputTextDelta: event.data.inputTextDelta,+ sequence: event.data.sequence,+ stepIndex: event.data.stepIndex,+ toolName: event.data.toolName,+ turnId: event.data.turnId,+ },+ meta: event.meta,+ type: "action.input.appended",+ };+ }++ return event;+}++function validateCurrentMessageStreamEvent(+ event: MessageStreamEventForVersion<"25">,+): MessageStreamEvent {+ if (event.type === "message.appended") {+ assertCurrentAppendDelta(event.data.messageDelta, "message");+ assertUnsupportedAppendField(event.data, "messageOffset", "message");+ assertUnsupportedAppendField(event.data, "messageSoFar", "message");+ } else if (event.type === "reasoning.appended") {+ assertCurrentAppendDelta(event.data.reasoningDelta, "reasoning");+ assertUnsupportedAppendField(event.data, "reasoningOffset", "reasoning");+ assertUnsupportedAppendField(event.data, "reasoningSoFar", "reasoning");+ } else if (event.type === "action.input.appended") {+ assertCurrentAppendDelta(event.data.inputTextDelta, "action input");+ assertUnsupportedAppendField(event.data, "inputTextOffset", "action input");+ }+ return event;+}++function assertCurrentAppendDelta(+ delta: unknown,+ stream: "action input" | "message" | "reasoning",+): void {+ if (typeof delta !== "string") {+ throw new TypeError(`Invalid ${stream} append delta for stream version 25.`);+ }+}++function assertUnsupportedAppendField(+ data: object,+ field: string,+ stream: "action input" | "message" | "reasoning",+): void {+ if (field in data) {+ throw new TypeError(`Invalid ${stream} append shape for stream version 25.`);+ }+}++function assertNever(value: never): never {+ throw new TypeError(`Unsupported message stream version: ${String(value)}.`);+}++function assertLegacyActionInputOffset(+ offset: unknown,+ version: LegacyMessageStreamVersion | undefined,+): void {+ if (!Number.isSafeInteger(offset) || (offset as number) < 0) {+ const source = version === undefined ? "persisted stream" : `stream version ${version}`;+ throw new TypeError(`Invalid action input append offset for ${source}.`);+ }+}++function assertLegacyAppendSnapshot(+ snapshot: string,+ delta: string,+ stream: "message" | "reasoning",+ version: LegacyMessageStreamVersion | undefined,+): void {+ const offset = snapshot.length - delta.length;+ if (offset < 0 || snapshot.slice(offset) !== delta) {+ const source = version === undefined ? "persisted stream" : `stream version ${version}`;+ throw new TypeError(`Invalid cumulative ${stream} append for ${source}.`);+ }+}diff --git a/packages/eve/src/protocol/message.test.ts b/packages/eve/src/protocol/message.test.tsindex 4a3698579..99ab68d1c 100644--- a/packages/eve/src/protocol/message.test.ts+++ b/packages/eve/src/protocol/message.test.ts@@ -11,7 +11,9 @@ import {createAuthorizationRequiredEvent,createContextClearedEvent,createInputResolvedEvent,+ createMessageAppendedEvent,createMessageReceivedEvent,+ createReasoningAppendedEvent,createResultCompletedEvent,createSessionWaitingEvent,createStepStartedEvent,@@ -20,12 +22,190 @@ import {encodeMessageStreamEvent,stampMessageStreamEvent,} from "#protocol/message.js";+import {+ normalizeMessageStreamEvent,+ normalizePersistedMessageStreamEvent,+ type MessageStreamEventForVersion,+} from "#protocol/message-version.js";import { isEventId } from "#protocol/event-id.js";import { createEveConnectionCallbackRoutePath } from "#protocol/routes.js";describe("message stream protocol", () => {it("pins the stream version for timed session events", () => {- expect(EVE_MESSAGE_STREAM_VERSION).toBe("24");+ expect(EVE_MESSAGE_STREAM_VERSION).toBe("25");+ });++ it.each(["21", "22", "23", "24"] as const)(+ "normalizes v%s cumulative appends into the v25 delta contract",+ (version) => {+ const legacyMessage = {+ data: {+ messageDelta: "lo",+ messageSoFar: "Hello",+ sequence: 3,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.000Z", id: "evt_legacy_message" },+ type: "message.appended",+ } satisfies MessageStreamEventForVersion<typeof version>;+ const legacyReasoning = {+ data: {+ reasoningDelta: "ink",+ reasoningSoFar: "think",+ sequence: 4,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.001Z", id: "evt_legacy_reasoning" },+ type: "reasoning.appended",+ } satisfies MessageStreamEventForVersion<typeof version>;++ expect(normalizeMessageStreamEvent(version, legacyMessage)).toEqual({+ data: {+ messageDelta: "lo",+ sequence: 3,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: legacyMessage.meta,+ type: "message.appended",+ });+ expect(normalizePersistedMessageStreamEvent(legacyReasoning)).toEqual({+ data: {+ reasoningDelta: "ink",+ sequence: 4,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: legacyReasoning.meta,+ type: "reasoning.appended",+ });+ },+ );++ it("normalizes v24 tool-input appends into plain deltas", () => {+ const legacy = {+ data: {+ callId: "call_1",+ inputTextDelta: "lo",+ inputTextOffset: 3,+ sequence: 4,+ stepIndex: 0,+ toolName: "render",+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.001Z", id: "evt_legacy_input" },+ type: "action.input.appended",+ } satisfies MessageStreamEventForVersion<"24">;++ expect(normalizeMessageStreamEvent("24", legacy)).toEqual({+ data: {+ callId: "call_1",+ inputTextDelta: "lo",+ sequence: 4,+ stepIndex: 0,+ toolName: "render",+ turnId: "turn_1",+ },+ meta: legacy.meta,+ type: "action.input.appended",+ });+ });++ it("strips repeated v24 zero offsets without adding stream markers", () => {+ const normalize = (inputTextDelta: string) => {+ const event = normalizeMessageStreamEvent("24", {+ data: {+ callId: "call_1",+ inputTextDelta,+ inputTextOffset: 0,+ sequence: 4,+ stepIndex: 0,+ toolName: "render",+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.001Z", id: `evt_${inputTextDelta.length}` },+ type: "action.input.appended",+ });+ if (event.type !== "action.input.appended") {+ throw new TypeError(`Expected an action input append, received ${event.type}.`);+ }+ return event;+ };++ expect(normalize("").data).toEqual({+ callId: "call_1",+ inputTextDelta: "",+ sequence: 4,+ stepIndex: 0,+ toolName: "render",+ turnId: "turn_1",+ });+ expect(normalize("{").data).toEqual({+ callId: "call_1",+ inputTextDelta: "{",+ sequence: 4,+ stepIndex: 0,+ toolName: "render",+ turnId: "turn_1",+ });+ });++ it("rejects append variants that contradict their declared stream version", () => {+ const v24ToolInput = {+ data: {+ callId: "call_1",+ inputTextDelta: "{",+ inputTextOffset: 0,+ sequence: 4,+ stepIndex: 0,+ toolName: "render",+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.001Z", id: "evt_v24_input" },+ type: "action.input.appended",+ } satisfies MessageStreamEventForVersion<"24">;+ const hybridV25 = {+ data: {+ messageDelta: "Hel",+ messageSoFar: "Hel",+ sequence: 1,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.000Z", id: "evt_hybrid" },+ type: "message.appended",+ };+ const parseWireEvent = <Version extends "23" | "25">(+ event: object,+ ): MessageStreamEventForVersion<Version> =>+ JSON.parse(JSON.stringify(event)) as MessageStreamEventForVersion<Version>;++ expect(() => normalizeMessageStreamEvent("23", parseWireEvent<"23">(v24ToolInput))).toThrow(+ "Invalid action input append for stream version 23.",+ );+ expect(() => normalizeMessageStreamEvent("25", parseWireEvent<"25">(hybridV25))).toThrow(+ "Invalid message append shape for stream version 25.",+ );+ });++ it("rejects a v25 append without its delta", () => {+ const malformed = JSON.parse(+ JSON.stringify({+ data: {+ sequence: 1,+ stepIndex: 0,+ turnId: "turn_1",+ },+ meta: { at: "2026-09-02T00:00:00.000Z", id: "evt_malformed" },+ type: "message.appended",+ }),+ ) as MessageStreamEventForVersion<"25">;++ expect(() => normalizeMessageStreamEvent("25", malformed)).toThrow(+ "Invalid message append delta for stream version 25.",+ );});it("creates authoritative input resolution batches", () => {@@ -190,6 +370,41 @@ describe("message stream protocol", () => {expect(decoded).toEqual(stamped);});+ it("keeps encoded text append bytes linear as streams grow", () => {+ const encodedBytes = (chunkCount: number): number => {+ const delta = "x".repeat(40);+ let bytes = 0;++ for (let index = 0; index < chunkCount; index += 1) {+ const events = [+ createMessageAppendedEvent({+ messageDelta: delta,+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_0",+ }),+ createReasoningAppendedEvent({+ reasoningDelta: delta,+ sequence: 0,+ stepIndex: 0,+ turnId: "turn_0",+ }),+ ];++ for (const event of events) {+ bytes += encodeMessageStreamEvent(stampMessageStreamEvent(event)).byteLength;+ }+ }++ return bytes;+ };++ const halfStreamBytes = encodedBytes(250);+ const fullStreamBytes = encodedBytes(500);++ expect(fullStreamBytes / halfStreamBytes).toBeLessThan(2.1);+ });+it("mints a distinct id for each emission of an identical payload", () => {const event = createStepStartedEvent({modelId: "openai/gpt-5.5",diff --git a/packages/eve/src/protocol/message.ts b/packages/eve/src/protocol/message.tsindex 4a9ab24ed..d09ecf47d 100644--- a/packages/eve/src/protocol/message.ts+++ b/packages/eve/src/protocol/message.ts@@ -27,7 +27,7 @@ export const EVE_STREAM_TAIL_INDEX_HEADER = "x-eve-stream-tail-index";export const EVE_STREAM_VERSION_HEADER = "x-eve-stream-version";export const EVE_MESSAGE_STREAM_CONTENT_TYPE = "application/x-ndjson; charset=utf-8";export const EVE_MESSAGE_STREAM_FORMAT = "ndjson";-export const EVE_MESSAGE_STREAM_VERSION = "24";+export const EVE_MESSAGE_STREAM_VERSION = "25";/*** eve-owned finish reason for one completed assistant step.@@ -415,7 +415,6 @@ export interface SubagentCompletedStreamEvent {export interface MessageAppendedStreamEvent {data: {messageDelta: string;- messageSoFar: string;sequence: number;stepIndex: number;turnId: string;@@ -431,8 +430,6 @@ export interface ActionInputAppendedStreamEvent {data: {callId: string;inputTextDelta: string;- /** Zero-based UTF-16 code-unit offset where `inputTextDelta` begins. */- inputTextOffset: number;sequence: number;stepIndex: number;toolName: string;@@ -448,7 +445,6 @@ export interface ActionInputAppendedStreamEvent {export interface ReasoningAppendedStreamEvent {data: {reasoningDelta: string;- reasoningSoFar: string;sequence: number;stepIndex: number;turnId: string;@@ -1104,7 +1100,6 @@ export function createActionsRequestedEvent(input: {export function createActionInputAppendedEvent(input: {readonly callId: string;readonly inputTextDelta: string;- readonly inputTextOffset: number;readonly sequence: number;readonly stepIndex: number;readonly toolName: string;@@ -1114,7 +1109,6 @@ export function createActionInputAppendedEvent(input: {data: {callId: input.callId,inputTextDelta: input.inputTextDelta,- inputTextOffset: input.inputTextOffset,sequence: input.sequence,stepIndex: input.stepIndex,toolName: input.toolName,@@ -1357,7 +1351,6 @@ export function createSubagentCalledEvent(input: {*/export function createMessageAppendedEvent(input: {readonly messageDelta: string;- readonly messageSoFar: string;readonly sequence: number;readonly stepIndex: number;readonly turnId: string;@@ -1365,7 +1358,6 @@ export function createMessageAppendedEvent(input: {return {data: {messageDelta: input.messageDelta,- messageSoFar: input.messageSoFar,sequence: input.sequence,stepIndex: input.stepIndex,turnId: input.turnId,@@ -1379,7 +1371,6 @@ export function createMessageAppendedEvent(input: {*/export function createReasoningAppendedEvent(input: {readonly reasoningDelta: string;- readonly reasoningSoFar: string;readonly sequence: number;readonly stepIndex: number;readonly turnId: string;@@ -1387,7 +1378,6 @@ export function createReasoningAppendedEvent(input: {return {data: {reasoningDelta: input.reasoningDelta,- reasoningSoFar: input.reasoningSoFar,sequence: input.sequence,stepIndex: input.stepIndex,turnId: input.turnId,diff --git a/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.test.ts b/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.test.tsindex 966e33095..187e3477f 100644--- a/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.test.ts+++ b/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.test.ts@@ -518,7 +518,6 @@ describe("chatSdkChannel", () => {channelAdapter,makeEvent("message.appended", {messageDelta: "Hel",- messageSoFar: "Hel",sequence: 1,stepIndex: 0,turnId: "turn-1",@@ -532,7 +531,6 @@ describe("chatSdkChannel", () => {channelAdapter,makeEvent("message.appended", {messageDelta: "lo",- messageSoFar: "Hello",sequence: 2,stepIndex: 0,turnId: "turn-1",@@ -544,6 +542,50 @@ describe("chatSdkChannel", () => {]);});+ it("finalizes a retried stream from the canonical completed message", async () => {+ const adapter = testAdapter();+ const bridge = chatSdkChannel({+ adapters: { test: adapter },+ state: memoryState(),+ streamingEditIntervalMs: 0,+ userName: "bot",+ });+ const state: ChatSdkChannelState = { thread: serializedThread() };+ const channelAdapter = withState(getAdapter(bridge.channel), state);+ const ctx = buildAdapterContext(channelAdapter, stubAccessor());++ for (const messageDelta of ["abandoned", "replacement"]) {+ await callEvent(+ channelAdapter,+ makeEvent("message.appended", {+ messageDelta,+ sequence: 1,+ stepIndex: 0,+ turnId: "turn-1",+ }),+ ctx,+ );+ }+ await callEvent(+ channelAdapter,+ makeEvent("message.completed", {+ finishReason: "stop",+ message: "replacement",+ sequence: 1,+ stepIndex: 0,+ turnId: "turn-1",+ }),+ ctx,+ );++ expect(adapter.edited.at(-1)).toEqual({+ message: { markdown: "replacement" },+ messageId: "posted-1",+ threadId: THREAD_ID,+ });+ expect(state.anchorMessageId).toBeNull();+ });+it("falls back to a fresh post when streaming edits are not implemented", async () => {const adapter = testAdapter();adapter.editError = new NotImplementedError("editMessage");diff --git a/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.ts b/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.tsindex 6abd8b75f..95f9a9a3f 100644--- a/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.ts+++ b/packages/eve/src/public/channels/chat-sdk/chatSdkChannel.ts@@ -52,6 +52,7 @@ const DEFAULT_ROUTE = "/eve/v1";const DEFAULT_INPUT_ACTION_PREFIX = "eve_input:";const DEFAULT_STREAMING_EDIT_INTERVAL_MS = 1_000;const MAX_TYPING_STATUS = 80;+const streamTextByState = new WeakMap<ChatSdkChannelState, string>();type ChatSdkAdapters = Record<string, Adapter>;type ChatSdkSendInput = string | UserContent | SendPayload;@@ -86,7 +87,6 @@ export interface ChatSdkChannelState extends Record<string, unknown> {pendingToolCallMessage?: string | null;/** Authorization status messages, keyed by connection name. */pendingAuthMessageIds?: Record<string, string>;- /** Step index the current stream anchor belongs to (resets per step). */streamStepIndex?: number | null;}@@ -371,10 +371,17 @@ function defaultEvents<TAdapters extends ChatSdkAdapters>(await safeStartTyping(channel.thread, truncate(`Running ${labels.join(", ")}...`));},async "message.appended"(event, channel, _ctx) {- if (!channel.thread || !event.messageSoFar || !canStream(channel)) return;+ if (!channel.thread || !canStream(channel)) return;+ const currentText =+ channel.state.streamStepIndex === event.stepIndex+ ? streamTextByState.get(channel.state)+ : undefined;+ const message = (currentText ?? "") + event.messageDelta;+ if (!message) return;+ streamTextByState.set(channel.state, message);const anchor = channel.state.anchorMessageId;if (!anchor || channel.state.streamStepIndex !== event.stepIndex) {- const sent = await channel.thread.post({ markdown: event.messageSoFar });+ const sent = await channel.thread.post({ markdown: message });channel.state.anchorMessageId = sent.id;channel.state.streamStepIndex = event.stepIndex;channel.state.lastEditAtMs = Date.now();@@ -383,7 +390,7 @@ function defaultEvents<TAdapters extends ChatSdkAdapters>(const lastEdit = channel.state.lastEditAtMs ?? 0;if (Date.now() - lastEdit < channel.streamingEditIntervalMs) return;try {- await editMessage(channel.thread, anchor, event.messageSoFar);+ await editMessage(channel.thread, anchor, message);channel.state.lastEditAtMs = Date.now();} catch (error) {if (!isNotImplemented(error)) throw error;@@ -493,6 +500,7 @@ function clearStream(state: ChatSdkChannelState): void {state.anchorMessageId = null;state.lastEditAtMs = null;state.streamStepIndex = null;+ streamTextByState.delete(state);}/** First non-blank line of `text`, used as a compact typing status. */diff --git a/packages/eve/src/public/channels/slack/defaults.ts b/packages/eve/src/public/channels/slack/defaults.tsindex ac118d2d8..d61a4f75c 100644--- a/packages/eve/src/public/channels/slack/defaults.ts+++ b/packages/eve/src/public/channels/slack/defaults.ts@@ -24,6 +24,7 @@ import {import type {SlackChannelEvents,SlackChannelInternalEvents,+ SlackChannelState,SlackContext,SlackMentionResult,} from "#public/channels/slack/slackChannel.js";@@ -32,6 +33,12 @@ import type { InputRequest } from "#shared/input.js";const log = createLogger("slack.defaults");const REASONING_TYPING_REFRESH_INTERVAL_MS = 5_000;const REASONING_TYPING_MIN_PROGRESS_CHARS = 4;+interface ReasoningAccumulator {+ readonly stepIndex: number;+ readonly text: string;+ readonly turnId: string;+}+const reasoningByState = new WeakMap<SlackChannelState, ReasoningAccumulator>();interface SlackSemanticErrorSummary {readonly hint?: string;@@ -321,11 +328,25 @@ export const defaultEvents: SlackChannelInternalEvents = {channel.state.pendingToolCallMessage = null;channel.state.lastReasoningTypingAtMs = null;channel.state.lastReasoningTypingStatus = null;+ reasoningByState.delete(channel.state);await channel.thread.startTyping("Working...");},async "reasoning.appended"(event, channel, _ctx) {- const line = firstNonEmptyLine(event.reasoningSoFar);+ const current = reasoningByState.get(channel.state);+ const continuesCurrentBlock =+ current?.turnId === event.turnId && current.stepIndex === event.stepIndex;+ if (!continuesCurrentBlock) {+ channel.state.lastReasoningTypingAtMs = null;+ channel.state.lastReasoningTypingStatus = null;+ }+ const reasoning = (continuesCurrentBlock ? current.text : "") + event.reasoningDelta;+ reasoningByState.set(channel.state, {+ stepIndex: event.stepIndex,+ text: reasoning,+ turnId: event.turnId,+ });+ const line = firstNonEmptyLine(reasoning);if (line === undefined) return;const status = truncateTypingStatus(line);@@ -347,6 +368,14 @@ export const defaultEvents: SlackChannelInternalEvents = {channel.state.lastReasoningTypingStatus = status;},+ async "reasoning.completed"(event, channel, _ctx) {+ const current = reasoningByState.get(channel.state);+ if (current?.turnId !== event.turnId || current.stepIndex !== event.stepIndex) return;+ reasoningByState.delete(channel.state);+ channel.state.lastReasoningTypingAtMs = null;+ channel.state.lastReasoningTypingStatus = null;+ },+async "actions.requested"(event, channel, _ctx) {const buffered = channel.state.pendingToolCallMessage;channel.state.pendingToolCallMessage = null;diff --git a/packages/eve/src/public/channels/slack/slackChannel.test.ts b/packages/eve/src/public/channels/slack/slackChannel.test.tsindex a9d7dde67..86d6eb022 100644--- a/packages/eve/src/public/channels/slack/slackChannel.test.ts+++ b/packages/eve/src/public/channels/slack/slackChannel.test.ts@@ -911,8 +911,7 @@ describe("slackChannel() default event handlers", () => {await callEvent(adapter,makeEvent("reasoning.appended", {- reasoningDelta: longReasoning,- reasoningSoFar: `${longReasoning}\nThen continue.`,+ reasoningDelta: `${longReasoning}\nThen continue.`,sequence: 0,stepIndex: 0,turnId: "t1",@@ -942,26 +941,26 @@ describe("slackChannel() default event handlers", () => {THREAD_STATE,);const ctx = buildAdapterContext(adapter, stubAccessor());- const reasoningEvent = (reasoningDelta: string, reasoningSoFar: string) =>+ const reasoningEvent = (reasoningDelta: string) =>makeEvent("reasoning.appended", {reasoningDelta,- reasoningSoFar,sequence: 0,stepIndex: 0,turnId: "t1",});- await callEvent(adapter, reasoningEvent("I", "I"), ctx);- await callEvent(adapter, reasoningEvent(" ca", "I ca"), ctx);- await callEvent(adapter, reasoningEvent("n", "I can"), ctx);+ await callEvent(adapter, reasoningEvent("I"), ctx);+ await callEvent(adapter, reasoningEvent(" ca"), ctx);+ await callEvent(adapter, reasoningEvent("n"), ctx);const statuses = fetchMock.mock.calls.map(([, init]) => parseSlackRequestBody(init as RequestInit).status,);expect(statuses).toEqual(["I", "I can"]);+ expect(ctx.state).not.toHaveProperty("reasoningText");});- it("reasoning.appended requires a matching prefix and four new characters", async () => {+ it("reasoning.appended refreshes a short extension after the throttle interval", async () => {vi.useFakeTimers();vi.setSystemTime(new Date("2026-06-18T12:00:00Z"));const adapter = withState(@@ -969,10 +968,9 @@ describe("slackChannel() default event handlers", () => {THREAD_STATE,);const ctx = buildAdapterContext(adapter, stubAccessor());- const reasoningEvent = (reasoningSoFar: string) =>+ const reasoningEvent = (reasoningDelta: string) =>makeEvent("reasoning.appended", {- reasoningDelta: reasoningSoFar,- reasoningSoFar,+ reasoningDelta,sequence: 0,stepIndex: 0,turnId: "t1",@@ -980,16 +978,51 @@ describe("slackChannel() default event handlers", () => {await callEvent(adapter, reasoningEvent("Need"), ctx);vi.setSystemTime(new Date("2026-06-18T12:00:01Z"));- await callEvent(adapter, reasoningEvent("Need to"), ctx);- await callEvent(adapter, reasoningEvent("Check something else"), ctx);+ await callEvent(adapter, reasoningEvent(" to"), ctx);vi.setSystemTime(new Date("2026-06-18T12:00:05Z"));- await callEvent(adapter, reasoningEvent("Need to"), ctx);+ await callEvent(adapter, reasoningEvent("."), ctx);expect(fetchMock).toHaveBeenCalledTimes(2);const statuses = fetchMock.mock.calls.map(([, init]) => parseSlackRequestBody(init as RequestInit).status,);- expect(statuses).toEqual(["Need", "Need to"]);+ expect(statuses).toEqual(["Need", "Need to."]);+ });++ it("starts fresh reasoning status for completed blocks and new steps", async () => {+ vi.useFakeTimers();+ vi.setSystemTime(new Date("2026-06-18T12:00:00Z"));+ const adapter = withState(+ getAdapter(slackChannel({ credentials: { botToken: "xoxb-test" } })),+ THREAD_STATE,+ );+ const ctx = buildAdapterContext(adapter, stubAccessor());+ const reasoningEvent = (reasoningDelta: string, stepIndex: number) =>+ makeEvent("reasoning.appended", {+ reasoningDelta,+ sequence: 0,+ stepIndex,+ turnId: "t1",+ });++ await callEvent(adapter, reasoningEvent("First block", 0), ctx);+ await callEvent(+ adapter,+ makeEvent("reasoning.completed", {+ reasoning: "First block",+ sequence: 0,+ stepIndex: 0,+ turnId: "t1",+ }),+ ctx,+ );+ await callEvent(adapter, reasoningEvent("Second block", 0), ctx);+ await callEvent(adapter, reasoningEvent("Next step", 1), ctx);++ const statuses = fetchMock.mock.calls.map(+ ([, init]) => parseSlackRequestBody(init as RequestInit).status,+ );+ expect(statuses).toEqual(["First block", "Second block", "Next step"]);});it("turn.started resets reasoning status throttling", async () => {@@ -1005,7 +1038,6 @@ describe("slackChannel() default event handlers", () => {adapter,makeEvent("reasoning.appended", {reasoningDelta: "Need to inspect the repo.",- reasoningSoFar: "Need to inspect the repo.",sequence: 0,stepIndex: 0,turnId: "t1",@@ -1022,7 +1054,6 @@ describe("slackChannel() default event handlers", () => {adapter,makeEvent("reasoning.appended", {reasoningDelta: "Fresh turn reasoning.",- reasoningSoFar: "Fresh turn reasoning.",sequence: 1,stepIndex: 0,turnId: "t2",diff --git a/packages/eve/src/public/definitions/channel.test.ts b/packages/eve/src/public/definitions/channel.test.tsindex 068a46b58..3e18f29ce 100644--- a/packages/eve/src/public/definitions/channel.test.ts+++ b/packages/eve/src/public/definitions/channel.test.ts@@ -474,7 +474,6 @@ describe("defineChannel", () => {type: "reasoning.appended",data: {reasoningDelta: "Need",- reasoningSoFar: "Need",sequence: 0,stepIndex: 0,turnId: "turn-1",@@ -499,7 +498,6 @@ describe("defineChannel", () => {expect(appendedData).toMatchObject({reasoningDelta: "Need",- reasoningSoFar: "Need",turnId: "turn-1",});expect(completedData).toMatchObject({diff --git a/packages/eve/src/react/use-eve-agent.test.ts b/packages/eve/src/react/use-eve-agent.test.tsindex 5730e3561..bdba3ae8b 100644--- a/packages/eve/src/react/use-eve-agent.test.ts+++ b/packages/eve/src/react/use-eve-agent.test.ts@@ -4,7 +4,11 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { useEveAgent, type UseEveAgentHelpers } from "#react/use-eve-agent.js";import type { EveMessageData } from "#client/message-reducer.js";-import { EVE_SESSION_ID_HEADER } from "#protocol/message.js";+import {+ EVE_MESSAGE_STREAM_VERSION,+ EVE_SESSION_ID_HEADER,+ EVE_STREAM_VERSION_HEADER,+} from "#protocol/message.js";import {createMessageCompletedEvent,createMessageReceivedEvent,@@ -39,6 +43,9 @@ function createEagerStreamResponse(events: readonly UnstampedMessageStreamEvent[controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}@@ -165,6 +172,9 @@ describe("useEveAgent", () => {streamSignal?.addEventListener("abort", () => controller.error(createAbortError()));},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);});diff --git a/packages/eve/src/services/dev-client.test.ts b/packages/eve/src/services/dev-client.test.tsindex dd7ef787f..e55c32aef 100644--- a/packages/eve/src/services/dev-client.test.ts+++ b/packages/eve/src/services/dev-client.test.ts@@ -1,6 +1,7 @@import { afterEach, describe, expect, it, vi } from "vitest";import { Client } from "#client/index.js";+import { EVE_MESSAGE_STREAM_VERSION, EVE_STREAM_VERSION_HEADER } from "#protocol/message.js";import { createDevelopmentRuntimeArtifactRefresher } from "#services/dev-client.js";const encoder = new TextEncoder();@@ -305,6 +306,9 @@ function createDevFetchMock(input: {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);});}diff --git a/packages/eve/src/svelte/use-eve-agent.test.ts b/packages/eve/src/svelte/use-eve-agent.test.tsindex a16b498fb..3d261701b 100644--- a/packages/eve/src/svelte/use-eve-agent.test.ts+++ b/packages/eve/src/svelte/use-eve-agent.test.ts@@ -1,7 +1,11 @@import { afterEach, describe, expect, it, vi } from "vitest";import { useEveAgent } from "#svelte/use-eve-agent.js";-import { EVE_SESSION_ID_HEADER } from "#protocol/message.js";+import {+ EVE_MESSAGE_STREAM_VERSION,+ EVE_SESSION_ID_HEADER,+ EVE_STREAM_VERSION_HEADER,+} from "#protocol/message.js";import {createMessageCompletedEvent,createMessageReceivedEvent,@@ -31,6 +35,9 @@ function createEagerStreamResponse(events: readonly UnstampedMessageStreamEvent[controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}diff --git a/packages/eve/src/vue/use-eve-agent.test.ts b/packages/eve/src/vue/use-eve-agent.test.tsindex ed7cc1af5..0ada16fc4 100644--- a/packages/eve/src/vue/use-eve-agent.test.ts+++ b/packages/eve/src/vue/use-eve-agent.test.ts@@ -4,7 +4,11 @@ import { effectScope } from "vue";import { EveAgentStore, type EveAgentStoreSnapshot } from "#client/eve-agent-store.js";import { useEveAgent } from "#vue/use-eve-agent.js";import type { EveMessageData } from "#client/message-reducer.js";-import { EVE_SESSION_ID_HEADER } from "#protocol/message.js";+import {+ EVE_MESSAGE_STREAM_VERSION,+ EVE_SESSION_ID_HEADER,+ EVE_STREAM_VERSION_HEADER,+} from "#protocol/message.js";import {createMessageCompletedEvent,createMessageReceivedEvent,@@ -37,6 +41,9 @@ function createEagerStreamResponse(events: readonly UnstampedMessageStreamEvent[controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}diff --git a/packages/eve/test/client.test.ts b/packages/eve/test/client.test.tsindex 29d21e005..39166862e 100644--- a/packages/eve/test/client.test.ts+++ b/packages/eve/test/client.test.ts@@ -9,6 +9,8 @@ import {} from "../src/client/index.js";import {EVE_SESSION_ID_HEADER,+ EVE_MESSAGE_STREAM_VERSION,+ EVE_STREAM_VERSION_HEADER,createMessageCompletedEvent,createMessageReceivedEvent,createResultCompletedEvent,@@ -50,6 +52,9 @@ function createControlledStreamResponse(): {controller = streamController;},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },),};}@@ -83,6 +88,9 @@ function createEagerStreamResponse(events: readonly unknown[]): Response {controller.close();},}),+ {+ headers: { [EVE_STREAM_VERSION_HEADER]: EVE_MESSAGE_STREAM_VERSION },+ },);}diff --git a/packages/eve/test/scenarios/mounted-extension-installed.scenario.test.ts b/packages/eve/test/scenarios/mounted-extension-installed.scenario.test.tsindex 5e1461624..10dce105e 100644--- a/packages/eve/test/scenarios/mounted-extension-installed.scenario.test.ts+++ b/packages/eve/test/scenarios/mounted-extension-installed.scenario.test.ts@@ -249,7 +249,7 @@ describe("mounted extension installed under node_modules", () => {);expect(JSON.parse(extensionFiles[`node_modules/${PACKAGE_NAME}/dist/extension/_manifest.json`]!),- ).toMatchObject({ requires: { channel: 12, schedule: 5, subagent: 5 } });+ ).toMatchObject({ requires: { channel: 13, schedule: 6, subagent: 6 } });const app = await scenarioApp({name: "mounted-extension-installed",installDependencies: true,diff --git a/research/delta-text-streams.md b/research/delta-text-streams.mdnew file mode 100644index 000000000..620892dbc--- /dev/null+++ b/research/delta-text-streams.md@@ -0,0 +1,73 @@+---+issue: TBD+status: prototype+last_updated: "2026-09-02"+---++# Delta text streams++## Summary++`message.appended` and `reasoning.appended` currently persist both the latest model delta and the complete text accumulated for that block. Repeating a growing cumulative snapshot makes durable bytes grow quadratically with the generated text, even though `message.completed` and `reasoning.completed` persist the final blocks.++Store only each delta. Consumers that need progressive text accumulate those deltas in stream order; completed events carry the authoritative value for each finalized block.++## Stream contract++```ts+type MessageAppendedData = {+ messageDelta: string;+ // Existing stream coordinates remain unchanged.+};++type ReasoningAppendedData = {+ reasoningDelta: string;+ // Existing stream coordinates remain unchanged.+};+```++Adjacent deltas may be coalesced while a durable write is in flight when their event type, stream coordinates, and tool `callId` match. The resulting text and event ordering stay the same. Completed events carry finalized block values.++This is a stream-version 25 breaking change: `messageDelta` replaces the `messageDelta` plus `messageSoFar` pair, and `reasoningDelta` replaces the `reasoningDelta` plus `reasoningSoFar` pair. Streamed tool input drops `inputTextOffset` and uses the same plain-delta contract.++## Consumer rule++```ts+current += delta;+```++Replay produces the same accumulated state as live delivery when it begins before the relevant deltas.++## Consumer migration++| Consumer | Cumulative state | Projection |+| --------------------------- | --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |+| Default message reducer | Latest streaming text/reasoning/tool-input part | Appends deltas and replaces provisional text with the completed event. |+| Chat SDK channel | In-memory text keyed by channel-state identity | Posts the first delta, edits with accumulated text, and finalizes from `message.completed`. |+| Slack channel | In-memory reasoning keyed by channel-state identity | Preserves progressive reasoning status and throttling behavior. |+| TUI | Text per turn, step, type, and generation | Emits deltas; a divergent completed event renders as a separate canonical generation. |+| Next.js trace viewer | Text per trace step | Uses the public `MessageStreamEvent` union, so stream schema changes fail its compile rather than its runtime. |+| ACP and subagent pump | None | Continue forwarding each raw delta; no migration is required. |+| Authored channels and hooks | Consumer-owned | Append deltas when cumulative text is required, or handle each chunk directly. |+| Published extensions | Compiled capability contracts | Rebuild and republish packages whose manifest uses an epoch advanced by this stream event change. |++## Retry and reconnect semantics++A provider retry reuses its turn and step coordinates. If the failed attempt emitted partial text, raw delta consumers see that text followed by the successful attempt's deltas because the append protocol does not carry attempt identity. When the failed attempt emitted only deltas, the default reducer and Chat SDK channel replace provisional text when a completed event arrives. The TUI cannot retract text already emitted to its renderer, so it renders a divergent completed event as a separate generation. Completed blocks from an attempt that later fails remain durable; retracting them would require attempt identity.++A consumer that reconnects with both its prior accumulator and stream cursor continues normally. A consumer that retained only the cursor cannot reconstruct earlier text from a later delta; it must replay the earlier events or wait for the completed event. This is the capability removed with cumulative append snapshots. Numeric character positions do not solve that missing-content problem, so the protocol does not carry them.++Supported clients rely on the durable event cursor for ordered delivery. The delta contract does not validate character continuity. A raw consumer that omits an event can produce an incomplete accumulator; numeric positions could detect some such gaps but could not recover the missing text.++The client reads the stream version header on every connection. It normalizes v21–v24 cumulative message and reasoning appends, plus v24 offset-based tool-input appends, into the v25 delta-only contract before reducers see them, including when a reconnect crosses deployments. A current server performs the same normalization when replaying events persisted by an earlier deployment. Missing, unsupported, or shape-inconsistent versions fail instead of being cast to the current event union.++Built-in channel accumulators live in weak maps keyed by in-memory channel-state identity, not as properties of persisted channel state. The runtime serializes `channel.state` at the durable turn-step boundary, so putting cumulative text there would reintroduce an unnecessary snapshot write even though it would not repeat once per append event.++## Validation++- Protocol and emission tests assert plain-delta shapes and coalescing boundaries.+- Default reducer tests cover accumulation and canonical completion after an interrupted attempt.+- Chat SDK, Slack, and TUI regressions cover their cumulative projections and completed-event behavior.+- A reconnect regression starts with a v24 cumulative append and completes the same block from a v25 continuation.+- The Next.js trace aliases the public event union, making stale append-field reads a compile-time error.+- Extension-contract reports identify every capability epoch that extension authors must rebuild.