@assistant-ui/eve 0.0.21 → 0.0.23

package/src/convertEveMessages.ts

@@ -19,7 +19,10 @@ import {
 } from "@assistant-ui/core";
 import {
   httpUrlPattern,
+  resolveFileMediaType,
   resolveFilePartSource,
+  resolveImageMediaType,
+  toMediaWireUrl,
 } from "@assistant-ui/core/internal";
 import type {
   EveAuthorizationOutcome,
@@ -31,6 +34,7 @@ import type {
   EveMessagePart,
 } from "eve/react";
 import type { InputResponse } from "eve/client";
+import type { MessageStreamEvent } from "eve/client";
 
 const ASSISTANT_COMPLETE_STATUS = {
   type: "complete",
@@ -64,6 +68,12 @@ export type ConvertEveMessagesOptions = {
    */
   readonly error?: unknown;
   readonly getCreatedAt?: ((message: EveMessage) => Date) | undefined;
+  /**
+   * The session's stream events. A `turn.failed` or `turn.cancelled` event
+   * marks its turn's assistant message as incomplete, with a failure's code
+   * and message as its error.
+   */
+  readonly events?: readonly MessageStreamEvent[] | undefined;
 };
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -88,9 +98,16 @@ const toMessageStatus = (
   index: number,
   messages: readonly EveMessage[],
   options: ConvertEveMessagesOptions,
+  interruptedTurns: ReadonlyMap<string, MessageStatus>,
 ): MessageStatus => {
   if (message.role !== "assistant") return USER_FALLBACK_STATUS;
 
+  const interrupted =
+    message.metadata?.turnId === undefined
+      ? undefined
+      : interruptedTurns.get(message.metadata.turnId);
+  if (interrupted) return interrupted;
+
   const isLast = index === messages.length - 1;
   const hasPendingApproval = message.parts.some(
     (part) =>
@@ -123,9 +140,7 @@ const toMessageStatus = (
     return ASSISTANT_RUNNING_STATUS;
   }
 
-  // Eve's default reducer never terminalizes the "streaming" marker on
-  // cancellation or turn/session failure, so liveness comes from isRunning and
-  // a leftover marker means the turn was interrupted.
+  // Some eve versions leave the streaming marker after cancellation or failure.
   if (message.metadata?.status === "streaming") {
     if (options.isRunning === undefined) {
       return ASSISTANT_RUNNING_STATUS;
@@ -274,7 +289,7 @@ const convertDynamicToolPart = (
     toolCallId: part.toolCallId,
     toolName: part.toolName,
     args: toJsonObject(part.input),
-    argsText: stringifyArgs(part.input),
+    argsText: part.state === "input-streaming" ? "" : stringifyArgs(part.input),
     ...(approval && { approval }),
     ...(providerMetadata && { providerMetadata }),
   };
@@ -361,7 +376,7 @@ const convertFilePart = (
   return {
     type: "file",
     data: part.url,
-    mimeType: part.mediaType ?? "unknown/unknown",
+    mimeType: resolveFileMediaType(part.url, part.mediaType),
     ...(part.filename && { filename: part.filename }),
     ...(httpUrlPattern.test(part.url) && { sourceType: "url" as const }),
   };
@@ -469,6 +484,21 @@ export const convertEveMessage = (
   index: number,
   messages: readonly EveMessage[],
   options: ConvertEveMessagesOptions = {},
+): ThreadMessage =>
+  convertEveMessageWithInterruptions(
+    message,
+    index,
+    messages,
+    options,
+    getInterruptedTurns(options.events),
+  );
+
+const convertEveMessageWithInterruptions = (
+  message: EveMessage,
+  index: number,
+  messages: readonly EveMessage[],
+  options: ConvertEveMessagesOptions,
+  interruptedTurns: ReadonlyMap<string, MessageStatus>,
 ): ThreadMessage => {
   const createdAt = options.getCreatedAt?.(message) ?? new Date();
   const metadata = {
@@ -501,20 +531,81 @@ export const convertEveMessage = (
   return fromThreadMessageLike(
     like,
     message.id,
-    toMessageStatus(message, index, messages, options),
+    toMessageStatus(message, index, messages, options, interruptedTurns),
   );
 };
 
+export type InterruptedTurnEventCache = {
+  lastEvents: readonly MessageStreamEvent[];
+  interruptions: readonly MessageStreamEvent[];
+};
+
+const isTurnInterruption = (event: MessageStreamEvent) =>
+  event.type === "turn.failed" || event.type === "turn.cancelled";
+
+/**
+ * Collects the `turn.failed` and `turn.cancelled` events of an append-only
+ * event log, scanning only the events appended since the cached call. The
+ * returned array keeps its identity until a new interruption arrives.
+ */
+export const collectInterruptedTurnEvents = (
+  events: readonly MessageStreamEvent[],
+  cache: InterruptedTurnEventCache,
+): readonly MessageStreamEvent[] => {
+  if (events === cache.lastEvents) return cache.interruptions;
+
+  const scanned = cache.lastEvents;
+  const resumesScan =
+    scanned.length === 0 ||
+    events[scanned.length - 1] === scanned[scanned.length - 1];
+
+  let interruptions = resumesScan ? cache.interruptions : [];
+  for (let i = resumesScan ? scanned.length : 0; i < events.length; i++) {
+    const event = events[i]!;
+    if (isTurnInterruption(event)) interruptions = [...interruptions, event];
+  }
+
+  cache.lastEvents = events;
+  cache.interruptions = interruptions;
+  return interruptions;
+};
+
+const getInterruptedTurns = (
+  events: readonly MessageStreamEvent[] | undefined,
+) => {
+  const interrupted = new Map<string, MessageStatus>();
+  for (const event of events ?? []) {
+    if (event.type === "turn.failed") {
+      interrupted.set(event.data.turnId, {
+        type: "incomplete",
+        reason: "error",
+        error: { code: event.data.code, message: event.data.message },
+      });
+    } else if (event.type === "turn.cancelled") {
+      interrupted.set(event.data.turnId, ASSISTANT_CANCELLED_STATUS);
+    }
+  }
+  return interrupted;
+};
+
 /**
  * Converts the full Eve message data object into assistant-ui thread messages.
  */
 export const convertEveMessages = (
   data: EveMessageData,
   options: ConvertEveMessagesOptions = {},
-): ThreadMessage[] =>
-  data.messages.map((message, index, messages) =>
-    convertEveMessage(message, index, messages, options),
+): ThreadMessage[] => {
+  const interruptedTurns = getInterruptedTurns(options.events);
+  return data.messages.map((message, index, messages) =>
+    convertEveMessageWithInterruptions(
+      message,
+      index,
+      messages,
+      options,
+      interruptedTurns,
+    ),
   );
+};
 
 /**
  * Structural subset of the `string | UserContent` message content Eve's `send`
@@ -533,6 +624,10 @@ export type EveMessageContent =
         }
     )[];
 
+type OutboundPart = AppendMessage["content"][number] & {
+  readonly contentType?: string | undefined;
+};
+
 /**
  * Converts an assistant-ui append message into the message payload accepted by
  * Eve's `send` API.
@@ -540,9 +635,14 @@ export type EveMessageContent =
 export const getEveMessageContent = (
   message: AppendMessage,
 ): EveMessageContent => {
-  const content = [
+  const content: OutboundPart[] = [
     ...message.content,
-    ...(message.attachments?.flatMap((attachment) => attachment.content) ?? []),
+    ...(message.attachments?.flatMap((attachment) =>
+      attachment.content.map((part) => ({
+        ...part,
+        contentType: attachment.contentType,
+      })),
+    ) ?? []),
   ];
 
   const parts = content.flatMap((part) => {
@@ -551,21 +651,31 @@ export const getEveMessageContent = (
       case "text":
         return { type: "text" as const, text: part.text };
 
-      case "file":
+      case "file": {
+        const mediaType = resolveFileMediaType(
+          part.data,
+          part.mimeType || part.contentType,
+        );
         return {
           type: "file" as const,
-          data: part.data,
-          mediaType: part.mimeType,
+          data:
+            part.sourceType === "id"
+              ? part.data
+              : toMediaWireUrl(part.data, mediaType),
+          mediaType,
           ...(part.filename && { filename: part.filename }),
         };
+      }
 
-      case "image":
+      case "image": {
+        const mediaType = resolveImageMediaType(part.image, part.contentType);
         return {
           type: "file" as const,
-          data: part.image,
-          mediaType: "image/*",
+          data: toMediaWireUrl(part.image, mediaType),
+          mediaType,
           ...(part.filename && { filename: part.filename }),
         };
+      }
 
       case "audio": {
         // A data URL's own media type wins over `mediaType` downstream, so the

package/src/deriveCreatedAt.test.ts

@@ -29,6 +29,7 @@ const compactionRequested = (at: string, turnId = TURN) =>
       modelId: "m",
       sequence: 3,
       sessionId: "s",
+      stepIndex: 0,
       turnId,
       usageInputTokens: null,
     },

package/src/testUtils.ts

@@ -0,0 +1,57 @@
+import { ClientSession, type MessageStreamEvent } from "eve/client";
+import { vi } from "vitest";
+
+export const createEveSessionFixture = ({
+  events = [],
+  tailIndex = events.length - 1,
+  onSend,
+}: {
+  events?: readonly MessageStreamEvent[];
+  tailIndex?: number;
+  onSend?: () => void;
+}) => {
+  const encoder = new TextEncoder();
+  let controller: ReadableStreamDefaultController<Uint8Array> | undefined;
+  const pending = [...events];
+  const push = (events: readonly MessageStreamEvent[]) => {
+    if (controller === undefined) {
+      pending.push(...events);
+      return;
+    }
+    for (const event of events) {
+      controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
+    }
+  };
+  const fetch = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+    if (init?.method === "POST") {
+      onSend?.();
+      return new Response(
+        JSON.stringify({
+          sessionId: "session_resumed",
+          deliveryId: "delivery_1",
+        }),
+        { status: 202, headers: { "content-type": "application/json" } },
+      );
+    }
+    return new Response(
+      new ReadableStream<Uint8Array>({
+        start(streamController) {
+          controller = streamController;
+          push(pending.splice(0));
+        },
+      }),
+      {
+        headers: {
+          "x-eve-stream-version": "26",
+          "x-eve-stream-tail-index": String(tailIndex),
+        },
+      },
+    );
+  });
+  vi.stubGlobal("fetch", fetch);
+  const session = new ClientSession(
+    { host: "http://localhost", resolveHeaders: async () => new Headers() },
+    { sessionId: "session_resumed", streamIndex: 0 },
+  );
+  return { fetch, push, session };
+};

package/src/useEveAgentRuntime.eveResume.test.tsx

@@ -1,14 +1,10 @@
 // @vitest-environment jsdom
 
-// Deliberately does not mock `eve/react`: the real `useEveAgent` resumes an
-// offline session so the durable `meta.at` values travel through eve's own
-// store and reducer before the adapter reads them. Supplying `session` keeps
-// the store from constructing a network client.
-
 import { act, renderHook, waitFor } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import type { MessageStreamEvent } from "eve/client";
 
+import { createEveSessionFixture } from "./testUtils";
 import { useEveAgentRuntime } from "./useEveAgentRuntime";
 
 const TURN = "turn_resumed";
@@ -61,7 +57,11 @@ const nextTurnEvents = [
   {
     type: "message.received",
     data: { message: "follow up", sequence: 8, turnId: NEXT_TURN },
-    meta: { at: "2026-01-02T10:03:01.000Z", id: "evt_202" },
+    meta: {
+      at: "2026-01-02T10:03:01.000Z",
+      id: "evt_202",
+      deliveryIds: ["delivery_1"],
+    },
   },
   {
     type: "step.started",
@@ -108,23 +108,13 @@ const parkedEvents = [
 const copyEvents = (events: readonly MessageStreamEvent[]) =>
   JSON.parse(JSON.stringify(events)) as readonly MessageStreamEvent[];
 
-const offlineSession = {
-  state: { sessionId: "session_resumed", streamIndex: 0 },
-  cancel: async () => ({ status: "no_active_turn" }),
-  send: () => {
-    throw new Error("the resume test must not reach the network");
-  },
-  stream: async function* () {
-    yield* JSON.parse(
-      JSON.stringify(resumedEvents),
-    ) as readonly MessageStreamEvent[];
-  },
-} as never;
+afterEach(() => vi.unstubAllGlobals());
 
 describe("useEveAgentRuntime against a resumed eve session", () => {
   it("renders resumed history at its durable event times, not the current time", async () => {
+    const { session } = createEveSessionFixture({ events: resumedEvents });
     const { result } = renderHook(() =>
-      useEveAgentRuntime({ resume: true, session: offlineSession }),
+      useEveAgentRuntime({ resume: true, session }),
     );
 
     await waitFor(() =>
@@ -137,44 +127,34 @@ describe("useEveAgentRuntime against a resumed eve session", () => {
   });
 
   it("reports the replay as loading and holds a send typed during it until the replay ends", async () => {
-    let openReplay!: () => void;
-    const replayOpened = new Promise<void>((resolve) => {
-      openReplay = resolve;
+    const { fetch, push, session } = createEveSessionFixture({
+      tailIndex: parkedEvents.length - 1,
+      onSend: () => setTimeout(() => push(copyEvents(nextTurnEvents)), 0),
     });
-    const stream = vi.fn(async function* () {
-      await replayOpened;
-      yield* copyEvents(parkedEvents);
-    });
-    const send = vi.fn(async function* () {
-      yield* copyEvents(nextTurnEvents);
-    });
-    const session = {
-      state: { sessionId: "session_resumed", streamIndex: 0 },
-      cancel: async () => ({ status: "no_active_turn" }),
-      send,
-      stream,
-    } as never;
 
     const { result } = renderHook(() =>
       useEveAgentRuntime({ resume: true, session }),
     );
 
-    await waitFor(() => expect(stream).toHaveBeenCalledOnce());
+    await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
     expect(result.current.thread.getState().isLoading).toBe(true);
 
     act(() => result.current.thread.append("follow up"));
     await act(async () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
     });
-    expect(send).not.toHaveBeenCalled();
-    expect(stream).toHaveBeenCalledOnce();
+    expect(fetch).toHaveBeenCalledOnce();
 
-    await act(async () => openReplay());
+    await act(async () => {
+      push(copyEvents(parkedEvents));
+    });
 
     await waitFor(() =>
       expect(result.current.thread.getState().messages).toHaveLength(4),
     );
-    expect(send).toHaveBeenCalledOnce();
+    expect(
+      fetch.mock.calls.filter(([, init]) => init?.method === "POST"),
+    ).toHaveLength(1);
     expect(result.current.thread.getState().isLoading).toBe(false);
   });
 });

package/src/useEveAgentRuntime.interruptedTurn.test.tsx

@@ -0,0 +1,80 @@
+// @vitest-environment jsdom
+
+import { renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { createEveSessionFixture } from "./testUtils";
+import { useEveAgentRuntime } from "./useEveAgentRuntime";
+
+const meta = (second: number) => ({
+  at: `2026-01-02T10:00:0${second}.000Z`,
+  id: `t1-${second}`,
+});
+
+const interruptedTurn = (ending: Record<string, unknown>) => [
+  { type: "turn.started", data: { sequence: 1, turnId: "t1" }, meta: meta(0) },
+  {
+    type: "message.received",
+    data: { message: "hi", sequence: 2, turnId: "t1" },
+    meta: meta(1),
+  },
+  {
+    type: "step.started",
+    data: { modelId: "m", sequence: 3, stepIndex: 0, turnId: "t1" },
+    meta: meta(2),
+  },
+  {
+    type: "message.appended",
+    data: {
+      messageDelta: "Let me th",
+      sequence: 4,
+      stepIndex: 0,
+      turnId: "t1",
+    },
+    meta: meta(3),
+  },
+  { ...ending, meta: meta(4) },
+];
+
+const renderInterruptedTurn = (ending: Record<string, unknown>) => {
+  const { session } = createEveSessionFixture({});
+  return renderHook(() =>
+    useEveAgentRuntime({
+      initialEvents: interruptedTurn(ending) as never,
+      session,
+    }),
+  );
+};
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("useEveAgentRuntime with an interrupted turn", () => {
+  it("shows a failed turn's assistant message as an error", async () => {
+    const { result } = renderInterruptedTurn({
+      type: "turn.failed",
+      data: { code: "internal", message: "boom", sequence: 5, turnId: "t1" },
+    });
+
+    await waitFor(() =>
+      expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+        type: "incomplete",
+        reason: "error",
+        error: { code: "internal", message: "boom" },
+      }),
+    );
+  });
+
+  it("shows a cancelled turn's assistant message as cancelled", async () => {
+    const { result } = renderInterruptedTurn({
+      type: "turn.cancelled",
+      data: { sequence: 5, turnId: "t1" },
+    });
+
+    await waitFor(() =>
+      expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+        type: "incomplete",
+        reason: "cancelled",
+      }),
+    );
+  });
+});

package/src/useEveAgentRuntime.refetch.test.tsx

@@ -1,9 +1,10 @@
 // @vitest-environment jsdom
 
 import { act, renderHook } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import type { HandleMessageStreamEvent } from "eve/client";
 
+import { createEveSessionFixture } from "./testUtils";
 import { useEveAgentRuntime } from "./useEveAgentRuntime";
 
 const completedTurn = (
@@ -49,18 +50,24 @@ const completedTurn = (
 const knownTurn = completedTurn("t1", "hi", "hello", 1);
 const outOfBandTurn = completedTurn("t2", "answered elsewhere", "done", 6);
 
+afterEach(() => vi.unstubAllGlobals());
+
 describe("useEveAgentRuntime against a durable eve session", () => {
   it("surfaces a turn the server appended out of band after reloadMainThread", async () => {
-    const stream = vi.fn(async function* () {
-      yield* [...knownTurn, ...outOfBandTurn];
+    const { fetch, session } = createEveSessionFixture({
+      events: [
+        ...knownTurn,
+        ...outOfBandTurn,
+        {
+          type: "session.waiting",
+          data: {
+            continuationToken: "session_resumed",
+            wait: "next-user-message",
+          },
+          meta: { at: "2026-01-02T10:00:05.000Z", id: "waiting" },
+        },
+      ],
     });
-    const session = {
-      state: { sessionId: "s1" },
-      stream,
-      send: () => {
-        throw new Error("the refetch test must not send");
-      },
-    } as never;
 
     const { result } = renderHook(() =>
       useEveAgentRuntime({ initialEvents: knownTurn as never, session }),
@@ -73,7 +80,10 @@ describe("useEveAgentRuntime against a durable eve session", () => {
       await result.current.threads.reloadMainThread();
     });
 
-    expect(stream).toHaveBeenCalled();
+    expect(fetch).toHaveBeenCalled();
+    expect(
+      fetch.mock.calls.filter(([, init]) => init?.method === "POST"),
+    ).toHaveLength(0);
     const messages = result.current.thread.getState().messages;
     expect(messages.map((m) => m.role)).toEqual([
       "user",