@assistant-ui/eve 0.0.15 → 0.0.17

package/src/useEveAgentRuntime.eveResume.test.tsx

@@ -0,0 +1,80 @@
+// @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 { renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import type { MessageStreamEvent } from "eve/client";
+
+import { useEveAgentRuntime } from "./useEveAgentRuntime";
+
+const TURN = "turn_resumed";
+
+const USER_AT = "2026-01-02T10:00:01.000Z";
+const ASSISTANT_AT = "2026-01-02T10:02:00.000Z";
+
+const resumedEvents = [
+  {
+    type: "turn.started",
+    data: { sequence: 1, turnId: TURN },
+    meta: { at: "2026-01-02T10:00:00.000Z", id: "evt_001" },
+  },
+  {
+    type: "message.received",
+    data: { message: "hi", sequence: 2, turnId: TURN },
+    meta: { at: USER_AT, id: "evt_101" },
+  },
+  {
+    type: "step.started",
+    data: { modelId: "test-model", sequence: 3, stepIndex: 0, turnId: TURN },
+    meta: { at: ASSISTANT_AT, id: "evt_102" },
+  },
+  {
+    type: "message.completed",
+    data: {
+      finishReason: "stop",
+      message: "hello",
+      sequence: 5,
+      stepIndex: 0,
+      turnId: TURN,
+    },
+    meta: { at: "2026-01-02T10:02:06.000Z", id: "evt_003" },
+  },
+  {
+    type: "turn.completed",
+    data: { sequence: 6, turnId: TURN },
+    meta: { at: "2026-01-02T10:02:07.000Z", id: "evt_004" },
+  },
+] as const satisfies 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;
+
+describe("useEveAgentRuntime against a resumed eve session", () => {
+  it("renders resumed history at its durable event times, not the current time", async () => {
+    const { result } = renderHook(() =>
+      useEveAgentRuntime({ resume: true, session: offlineSession }),
+    );
+
+    await waitFor(() =>
+      expect(result.current.thread.getState().messages).toHaveLength(2),
+    );
+
+    const messages = result.current.thread.getState().messages;
+    expect(messages[0]?.createdAt).toEqual(new Date(USER_AT));
+    expect(messages[1]?.createdAt).toEqual(new Date(ASSISTANT_AT));
+  });
+});

package/src/useEveAgentRuntime.test.tsx

@@ -1,6 +1,12 @@
 // @vitest-environment jsdom
 
