@assistant-ui/eve 0.0.12 → 0.0.14

package/src/convertEveMessages.test.ts

@@ -8,6 +8,11 @@ import {
 } from "./convertEveMessages";
 import type { AppendMessage } from "@assistant-ui/core";
 
+const eventMeta = (sequence: number) => ({
+  at: "2026-01-01T00:00:00.000Z",
+  id: `evt_${sequence}`,
+});
+
 describe("convertEveMessages", () => {
   it("converts text and reasoning parts", () => {
     const data = {
@@ -48,6 +53,75 @@ describe("convertEveMessages", () => {
     });
   });
 
+  it("omits the part status when the part state is still streaming", () => {
+    const data = {
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          metadata: { status: "streaming" },
+          parts: [
+            { type: "reasoning", text: "Thinking", state: "streaming" },
+            { type: "text", text: "Hi", state: "streaming" },
+          ],
+        },
+      ],
+    } satisfies EveMessageData;
+
+    const messages = convertEveMessages(data, { isRunning: true });
+
+    for (const part of messages[0]!.content) {
+      expect(part).not.toHaveProperty("status");
+    }
+  });
+
+  it("maps a done part state to a complete part status", () => {
+    const data = {
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          metadata: { status: "complete" },
+          parts: [
+            { type: "reasoning", text: "Thinking", state: "done" },
+            { type: "text", text: "Hi", state: "done" },
+          ],
+        },
+      ],
+    } satisfies EveMessageData;
+
+    const messages = convertEveMessages(data);
+
+    expect(messages[0]!.content).toEqual([
+      expect.objectContaining({
+        type: "reasoning",
+        status: { type: "complete" },
+      }),
+      expect.objectContaining({ type: "text", status: { type: "complete" } }),
+    ]);
+  });
+
+  it("omits the part status when the part state is absent", () => {
+    const data = {
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            { type: "reasoning", text: "Thinking" },
+            { type: "text", text: "Hi" },
+          ],
+        },
+      ],
+    } satisfies EveMessageData;
+
+    const messages = convertEveMessages(data);
+
+    for (const part of messages[0]!.content) {
+      expect(part).not.toHaveProperty("status");
+    }
+  });
+
   it("converts dynamic tool parts with approval options", () => {
     const data = {
       messages: [
@@ -68,11 +142,12 @@ describe("convertEveMessages", () => {
                   name: "send_email",
                   inputRequest: {
                     requestId: "req_1",
+                    kind: "tool-approval",
                     prompt: "Send the email?",
                     display: "confirmation",
                     options: [
                       { id: "approve", label: "Approve" },
-                      { id: "deny", label: "Deny", style: "danger" },
+                      { id: "cancel", label: "Cancel", style: "danger" },
                       { id: "escalate", label: "Escalate" },
                     ],
                   },
@@ -98,7 +173,7 @@ describe("convertEveMessages", () => {
             id: "req_1",
             options: [
               { id: "approve", kind: "allow-once", label: "Approve" },
-              { id: "deny", kind: "reject-once", label: "Deny" },
+              { id: "cancel", kind: "reject-once", label: "Cancel" },
               { id: "escalate", kind: "_escalate", label: "Escalate" },
             ],
           },
@@ -846,6 +921,7 @@ describe("convertEveMessages", () => {
       const events: readonly EveAgentReducerEvent[] = [
         {
           type: "authorization.required",
+          meta: eventMeta(0),
           data: {
             turnId: "turn_1",
             stepIndex: 0,
@@ -856,6 +932,7 @@ describe("convertEveMessages", () => {
         },
         {
           type: "turn.cancelled",
+          meta: eventMeta(1),
           data: { turnId: "turn_1", sequence: 1 },
         },
       ];
@@ -1010,14 +1087,22 @@ describe("convertEveMessages", () => {
         },
         {
           type: "turn.started",
+          meta: eventMeta(0),
           data: { turnId: "turn_1", sequence: 0 },
         },
         {
           type: "step.started",
-          data: { turnId: "turn_1", stepIndex: 0, sequence: 1 },
+          meta: eventMeta(1),
+          data: {
+            turnId: "turn_1",
+            stepIndex: 0,
+            sequence: 1,
+            modelId: "test-model",
+          },
         },
         {
           type: "message.appended",
+          meta: eventMeta(2),
           data: {
             turnId: "turn_1",
             stepIndex: 0,
@@ -1033,6 +1118,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents,
           {
             type: "authorization.required",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1073,6 +1159,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents,
           {
             type: "authorization.required",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1083,6 +1170,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "authorization.completed",
+            meta: eventMeta(4),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1112,6 +1200,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents,
           {
             type: "authorization.required",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1122,6 +1211,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "authorization.required",
+            meta: eventMeta(4),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1132,6 +1222,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "authorization.completed",
+            meta: eventMeta(5),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1147,6 +1238,193 @@ describe("convertEveMessages", () => {
         ).toEqual({ type: "requires-action", reason: "interrupt" });
       });
 
+      it("leaves a reasoning part unsettled when a tool call follows it", () => {
+        const state = replay([
+          ...midStreamEvents.slice(0, 3),
+          {
+            type: "reasoning.appended",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 2,
+              reasoningDelta: "Think",
+              reasoningSoFar: "Think",
+            },
+          },
+          {
+            type: "actions.requested",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 3,
+              actions: [
+                {
+                  kind: "tool-call",
+                  callId: "call_1",
+                  toolName: "search",
+                  input: {},
+                },
+              ],
+            },
+          },
+        ]);
+
+        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" }),
+          ]),
+        );
+
+        const content = convertEveMessages(state, { isRunning: true }).at(
+          -1,
+        )?.content;
+        expect(content).toEqual([
+          expect.objectContaining({ type: "reasoning" }),
+          expect.objectContaining({ type: "tool-call" }),
+        ]);
+        expect(content?.[0]).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",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 2,
+              reasoningDelta: "Think",
+              reasoningSoFar: "Think",
+            },
+          },
+          {
+            type: "actions.requested",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 3,
+              actions: [
+                {
+                  kind: "tool-call",
+                  callId: "call_1",
+                  toolName: "search",
+                  input: {},
+                },
+              ],
+            },
+          },
+          {
+            type: "reasoning.completed",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 4,
+              reasoning: "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" }),
+          ]),
+        );
+
+        const content = convertEveMessages(state, { isRunning: true }).at(
+          -1,
+        )?.content;
+        expect(content).toEqual([
+          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),
+          {
+            type: "message.appended",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 2,
+              messageDelta: "First",
+              messageSoFar: "First",
+            },
+          },
+          {
+            type: "message.completed",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 3,
+              finishReason: "tool-calls",
+              message: "First",
+            },
+          },
+          {
+            type: "step.completed",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 4,
+              finishReason: "tool-calls",
+            },
+          },
+          {
+            type: "step.started",
+            data: { turnId: "turn_1", stepIndex: 1, sequence: 5 },
+          },
+          {
+            type: "message.appended",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 1,
+              sequence: 6,
+              messageDelta: "Sec",
+              messageSoFar: "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;
+        expect(content).toEqual([
+          expect.objectContaining({
+            type: "text",
+            text: "First",
+            status: { type: "complete" },
+          }),
+          expect.objectContaining({ type: "text", text: "Sec" }),
+        ]);
+        expect(content?.[1]).not.toHaveProperty("status");
+      });
+
       it("a locally aborted turn keeps its streaming marker and converts to cancelled", () => {
         const state = replay(midStreamEvents);
 
@@ -1165,6 +1443,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents,
           {
             type: "session.failed",
+            meta: eventMeta(3),
             data: { sessionId: "session_1", code: "internal", message: "boom" },
           },
         ]);
@@ -1188,6 +1467,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents,
           {
             type: "turn.failed",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               sequence: 3,
@@ -1209,6 +1489,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents,
           {
             type: "message.completed",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1219,18 +1500,32 @@ describe("convertEveMessages", () => {
           },
           {
             type: "turn.completed",
+            meta: eventMeta(4),
             data: { turnId: "turn_1", sequence: 4 },
           },
         ]);
 
         const assistant = state.messages.find((m) => m.role === "assistant");
         expect(assistant?.metadata?.status).toBe("complete");
+        expect(assistant?.parts).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({ type: "text", state: "done" }),
+          ]),
+        );
 
         const converted = convertEveMessages(state, { isRunning: false });
         expect(converted.at(-1)?.status).toEqual({
           type: "complete",
           reason: "stop",
         });
+        expect(converted.at(-1)?.content).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              type: "text",
+              status: { type: "complete" },
+            }),
+          ]),
+        );
       });
     });
   });
