@assistant-ui/eve 0.0.23 → 0.0.25

package/src/deriveCreatedAt.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import type { MessageStreamEvent } from "eve/client";
+import type { SessionStreamEvent } from "eve/client";
 
 import {
   collectTurnTimestamps,
@@ -11,59 +11,53 @@ const TURN = "turn_1";
 const turnStarted = (at: string, turnId = TURN) =>
   ({
     type: "turn.started",
-    data: { sequence: 1, turnId },
-    meta: { at, id: `evt_${at}` },
-  }) as const satisfies MessageStreamEvent;
+    data: { turnId, cause: { deliveryId: "delivery_1" }, follows: null },
+    meta: { at, position: { line: 1, index: 0 } },
+  }) as const satisfies SessionStreamEvent;
 
-const messageReceived = (at: string, turnId = TURN) =>
+const deliveryConsumed = (at: string, turnId = TURN) =>
   ({
-    type: "message.received",
-    data: { message: "hi", sequence: 2, turnId },
-    meta: { at, id: `evt_${at}` },
-  }) as const satisfies MessageStreamEvent;
-
-const compactionRequested = (at: string, turnId = TURN) =>
-  ({
-    type: "compaction.requested",
+    type: "delivery.consumed",
     data: {
-      modelId: "m",
-      sequence: 3,
-      sessionId: "s",
-      stepIndex: 0,
+      deliveryId: "delivery_1",
+      parts: [{ kind: "text", text: "hi" }],
       turnId,
-      usageInputTokens: null,
     },
-    meta: { at, id: `evt_${at}` },
-  }) as const satisfies MessageStreamEvent;
+    meta: { at, position: { line: 2, index: 0 } },
+  }) as const satisfies SessionStreamEvent;
 
-const messageAppended = (at: string, turnId = TURN) =>
+const contextStarted = (at: string, turnId = TURN) =>
   ({
-    type: "message.appended",
-    data: {
-      messageDelta: "he",
-      sequence: 4,
-      stepIndex: 0,
-      turnId,
-    },
-    meta: { at, id: `evt_${at}` },
-  }) as const satisfies MessageStreamEvent;
+    type: "context.started",
+    data: { changeId: "change_1", kind: "compaction", turnId },
+    meta: { at, position: { line: 3, index: 0 } },
+  }) as const satisfies SessionStreamEvent;
 
