@assistant-ui/eve 0.0.24 → 0.0.25

package/src/useEveAgentRuntime.fast-refresh.test.tsx

@@ -1,9 +1,11 @@
 // @vitest-environment jsdom
 
-import { act, type ReactNode } from "react";
-import type { AssistantCloud } from "assistant-cloud";
+import { Activity, act, type ReactNode, version } from "react";
+import { AssistantCloud } from "assistant-cloud";
+import { emptySessionView } from "eve/events";
 import { afterAll, afterEach, expect, it, vi } from "vitest";
 import type { EveCloudSessions } from "./eveCloudSessions";
+import { createEveDelivery, createEveDeliveryAfter } from "./testUtils";
 
 const { mockUseEveAgent, directRuntimeHook, sessionInstances } = vi.hoisted(
   () => ({
@@ -104,6 +106,9 @@ afterEach(() => {
 });
 afterAll(() => vi.unstubAllGlobals());
 
+// Activity is React 19 only
+const onReact18 = version.startsWith("18.");
+
 const refresh = async (Before: unknown, After: unknown) => {
   const family: Family = { current: After };
   renderer!.setRefreshHandler((type) =>
@@ -121,24 +126,23 @@ const refresh = async (Before: unknown, After: unknown) => {
 };
 
 const makeAgent = (send: (content: string) => Promise<void>) => ({
-  data: {
-    messages: [
-      { id: "u1", role: "user", parts: [{ type: "text", text: "earlier" }] },
-      {
-        id: "a1",
-        role: "assistant",
-        parts: [{ type: "text", text: "earlier answer" }],
-      },
-    ],
-  },
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "earlier" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [{ type: "text", text: "earlier answer" }],
+    },
+  ],
+  view: emptySessionView(),
   error: undefined,
   events: [],
   session: undefined,
-  status: "ready",
-  send: vi.fn(send),
-  respond: vi.fn(async () => {}),
-  cancel: vi.fn(async () => ({ status: "no_active_turn" })),
-  reset: vi.fn(),
+  status: "idle",
+  send: vi.fn(async (content: string) => createEveDeliveryAfter(send(content))),
+  respond: vi.fn(async () => createEveDelivery()),
+  cancel: vi.fn(async () => createEveDelivery()),
+  newSession: vi.fn(),
   resume: vi.fn(async () => {}),
 });
 
@@ -214,25 +218,29 @@ it("abandons an Eve send still queued when the runtime unmounts", async () => {
 });
 
 const makeCloud = () => {
-  const create = vi.fn(async () => ({ thread_id: "cloud-1" }));
-  const cloud = {
-    threads: {
-      list: vi.fn(async () => ({ threads: [] })),
-      create,
-      update: vi.fn(async () => {}),
-      delete: vi.fn(async () => {}),
-      get: vi.fn(),
-      messages: {
-        list: vi.fn(async () => ({ messages: [] })),
-        create: vi.fn(async () => ({ message_id: "cloud-message" })),
-        update: vi.fn(async () => {}),
-      },
-    },
-    events: { track: vi.fn() },
-    telemetry: { enabled: false },
-    runs: { report: vi.fn(async () => {}) },
-    registerSdk: vi.fn(),
-  } as unknown as AssistantCloud;
+  const cloud = new AssistantCloud({
+    baseUrl: "http://localhost",
+    apiKey: "test-key",
+    userId: "test-user",
+    workspaceId: "test-workspace",
+    telemetry: false,
+  });
+  let created = 0;
+  vi.spyOn(cloud.threads, "list").mockResolvedValue({ threads: [] });
+  const create = vi
+    .spyOn(cloud.threads, "create")
+    .mockImplementation(async () => ({
+      thread_id: `cloud-${++created}`,
+    }));
+  vi.spyOn(cloud.threads, "update").mockResolvedValue(undefined);
+  vi.spyOn(cloud.threads, "delete").mockResolvedValue(undefined);
+  vi.spyOn(cloud.threads.messages, "list").mockResolvedValue({ messages: [] });
+  vi.spyOn(cloud.threads.messages, "create").mockResolvedValue({
+    message_id: "cloud-message",
+  });
+  vi.spyOn(cloud.events, "track").mockImplementation(() => {});
+  vi.spyOn(cloud.runs, "report").mockResolvedValue({ run_id: "test-run" });
+  vi.spyOn(cloud, "registerSdk").mockImplementation(() => {});
   return { cloud, create };
 };
 
@@ -242,7 +250,7 @@ it("resolves a pending first Eve session after Fast Refresh", async () => {
     | ((session: { sessionId: string; streamIndex: number }) => void)
     | undefined;
   const agent = makeAgent(async () => {});
-  agent.data.messages = [];
+  agent.messages = [];
   mockUseEveAgent.mockImplementation((options) => {
     onSessionChange = options.onSessionChange;
     return agent;
@@ -340,3 +348,153 @@ it("keeps a first Eve session wait alive when a nested runtimeHook refreshes", a
   await expect(waiting).resolves.toBe("session-1");
   view.unmount();
 });
+
+it.skipIf(onReact18)(
+  "reads Eve delivery results again after an Activity hides and shows the runtime",
+  async () => {
+    const agent = makeAgent(async () => {});
+    agent.send.mockImplementation(async () => {
+      const receipt = createEveDelivery();
+      return {
+        ...receipt,
+        result: (options?: { readonly signal?: AbortSignal }) =>
+          options?.signal?.aborted
+            ? Promise.reject(options.signal.reason)
+            : receipt.result(),
+      };
+    });
+    mockUseEveAgent.mockReturnValue(agent);
+    let runtime!: ReturnType<typeof useEveAgentRuntime>;
+    const Host = () => {
+      runtime = useEveAgentRuntime();
+      return null;
+    };
+    const view = render(
+      <Activity mode="visible">
+        <Host />
+      </Activity>,
+    );
+    view.rerender(
+      <Activity mode="hidden">
+        <Host />
+      </Activity>,
+    );
+    await act(async () => {});
+    view.rerender(
+      <Activity mode="visible">
+        <Host />
+      </Activity>,
+    );
+    await act(async () => {});
+
+    act(() => {
+      runtime.thread.composer.setText("after show");
+      runtime.thread.composer.send();
+    });
+    await waitFor(() =>
+      expect(agent.send).toHaveBeenCalledWith("after show", undefined),
+    );
+    await act(async () => {});
+    expect(runtime.thread.composer.getState().text).toBe("");
+    view.unmount();
+  },
+);
+
+it.skipIf(onReact18)(
+  "keeps a send queued after an Activity re-show behind the turn still in flight",
+  async () => {
+    let releaseFirst!: () => void;
+    const agent = makeAgent(
+      vi
+        .fn()
+        .mockImplementationOnce(
+          () =>
+            new Promise<void>((resolve) => {
+              releaseFirst = resolve;
+            }),
+        )
+        .mockResolvedValue(undefined),
+    );
+    mockUseEveAgent.mockReturnValue(agent);
+    let runtime!: ReturnType<typeof useEveAgentRuntime>;
+    const Host = () => {
+      runtime = useEveAgentRuntime();
+      return null;
+    };
+    const view = render(
+      <Activity mode="visible">
+        <Host />
+      </Activity>,
+    );
+
+    await act(async () => runtime.thread.append("first"));
+    await waitFor(() => expect(agent.send).toHaveBeenCalledTimes(1));
+    view.rerender(
+      <Activity mode="hidden">
+        <Host />
+      </Activity>,
+    );
+    await act(async () => {});
+    view.rerender(
+      <Activity mode="visible">
+        <Host />
+      </Activity>,
+    );
+    await act(async () => {});
+
+    await act(async () => runtime.thread.append("second"));
+    await act(async () => {});
+    expect(agent.send).toHaveBeenCalledTimes(1);
+
+    await act(async () => releaseFirst());
+    await waitFor(() => expect(agent.send).toHaveBeenCalledTimes(2));
+    expect(agent.send).toHaveBeenNthCalledWith(2, "second", undefined);
+    view.unmount();
+  },
+);
+
+it("keeps the composer empty when a reset ends a send Eve already accepted", async () => {
+  const agent = makeAgent(async () => {});
+  agent.send.mockImplementation(async () => {
+    const receipt = createEveDelivery();
+    return {
+      ...receipt,
+      result: (options?: { readonly signal?: AbortSignal }) =>
+        new Promise<never>((_, reject) => {
+          options?.signal?.addEventListener("abort", () =>
+            reject(options.signal?.reason),
+          );
+        }),
+    };
+  });
+  mockUseEveAgent.mockReturnValue(agent);
+  let runtime!: ReturnType<typeof useEveAgentRuntime>;
+  let reset!: () => void;
+  const Probe = () => {
+    reset = useEveReset();
+    return null;
+  };
+  const Host = () => {
+    runtime = useEveAgentRuntime();
+    return (
+      <AssistantRuntimeProvider runtime={runtime}>
+        <Probe />
+      </AssistantRuntimeProvider>
+    );
+  };
+  const view = render(<Host />);
+
+  act(() => {
+    runtime.thread.composer.setText("sent");
+    runtime.thread.composer.send();
+  });
+  await waitFor(() =>
+    expect(agent.send).toHaveBeenCalledWith("sent", undefined),
+  );
+  act(() => reset());
+  await act(async () => {});
+
+  expect(agent.newSession).toHaveBeenCalledTimes(1);
+  expect(runtime.thread.composer.getState().text).toBe("");
+  view.unmount();
+});

package/src/useEveAgentRuntime.interruptedTurn.test.tsx

@@ -1,48 +1,93 @@
 // @vitest-environment jsdom
 
 import { renderHook, waitFor } from "@testing-library/react";
+import type { SessionEvent } from "eve/client";
 import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createEveSessionFixture } from "./testUtils";
+import { createEveEvents, 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",
+const renderInterruptedTurn = (
+  ending: Extract<SessionEvent, { type: "turn.settled" }>["data"],
+) => {
+  const at = "2026-01-02T10:00:00.000Z";
+  const events = createEveEvents([
+    { at, event: { type: "session.started", data: {} } },
+    {
+      at,
+      event: { type: "delivery.admitted", data: { deliveryId: "d1" } },
     },
-    meta: meta(3),
-  },
-  { ...ending, meta: meta(4) },
-];
-
-const renderInterruptedTurn = (ending: Record<string, unknown>) => {
+    {
+      at,
+      event: {
+        type: "turn.started",
+        data: { turnId: "t1", cause: { deliveryId: "d1" }, follows: null },
+      },
+    },
+    {
+      at,
+      event: {
+        type: "delivery.consumed",
+        data: {
+          deliveryId: "d1",
+          turnId: "t1",
+          parts: [{ kind: "text", text: "hi" }],
+        },
+      },
+    },
+    {
+      at,
+      event: {
+        type: "model.requested",
+        data: { runId: "r1", owner: { turnId: "t1" } },
+        scope: { turnId: "t1" },
+      },
+    },
+    {
+      at,
+      event: {
+        type: "model.started",
+        data: { runId: "r1", modelId: "m", attempt: 0 },
+        scope: { turnId: "t1", runId: "r1" },
+      },
+    },
+    {
+      at,
+      event: {
+        type: "content.completed",
+        data: {
+          partId: "p1",
+          runId: "r1",
+          kind: "text",
+          value: "Let me th",
+          phase: "reply",
+          interrupted: true,
+        },
+        scope: { turnId: "t1", runId: "r1" },
+      },
+    },
+    {
+      at,
+      event: {
+        type: "model.settled",
+        data: { runId: "r1", outcome: "interrupted" },
+        scope: { turnId: "t1", runId: "r1" },
+      },
+    },
+    {
+      at,
+      event: { type: "turn.settled", data: ending, scope: { turnId: "t1" } },
+    },
+    {
+      at,
+      event: {
+        type: "delivery.settled",
+        data: { deliveryId: "d1", turnId: "t1", outcome: "handled" },
+      },
+    },
+  ] satisfies readonly { at: string; event: SessionEvent }[]);
   const { session } = createEveSessionFixture({});
   return renderHook(() =>
-    useEveAgentRuntime({
-      initialEvents: interruptedTurn(ending) as never,
-      session,
-    }),
+    useEveAgentRuntime({ initialEvents: events, session }),
   );
 };
 
@@ -51,8 +96,9 @@ 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" },
+      turnId: "t1",
+      outcome: "failed",
+      error: { code: "internal", message: "boom" },
     });
 
     await waitFor(() =>
@@ -66,8 +112,8 @@ describe("useEveAgentRuntime with an interrupted turn", () => {
 
   it("shows a cancelled turn's assistant message as cancelled", async () => {
     const { result } = renderInterruptedTurn({
-      type: "turn.cancelled",
-      data: { sequence: 5, turnId: "t1" },
+      turnId: "t1",
+      outcome: "cancelled",
     });
 
     await waitFor(() =>

package/src/useEveAgentRuntime.refetch.test.tsx

@@ -2,75 +2,36 @@
 
 import { act, renderHook } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import type { HandleMessageStreamEvent } from "eve/client";
-
-import { createEveSessionFixture } from "./testUtils";
+import {
+  createCompletedTurnEvents,
+  createEveSessionFixture,
+} from "./testUtils";
 import { useEveAgentRuntime } from "./useEveAgentRuntime";
 
-const completedTurn = (
-  turnId: string,
-  text: string,
-  reply: string,
-  sequence: number,
-) =>
-  [
-    {
-      type: "turn.started",
-      data: { sequence, turnId },
-      meta: { at: "2026-01-02T10:00:00.000Z", id: `${turnId}-1` },
-    },
-    {
-      type: "message.received",
-      data: { message: text, sequence: sequence + 1, turnId },
-      meta: { at: "2026-01-02T10:00:01.000Z", id: `${turnId}-2` },
-    },
-    {
-      type: "step.started",
-      data: { modelId: "m", sequence: sequence + 2, stepIndex: 0, turnId },
-      meta: { at: "2026-01-02T10:00:02.000Z", id: `${turnId}-3` },
-    },
-    {
-      type: "message.completed",
-      data: {
-        finishReason: "stop",
-        message: reply,
-        sequence: sequence + 3,
-        stepIndex: 0,
-        turnId,
-      },
-      meta: { at: "2026-01-02T10:00:03.000Z", id: `${turnId}-4` },
-    },
-    {
-      type: "turn.completed",
-      data: { sequence: sequence + 4, turnId },
-      meta: { at: "2026-01-02T10:00:04.000Z", id: `${turnId}-5` },
-    },
-  ] as const satisfies readonly HandleMessageStreamEvent[];
-
-const knownTurn = completedTurn("t1", "hi", "hello", 1);
-const outOfBandTurn = completedTurn("t2", "answered elsewhere", "done", 6);
+const knownTurn = createCompletedTurnEvents({
+  turnId: "t1",
+  text: "hi",
+  reply: "hello",
+});
+const outOfBandTurn = createCompletedTurnEvents({
+  turnId: "t2",
+  text: "answered elsewhere",
+  reply: "done",
+  startLine: knownTurn.length,
+  follows: "t1",
+});
 
 afterEach(() => vi.unstubAllGlobals());
 
 describe("useEveAgentRuntime against a durable eve session", () => {
   it("surfaces a turn the server appended out of band after reloadMainThread", async () => {
     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" },
-        },
-      ],
+      events: outOfBandTurn,
+      tailIndex: knownTurn.length + outOfBandTurn.length - 1,
     });
 
     const { result } = renderHook(() =>
-      useEveAgentRuntime({ initialEvents: knownTurn as never, session }),
+      useEveAgentRuntime({ initialEvents: knownTurn, session }),
     );
     expect(
       result.current.thread.getState().messages.map((m) => m.role),