@@ -1428,7 +1723,7 @@ describe("toEveInputResponse", () => {
       }),
     ).toEqual({
       requestId: "req_1",
-      optionId: "deny",
+      optionId: "cancel",
       text: "Not yet",
     });
   });

package/src/convertEveMessages.ts

@@ -5,6 +5,7 @@ import {
   type CompleteAttachment,
   type DataMessagePart,
   type FileMessagePart,
+  type MessagePartStreamStatus,
   type MessageStatus,
   type RespondToToolApprovalOptions,
   type ThreadAssistantMessagePart,
@@ -24,7 +25,7 @@ import type {
   EveMessageInputRequest,
   EveMessagePart,
 } from "eve/react";
-import type { InputResponse, SendTurnPayload } from "eve/client";
+import type { InputResponse } from "eve/client";
 
 const ASSISTANT_COMPLETE_STATUS = {
   type: "complete",
@@ -148,7 +149,7 @@ const toolApprovalOptionsFromInputRequest = (
     kind:
       option.id === "approve"
         ? "allow-once"
-        : option.id === "deny"
+        : option.id === "cancel"
           ? "reject-once"
           : `_${option.id}`,
     ...(option.label && { label: option.label }),
@@ -287,13 +288,31 @@ const convertFilePart = (
   };
 };
 
+// Eve's `state` is a run marker: the reducer settles a part to "done" only on
+// `reasoning.completed`, `message.completed`, or `turn.cancelled`.
+// `emitStreamContent` does not flush leftover reasoning on a tool-call, so a
+// non-last reasoning part stays `streaming` until the model stream ends and the
+// leftover flush runs. Mapping `streaming` to running would pin that block
+// open. Only `done` is trustworthy; an unsettled part falls back to core's
+// last-part rule.
+const partStateToStatus = (
+  state: "done" | "streaming" | undefined,
+): MessagePartStreamStatus | undefined =>
+  state === "done" ? { type: "complete" } : undefined;
+
 const convertAssistantPart = (
   part: EveMessagePart,
 ): ThreadAssistantMessagePart | null => {
   switch (part.type) {
     case "text":
-    case "reasoning":
-      return { type: part.type, text: part.text };
+    case "reasoning": {
+      const status = partStateToStatus(part.state);
+      return {
+        type: part.type,
+        text: part.text,
+        ...(status && { status }),
+      };
+    }
 
     case "step-start":
       return null;
@@ -418,13 +437,30 @@ export const convertEveMessages = (
     convertEveMessage(message, index, messages, options),
   );
 
+/**
+ * Structural subset of the `string | UserContent` message content Eve's `send`
+ * API accepts. The helpers declare the shapes they produce and leave
+ * assignability to the send call site, checked against the installed version.
+ */
+export type EveMessageContent =
+  | string
+  | (
+      | { readonly type: "text"; readonly text: string }
+      | {
+          readonly type: "file";
+          readonly data: string;
+          readonly mediaType: string;
+          readonly filename?: string;
+        }
+    )[];
+
 /**
  * Converts an assistant-ui append message into the message payload accepted by
  * Eve's `send` API.
  */
 export const getEveMessageContent = (
   message: AppendMessage,
-): NonNullable<SendTurnPayload["message"]> => {
+): EveMessageContent => {
   const content = [
     ...message.content,
     ...(message.attachments?.flatMap((attachment) => attachment.content) ?? []),
@@ -496,6 +532,6 @@ export const toEveInputResponse = (
   response: RespondToToolApprovalOptions,
 ): InputResponse => ({
   requestId: response.approvalId,
-  optionId: response.optionId ?? (response.approved ? "approve" : "deny"),
+  optionId: response.optionId ?? (response.approved ? "approve" : "cancel"),
   ...(response.reason && { text: response.reason }),
 });

package/src/eveExtras.ts

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

package/src/hooks.test.tsx

@@ -0,0 +1,84 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { extrasRef } = vi.hoisted(() => ({
+  extrasRef: { current: undefined as unknown },
+}));
+
+vi.mock("@assistant-ui/store", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@assistant-ui/store")>()),
+  useAui: (() => ({
+    thread: { getState: () => ({ extras: extrasRef.current }) },
+  })) as unknown as typeof import("@assistant-ui/store").useAui,
+  useAuiState: ((selector: (s: unknown) => unknown) =>
+    selector({
+      thread: { extras: extrasRef.current },
+    })) as typeof import("@assistant-ui/store").useAuiState,
+}));
+
+import { eveExtras, type EveRuntimeExtras } from "./eveExtras";
+import { useEveError, useEveEvents, useEveReset, useEveSession } from "./hooks";
+
+const provideExtras = (over: Partial<EveRuntimeExtras>) =>
+  eveExtras.provide({
+    error: undefined,
+    events: [],
+    session: {} as EveRuntimeExtras["session"],
+    reset: () => {},
+    ...over,
+  });
+
+afterEach(() => {
+  extrasRef.current = undefined;
+});
+
+describe("Eve accessor hooks", () => {
+  it("reads the session error from the runtime extras", () => {
+    const error = new Error("boom");
+    extrasRef.current = provideExtras({ error });
+
+    expect(renderHook(() => useEveError()).result.current).toBe(error);
+  });
+
+  it("reads the session cursor from the runtime extras", () => {
+    const session = {
+      sessionId: "s1",
+    } as unknown as EveRuntimeExtras["session"];
+    extrasRef.current = provideExtras({ session });
+
+    expect(renderHook(() => useEveSession()).result.current).toBe(session);
+  });
+
+  it("reads the server event stream from the runtime extras", () => {
+    const events = [
+      { type: "session.started" },
+    ] as unknown as EveRuntimeExtras["events"];
+    extrasRef.current = provideExtras({ events });
+
+    expect(renderHook(() => useEveEvents()).result.current).toBe(events);
+  });
+
+  it("reads reset from the runtime extras", () => {
+    const reset = vi.fn();
+    extrasRef.current = provideExtras({ reset });
+
+    renderHook(() => useEveReset()).result.current();
+
+    expect(reset).toHaveBeenCalledTimes(1);
+  });
+
+  it("supplies fallbacks outside an Eve runtime, and defers the reset throw to invocation", () => {
+    expect(renderHook(() => useEveError()).result.current).toBeUndefined();
+    expect(renderHook(() => useEveSession()).result.current).toBeUndefined();
+
+    const events = renderHook(() => useEveEvents()).result.current;
+    expect(events).toEqual([]);
+    expect(renderHook(() => useEveEvents()).result.current).toBe(events);
+    expect(Object.isFrozen(events)).toBe(true);
+
+    const reset = renderHook(() => useEveReset()).result.current;
+    expect(() => reset()).toThrow("useEveAgentRuntime");
+  });
+});

package/src/hooks.ts

@@ -0,0 +1,36 @@
+"use client";
+
+import { useAui } from "@assistant-ui/store";
+import { eveExtras } from "./eveExtras";
+import type { EveRuntimeExtras } from "./eveExtras";
+
+const EMPTY_EVENTS: EveRuntimeExtras["events"] = Object.freeze([]);
+
+/** Read the last Eve session error from the runtime extras. */
+export const useEveError = () => eveExtras.use((e) => e.error, undefined);
+
+/**
+ * Read the current Eve session cursor from the runtime extras. Persist it to
+ * resume the session later via `initialSession`. `undefined` when no session
+ * exists yet or outside an Eve runtime.
+ */
+export const useEveSession = (): EveRuntimeExtras["session"] | undefined =>
+  eveExtras.use((e) => e.session, undefined);
+
+/**
+ * Read the authoritative Eve server event stream from the runtime extras.
+ * Defaults to an empty array outside an Eve runtime.
+ */
+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
+ * outside an Eve runtime; invoking the returned function there throws.
+ */
+export const useEveReset = () => {
+  const aui = useAui();
+  return () => eveExtras.get(aui).reset();
+};

package/src/index.ts

@@ -9,6 +9,9 @@ export {
 export type {
   ConvertEveMessagesOptions,
   EveAuthorizationData,
+  EveMessageContent,
 } from "./convertEveMessages";
 export { useEveAgentRuntime } from "./useEveAgentRuntime";
 export type { UseEveAgentRuntimeOptions } from "./useEveAgentRuntime";
+export { useEveError, useEveEvents, useEveReset, useEveSession } from "./hooks";
+export type { EveRuntimeExtras } from "./eveExtras";