@assistant-ui/eve 0.0.23 → 0.0.25

package/src/convertEveMessages.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, it } from "vitest";
-import type { EveMessageData, EveMessageInputRequest } from "eve/react";
+import type { EveInteractionPart, EveToolPart, Interaction } from "eve/react";
 import {
-  defaultMessageReducer,
-  type EveAgentReducerEvent,
-  type MessageStreamEvent,
+  conversationOf,
+  type ConversationState,
+  type SessionEvent,
+  type SessionStreamEvent,
 } from "eve/client";
 import {
   collectInterruptedTurnEvents,
+  convertEveMessage,
   convertEveMessages,
   type InterruptedTurnEventCache,
   findEveInputRequest,
@@ -15,36 +17,137 @@ import {
 } from "./convertEveMessages";
 import type { AppendMessage } from "@assistant-ui/core";
 
-const withApprovalPart = (eve?: {
-  kind: "tool-call";
-  name: string;
-  inputRequest?: EveMessageInputRequest;
-}): EveMessageData => ({
+type MessageData = Pick<ConversationState, "messages">;
+type InputRequest = Interaction["request"];
+
+const approvalInteraction = (
+  request: InputRequest = { kind: "approval", prompt: "Send the email?" },
+): Interaction => ({
+  interactionId: "req_1",
+  turnId: "turn_1",
+  stepIndex: 0,
+  status: "open",
+  request,
+  call: { callId: "call_1", name: "send_email", input: {} },
+});
+
+const toolPart = (
+  overrides: {
+    state?: "requested" | "approval" | "rejected";
+    input?: unknown;
+    interaction?: Interaction;
+    name?: string;
+    label?: string;
+  } = {},
+): Exclude<EveToolPart, { state: "streaming" }> => ({
+  type: "tool",
+  callId: "call_1",
+  stepIndex: 0,
+  kind: "tool",
+  name: "send_email",
+  label: "send_email",
+  state: overrides.interaction ? "approval" : "requested",
+  input: {},
+  ...overrides,
+});
+
+const signInPart = (
+  request: InputRequest,
+  overrides: Partial<Interaction> = {},
+): EveInteractionPart => ({
+  type: "interaction",
+  interactionId: "auth_1",
+  turnId: "turn_1",
+  stepIndex: 0,
+  status: "open",
+  request,
+  ...overrides,
+});
+
+const withApprovalPart = (request?: InputRequest): MessageData => ({
   messages: [
     {
       id: "a1",
       role: "assistant",
-      parts: [
-        {
-          type: "dynamic-tool",
-          state: "approval-requested",
-          toolCallId: "call_1",
-          toolName: "send_email",
-          input: {},
-          approval: { id: "req_1" },
-          ...(eve && { toolMetadata: { eve } }),
-        },
-      ],
+      parts: [toolPart({ interaction: approvalInteraction(request) })],
     },
   ],
 });
 
 const eventMeta = (sequence: number) => ({
   at: "2026-01-01T00:00:00.000Z",
-  id: `evt_${sequence}`,
+  position: { line: sequence, index: 0 },
+});
+
+const replay = (events: readonly SessionEvent[]) =>
+  conversationOf(
+    events.map((event, index) => ({ ...event, meta: eventMeta(index) })),
+  );
+
+const initialTurnEvents = [
+  { type: "session.started", data: {} },
+  { type: "delivery.admitted", data: { deliveryId: "delivery_1" } },
+  {
+    type: "turn.started",
+    data: {
+      turnId: "turn_1",
+      cause: { deliveryId: "delivery_1" },
+      follows: null,
+    },
+  },
+  {
+    type: "delivery.consumed",
+    data: {
+      deliveryId: "delivery_1",
+      turnId: "turn_1",
+      parts: [{ kind: "text", text: "hi" }],
+    },
+  },
+  {
+    type: "model.requested",
+    scope: { turnId: "turn_1" },
+    data: { runId: "run_1", owner: { turnId: "turn_1" } },
+  },
+  {
+    type: "model.started",
+    scope: { turnId: "turn_1", runId: "run_1" },
+    data: { runId: "run_1", modelId: "test-model", attempt: 0 },
+  },
+] as const satisfies readonly SessionEvent[];
+
+const signInOpened = (
+  name: string,
+  signIn: Partial<NonNullable<InputRequest["signIn"]>> = {},
+): SessionEvent => ({
+  type: "interaction.opened",
+  scope: { turnId: "turn_1" },
+  data: {
+    interactionId: `auth_${name}`,
+    subject: { turnId: "turn_1" },
+    request: {
+      kind: "sign-in",
+      prompt: `Authorization required for ${signIn.displayName ?? name}`,
+      signIn: { name, ...signIn },
+    },
+  },
 });
 
 describe("convertEveMessages", () => {
+  it("converts a single completed message with default options", () => {
+    const message = {
+      id: "a1",
+      role: "assistant",
+      parts: [{ type: "text", text: "Hello" }],
+    } as const satisfies MessageData["messages"][number];
+
+    expect(convertEveMessage(message, 0, [message])).toMatchObject({
+      id: "a1",
+      role: "assistant",
+      content: [{ type: "text", text: "Hello" }],
+      status: { type: "complete", reason: "stop" },
+    });
+  });
+
   it("converts text and reasoning parts", () => {
     const data = {
       messages: [
@@ -63,7 +166,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const messages = convertEveMessages(data, { isRunning: true });
 
@@ -97,7 +200,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const messages = convertEveMessages(data, { isRunning: true });
 
@@ -119,7 +222,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const messages = convertEveMessages(data);
 
@@ -144,7 +247,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const messages = convertEveMessages(data);
 
@@ -153,42 +256,30 @@ describe("convertEveMessages", () => {
     }
   });
 
-  it("converts dynamic tool parts with approval options", () => {
+  it("converts tool parts with approval options", () => {
     const data = {
       messages: [
         {
           id: "a1",
           role: "assistant",
           parts: [
-            {
-              type: "dynamic-tool",
-              state: "approval-requested",
-              toolCallId: "call_1",
-              toolName: "send_email",
+            toolPart({
               input: { to: "dev@example.com" },
-              approval: { id: "req_1" },
-              toolMetadata: {
-                eve: {
-                  kind: "tool-call",
-                  name: "send_email",
-                  inputRequest: {
-                    requestId: "req_1",
-                    kind: "tool-approval",
-                    prompt: "Send the email?",
-                    display: "confirmation",
-                    options: [
-                      { id: "approve", label: "Approve" },
-                      { id: "cancel", label: "Cancel", style: "danger" },
-                      { id: "escalate", label: "Escalate" },
-                    ],
-                  },
-                },
-              },
-            },
+              interaction: approvalInteraction({
+                kind: "approval",
+                prompt: "Send the email?",
+                display: "confirmation",
+                options: [
+                  { id: "approve", label: "Approve" },
+                  { id: "cancel", label: "Cancel", style: "danger" },
+                  { id: "escalate", label: "Escalate" },
+                ],
+              }),
+            }),
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -204,7 +295,7 @@ describe("convertEveMessages", () => {
             id: "req_1",
             options: [
               { id: "approve", kind: "allow-once", label: "Approve" },
-              { id: "cancel", kind: "reject-once", label: "Cancel" },
+              { id: "cancel", kind: "_cancel", label: "Cancel" },
               { id: "escalate", kind: "_escalate", label: "Escalate" },
             ],
           },
@@ -213,7 +304,7 @@ describe("convertEveMessages", () => {
     });
   });
 
-  it("keeps streaming dynamic tool args incomplete until input is available", () => {
+  it("keeps streaming tool args incomplete until input is available", () => {
     const streamingData = {
       messages: [
         {
@@ -221,17 +312,19 @@ describe("convertEveMessages", () => {
           role: "assistant",
           parts: [
             {
-              type: "dynamic-tool",
-              state: "input-streaming",
-              toolCallId: "call_1",
-              toolName: "search",
-              input: undefined,
+              type: "tool",
+              state: "streaming",
+              callId: "call_1",
+              stepIndex: 0,
+              kind: "tool",
+              name: "search",
+              label: "search",
               inputText: "",
             },
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [streamingMessage] = convertEveMessages(streamingData);
 
@@ -247,17 +340,15 @@ describe("convertEveMessages", () => {
           id: "a1",
           role: "assistant",
           parts: [
-            {
-              type: "dynamic-tool",
-              state: "input-available",
-              toolCallId: "call_1",
-              toolName: "search",
+            toolPart({
+              name: "search",
+              label: "search",
               input: { query: "badge" },
-            },
+            }),
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [availableMessage] = convertEveMessages(availableData);
 
@@ -272,8 +363,7 @@ describe("convertEveMessages", () => {
     [
       "a confirmation request",
       {
-        requestId: "req_1",
-        kind: "tool-approval",
+        kind: "approval",
         prompt: "Send the email?",
         display: "confirmation",
         options: [
@@ -286,7 +376,6 @@ describe("convertEveMessages", () => {
     [
       "a select question that also takes a typed answer",
       {
-        requestId: "req_1",
         kind: "question",
         prompt: "Which environment?",
         display: "select",
@@ -302,7 +391,6 @@ describe("convertEveMessages", () => {
     [
       "a text question",
       {
-        requestId: "req_1",
         kind: "question",
         prompt: "What should the subject line be?",
         display: "text",
@@ -315,19 +403,13 @@ describe("convertEveMessages", () => {
     ],
     [
       "a question with neither a display nor options",
-      { requestId: "req_1", kind: "question", prompt: "Anything else?" },
+      { kind: "question", prompt: "Anything else?" },
       { prompt: "Anything else?", display: "text", allowFreeform: true },
     ],
-  ] satisfies [string, EveMessageInputRequest, object][])(
+  ] satisfies [string, InputRequest, object][])(
     "describes %s on the approval itself",
     (_label, inputRequest, expected) => {
-      const [message] = convertEveMessages(
-        withApprovalPart({
-          kind: "tool-call",
-          name: "send_email",
-          inputRequest,
-        }),
-      );
+      const [message] = convertEveMessages(withApprovalPart(inputRequest));
 
       expect(message!.content[0]).toMatchObject({ approval: expected });
     },
@@ -342,14 +424,9 @@ describe("convertEveMessages", () => {
     (_label, display) => {
       const [message] = convertEveMessages(
         withApprovalPart({
-          kind: "tool-call",
-          name: "send_email",
-          inputRequest: {
-            requestId: "req_1",
-            kind: "tool-approval",
-            prompt: "Send the email?",
-            ...(display && { display }),
-          },
+          kind: "approval",
+          prompt: "Send the email?",
+          ...(display && { display }),
         }),
       );
 
@@ -365,13 +442,8 @@ describe("convertEveMessages", () => {
   it("does not offer a typed answer on a tool approval whose options were dropped", () => {
     const [message] = convertEveMessages(
       withApprovalPart({
-        kind: "tool-call",
-        name: "send_email",
-        inputRequest: {
-          requestId: "req_1",
-          kind: "tool-approval",
-          prompt: "Send the email?",
-        },
+        kind: "approval",
+        prompt: "Send the email?",
       }),
     );
 
@@ -385,18 +457,13 @@ describe("convertEveMessages", () => {
   it("does not offer a typed answer on a confirmation request", () => {
     const [message] = convertEveMessages(
       withApprovalPart({
-        kind: "tool-call",
-        name: "send_email",
-        inputRequest: {
-          requestId: "req_1",
-          kind: "tool-approval",
-          prompt: "Send the email?",
-          display: "confirmation",
-          options: [
-            { id: "approve", label: "Approve" },
-            { id: "cancel", label: "Cancel" },
-          ],
-        },
+        kind: "approval",
+        prompt: "Send the email?",
+        display: "confirmation",
+        options: [
+          { id: "approve", label: "Approve" },
+          { id: "cancel", label: "Cancel" },
+        ],
       }),
     );
 
@@ -409,7 +476,6 @@ describe("convertEveMessages", () => {
     [
       "the full input request",
       {
-        requestId: "req_1",
         prompt: "Which environment?",
         kind: "question",
         display: "select",
@@ -423,40 +489,29 @@ describe("convertEveMessages", () => {
     [
       "only the fields the request defines",
       {
-        requestId: "req_1",
         prompt: "What should the subject line be?",
         kind: "question",
       },
     ],
-  ] satisfies [string, EveMessageInputRequest][])(
+  ] satisfies [string, InputRequest][])(
     "projects %s onto providerMetadata.eve",
     (_label, inputRequest) => {
-      const [message] = convertEveMessages(
-        withApprovalPart({
-          kind: "tool-call",
-          name: "send_email",
-          inputRequest,
-        }),
-      );
+      const [message] = convertEveMessages(withApprovalPart(inputRequest));
       const part = message!.content[0];
 
       expect(part).toMatchObject({ type: "tool-call" });
       expect((part as { providerMetadata?: unknown }).providerMetadata).toEqual(
         {
-          eve: { inputRequest },
+          eve: { interaction: { interactionId: "req_1", ...inputRequest } },
         },
       );
     },
   );
 
-  it.each([
-    [
-      "eve metadata without an input request",
-      { kind: "tool-call" as const, name: "send_email" },
-    ],
-    ["no eve metadata at all", undefined],
-  ])("omits providerMetadata for a tool part with %s", (_label, eve) => {
-    const [message] = convertEveMessages(withApprovalPart(eve));
+  it("omits providerMetadata for a tool part without an interaction", () => {
+    const [message] = convertEveMessages({
+      messages: [{ id: "a1", role: "assistant", parts: [toolPart()] }],
+    });
 
     expect(message!.content[0]).not.toHaveProperty("providerMetadata");
   });
@@ -469,17 +524,20 @@ describe("convertEveMessages", () => {
           role: "assistant",
           parts: [
             {
-              type: "dynamic-tool",
-              state: "output-denied",
-              toolCallId: "call_1",
-              toolName: "send_email",
-              input: { to: "dev@example.com" },
-              approval: { id: "req_1", approved: false },
+              ...toolPart({
+                state: "rejected",
+                input: { to: "dev@example.com" },
+                interaction: {
+                  ...approvalInteraction(),
+                  status: "settled",
+                  outcome: "declined",
+                },
+              }),
             },
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -496,6 +554,161 @@ describe("convertEveMessages", () => {
     });
   });
 
+  it.each([
+    ["completed", { answer: "sent" }, { answer: "sent" }, false],
+    ["failed", undefined, { error: "Tool call failed" }, true],
+    ["cancelled", undefined, { error: "Tool call cancelled" }, true],
+  ] as const)(
+    "maps a %s tool call to its result and error state",
+    (state, output, result, isError) => {
+      const [message] = convertEveMessages({
+        messages: [
+          {
+            id: "a1",
+            role: "assistant",
+            parts: [{ ...toolPart(), state, output }],
+          },
+        ],
+      });
+
+      expect(message?.content[0]).toMatchObject({ type: "tool-call", result });
+      expect(Object.hasOwn(message?.content[0] ?? {}, "isError")).toBe(isError);
+      expect(message?.content[0]).toMatchObject(isError ? { isError } : {});
+    },
+  );
+
+  it("uses a failed tool's error before its interaction reason", () => {
+    const [message] = convertEveMessages({
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              ...toolPart({
+                interaction: { ...approvalInteraction(), reason: "Denied" },
+              }),
+              state: "failed",
+              error: { code: "internal", message: "Service unavailable" },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(message?.content[0]).toMatchObject({
+      result: { error: "Service unavailable" },
+      isError: true,
+    });
+  });
+
+  it("exposes preliminary tool output before the call settles", () => {
+    const [message] = convertEveMessages({
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [{ ...toolPart({ input: ["first"] }), output: "partial" }],
+        },
+      ],
+    });
+
+    expect(message?.content[0]).toMatchObject({
+      args: { value: ["first"] },
+      argsText: '["first"]',
+      result: "partial",
+      isPreliminary: true,
+    });
+  });
+
+  it.each([
+    [
+      "accepted",
+      { approved: true, optionId: "approve", text: "Proceed" },
+      false,
+    ],
+    ["declined", { approved: false, optionId: "deny", text: "Later" }, true],
+    ["expired", { resolution: "expired" }, true],
+    ["withdrawn", { resolution: "cancelled" }, true],
+  ] as const)(
+    "projects a settled %s interaction with its answer or resolution",
+    (outcome, approval, isError) => {
+      const interaction = signInPart(
+        { kind: "question", prompt: "Proceed?", options: approveCancel },
+        {
+          status: "settled",
+          outcome,
+          reason: "Session finished",
+          ...(outcome === "accepted" || outcome === "declined"
+            ? {
+                answer: {
+                  interactionId: "auth_1",
+                  optionId: outcome === "accepted" ? "approve" : "deny",
+                  text: outcome === "accepted" ? "Proceed" : "Later",
+                },
+              }
+            : {}),
+        },
+      );
+      const [message] = convertEveMessages({
+        messages: [{ id: "a1", role: "assistant", parts: [interaction] }],
+      });
+
+      expect(message?.content[0]).toMatchObject({
+        type: "tool-call",
+        toolName: "question",
+        approval: { ...approval, reason: "Session finished" },
+      });
+      expect(Object.hasOwn(message?.content[0] ?? {}, "isError")).toBe(isError);
+      expect(message?.content[0]).toMatchObject(isError ? { isError } : {});
+      expect(message?.content[0]).toHaveProperty(
+        "result",
+        outcome === "accepted" || outcome === "declined"
+          ? {
+              interactionId: "auth_1",
+              optionId: outcome === "accepted" ? "approve" : "deny",
+              text: outcome === "accepted" ? "Proceed" : "Later",
+            }
+          : { outcome, reason: "Session finished" },
+      );
+    },
+  );
+
+  it.each([
+    ["declined", "declined"],
+    ["invalid", "declined"],
+    ["expired", "timed-out"],
+    ["failed", "failed"],
+    ["withdrawn", "cancelled"],
+  ] as const)("maps a %s sign-in to %s", (outcome, mapped) => {
+    const [message] = convertEveMessages({
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            signInPart(
+              { kind: "sign-in", prompt: "Connect", title: "Account" },
+              { status: "settled", outcome, reason: "Session finished" },
+            ),
+          ],
+        },
+      ],
+    });
+
+    expect(message?.content[0]).toEqual({
+      type: "data",
+      name: "authorization",
+      data: {
+        state: "completed",
+        name: "Account",
+        description: "Connect",
+        outcome: mapped,
+        reason: "Session finished",
+      },
+    });
+  });
+
   it("drops empty and whitespace-only assistant text and reasoning parts", () => {
     const data = {
       messages: [
@@ -509,7 +722,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -526,7 +739,7 @@ describe("convertEveMessages", () => {
           parts: [{ type: "text", text: "Hello" }],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -543,7 +756,7 @@ describe("convertEveMessages", () => {
           parts: [{ type: "text", text: "Hello" }],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -559,7 +772,7 @@ describe("convertEveMessages", () => {
           parts: [{ type: "file", mediaType: "image/png" }],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -579,14 +792,14 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
     expect(message?.content).toEqual([{ type: "text", text: "Hello" }]);
   });
 
-  it("converts a user file part into content and a file attachment", () => {
+  it("converts a user file part into a file attachment and keeps it out of content", () => {
     const data = {
       messages: [
         {
@@ -604,19 +817,12 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
     expect(message?.content).toEqual([
       { type: "text", text: "See the report" },
-      {
-        type: "file",
-        data: "https://example.com/report.pdf",
-        mimeType: "application/pdf",
-        filename: "report.pdf",
-        sourceType: "url",
-      },
     ]);
     expect(message?.attachments).toEqual([
       {
@@ -654,19 +860,11 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
-    expect(message?.content).toEqual([
-      {
-        type: "file",
-        data: "https://example.com/photo.png",
-        mimeType: "image/png",
-        filename: "photo.png",
-        sourceType: "url",
-      },
-    ]);
+    expect(message?.content).toEqual([]);
     expect(message?.attachments).toEqual([
       {
         id: "0",
@@ -700,17 +898,11 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
-    expect(message?.content).toEqual([
-      {
-        type: "file",
-        data: "data:application/pdf;base64,QUJD",
-        mimeType: "application/pdf",
-      },
-    ]);
+    expect(message?.content).toEqual([]);
     expect(message?.attachments).toEqual([
       {
         id: "0",
@@ -750,7 +942,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -760,71 +952,6 @@ describe("convertEveMessages", () => {
     ]);
   });
 
-  it("defaults a file part with a missing mediaType to application/octet-stream", () => {
-    const data = {
-      messages: [
-        {
-          id: "u1",
-          role: "user",
-          parts: [{ type: "file", url: "https://example.com/blob" }],
-        },
-      ],
-    } as unknown as EveMessageData;
-
-    const [message] = convertEveMessages(data);
-
-    expect(message?.content).toEqual([
-      {
-        type: "file",
-        data: "https://example.com/blob",
-        mimeType: "application/octet-stream",
-        sourceType: "url",
-      },
-    ]);
-    expect(message?.attachments).toEqual([
-      {
-        id: "0",
-        type: "file",
-        name: "file",
-        content: [
-          {
-            type: "file",
-            data: "https://example.com/blob",
-            mimeType: "application/octet-stream",
-            sourceType: "url",
-          },
-        ],
-        contentType: "application/octet-stream",
-        status: { type: "complete" },
-      },
-    ]);
-  });
-
-  it("reads the media type from a data URL when eve omits mediaType", () => {
-    const data = {
-      messages: [
-        {
-          id: "u1",
-          role: "user",
-          parts: [{ type: "file", url: "data:image/png;base64,iVBORw0KGgo=" }],
-        },
-      ],
-    } as unknown as EveMessageData;
-
-    const [message] = convertEveMessages(data);
-
-    expect(message?.content).toEqual([
-      {
-        type: "file",
-        data: "data:image/png;base64,iVBORw0KGgo=",
-        mimeType: "image/png",
-      },
-    ]);
-    expect(message?.attachments?.map((a) => [a.type, a.contentType])).toEqual([
-      ["image", "image/png"],
-    ]);
-  });
-
   it("prefers an explicit mediaType over the data URL declaration", () => {
     const data = {
       messages: [
@@ -840,13 +967,13 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
-    expect(message?.content[0]).toMatchObject({
+    expect(message?.attachments?.[0]).toMatchObject({
       type: "file",
-      mimeType: "application/pdf",
+      contentType: "application/pdf",
     });
   });
 
@@ -867,7 +994,7 @@ describe("convertEveMessages", () => {
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -883,6 +1010,25 @@ describe("convertEveMessages", () => {
     ]);
   });
 
+  it("drops a URL-less assistant file part while retaining text", () => {
+    const data = {
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            { type: "file", mediaType: "application/pdf" },
+            { type: "text", text: "Done" },
+          ],
+        },
+      ],
+    } satisfies MessageData;
+
+    const [message] = convertEveMessages(data);
+
+    expect(message?.content).toEqual([{ type: "text", text: "Done" }]);
+  });
+
   it("drops non-convertible part types instead of throwing", () => {
     const data = {
       messages: [
@@ -890,14 +1036,12 @@ describe("convertEveMessages", () => {
           id: "a1",
           role: "assistant",
           parts: [
-            { type: "step-start" },
             { type: "future-part", payload: {} },
-            { type: "file", mediaType: "application/pdf" },
             { type: "text", text: "Done" },
           ],
         },
       ],
-    } as unknown as EveMessageData;
+    } as unknown as MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -911,26 +1055,22 @@ describe("convertEveMessages", () => {
           id: "a1",
           role: "assistant",
           parts: [
-            {
-              type: "authorization",
-              state: "required",
-              name: "github",
-              description: "Sign in to GitHub",
-              displayName: "GitHub",
-              stepIndex: 0,
-              turnId: "turn_1",
-              authorization: {
+            signInPart({
+              kind: "sign-in",
+              prompt: "Sign in to GitHub",
+              signIn: {
+                name: "github",
                 displayName: "GitHub",
                 instructions: "Enter the code on the device page",
                 url: "https://github.com/login/device",
                 userCode: "ABCD-1234",
                 expiresAt: "2026-01-01T00:00:00Z",
               },
-            },
+            }),
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -959,15 +1099,15 @@ describe("convertEveMessages", () => {
           id: "a1",
           role: "assistant",
           parts: [
-            {
-              type: "authorization",
-              state: "required",
-              name: "github",
-            },
+            signInPart({
+              kind: "sign-in",
+              prompt: "",
+              signIn: { name: "github" },
+            }),
           ],
         },
       ],
-    } as unknown as EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -975,7 +1115,7 @@ describe("convertEveMessages", () => {
       {
         type: "data",
         name: "authorization",
-        data: { state: "required", name: "github" },
+        data: { state: "required", name: "github", description: "" },
       },
     ]);
   });
@@ -987,19 +1127,19 @@ describe("convertEveMessages", () => {
           id: "a1",
           role: "assistant",
           parts: [
-            {
-              type: "authorization",
-              state: "required",
-              name: "github",
-              authorization: {
+            signInPart({
+              kind: "sign-in",
+              prompt: "",
+              signIn: {
+                name: "github",
                 url: "javascript:alert(1)",
                 userCode: "ABCD-1234",
               },
-            },
+            }),
           ],
         },
       ],
-    } as unknown as EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -1007,7 +1147,12 @@ describe("convertEveMessages", () => {
       {
         type: "data",
         name: "authorization",
-        data: { state: "required", name: "github", userCode: "ABCD-1234" },
+        data: {
+          state: "required",
+          name: "github",
+          description: "",
+          userCode: "ABCD-1234",
+        },
       },
     ]);
   });
@@ -1019,20 +1164,18 @@ describe("convertEveMessages", () => {
           id: "a1",
           role: "assistant",
           parts: [
-            {
-              type: "authorization",
-              state: "completed",
-              name: "github",
-              description: "Sign in to GitHub",
-              displayName: "GitHub",
-              stepIndex: 0,
-              turnId: "turn_1",
-              outcome: "authorized",
-            },
+            signInPart(
+              {
+                kind: "sign-in",
+                prompt: "Sign in to GitHub",
+                signIn: { name: "github", displayName: "GitHub" },
+              },
+              { status: "settled", outcome: "accepted" },
+            ),
           ],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data);
 
@@ -1054,7 +1197,7 @@ describe("convertEveMessages", () => {
   describe("assistant message status mapping", () => {
     const withStatus = (
       status: "streaming" | "complete" | "failed",
-    ): EveMessageData => ({
+    ): MessageData => ({
       messages: [
         {
           id: "a1",
@@ -1118,7 +1261,7 @@ describe("convertEveMessages", () => {
             parts: [{ type: "text", text: "Try again" }],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
       const [assistant] = convertEveMessages(data, {
         isRunning: true,
@@ -1148,6 +1291,101 @@ describe("convertEveMessages", () => {
       expect(message?.status).toEqual({ type: "incomplete", reason: "error" });
     });
 
+    it("keeps a failed turn incomplete when the event has no error detail", () => {
+      const failure = {
+        type: "turn.settled",
+        data: { turnId: "turn_1", outcome: "failed" },
+        meta: eventMeta(1),
+      } as const satisfies SessionStreamEvent;
+      const [message] = convertEveMessages(
+        {
+          messages: [
+            {
+              id: "a1",
+              role: "assistant",
+              metadata: { turnId: "turn_1", status: "complete" },
+              parts: [{ type: "text", text: "Partial response" }],
+            },
+          ],
+        },
+        { events: [failure] },
+      );
+
+      expect(message?.status).toEqual({ type: "incomplete", reason: "error" });
+    });
+
+    it("scopes session failures to their turn and gives them precedence over turn cancellation", () => {
+      const events = [
+        {
+          type: "turn.settled",
+          data: { turnId: "turn_1", outcome: "cancelled" },
+          meta: eventMeta(1),
+        },
+        {
+          type: "session.ended",
+          data: { outcome: "failed", cause: { turnId: "turn_1" } },
+          meta: eventMeta(2),
+        },
+      ] as const satisfies readonly SessionStreamEvent[];
+      const messages = convertEveMessages(
+        {
+          messages: [
+            {
+              id: "a1",
+              role: "assistant",
+              metadata: { turnId: "turn_1" },
+              parts: [{ type: "text", text: "First" }],
+            },
+            {
+              id: "a2",
+              role: "assistant",
+              metadata: { turnId: "turn_2" },
+              parts: [{ type: "text", text: "Second" }],
+            },
+          ],
+        },
+        { events, isRunning: false },
+      );
+
+      expect(messages.map((message) => message.status)).toEqual([
+        { type: "incomplete", reason: "error" },
+        { type: "complete", reason: "stop" },
+      ]);
+    });
+
+    it.each([
+      ["completed", { outcome: "completed" }],
+      ["failed without a cause", { outcome: "failed" }],
+      [
+        "failed outside a turn",
+        { outcome: "failed", cause: { deliveryId: "delivery_1" } },
+      ],
+    ] as const)(
+      "does not assign a %s session ending to a turn",
+      (_label, data) => {
+        const event = {
+          type: "session.ended",
+          data,
+          meta: eventMeta(1),
+        } as const satisfies SessionStreamEvent;
+        const [message] = convertEveMessages(
+          {
+            messages: [
+              {
+                id: "a1",
+                role: "assistant",
+                metadata: { turnId: "turn_1" },
+                parts: [{ type: "text", text: "Done" }],
+              },
+            ],
+          },
+          { events: [event], isRunning: false },
+        );
+
+        expect(message?.status).toEqual({ type: "complete", reason: "stop" });
+      },
+    );
+
     it("keeps requires-action for pending approvals when not running", () => {
       const data = {
         messages: [
@@ -1155,21 +1393,12 @@ describe("convertEveMessages", () => {
             id: "a1",
             role: "assistant",
             metadata: { status: "streaming" },
-            parts: [
-              {
-                type: "dynamic-tool",
-                state: "approval-requested",
-                toolCallId: "call_1",
-                toolName: "send_email",
-                input: {},
-                approval: { id: "req_1" },
-              },
-            ],
+            parts: [toolPart({ interaction: approvalInteraction() })],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
-      const [message] = convertEveMessages(data, { isRunning: false });
+      const message = convertEveMessages(data, { isRunning: false }).at(-1);
 
       expect(message?.status).toEqual({
         type: "requires-action",
@@ -1185,19 +1414,15 @@ describe("convertEveMessages", () => {
             role: "assistant",
             metadata: { status: "streaming" },
             parts: [
-              {
-                type: "authorization",
-                state: "required",
-                name: "github",
-                description: "Sign in to GitHub",
-                displayName: "GitHub",
-                stepIndex: 0,
-                turnId: "turn_1",
-              },
+              signInPart({
+                kind: "sign-in",
+                prompt: "Sign in to GitHub",
+                signIn: { name: "github", displayName: "GitHub" },
+              }),
             ],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
       const [message] = convertEveMessages(data, { isRunning: false });
 
@@ -1215,27 +1440,16 @@ describe("convertEveMessages", () => {
             role: "assistant",
             metadata: { status: "streaming" },
             parts: [
-              {
-                type: "dynamic-tool",
-                state: "approval-requested",
-                toolCallId: "call_1",
-                toolName: "send_email",
-                input: {},
-                approval: { id: "req_1" },
-              },
-              {
-                type: "authorization",
-                state: "required",
-                name: "github",
-                description: "Sign in to GitHub",
-                displayName: "GitHub",
-                stepIndex: 0,
-                turnId: "turn_1",
-              },
+              toolPart({ interaction: approvalInteraction() }),
+              signInPart({
+                kind: "sign-in",
+                prompt: "Sign in to GitHub",
+                signIn: { name: "github", displayName: "GitHub" },
+              }),
             ],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
       const [message] = convertEveMessages(data, { isRunning: false });
 
@@ -1246,52 +1460,26 @@ describe("convertEveMessages", () => {
     });
 
     it("settles a cancelled turn with a pending authorization", () => {
-      const reducer = defaultMessageReducer();
-      const events: readonly EveAgentReducerEvent[] = [
-        {
-          type: "authorization.required",
-          meta: eventMeta(0),
-          data: {
-            turnId: "turn_1",
-            stepIndex: 0,
-            sequence: 0,
-            name: "github",
-            description: "Sign in to GitHub",
-          },
-        },
-        {
-          type: "turn.cancelled",
-          meta: eventMeta(1),
-          data: { turnId: "turn_1", sequence: 1 },
-        },
-      ];
-      const pendingData = events
-        .slice(0, 1)
-        .reduce(
-          (state, event) => reducer.reduce(state, event),
-          reducer.initial(),
-        );
+      const events = [...initialTurnEvents, signInOpened("github")];
+      const pendingData = replay(events);
       const pendingAssistant = pendingData.messages.find(
         (message) => message.role === "assistant",
       );
       expect(pendingAssistant?.metadata?.status).toBe("streaming");
       expect(
         convertEveMessages(pendingData, { isRunning: false }).at(-1)?.status,
-      ).toEqual({
-        type: "requires-action",
-        reason: "interrupt",
-      });
-
-      const data = events
-        .slice(1)
-        .reduce((state, event) => reducer.reduce(state, event), pendingData);
-
-      const [message] = convertEveMessages(data, { isRunning: false });
+      ).toEqual({ type: "requires-action", reason: "interrupt" });
 
-      expect(message?.status).toEqual({
-        type: "complete",
-        reason: "stop",
-      });
+      const data = replay([
+        ...events,
+        {
+          type: "turn.settled",
+          data: { turnId: "turn_1", outcome: "cancelled" },
+        },
+      ]);
+      const message = convertEveMessages(data, { isRunning: false }).at(-1);
+
+      expect(message?.status).toEqual({ type: "complete", reason: "stop" });
     });
 
     it("reports a failed turn with a pending authorization", () => {
@@ -1302,19 +1490,15 @@ describe("convertEveMessages", () => {
             role: "assistant",
             metadata: { status: "streaming" },
             parts: [
-              {
-                type: "authorization",
-                state: "required",
-                name: "github",
-                description: "Sign in to GitHub",
-                displayName: "GitHub",
-                stepIndex: 0,
-                turnId: "turn_1",
-              },
+              signInPart({
+                kind: "sign-in",
+                prompt: "Sign in to GitHub",
+                signIn: { name: "github", displayName: "GitHub" },
+              }),
             ],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
       const error = new Error("authorization failed");
       const [message] = convertEveMessages(data, {
@@ -1340,15 +1524,11 @@ describe("convertEveMessages", () => {
             role: "assistant",
             metadata: { status: "streaming" },
             parts: [
-              {
-                type: "authorization",
-                state: "required",
-                name: "github",
-                description: "Sign in to GitHub",
-                displayName: "GitHub",
-                stepIndex: 0,
-                turnId: "turn_1",
-              },
+              signInPart({
+                kind: "sign-in",
+                prompt: "Sign in to GitHub",
+                signIn: { name: "github", displayName: "GitHub" },
+              }),
             ],
           },
           {
@@ -1358,7 +1538,7 @@ describe("convertEveMessages", () => {
             parts: [{ type: "text", text: "Later turn" }],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
       const [authorization] = convertEveMessages(data, {
         isRunning: false,
@@ -1379,93 +1559,70 @@ describe("convertEveMessages", () => {
             role: "assistant",
             metadata: { status: "complete" },
             parts: [
-              {
-                type: "authorization",
-                state: "completed",
-                name: "github",
-                description: "Sign in to GitHub",
-                displayName: "GitHub",
-                stepIndex: 0,
-                turnId: "turn_1",
-                outcome: "authorized",
-              },
+              signInPart(
+                {
+                  kind: "sign-in",
+                  prompt: "Sign in to GitHub",
+                  signIn: { name: "github", displayName: "GitHub" },
+                },
+                { status: "settled", outcome: "accepted" },
+              ),
               { type: "text", text: "Done" },
             ],
           },
         ],
-      } satisfies EveMessageData;
+      } satisfies MessageData;
 
       const [message] = convertEveMessages(data, { isRunning: false });
 
       expect(message?.status).toEqual({ type: "complete", reason: "stop" });
     });
 
-    describe("contract with eve's default reducer", () => {
-      const replay = (events: readonly EveAgentReducerEvent[]) => {
-        const reducer = defaultMessageReducer();
-        return events.reduce(
-          (state, event) => reducer.reduce(state, event),
-          reducer.initial(),
-        );
-      };
-
-      const midStreamEvents: readonly EveAgentReducerEvent[] = [
-        {
-          type: "client.message.submitted",
-          data: { submissionId: "sub_1", message: "hi", createdAt: 0 },
-        },
-        {
-          type: "turn.started",
-          meta: eventMeta(0),
-          data: { turnId: "turn_1", sequence: 0 },
-        },
-        {
-          type: "step.started",
-          meta: eventMeta(1),
-          data: {
-            turnId: "turn_1",
-            stepIndex: 0,
-            sequence: 1,
-            modelId: "test-model",
-          },
-        },
+    describe("contract with eve's conversation projection", () => {
+      const midStreamEvents: readonly SessionEvent[] = [
+        ...initialTurnEvents,
         {
-          type: "message.appended",
-          meta: eventMeta(2),
-          data: {
-            turnId: "turn_1",
-            stepIndex: 0,
-            sequence: 2,
-            messageDelta: "Let me th",
-          },
+          type: "content.delta",
+          scope: { turnId: "turn_1", runId: "run_1" },
+          data: { partId: "part_1", kind: "text", delta: "Let me th" },
         },
       ];
 
+      const completedContent = (
+        kind: "text" | "reasoning",
+        partId: string,
+        value: string,
+        runId = "run_1",
+      ): SessionEvent => ({
+        type: "content.completed",
+        scope: { turnId: "turn_1", runId },
+        data: { partId, runId, kind, value, phase: "narration" },
+      });
+
+      const callRequested = {
+        type: "call.requested",
+        scope: { turnId: "turn_1", runId: "run_1" },
+        data: {
+          callId: "call_1",
+          owner: { runId: "run_1" },
+          capability: { kind: "tool", name: "search" },
+          input: {},
+        },
+      } as const satisfies SessionEvent;
+
       it("carries the challenge Eve projects onto an authorization part", () => {
         const state = replay([
           ...midStreamEvents,
-          {
-            type: "authorization.required",
-            meta: eventMeta(3),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
-              name: "github",
-              description: "Authorization required for github",
-              authorization: {
-                displayName: "GitHub",
-                instructions: "Enter the code on the device page",
-                url: "https://github.com/login/device",
-                userCode: "ABCD-1234",
-                expiresAt: "2026-01-01T00:00:00Z",
-              },
-            },
-          },
+          signInOpened("github", {
+            displayName: "GitHub",
+            instructions: "Enter the code on the device page",
+            url: "https://github.com/login/device",
+            userCode: "ABCD-1234",
+            expiresAt: "2026-01-01T00:00:00Z",
+          }),
         ]);
 
         const converted = convertEveMessages(state, { isRunning: false });
-
         expect(converted.at(-1)?.content).toContainEqual({
           type: "data",
           name: "authorization",
@@ -1485,39 +1642,19 @@ describe("convertEveMessages", () => {
       it("releases the hold when Eve settles the authorization part in place", () => {
         const state = replay([
           ...midStreamEvents,
+          signInOpened("github"),
           {
-            type: "authorization.required",
-            meta: eventMeta(3),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
-              name: "github",
-              description: "Authorization required for github",
-            },
-          },
-          {
-            type: "authorization.completed",
-            meta: eventMeta(4),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 4,
-              name: "github",
-              outcome: "authorized",
-            },
+            type: "interaction.settled",
+            data: { interactionId: "auth_github", outcome: "accepted" },
           },
         ]);
 
         const assistant = state.messages.find((m) => m.role === "assistant");
         const authorizationParts = assistant?.parts.filter(
-          (part) => part.type === "authorization",
+          (part) => part.type === "interaction",
         );
         expect(authorizationParts).toHaveLength(1);
-        expect(authorizationParts?.[0]).toMatchObject({ state: "completed" });
-
-        // Eve leaves the streaming marker set, so the released turn falls back
-        // to the stale-marker mapping rather than to a terminal status.
+        expect(authorizationParts?.[0]).toMatchObject({ status: "settled" });
         expect(
           convertEveMessages(state, { isRunning: false }).at(-1)?.status,
         ).toEqual({ type: "incomplete", reason: "cancelled" });
@@ -1526,38 +1663,11 @@ describe("convertEveMessages", () => {
       it("keeps the hold while another connector is still required", () => {
         const state = replay([
           ...midStreamEvents,
+          signInOpened("github"),
+          signInOpened("slack"),
           {
-            type: "authorization.required",
-            meta: eventMeta(3),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
-              name: "github",
-              description: "Authorization required for github",
-            },
-          },
-          {
-            type: "authorization.required",
-            meta: eventMeta(4),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 4,
-              name: "slack",
-              description: "Authorization required for slack",
-            },
-          },
-          {
-            type: "authorization.completed",
-            meta: eventMeta(5),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 5,
-              name: "github",
-              outcome: "authorized",
-            },
+            type: "interaction.settled",
+            data: { interactionId: "auth_github", outcome: "accepted" },
           },
         ]);
 
@@ -1567,51 +1677,41 @@ describe("convertEveMessages", () => {
       });
 
       it("projects the input request onto the approval part it gates", () => {
-        const events: readonly EveAgentReducerEvent[] = [
+        const events: readonly SessionEvent[] = [
           ...midStreamEvents,
           {
-            type: "input.requested",
+            ...callRequested,
             data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
-              requests: [
-                {
-                  requestId: "req_1",
-                  prompt: "What should the subject line be?",
-                  kind: "question",
-                  display: "text",
-                  action: {
-                    kind: "tool-call",
-                    callId: "call_1",
-                    toolName: "ask_question",
-                    input: {},
-                  },
-                },
-              ],
+              ...callRequested.data,
+              capability: { kind: "tool", name: "ask_question" },
+            },
+          },
+          {
+            type: "interaction.opened",
+            scope: { turnId: "turn_1" },
+            data: {
+              interactionId: "req_1",
+              subject: { callId: "call_1" },
+              request: {
+                kind: "question",
+                prompt: "What should the subject line be?",
+                display: "text",
+              },
             },
-            meta: eventMeta(3),
           },
         ];
-
-        // Rehydration replays the *stored* event log, which has been through
-        // the wire and back, so the reloaded case is the serialized payload
-        // rather than the same objects a second time.
-        const rehydrated = JSON.parse(
-          JSON.stringify(events),
-        ) as readonly EveAgentReducerEvent[];
+        const rehydrated = JSON.parse(JSON.stringify(events)) as SessionEvent[];
 
         for (const state of [replay(events), replay(rehydrated)]) {
           const part = state.messages
             .find((message) => message.role === "assistant")
-            ?.parts.find((candidate) => candidate.type === "dynamic-tool");
+            ?.parts.find((candidate) => candidate.type === "tool");
 
           expect(part).toMatchObject({
-            state: "approval-requested",
-            approval: { id: "req_1" },
+            type: "tool",
+            interaction: { interactionId: "req_1", status: "open" },
           });
           expect(findEveInputRequest(state, "req_1")).toMatchObject({
-            requestId: "req_1",
             prompt: "What should the subject line be?",
             display: "text",
           });
@@ -1620,188 +1720,110 @@ describe("convertEveMessages", () => {
 
       it("leaves a reasoning part unsettled when a tool call follows it", () => {
         const state = replay([
-          ...midStreamEvents.slice(0, 3),
+          ...initialTurnEvents,
           {
-            type: "reasoning.appended",
-            meta: eventMeta(2),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 2,
-              reasoningDelta: "Think",
-            },
-          },
-          {
-            type: "actions.requested",
-            meta: eventMeta(3),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
-              actions: [
-                {
-                  kind: "tool-call",
-                  callId: "call_1",
-                  toolName: "search",
-                  input: {},
-                },
-              ],
-            },
+            type: "content.delta",
+            scope: { turnId: "turn_1", runId: "run_1" },
+            data: { partId: "reason_1", kind: "reasoning", delta: "Think" },
           },
+          callRequested,
         ]);
 
         const message = state.messages.find((m) => m.role === "assistant");
         expect(message?.parts).toEqual(
           expect.arrayContaining([
             expect.objectContaining({ type: "reasoning", state: "streaming" }),
-            expect.objectContaining({ type: "dynamic-tool" }),
+            expect.objectContaining({ type: "tool" }),
           ]),
         );
-
         const content = convertEveMessages(state, { isRunning: true }).at(
           -1,
         )?.content;
         expect(content).toEqual([
-          expect.objectContaining({ type: "reasoning" }),
           expect.objectContaining({ type: "tool-call" }),
+          expect.objectContaining({ type: "reasoning" }),
         ]);
-        expect(content?.[0]).not.toHaveProperty("status");
+        expect(content?.[1]).not.toHaveProperty("status");
       });
 
       it("settles leftover reasoning after the model stream completes a tool call", () => {
         const state = replay([
-          ...midStreamEvents.slice(0, 3),
-          {
-            type: "reasoning.appended",
-            meta: eventMeta(2),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 2,
-              reasoningDelta: "Think",
-            },
-          },
-          {
-            type: "actions.requested",
-            meta: eventMeta(3),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
-              actions: [
-                {
-                  kind: "tool-call",
-                  callId: "call_1",
-                  toolName: "search",
-                  input: {},
-                },
-              ],
-            },
-          },
+          ...initialTurnEvents,
           {
-            type: "reasoning.completed",
-            meta: eventMeta(4),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 4,
-              reasoning: "Think",
-            },
+            type: "content.delta",
+            scope: { turnId: "turn_1", runId: "run_1" },
+            data: { partId: "reason_1", kind: "reasoning", delta: "Think" },
           },
+          callRequested,
+          completedContent("reasoning", "reason_1", "Think"),
         ]);
 
         const message = state.messages.find((m) => m.role === "assistant");
         expect(message?.parts).toEqual(
           expect.arrayContaining([
             expect.objectContaining({ type: "reasoning", state: "done" }),
-            expect.objectContaining({ type: "dynamic-tool" }),
+            expect.objectContaining({ type: "tool" }),
           ]),
         );
-
         const content = convertEveMessages(state, { isRunning: true }).at(
           -1,
         )?.content;
         expect(content).toEqual([
+          expect.objectContaining({ type: "tool-call" }),
           expect.objectContaining({
             type: "reasoning",
             status: { type: "complete" },
           }),
-          expect.objectContaining({ type: "tool-call" }),
         ]);
       });
 
       it("keeps a later step's live text part unsettled after an earlier step completed", () => {
         const state = replay([
-          ...midStreamEvents.slice(0, 3),
+          ...initialTurnEvents,
           {
-            type: "message.appended",
-            meta: eventMeta(2),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 2,
-              messageDelta: "First",
-            },
+            type: "content.delta",
+            scope: { turnId: "turn_1", runId: "run_1" },
+            data: { partId: "part_1", kind: "text", delta: "First" },
           },
+          completedContent("text", "part_1", "First"),
           {
-            type: "message.completed",
-            meta: eventMeta(3),
+            type: "model.settled",
             data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
+              runId: "run_1",
+              outcome: "completed",
               finishReason: "tool-calls",
-              message: "First",
             },
           },
           {
-            type: "step.completed",
-            meta: eventMeta(4),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 4,
-              finishReason: "tool-calls",
-            },
+            type: "model.requested",
+            scope: { turnId: "turn_1" },
+            data: { runId: "run_2", owner: { turnId: "turn_1" } },
           },
           {
-            type: "step.started",
-            meta: eventMeta(5),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 1,
-              sequence: 5,
-              modelId: "test-model",
-            },
+            type: "model.started",
+            scope: { turnId: "turn_1", runId: "run_2" },
+            data: { runId: "run_2", modelId: "test-model", attempt: 0 },
           },
           {
-            type: "message.appended",
-            meta: eventMeta(6),
-            data: {
-              turnId: "turn_1",
-              stepIndex: 1,
-              sequence: 6,
-              messageDelta: "Sec",
-            },
+            type: "content.delta",
+            scope: { turnId: "turn_1", runId: "run_2" },
+            data: { partId: "part_2", kind: "text", delta: "Sec" },
           },
         ]);
 
         const assistant = state.messages.find((m) => m.role === "assistant");
         expect(assistant?.parts).toEqual([
-          expect.objectContaining({ type: "step-start" }),
           expect.objectContaining({
             type: "text",
             text: "First",
             state: "done",
           }),
-          expect.objectContaining({ type: "step-start" }),
           expect.objectContaining({
             type: "text",
             text: "Sec",
             state: "streaming",
           }),
         ]);
-
         const content = convertEveMessages(state, { isRunning: true }).at(
           -1,
         )?.content;
@@ -1818,59 +1840,68 @@ describe("convertEveMessages", () => {
 
       it("a locally aborted turn keeps its streaming marker and converts to cancelled", () => {
         const state = replay(midStreamEvents);
-
         const assistant = state.messages.find((m) => m.role === "assistant");
         expect(assistant?.metadata?.status).toBe("streaming");
-
-        const converted = convertEveMessages(state, { isRunning: false });
-        expect(converted.at(-1)?.status).toEqual({
+        expect(
+          convertEveMessages(state, { isRunning: false }).at(-1)?.status,
+        ).toEqual({
           type: "incomplete",
           reason: "cancelled",
         });
       });
 
       it("a failed session keeps its streaming marker and converts to error", () => {
-        const state = replay([
-          ...midStreamEvents,
-          {
-            type: "session.failed",
-            meta: eventMeta(3),
-            data: { sessionId: "session_1", code: "internal", message: "boom" },
+        const sessionFailure = {
+          type: "session.ended",
+          meta: eventMeta(midStreamEvents.length),
+          data: {
+            outcome: "failed",
+            cause: { turnId: "turn_1" },
+            error: { code: "internal", message: "boom" },
           },
-        ]);
-
+        } as const satisfies SessionStreamEvent;
+        const state = replay([...midStreamEvents, sessionFailure]);
         const assistant = state.messages.find((m) => m.role === "assistant");
         expect(assistant?.metadata?.status).toBe("streaming");
-
-        const converted = convertEveMessages(state, {
-          isRunning: false,
-          error: new Error("boom"),
-        });
-        expect(converted.at(-1)?.status).toEqual({
+        expect(
+          convertEveMessages(state, {
+            isRunning: false,
+            error: new Error("boom"),
+          }).at(-1)?.status,
+        ).toEqual({
           type: "incomplete",
           reason: "error",
           error: { code: "unknown", message: "boom" },
         });
+        expect(
+          convertEveMessages(state, {
+            isRunning: false,
+            events: [sessionFailure],
+          }).at(-1)?.status,
+        ).toEqual({
+          type: "incomplete",
+          reason: "error",
+          error: { code: "internal", message: "boom" },
+        });
       });
 
       it("a failed turn stays incomplete after Eve settles its message", () => {
         const failureEvent = {
-          type: "turn.failed",
-          meta: eventMeta(3),
+          type: "turn.settled",
+          meta: eventMeta(8),
           data: {
             turnId: "turn_1",
-            sequence: 3,
-            code: "internal",
-            message: "boom",
+            outcome: "failed",
+            error: { code: "internal", message: "boom" },
           },
-        } as const satisfies MessageStreamEvent;
+        } as const satisfies SessionStreamEvent;
         const state = replay([...midStreamEvents, failureEvent]);
-
-        const converted = convertEveMessages(state, {
-          isRunning: false,
-          events: [failureEvent],
-        });
-        expect(converted.at(-1)?.status).toEqual({
+        expect(
+          convertEveMessages(state, {
+            isRunning: false,
+            events: [failureEvent],
+          }).at(-1)?.status,
+        ).toEqual({
           type: "incomplete",
           reason: "error",
           error: { code: "internal", message: "boom" },
@@ -1879,44 +1910,45 @@ describe("convertEveMessages", () => {
 
       it("a cancelled turn stays cancelled after Eve settles its message", () => {
         const cancelEvent = {
-          type: "turn.cancelled",
-          meta: eventMeta(3),
-          data: { turnId: "turn_1", sequence: 3 },
-        } as const satisfies MessageStreamEvent;
+          type: "turn.settled",
+          meta: eventMeta(8),
+          data: { turnId: "turn_1", outcome: "cancelled" },
+        } as const satisfies SessionStreamEvent;
         const state = replay([...midStreamEvents, cancelEvent]);
-
         expect(
           convertEveMessages(state, { isRunning: false }).at(-1)?.status,
-        ).toEqual({ type: "complete", reason: "stop" });
+        ).toEqual({
+          type: "complete",
+          reason: "stop",
+        });
         expect(
           convertEveMessages(state, {
             isRunning: false,
             events: [cancelEvent],
           }).at(-1)?.status,
-        ).toEqual({ type: "incomplete", reason: "cancelled" });
+        ).toEqual({
+          type: "incomplete",
+          reason: "cancelled",
+        });
       });
 
       it("a completed turn terminalizes the streaming marker and converts to complete", () => {
         const state = replay([
           ...midStreamEvents,
+          completedContent("text", "part_1", "Let me think"),
           {
-            type: "message.completed",
-            meta: eventMeta(3),
+            type: "model.settled",
             data: {
-              turnId: "turn_1",
-              stepIndex: 0,
-              sequence: 3,
+              runId: "run_1",
+              outcome: "completed",
               finishReason: "stop",
-              message: "Let me think",
             },
           },
           {
-            type: "turn.completed",
-            meta: eventMeta(4),
-            data: { turnId: "turn_1", sequence: 4 },
+            type: "turn.settled",
+            data: { turnId: "turn_1", outcome: "completed", reply: ["part_1"] },
           },
         ]);
-
         const assistant = state.messages.find((m) => m.role === "assistant");
         expect(assistant?.metadata?.status).toBe("complete");
         expect(assistant?.parts).toEqual(
@@ -1924,7 +1956,6 @@ describe("convertEveMessages", () => {
             expect.objectContaining({ type: "text", state: "done" }),
           ]),
         );
-
         const converted = convertEveMessages(state, { isRunning: false });
         expect(converted.at(-1)?.status).toEqual({
           type: "complete",
@@ -1952,7 +1983,7 @@ describe("convertEveMessages", () => {
           parts: [{ type: "text", text: "Hello" }],
         },
       ],
-    } satisfies EveMessageData;
+    } satisfies MessageData;
 
     const [message] = convertEveMessages(data, {
       getCreatedAt: () => createdAt,
@@ -1982,11 +2013,42 @@ describe("getEveMessageContent", () => {
     expect(getEveMessageContent(message)).toBe("Hello");
   });
 
+  it("preserves multiple text parts without attachments", () => {
+    const message = {
+      role: "user",
+      createdAt: new Date(),
+      parentId: null,
+      sourceId: null,
+      runConfig: undefined,
+      metadata: { custom: {} },
+      content: [
+        { type: "text", text: "First" },
+        { type: "text", text: "Second" },
+      ],
+    } satisfies AppendMessage;
+
+    expect(getEveMessageContent(message)).toEqual([
+      { type: "text", text: "First" },
+      { type: "text", text: "Second" },
+    ]);
+  });
+
+  it("rejects an unsupported append part instead of sending it to Eve", () => {
+    const message = {
+      ...baseAppendMessage,
+      content: [{ type: "reasoning", text: "Private reasoning" }],
+    } as AppendMessage;
+
+    expect(() => getEveMessageContent(message)).toThrow(
+      "Unsupported eve append message part type: reasoning",
+    );
+  });
+
   it("declares the data URL subtype of an image part", () => {
     const message = {
       ...baseAppendMessage,
       content: [{ type: "image", image: "data:image/jpeg;base64,/9j/4AAQ" }],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2007,7 +2069,7 @@ describe("getEveMessageContent", () => {
             "data:application/octet-stream;base64,iVBORw0KGgoAAAANSUhEUgAAAAE=",
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2028,7 +2090,7 @@ describe("getEveMessageContent", () => {
           filename: "photo",
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2054,7 +2116,7 @@ describe("getEveMessageContent", () => {
           status: { type: "complete" },
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2154,7 +2216,7 @@ describe("getEveMessageContent", () => {
     const message = {
       ...baseAppendMessage,
       content: [{ type: "audio", audio: { data: "QUJD", format: "mp3" } }],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2169,7 +2231,7 @@ describe("getEveMessageContent", () => {
     const message = {
       ...baseAppendMessage,
       content: [{ type: "audio", audio: { data: "QUJD", format: "wav" } }],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2189,7 +2251,7 @@ describe("getEveMessageContent", () => {
           audio: { data: "data:audio/mpeg;base64,QUJD", format: "mp3" },
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2209,7 +2271,7 @@ describe("getEveMessageContent", () => {
           audio: { data: "data:;base64,QUJD", format: "mp3" },
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2229,7 +2291,7 @@ describe("getEveMessageContent", () => {
           audio: { data: "https://cdn.example.com/memo.mp3", format: "mp3" },
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2260,7 +2322,7 @@ describe("getEveMessageContent", () => {
           status: { type: "complete" },
         },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toEqual([
       {
@@ -2287,16 +2349,19 @@ describe("getEveMessageContent", () => {
           ],
         },
       ],
-    } satisfies EveMessageData);
+    } satisfies MessageData);
 
-    expect(echoed?.content).toEqual([
-      {
-        type: "file",
-        data: "https://example.com/report.pdf",
-        mimeType: "application/pdf",
-        filename: "report.pdf",
-        sourceType: "url",
-      },
+    expect(echoed?.content).toEqual([]);
+    expect(echoed?.attachments?.map((a) => a.content)).toEqual([
+      [
+        {
+          type: "file",
+          data: "https://example.com/report.pdf",
+          mimeType: "application/pdf",
+          filename: "report.pdf",
+          sourceType: "url",
+        },
+      ],
     ]);
   });
 
@@ -2307,7 +2372,7 @@ describe("getEveMessageContent", () => {
         { type: "text", text: "hi" },
         { type: "data", name: "chart", data: { x: 1 } },
       ],
-    } as unknown as AppendMessage;
+    } as AppendMessage;
 
     expect(getEveMessageContent(message)).toBe("hi");
   });
@@ -2315,7 +2380,7 @@ describe("getEveMessageContent", () => {
 
 const approveCancel = [
   { id: "approve", label: "Approve" },
-  { id: "cancel", label: "Cancel" },
+  { id: "deny", label: "Cancel" },
 ];
 const environments = [
   { id: "staging", label: "Staging" },
@@ -2323,9 +2388,8 @@ const environments = [
 ];
 
 const withInputRequest = (
-  overrides: Partial<EveMessageInputRequest> = {},
-): EveMessageInputRequest => ({
-  requestId: "req_1",
+  overrides: Partial<InputRequest> = {},
+): InputRequest => ({
   prompt: "Send the email?",
   kind: "question",
   ...overrides,
@@ -2343,8 +2407,8 @@ describe("toEveInputResponse", () => {
         withInputRequest({ display: "confirmation", options: approveCancel }),
       ),
     ).toEqual({
-      requestId: "req_1",
-      optionId: "cancel",
+      interactionId: "req_1",
+      optionId: "deny",
       text: "Not yet",
     });
   });
@@ -2352,7 +2416,7 @@ describe("toEveInputResponse", () => {
   it("keeps the shipped one-argument mapping when no request is available", () => {
     expect(toEveInputResponse({ approvalId: "req_1", approved: true })).toEqual(
       {
-        requestId: "req_1",
+        interactionId: "req_1",
         optionId: "approve",
       },
     );
@@ -2363,7 +2427,7 @@ describe("toEveInputResponse", () => {
         approved: false,
         reason: "Not yet",
       }),
-    ).toEqual({ requestId: "req_1", optionId: "cancel", text: "Not yet" });
+    ).toEqual({ interactionId: "req_1", optionId: "deny", text: "Not yet" });
 
     expect(
       toEveInputResponse({
@@ -2371,7 +2435,7 @@ describe("toEveInputResponse", () => {
         approved: true,
         optionId: "staging",
       }),
-    ).toEqual({ requestId: "req_1", optionId: "staging" });
+    ).toEqual({ interactionId: "req_1", optionId: "staging" });
   });
 
   it("keeps the confirmation mapping when the request carries approve/cancel options", () => {
@@ -2380,7 +2444,7 @@ describe("toEveInputResponse", () => {
         { approvalId: "req_1", approved: true },
         withInputRequest({ display: "confirmation", options: approveCancel }),
       ),
-    ).toEqual({ requestId: "req_1", optionId: "approve" });
+    ).toEqual({ interactionId: "req_1", optionId: "approve" });
   });
 
   it("maps a select response to the chosen option id", () => {
@@ -2389,7 +2453,36 @@ describe("toEveInputResponse", () => {
         { approvalId: "req_1", approved: true, optionId: "staging" },
         withInputRequest({ display: "select", options: environments }),
       ),
-    ).toEqual({ requestId: "req_1", optionId: "staging" });
+    ).toEqual({ interactionId: "req_1", optionId: "staging" });
+  });
+
+  it("preserves explanatory text with an explicitly selected option", () => {
+    expect(
+      toEveInputResponse(
+        {
+          approvalId: "req_1",
+          approved: true,
+          optionId: "staging",
+          text: "Use the safe environment",
+        },
+        withInputRequest({ display: "select", options: environments }),
+      ),
+    ).toEqual({
+      interactionId: "req_1",
+      optionId: "staging",
+      text: "Use the safe environment",
+    });
+  });
+
+  it("explains that an optionless request cannot accept an explicit option", () => {
+    expect(() =>
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true, optionId: "staging" },
+        withInputRequest({ display: "text" }),
+      ),
+    ).toThrow(
+      'Eve interaction "req_1" has no option with id "staging"; respond with one of: (the request carries no options)',
+    );
   });
 
   it.each([
@@ -2400,7 +2493,7 @@ describe("toEveInputResponse", () => {
       "a select display that allows freeform",
       { display: "select", allowFreeform: true, options: environments },
     ],
-  ] satisfies [string, Partial<EveMessageInputRequest>][])(
+  ] satisfies [string, Partial<InputRequest>][])(
     "answers a request with %s as free-form text, not a fabricated option id",
     (_label, overrides) => {
       const response = toEveInputResponse(
@@ -2409,7 +2502,7 @@ describe("toEveInputResponse", () => {
       );
 
       expect(response).toEqual({
-        requestId: "req_1",
+        interactionId: "req_1",
         text: "Quarterly results",
       });
       expect(response).not.toHaveProperty("optionId");
@@ -2431,7 +2524,7 @@ describe("toEveInputResponse", () => {
         { approvalId: "req_1", approved: true, text: "staging" },
         withInputRequest({ display: "text" }),
       ),
-    ).toEqual({ requestId: "req_1", text: "staging" });
+    ).toEqual({ interactionId: "req_1", text: "staging" });
   });
 
   it("prefers the response text over the reason it used to be smuggled in", () => {
@@ -2445,7 +2538,7 @@ describe("toEveInputResponse", () => {
         },
         withInputRequest({ display: "text" }),
       ),
-    ).toEqual({ requestId: "req_1", text: "staging" });
+    ).toEqual({ interactionId: "req_1", text: "staging" });
   });
 
   it("never fabricates approve for a text-display request without an answer", () => {
@@ -2474,9 +2567,6 @@ describe("toEveInputResponse", () => {
       ),
     ).toThrow(/no option with id "sandbox".*staging, production/s);
 
-    // A named option the request does not carry outranks the decision, even
-    // when the decision names an option the request does carry: substituting
-    // the literal deny here would discard the choice the caller made.
     expect(() =>
       toEveInputResponse(
         { approvalId: "req_1", approved: false, optionId: "schedule-later" },
@@ -2493,7 +2583,7 @@ describe("toEveInputResponse", () => {
 
     expect(
       toEveInputResponse({ approvalId: "req_1", approved: true }, inputRequest),
-    ).toEqual({ requestId: "req_1", optionId: "approve" });
+    ).toEqual({ interactionId: "req_1", optionId: "approve" });
 
     expect(
       toEveInputResponse(
@@ -2501,7 +2591,7 @@ describe("toEveInputResponse", () => {
         inputRequest,
       ),
     ).toEqual({
-      requestId: "req_1",
+      interactionId: "req_1",
       optionId: "approve",
       text: "Quarterly results",
     });
@@ -2509,25 +2599,25 @@ describe("toEveInputResponse", () => {
 
   it("answers a tool-approval by kind even when its options are missing", () => {
     const inputRequest = withInputRequest({
-      kind: "tool-approval",
+      kind: "approval",
       display: "confirmation",
     });
 
     expect(
       toEveInputResponse({ approvalId: "req_1", approved: true }, inputRequest),
-    ).toEqual({ requestId: "req_1", optionId: "approve" });
+    ).toEqual({ interactionId: "req_1", optionId: "approve" });
 
     expect(
       toEveInputResponse(
         { approvalId: "req_1", approved: false, reason: "not now" },
         inputRequest,
       ),
-    ).toEqual({ requestId: "req_1", optionId: "cancel", text: "not now" });
+    ).toEqual({ interactionId: "req_1", optionId: "deny", text: "not now" });
   });
 
   it("still requires a declared option when a tool-approval carries its own", () => {
     const inputRequest = withInputRequest({
-      kind: "tool-approval",
+      kind: "approval",
       display: "confirmation",
       options: [{ id: "schedule-later", label: "Schedule later" }],
     });
@@ -2541,7 +2631,7 @@ describe("toEveInputResponse", () => {
         { approvalId: "req_1", approved: true, optionId: "schedule-later" },
         inputRequest,
       ),
-    ).toEqual({ requestId: "req_1", optionId: "schedule-later" });
+    ).toEqual({ interactionId: "req_1", optionId: "schedule-later" });
   });
 
   it("never answers an optionless confirmation as free-form text", () => {
@@ -2560,41 +2650,25 @@ describe("toEveInputResponse", () => {
 });
 
 describe("findEveInputRequest", () => {
+  const request = {
+    kind: "question",
+    prompt: "What should the subject line be?",
+    display: "text",
+    allowFreeform: true,
+  } as const satisfies InputRequest;
   const data = {
     messages: [
       {
         id: "a1",
         role: "assistant",
-        parts: [
-          {
-            type: "dynamic-tool",
-            state: "approval-requested",
-            toolCallId: "call_1",
-            toolName: "ask_question",
-            input: {},
-            approval: { id: "req_1" },
-            toolMetadata: {
-              eve: {
-                kind: "tool-call",
-                name: "ask_question",
-                inputRequest: {
-                  requestId: "req_1",
-                  prompt: "What should the subject line be?",
-                  kind: "question",
-                  display: "text",
-                  allowFreeform: true,
-                },
-              },
-            },
-          },
-        ],
+        parts: [toolPart({ interaction: approvalInteraction(request) })],
       },
     ],
-  } satisfies EveMessageData;
+  } satisfies MessageData;
 
   it("finds the input request by approval id", () => {
     expect(findEveInputRequest(data, "req_1")).toMatchObject({
-      requestId: "req_1",
+      prompt: "What should the subject line be?",
       display: "text",
     });
   });
@@ -2603,16 +2677,24 @@ describe("findEveInputRequest", () => {
     expect(findEveInputRequest(data, "req_404")).toBeUndefined();
   });
 
-  it.each([
-    ["carries no input request", { eve: { kind: "tool-call", name: "ask" } }],
-    ["carries no eve tool metadata at all", undefined],
-  ])("returns undefined when the matching part %s", (_label, toolMetadata) => {
-    const part = { ...data.messages[0]!.parts[0]!, toolMetadata };
-    const bare = { messages: [{ ...data.messages[0]!, parts: [part] }] };
+  it("returns undefined when the matching tool has no interaction", () => {
+    const bare = {
+      messages: [{ id: "a1", role: "assistant", parts: [toolPart()] }],
+    } satisfies MessageData;
+    expect(findEveInputRequest(bare, "req_1")).toBeUndefined();
+  });
 
+  it("finds a standalone interaction by its approval id", () => {
     expect(
-      findEveInputRequest(bare as EveMessageData, "req_1"),
-    ).toBeUndefined();
+      findEveInputRequest(
+        {
+          messages: [
+            { id: "a1", role: "assistant", parts: [signInPart(request)] },
+          ],
+        },
+        "auth_1",
+      ),
+    ).toEqual(request);
   });
 });
 
@@ -2621,20 +2703,78 @@ describe("collectInterruptedTurnEvents", () => {
     ({
       type: "turn.started",
       meta: eventMeta(sequence),
-      data: { turnId, sequence },
-    }) as const satisfies MessageStreamEvent;
+      data: {
+        turnId,
+        cause: { deliveryId: `delivery_${turnId}` },
+        follows: null,
+      },
+    }) as const satisfies SessionStreamEvent;
   const failed = (turnId: string, sequence: number) =>
     ({
-      type: "turn.failed",
+      type: "turn.settled",
       meta: eventMeta(sequence),
-      data: { turnId, sequence, code: "internal", message: "boom" },
-    }) as const satisfies MessageStreamEvent;
+      data: {
+        turnId,
+        outcome: "failed",
+        error: { code: "internal", message: "boom" },
+      },
+    }) as const satisfies SessionStreamEvent;
   const cancelled = (turnId: string, sequence: number) =>
     ({
-      type: "turn.cancelled",
+      type: "turn.settled",
       meta: eventMeta(sequence),
-      data: { turnId, sequence },
-    }) as const satisfies MessageStreamEvent;
+      data: { turnId, outcome: "cancelled" },
+    }) as const satisfies SessionStreamEvent;
+
+  it.each([
+    [0, 128],
+    [0, 512],
+    [4, 128],
+    [4, 512],
+  ])(
+    "copies %i cached interruptions once when collecting %i more",
+    (cachedCount, appendedCount) => {
+      const previousEvents = Array.from({ length: cachedCount }, (_, index) =>
+        failed(`previous_${index}`, index),
+      );
+      const previousInterruptions = [...previousEvents];
+      const cache: InterruptedTurnEventCache = {
+        lastEvents: previousEvents,
+        interruptions: previousInterruptions,
+      };
+      const events = [
+        ...previousEvents,
+        ...Array.from({ length: appendedCount }, (_, index) =>
+          cancelled(`next_${index}`, cachedCount + index),
+        ),
+      ];
+      const iterator = Array.prototype[Symbol.iterator];
+      let copiedEntries = 0;
+      let interruptions: readonly SessionStreamEvent[];
+      try {
+        // A different copying primitive needs its own work counter.
+        Array.prototype[Symbol.iterator] = function* (this: unknown[]) {
+          for (const entry of iterator.call(this)) {
+            copiedEntries++;
+            yield entry;
+          }
+          return undefined;
+        };
+        interruptions = collectInterruptedTurnEvents(events, cache);
+      } finally {
+        Array.prototype[Symbol.iterator] = iterator;
+      }
+
+      expect(interruptions).toEqual(events);
+      expect(
+        interruptions.every((event, index) => event === events[index]),
+      ).toBe(true);
+      expect(previousInterruptions).toEqual(previousEvents);
+      expect(cache.interruptions).toBe(interruptions);
+      expect(cache.lastEvents).toBe(events);
+      expect(copiedEntries).toBe(cachedCount);
+    },
+  );
 
   it("scans only appended events and keeps the array until an interruption arrives", () => {
     const cache: InterruptedTurnEventCache = {
@@ -2660,4 +2800,29 @@ describe("collectInterruptedTurnEvents", () => {
     collectInterruptedTurnEvents([started("t1", 0), failed("t1", 1)], cache);
     expect(collectInterruptedTurnEvents([started("t2", 0)], cache)).toEqual([]);
   });
+
+  it("records failed session endings and ignores completed endings", () => {
+    const cache: InterruptedTurnEventCache = {
+      lastEvents: [],
+      interruptions: [],
+    };
+    const completed = {
+      type: "session.ended",
+      data: { outcome: "completed" },
+      meta: eventMeta(1),
+    } as const satisfies SessionStreamEvent;
+    const failedSession = {
+      type: "session.ended",
+      data: { outcome: "failed", cause: { turnId: "t1" } },
+      meta: eventMeta(2),
+    } as const satisfies SessionStreamEvent;
+    const events = [completed, failedSession];
+
+    expect(collectInterruptedTurnEvents(events, cache)).toEqual([
+      failedSession,
+    ]);
+    expect(collectInterruptedTurnEvents(events, cache)).toBe(
+      cache.interruptions,
+    );
+  });
 });