-const stepStarted = (at: string, turnId = TURN) =>
+const contentDelta = (at: string, turnId = TURN) =>
   ({
-    type: "step.started",
-    data: { modelId: "m", sequence: 4, stepIndex: 0, turnId },
-    meta: { at, id: `evt_${at}` },
-  }) as const satisfies MessageStreamEvent;
+    type: "content.delta",
+    scope: { turnId },
+    data: { partId: "part_1", kind: "text", delta: "he" },
+    meta: { at, position: { line: 4, index: 0 } },
+  }) as const satisfies SessionStreamEvent;
+
+const modelStarted = (at: string, turnId = TURN) =>
+  ({
+    type: "model.started",
+    scope: { turnId },
+    data: { runId: "run_1", modelId: "m", attempt: 0 },
+    meta: { at, position: { line: 4, index: 0 } },
+  }) as const satisfies SessionStreamEvent;
 
 describe("collectTurnTimestamps", () => {
-  it("stamps the user at message.received and the assistant at step.started, skipping the turn's other events", () => {
+  it("stamps the user at delivery.consumed and the assistant at model.started, skipping the turn's other events", () => {
     const timestamps = collectTurnTimestamps(
       [
         turnStarted("2026-01-02T10:00:00.000Z"),
-        messageReceived("2026-01-02T10:00:01.000Z"),
-        compactionRequested("2026-01-02T10:00:02.000Z"),
-        stepStarted("2026-01-02T10:02:00.000Z"),
-        stepStarted("2026-01-02T10:03:00.000Z"),
+        deliveryConsumed("2026-01-02T10:00:01.000Z"),
+        contextStarted("2026-01-02T10:00:02.000Z"),
+        modelStarted("2026-01-02T10:02:00.000Z"),
+        modelStarted("2026-01-02T10:03:00.000Z"),
       ],
       createTurnTimestampCache(),
     );
@@ -81,7 +75,7 @@ describe("collectTurnTimestamps", () => {
     const cache = createTurnTimestampCache();
     const events = [
       turnStarted("2026-01-02T10:00:00.000Z"),
-      messageReceived("2026-01-02T10:00:01.000Z"),
+      deliveryConsumed("2026-01-02T10:00:01.000Z"),
     ];
     const first = collectTurnTimestamps(events, cache);
     expect(first.get(TURN)?.assistant).toBe(undefined);
@@ -93,7 +87,7 @@ describe("collectTurnTimestamps", () => {
     expect(collectTurnTimestamps(quiet, cache)).toBe(first);
 
     const timestamps = collectTurnTimestamps(
-      [...quiet, stepStarted("2026-01-02T10:02:00.000Z")],
+      [...quiet, modelStarted("2026-01-02T10:02:00.000Z")],
       cache,
     );
     expect(timestamps.get(TURN)?.user).toEqual(
@@ -104,31 +98,13 @@ describe("collectTurnTimestamps", () => {
     );
   });
 
-  it("stamps an assistant created by a turn ending before its first step", () => {
-    const timestamps = collectTurnTimestamps(
-      [
-        messageReceived("2026-01-02T10:00:01.000Z"),
-        {
-          type: "turn.cancelled",
-          data: { sequence: 3, turnId: TURN },
-          meta: { at: "2026-01-02T10:00:05.000Z", id: "evt_cancel" },
-        },
-      ],
-      createTurnTimestampCache(),
-    );
-
-    expect(timestamps.get(TURN)?.assistant).toEqual(
-      new Date("2026-01-02T10:00:05.000Z"),
-    );
-  });
-
-  it("stamps the assistant from the turn's first message-creating event when no step.started precedes it", () => {
+  it("stamps the assistant from the turn's first content event when no model.started precedes it", () => {
     const timestamps = collectTurnTimestamps(
       [
         turnStarted("2026-01-02T10:00:00.000Z"),
-        messageReceived("2026-01-02T10:00:01.000Z"),
-        compactionRequested("2026-01-02T10:00:02.000Z"),
-        messageAppended("2026-01-02T10:02:00.000Z"),
+        deliveryConsumed("2026-01-02T10:00:01.000Z"),
+        contextStarted("2026-01-02T10:00:02.000Z"),
+        contentDelta("2026-01-02T10:02:00.000Z"),
       ],
       createTurnTimestampCache(),
     );
@@ -139,22 +115,11 @@ describe("collectTurnTimestamps", () => {
   });
 
   it("skips malformed events without throwing", () => {
-    const events = [
-      { type: "message.received", data: null, meta: { at: "x", id: "e1" } },
-      { type: "step.started", meta: { at: "2026-01-01T00:00:00Z", id: "e2" } },
-      {
-        type: "message.received",
-        data: { turnId: 42 },
-        meta: { at: "x", id: "e3" },
-      },
-      {
-        type: "message.received",
-        data: { message: "hi", sequence: 2, turnId: TURN },
-        meta: { at: "not a date", id: "e4" },
-      },
-      { type: "step.started", data: { stepIndex: 0, turnId: TURN } },
-      stepStarted("2026-01-02T10:02:00.000Z"),
-    ] as never as readonly MessageStreamEvent[];
+    const events: readonly SessionStreamEvent[] = [
+      deliveryConsumed("not a date"),
+      { ...modelStarted("2026-01-02T10:01:00.000Z"), scope: {} },
+      modelStarted("2026-01-02T10:02:00.000Z"),
+    ];
 
     const timestamps = collectTurnTimestamps(
       events,
@@ -171,14 +136,14 @@ describe("collectTurnTimestamps", () => {
     const cache = createTurnTimestampCache();
     collectTurnTimestamps(
       [
-        messageReceived("2026-01-02T10:00:01.000Z"),
-        stepStarted("2026-01-02T10:02:00.000Z"),
+        deliveryConsumed("2026-01-02T10:00:01.000Z"),
+        modelStarted("2026-01-02T10:02:00.000Z"),
       ],
       cache,
     );
 
     const timestamps = collectTurnTimestamps(
-      [messageReceived("2026-03-01T09:00:01.000Z")],
+      [deliveryConsumed("2026-03-01T09:00:01.000Z")],
       cache,
     );
 
@@ -187,11 +152,45 @@ describe("collectTurnTimestamps", () => {
     );
     expect(timestamps.get(TURN)?.assistant).toBe(undefined);
   });
+
+  it("ignores empty deliveries and stamps the first later delivery with parts", () => {
+    const empty = {
+      ...deliveryConsumed("2026-01-02T10:00:01.000Z"),
+      data: { deliveryId: "delivery_1", turnId: TURN, parts: [] },
+    } satisfies SessionStreamEvent;
+    const timestamps = collectTurnTimestamps(
+      [empty, deliveryConsumed("2026-01-02T10:00:02.000Z")],
+      createTurnTimestampCache(),
+    );
+
+    expect(timestamps.get(TURN)?.user).toEqual(
+      new Date("2026-01-02T10:00:02.000Z"),
+    );
+  });
+
+  it("resumes after an event without a timestamp and keeps the first valid assistant time", () => {
+    const cache = createTurnTimestampCache();
+    const missingTime = {
+      ...contentDelta("2026-01-02T10:01:00.000Z"),
+      meta: { position: { line: 4, index: 0 } },
+    } as unknown as SessionStreamEvent;
+    const firstEvents = [missingTime];
+    const first = collectTurnTimestamps(firstEvents, cache);
+
+    expect(first.get(TURN)).toBeUndefined();
+    expect(collectTurnTimestamps(firstEvents, cache)).toBe(first);
+
+    const appended = [...firstEvents, modelStarted("2026-01-02T10:02:00.000Z")];
+    const second = collectTurnTimestamps(appended, cache);
+
+    expect(second.get(TURN)?.assistant).toEqual(
+      new Date("2026-01-02T10:02:00.000Z"),
+    );
+    expect(collectTurnTimestamps(appended, cache)).toBe(second);
+  });
 });
 
 describe("collectTurnTimestamps prototype-inherited event types", () => {
-  // `type` arrives off the wire, so a lookup on a plain object literal can
-  // resolve an inherited member instead of missing.
   it.each(["__proto__", "constructor", "toString"])(
     "ignores an event whose type is %s",
     (type) => {
@@ -199,10 +198,13 @@ describe("collectTurnTimestamps prototype-inherited event types", () => {
       const events = [
         {
           type,
-          data: { sequence: 1, turnId: TURN },
-          meta: { at: "2026-01-01T00:00:00.000Z", id: "evt_x" },
+          data: {},
+          meta: {
+            at: "2026-01-01T00:00:00.000Z",
+            position: { line: 1, index: 0 },
+          },
         },
-      ] as unknown as MessageStreamEvent[];
+      ] as SessionStreamEvent[];
 
       const timestamps = collectTurnTimestamps(events, cache);
 

package/src/deriveCreatedAt.ts

@@ -1,4 +1,4 @@
-import type { MessageStreamEvent } from "eve/client";
+import type { SessionStreamEvent } from "eve/client";
 
 export type TurnTimestamps = {
   readonly user?: Date;
@@ -6,38 +6,31 @@ export type TurnTimestamps = {
 };
 
 export type TurnTimestampCache = {
-  lastEvents: readonly MessageStreamEvent[];
+  lastEvents: readonly SessionStreamEvent[];
   timestamps: ReadonlyMap<string, TurnTimestamps>;
 };
 
 /**
- * The reducer cases eve projects into a message: `message.received` creates
- * `${turnId}:user`, and every assistant entry reaches `updateAssistantMessage`,
- * which creates `${turnId}:assistant` for a turn that has none. It enumerates
- * that reducer across the `>=0.32.0` peer range rather than stating a rule
- * about turn ids, because `turn.started` and the compaction events carry one
- * before the model runs. An event eve adds to the creating set later is absent
- * here and falls back to the wall clock instead of stamping a wrong time.
+ * The facts eve projects into a message: a `delivery.consumed` carrying parts
+ * opens the turn's user message, and the model, content, call, and interaction
+ * facts open its assistant message. A fact eve adds to the creating set later
+ * is absent here and falls back to the wall clock instead of stamping a wrong
+ * time.
  */
 const ROLE_BY_EVENT_TYPE: Partial<
-  Record<MessageStreamEvent["type"], keyof TurnTimestamps>
+  Record<SessionStreamEvent["type"], keyof TurnTimestamps>
 > = {
-  "message.received": "user",
-  "step.started": "assistant",
-  "reasoning.appended": "assistant",
-  "reasoning.completed": "assistant",
-  "action.input.appended": "assistant",
-  "actions.requested": "assistant",
-  "input.requested": "assistant",
-  "action.result": "assistant",
-  "action.partial": "assistant",
-  "authorization.required": "assistant",
-  "authorization.completed": "assistant",
-  "message.appended": "assistant",
-  "message.completed": "assistant",
-  "result.completed": "assistant",
-  "turn.completed": "assistant",
-  "turn.cancelled": "assistant",
+  "delivery.consumed": "user",
+  "model.requested": "assistant",
+  "model.started": "assistant",
+  "content.delta": "assistant",
+  "content.completed": "assistant",
+  "call.input": "assistant",
+  "call.requested": "assistant",
+  "call.started": "assistant",
+  "call.settled": "assistant",
+  "call.progress": "assistant",
+  "interaction.opened": "assistant",
 };
 
 export const createTurnTimestampCache = (): TurnTimestampCache => ({
@@ -46,15 +39,15 @@ export const createTurnTimestampCache = (): TurnTimestampCache => ({
 });
 
 /**
- * Eve appends to its log (`[...events, event]`), so a snapshot that keeps the
- * previous scan's last element by identity shares the whole prefix and the
- * scan resumes there. Any other snapshot is re-derived into a fresh map: turn
- * ids are per-session sequence numbers that recur after `reset()`, so entries
- * must not outlive the log that produced them. Re-derivation is also what
- * makes the render-phase cache writes safe when React discards a render.
+ * Eve appends to its log, so a snapshot that keeps the previous scan's last
+ * element by identity shares the whole prefix and the scan resumes there. Any
+ * other snapshot is re-derived into a fresh map: turn ids are per-session
+ * sequence numbers that recur after `newSession()`, so entries must not
+ * outlive the log that produced them. Re-derivation is also what makes the
+ * render-phase cache writes safe when React discards a render.
  */
 export const collectTurnTimestamps = (
-  events: readonly MessageStreamEvent[],
+  events: readonly SessionStreamEvent[],
   cache: TurnTimestampCache,
 ): ReadonlyMap<string, TurnTimestamps> => {
   if (events === cache.lastEvents) return cache.timestamps;
@@ -79,9 +72,12 @@ export const collectTurnTimestamps = (
       continue;
     const role = ROLE_BY_EVENT_TYPE[event.type];
     if (role === undefined) continue;
-    const data: unknown = (event as { readonly data?: unknown }).data;
-    if (typeof data !== "object" || data === null) continue;
-    const turnId = (data as { readonly turnId?: unknown }).turnId;
+    const turnId =
+      event.type === "delivery.consumed"
+        ? event.data.turnId
+        : event.scope?.turnId;
+    if (event.type === "delivery.consumed" && event.data.parts.length === 0)
+      continue;
     if (typeof turnId !== "string") continue;
     const known = timestamps.get(turnId);
     if (known?.[role] !== undefined) continue;

package/src/eveExtras.ts

@@ -1,10 +1,10 @@
 import { createRuntimeExtras } from "@assistant-ui/core/react";
-import type { EveMessageData, UseEveAgentHelpers } from "eve/react";
+import type { UseEveAgentReturn } from "eve/react";
 
 export type EveRuntimeExtras = Pick<
-  UseEveAgentHelpers<EveMessageData>,
-  "error" | "events" | "session" | "reset"
->;
+  UseEveAgentReturn,
+  "error" | "events" | "session"
+> & { readonly reset: UseEveAgentReturn["newSession"] };
 
 export const eveExtras =
   createRuntimeExtras<EveRuntimeExtras>("useEveAgentRuntime");

package/src/hooks.ts

@@ -27,9 +27,10 @@ export const useEveEvents = (): EveRuntimeExtras["events"] =>
   eveExtras.use((e) => e.events, EMPTY_EVENTS);
 
 /**
- * Returns a function that resets the Eve session: aborts any in-flight turn,
- * recreates the owned session, and clears events and projected data. Pending
- * staged messages and tool execution state are discarded. Safe to render
+ * Returns a function that starts a new Eve session: it stops reading the
+ * current session and clears its events and messages, without cancelling a
+ * turn still running on the server. Pending staged messages and tool execution
+ * state are discarded. Safe to render
  * outside an Eve runtime; invoking the returned function there throws.
  *
  * With `cloud`, it starts a new thread instead, leaving the current thread and its session in the list.

package/src/testUtils.ts

@@ -1,25 +1,206 @@
-import { ClientSession, type MessageStreamEvent } from "eve/client";
+import { Client, type SessionEvent, type SessionStreamEvent } from "eve/client";
+import type { Delivery } from "eve/sessions";
 import { vi } from "vitest";
 
+export const createEveDelivery = (
+  status: "completed" | "failed" = "completed",
+): Delivery => ({
+  sessionId: "session_resumed",
+  deliveryId: "delivery_1",
+  async *stream() {},
+  async result() {
+    const result = {
+      sessionId: "session_resumed",
+      deliveryId: "delivery_1",
+      outcome: status === "failed" ? "failed" : "handled",
+      sessionEnded: false,
+      reply: undefined,
+      data: undefined,
+      interactions: [],
+    } as const;
+    return status === "failed"
+      ? { ...result, status, error: { code: "internal", message: "boom" } }
+      : { ...result, status };
+  },
+});
+
+const isDelivery = (value: unknown): value is Delivery =>
+  typeof value === "object" &&
+  value !== null &&
+  "result" in value &&
+  typeof value.result === "function";
+
+export const createEveDeliveryAfter = (pending: Promise<unknown>): Delivery => {
+  const receipt = createEveDelivery();
+  return {
+    ...receipt,
+    async result(options) {
+      const signal = options?.signal;
+      const value = await new Promise<unknown>((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new DOMException("The operation was aborted.", "AbortError"));
+          return;
+        }
+        const onAbort = () => {
+          signal?.removeEventListener("abort", onAbort);
+          reject(new DOMException("The operation was aborted.", "AbortError"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        pending.then(
+          (result) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(result);
+          },
+          (error) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(error);
+          },
+        );
+      });
+      return isDelivery(value)
+        ? value.result(options)
+        : receipt.result(options);
+    },
+  };
+};
+
+export const createEveEvents = (
+  entries: readonly { at: string; event: SessionEvent }[],
+  startLine = 0,
+): readonly SessionStreamEvent[] =>
+  entries.map(({ at, event }, index) => ({
+    ...event,
+    meta: { at, position: { line: startLine + index, index: 0 } },
+  }));
+
+export const createCompletedTurnEvents = ({
+  turnId,
+  text,
+  reply,
+  deliveryId = `delivery_${turnId}`,
+  startLine = 0,
+  follows = null,
+  userAt = "2026-01-02T10:00:01.000Z",
+  assistantAt = "2026-01-02T10:00:03.000Z",
+}: {
+  turnId: string;
+  text: string;
+  reply: string;
+  deliveryId?: string;
+  startLine?: number;
+  follows?: string | null;
+  userAt?: string;
+  assistantAt?: string;
+}): readonly SessionStreamEvent[] => {
+  const runId = `run_${turnId}`;
+  const partId = `part_${turnId}`;
+  return createEveEvents(
+    [
+      ...(startLine === 0
+        ? [
+            {
+              at: userAt,
+              event: { type: "session.started" as const, data: {} },
+            },
+          ]
+        : []),
+      {
+        at: userAt,
+        event: { type: "delivery.admitted", data: { deliveryId } },
+      },
+      {
+        at: userAt,
+        event: {
+          type: "turn.started",
+          data: { turnId, cause: { deliveryId }, follows },
+        },
+      },
+      {
+        at: userAt,
+        event: {
+          type: "delivery.consumed",
+          data: { deliveryId, turnId, parts: [{ kind: "text", text }] },
+        },
+      },
+      {
+        at: assistantAt,
+        event: {
+          type: "model.requested",
+          data: { runId, owner: { turnId } },
+          scope: { turnId },
+        },
+      },
+      {
+        at: assistantAt,
+        event: {
+          type: "model.started",
+          data: { runId, modelId: "test-model", attempt: 0 },
+          scope: { turnId, runId },
+        },
+      },
+      {
+        at: assistantAt,
+        event: {
+          type: "content.completed",
+          data: { partId, runId, kind: "text", value: reply, phase: "reply" },
+          scope: { turnId, runId },
+        },
+      },
+      {
+        at: assistantAt,
+        event: {
+          type: "model.settled",
+          data: { runId, outcome: "completed", finishReason: "stop" },
+          scope: { turnId, runId },
+        },
+      },
+      {
+        at: assistantAt,
+        event: {
+          type: "turn.settled",
+          data: { turnId, outcome: "completed", reply: [partId] },
+          scope: { turnId },
+        },
+      },
+      {
+        at: assistantAt,
+        event: {
+          type: "delivery.settled",
+          data: { deliveryId, outcome: "handled", turnId },
+        },
+      },
+    ] satisfies readonly { at: string; event: SessionEvent }[],
+    startLine,
+  );
+};
+
 export const createEveSessionFixture = ({
   events = [],
   tailIndex = events.length - 1,
   onSend,
 }: {
-  events?: readonly MessageStreamEvent[];
+  events?: readonly SessionStreamEvent[];
   tailIndex?: number;
   onSend?: () => void;
 }) => {
   const encoder = new TextEncoder();
   let controller: ReadableStreamDefaultController<Uint8Array> | undefined;
   const pending = [...events];
-  const push = (events: readonly MessageStreamEvent[]) => {
+  const encode = (event: SessionStreamEvent) => {
+    const { meta, ...fact } = event;
+    return `${JSON.stringify(
+      event.type.endsWith(".delta") || event.type.endsWith(".progress")
+        ? { progress: fact }
+        : { at: meta.at, facts: [fact] },
+    )}\n`;
+  };
+  const push = (events: readonly SessionStreamEvent[]) => {
     if (controller === undefined) {
       pending.push(...events);
       return;
     }
     for (const event of events) {
-      controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
+      controller.enqueue(encoder.encode(encode(event)));
     }
   };
   const fetch = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
@@ -42,16 +223,16 @@ export const createEveSessionFixture = ({
       }),
       {
         headers: {
-          "x-eve-stream-version": "26",
+          "x-eve-stream-version": "27",
           "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 },
+  const session = new Client({ baseUrl: "http://localhost" }).sessions.attach(
+    "session_resumed",
+    { streamIndex: 0 },
   );
   return { fetch, push, session };
 };