-import { act, renderHook, waitFor } from "@testing-library/react";
+import { act, render, renderHook, waitFor } from "@testing-library/react";
+import {
+  startTransition,
+  Suspense,
+  useLayoutEffect,
+  type PropsWithChildren,
+} from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 const { mockUseEveAgent } = vi.hoisted(() => ({
@@ -12,6 +18,7 @@ vi.mock("eve/react", async (importOriginal) => ({
   useEveAgent: mockUseEveAgent,
 }));
 
+import type { MessageStreamEvent } from "eve/client";
 import type { EveMessageData } from "eve/react";
 import { useEveAgentRuntime } from "./useEveAgentRuntime";
 import { eveExtras } from "./eveExtras";
@@ -388,9 +395,9 @@ describe("useEveAgentRuntime tool approval responses", () => {
     try {
       const { result } = renderHook(() => useEveAgentRuntime());
 
-      expect(() => respondToTextRequest(result, { approved: true })).toThrow(
-        /was not answered by this response/,
-      );
+      await expect(
+        respondToTextRequest(result, { approved: true }),
+      ).rejects.toThrow(/was not answered by this response/);
 
       await flushMicrotasks();
       await flushMicrotasks();
@@ -1205,6 +1212,7 @@ describe("useEveAgentRuntime extras wiring", () => {
     mockUseEveAgent.mockReturnValue(agent as never);
     const { result, rerender } = renderHook(() => useEveAgentRuntime());
 
+    let humanRequests = 0;
     const humanRejections: unknown[] = [];
     act(() => {
       result.current.registerModelContextProvider({
@@ -1216,6 +1224,7 @@ describe("useEveAgentRuntime extras wiring", () => {
                 _args: unknown,
                 context: { human: (payload: unknown) => Promise<unknown> },
               ) => {
+                humanRequests += 1;
                 try {
                   return await context.human({ request: "approve" });
                 } catch (error) {
@@ -1235,7 +1244,7 @@ describe("useEveAgentRuntime extras wiring", () => {
     rerender();
 
     await waitFor(() => {
-      expect(result.current.thread.getState().isRunning).toBe(true);
+      expect(humanRequests).toBe(2);
     });
 
     act(() => {
@@ -1817,6 +1826,131 @@ describe("useEveAgentRuntime cancel binding", () => {
 describe("useEveAgentRuntime thread refetch", () => {
   const session = { sessionId: "s1" };
 
+  const mockWorkspaceAgents = () => {
+    const resumeA = vi.fn().mockResolvedValue(undefined);
+    const resumeB = vi.fn().mockResolvedValue(undefined);
+    const agentA = createAgent({
+      data: {
+        messages: [
+          {
+            id: "workspace-a",
+            role: "user",
+            parts: [{ type: "text", text: "workspace A" }],
+          },
+        ],
+      },
+      session,
+      resume: resumeA,
+    });
+    const agentB = createAgent({
+      data: {
+        messages: [
+          {
+            id: "workspace-b",
+            role: "user",
+            parts: [{ type: "text", text: "workspace B" }],
+          },
+        ],
+      },
+      session,
+      resume: resumeB,
+    });
+    mockUseEveAgent.mockImplementation((options) =>
+      (options as { workspace: string }).workspace === "A"
+        ? (agentA as never)
+        : (agentB as never),
+    );
+    return { agentA, agentB, resumeA, resumeB };
+  };
+
+  it("publishes committed state before descendant layout effects", async () => {
+    const { resumeA, resumeB } = mockWorkspaceAgents();
+
+    let refetch: Promise<void> | undefined;
+    let currentRuntime: ReturnType<typeof useEveAgentRuntime> | undefined;
+    const RefetchOnLayout = ({
+      runtime,
+      enabled,
+    }: {
+      runtime: ReturnType<typeof useEveAgentRuntime>;
+      enabled: boolean;
+    }) => {
+      useLayoutEffect(() => {
+        if (!enabled) return;
+        runtime.thread.append({
+          role: "user",
+          content: [{ type: "text", text: "draft from B" }],
+          startRun: false,
+        });
+        refetch = runtime.threads.reloadMainThread();
+      }, [enabled, runtime]);
+      return null;
+    };
+    const Probe = ({
+      workspace,
+      refetchOnLayout,
+    }: {
+      workspace: string;
+      refetchOnLayout: boolean;
+    }) => {
+      const runtime = useEveAgentRuntime({ workspace } as never);
+      currentRuntime = runtime;
+      return <RefetchOnLayout runtime={runtime} enabled={refetchOnLayout} />;
+    };
+
+    const view = render(<Probe workspace="A" refetchOnLayout={false} />);
+    view.rerender(<Probe workspace="B" refetchOnLayout />);
+    await act(async () => {
+      await refetch;
+    });
+
+    expect(resumeA).not.toHaveBeenCalled();
+    expect(resumeB).toHaveBeenCalledTimes(1);
+    expect(getText(currentRuntime!)).toEqual(["workspace B", "draft from B"]);
+    view.unmount();
+  });
+
+  it("keeps refetches scoped to the committed agent", async () => {
+    const { agentB, resumeA, resumeB } = mockWorkspaceAgents();
+
+    const pending = new Promise<never>(() => {});
+    let blocked = false;
+    const Blocker = () => {
+      if (blocked) throw pending;
+      return null;
+    };
+    const Wrapper = ({ children }: PropsWithChildren) => (
+      <Suspense fallback={null}>
+        {children}
+        <Blocker />
+      </Suspense>
+    );
+
+    const { result, rerender } = renderHook(
+      ({ workspace }) => useEveAgentRuntime({ workspace } as never),
+      {
+        initialProps: { workspace: "A" },
+        wrapper: Wrapper,
+      },
+    );
+
+    act(() => {
+      blocked = true;
+      startTransition(() => rerender({ workspace: "B" }));
+    });
+    expect(mockUseEveAgent.mock.results.at(-1)?.value).toBe(agentB);
+
+    await act(async () => {
+      await result.current.threads.reloadMainThread();
+    });
+
+    expect(resumeB).not.toHaveBeenCalled();
+    expect(resumeA).toHaveBeenCalledTimes(1);
+
+    await stageMessage(result.current, "draft from A");
+    expect(getText(result.current)).toEqual(["workspace A", "draft from A"]);
+  });
+
   it("replays the session through eve resume when the thread is refetched", async () => {
     const resume = vi.fn().mockResolvedValue(undefined);
     const agent = createAgent({ session, resume });
@@ -2019,3 +2153,88 @@ describe("useEveAgentRuntime thread refetch", () => {
     });
   });
 });
+
+describe("useEveAgentRuntime createdAt derivation", () => {
+  const TURN = "turn_ts";
+  const USER_AT = "2026-01-02T10:00:01.000Z";
+  const ASSISTANT_AT = "2026-01-02T10:02:00.000Z";
+
+  const turnEvents = [
+    {
+      type: "turn.started",
+      data: { sequence: 1, turnId: TURN },
+      meta: { at: "2026-01-02T10:00:00.000Z", id: "evt_1" },
+    },
+    {
+      type: "message.received",
+      data: { message: "hi", sequence: 2, turnId: TURN },
+      meta: { at: USER_AT, id: "evt_2" },
+    },
+    {
+      type: "step.started",
+      data: { modelId: "m", sequence: 3, stepIndex: 0, turnId: TURN },
+      meta: { at: ASSISTANT_AT, id: "evt_3" },
+    },
+  ] satisfies readonly MessageStreamEvent[];
+
+  const turnData: EveMessageData = {
+    messages: [
+      {
+        id: `${TURN}:user`,
+        role: "user",
+        metadata: { turnId: TURN },
+        parts: [{ type: "text", text: "hi" }],
+      },
+      {
+        id: `${TURN}:assistant`,
+        role: "assistant",
+        metadata: { turnId: TURN },
+        parts: [{ type: "text", text: "hello" }],
+      },
+    ],
+  };
+
+  it("stamps a message with the wall clock when no event covers its turn, and keeps that stamp across renders", () => {
+    const before = Date.now();
+    const agent = createAgent({ data: turnData, events: [] });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    const stamped = result.current.thread.getState().messages[0]?.createdAt;
+    expect(stamped?.getTime()).toBeGreaterThanOrEqual(before);
+
+    mockUseEveAgent.mockReturnValue({
+      ...agent,
+      data: { messages: [...turnData.messages] },
+    } as never);
+    rerender();
+
+    expect(result.current.thread.getState().messages[0]?.createdAt).toBe(
+      stamped,
+    );
+  });
+
+  it("keeps the message list identity when appended events stamp no message", () => {
+    const agent = createAgent({ data: turnData, events: turnEvents });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+    const first = result.current.thread.getState().messages;
+
+    mockUseEveAgent.mockReturnValue({
+      ...agent,
+      events: [
+        ...turnEvents,
+        {
+          type: "turn.started",
+          data: { sequence: 4, turnId: "turn_next" },
+          meta: { at: "2026-01-02T10:05:00.000Z", id: "evt_4" },
+        },
+      ],
+    } as never);
+    rerender();
+
+    expect(result.current.thread.getState().messages).toBe(first);
+  });
+});

package/src/useEveAgentRuntime.ts

@@ -1,6 +1,13 @@
 "use client";
 
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useInsertionEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import {
   fromThreadMessageLike,
   generateId,
@@ -32,6 +39,10 @@ import {
   getEveMessageContent,
   toEveInputResponse,
 } from "./convertEveMessages";
+import {
+  collectTurnTimestamps,
+  createTurnTimestampCache,
+} from "./deriveCreatedAt";
 import { eveExtras } from "./eveExtras";
 
 const USER_STAGED_STATUS = {
@@ -204,6 +215,14 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
     agent.status === "submitted" || agent.status === "streaming";
   const isRunning = providerIsRunning || hasExecutingTools;
 
+  // Kept apart from the message memo so events that teach no timestamp keep
+  // the map identity and skip rebuilding every ThreadMessage.
+  const turnTimestampCacheRef = useRef(createTurnTimestampCache());
+  const turnTimestamps = useMemo(
+    () => collectTurnTimestamps(agent.events, turnTimestampCacheRef.current),
+    [agent.events],
+  );
+
   const convertedMessages = useMemo(() => {
     const createdAtByMessageId = createdAtByMessageIdRef.current;
     const messageIds = new Set(
@@ -217,6 +236,13 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
       isRunning,
       error: agent.error,
       getCreatedAt: (message) => {
+        const turnId = message.metadata?.turnId;
+        const durable =
+          turnId === undefined
+            ? undefined
+            : turnTimestamps.get(turnId)?.[message.role];
+        if (durable !== undefined) return durable;
+
         const existing = createdAtByMessageId.get(message.id);
         if (existing) return existing;
 
@@ -225,13 +251,17 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
         return createdAt;
       },
     });
-  }, [agent.data, agent.error, isRunning]);
+  }, [agent.data, agent.error, isRunning, turnTimestamps]);
 
   const messages = stagedMessages ?? convertedMessages;
   const messagesRef = useRef(messages);
-  messagesRef.current = messages;
   const agentRef = useRef(agent);
-  agentRef.current = agent;
+  // Descendant layout effects can dispatch against these refs synchronously;
+  // this matches useA2ARuntime's commit-scoped ref publication.
+  useInsertionEffect(() => {
+    messagesRef.current = messages;
+    agentRef.current = agent;
+  }, [agent, messages]);
 
   // Upstream `EveAgentStore` `send` and `respond` reject while a turn is in
   // flight and only resolve once the turn's stream parks, so a pending chain
@@ -464,10 +494,11 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
         }
       : {}),
     onRespondToToolApproval: (response) => {
-      // Eve leaves an unanswered request pending, so an unmappable response
-      // must stay answerable. Mapping before the first await lets the mapper's
-      // own error surface synchronously to the caller that rendered the
-      // controls, the only signal the void `respondToApproval` seam carries.
+      // Eve resolves a request the moment any response for it arrives, and an
+      // empty one is recorded as an answer with no content. Mapping before the
+      // send is enqueued keeps an unmappable response unsent, so the request
+      // stays answerable; the mapper's error reaches the caller as the seam's
+      // rejection.
       const inputResponse = toEveInputResponse(
         response,
         findEveInputRequest(agent.data, response.approvalId),