@assistant-ui/eve 0.0.6 → 0.0.8

package/src/convertEveMessages.ts

@@ -1,6 +1,10 @@
 import {
   fromThreadMessageLike,
+  toAssistantError,
   type AppendMessage,
+  type CompleteAttachment,
+  type DataMessagePart,
+  type FileMessagePart,
   type MessageStatus,
   type RespondToToolApprovalOptions,
   type ThreadAssistantMessagePart,
@@ -10,7 +14,10 @@ import {
   type ToolApprovalOption,
   type ToolCallMessagePart,
 } from "@assistant-ui/core";
+import { httpUrlPattern, parseDataUrl } from "@assistant-ui/core/internal";
 import type {
+  EveAuthorizationOutcome,
+  EveAuthorizationPart,
   EveDynamicToolPart,
   EveMessage,
   EveMessageData,
@@ -28,6 +35,11 @@ const ASSISTANT_RUNNING_STATUS = {
   type: "running",
 } satisfies MessageStatus;
 
+const ASSISTANT_CANCELLED_STATUS = {
+  type: "incomplete",
+  reason: "cancelled",
+} satisfies MessageStatus;
+
 const USER_FALLBACK_STATUS = {
   type: "complete",
   reason: "unknown",
@@ -36,9 +48,15 @@ const USER_FALLBACK_STATUS = {
 export type ConvertEveMessagesOptions = {
   /**
    * Marks the last assistant message as running while Eve is submitting or
-   * streaming.
+   * streaming. When omitted, a message carrying Eve's `"streaming"` marker is
+   * treated as running; pass `false` to settle interrupted messages to a
+   * terminal status.
    */
   readonly isRunning?: boolean | undefined;
+  /**
+   * The Eve session error, mapped onto the assistant message it interrupted.
+   */
+  readonly error?: unknown;
   readonly getCreatedAt?: ((message: EveMessage) => Date) | undefined;
 };
 
@@ -67,26 +85,55 @@ const toMessageStatus = (
 ): MessageStatus => {
   if (message.role !== "assistant") return USER_FALLBACK_STATUS;
 
+  const isLast = index === messages.length - 1;
   const hasPendingApproval = message.parts.some(
     (part) =>
       part.type === "dynamic-tool" && part.state === "approval-requested",
   );
+  // Scoped to the stale-marker case so a terminalized or errored turn keeps its
+  // own status; the hold only claims the fall-through that reads as cancelled.
+  const hasPendingAuthorization =
+    message.metadata?.status === "streaming" &&
+    (!isLast || options.error === undefined) &&
+    message.parts.some(
+      (part) => part.type === "authorization" && part.state === "required",
+    );
 
   if (hasPendingApproval) {
     return { type: "requires-action", reason: "tool-calls" };
   }
 
+  // A connector authorization is answered outside the thread, so the turn is
+  // held on external input rather than on a tool call awaiting a result.
+  if (hasPendingAuthorization) {
+    return { type: "requires-action", reason: "interrupt" };
+  }
+
   if (message.metadata?.status === "failed") {
     return { type: "incomplete", reason: "error" };
   }
 
-  if (
-    message.metadata?.status === "streaming" ||
-    (options.isRunning === true && index === messages.length - 1)
-  ) {
+  if (isLast && options.isRunning === true) {
     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.
+  if (message.metadata?.status === "streaming") {
+    if (options.isRunning === undefined) {
+      return ASSISTANT_RUNNING_STATUS;
+    }
+    if (isLast && options.error !== undefined) {
+      return {
+        type: "incomplete",
+        reason: "error",
+        error: toAssistantError(options.error),
+      };
+    }
+    return ASSISTANT_CANCELLED_STATUS;
+  }
+
   return ASSISTANT_COMPLETE_STATUS;
 };
 
@@ -175,6 +222,71 @@ const convertDynamicToolPart = (
   }
 };
 
+/**
+ * Payload of the `authorization` data part the Eve runtime emits for a
+ * connector authorization challenge. `state` discriminates a pending challenge
+ * from a settled one; every other field is present only when Eve projected it.
+ * This converter drops a `url` whose scheme is not `http(s)`, so a renderer can
+ * link to it without checking the scheme itself; Eve itself passes through
+ * whatever the connector supplied. Eve's
+ * `turnId` and `stepIndex` part identity is omitted: a renderer receives the
+ * one part it renders, in Eve's own step order, so display never has to
+ * re-identify a challenge among several.
+ */
+export type EveAuthorizationData = {
+  readonly state: EveAuthorizationPart["state"];
+  readonly name: string;
+  readonly displayName?: string;
+  readonly description?: string;
+  readonly url?: string;
+  readonly userCode?: string;
+  readonly instructions?: string;
+  readonly expiresAt?: string;
+  readonly outcome?: EveAuthorizationOutcome;
+  readonly reason?: string;
+};
+
+const convertAuthorizationPart = (
+  part: EveAuthorizationPart,
+): DataMessagePart<EveAuthorizationData> => ({
+  type: "data",
+  name: "authorization",
+  data: {
+    state: part.state,
+    name: part.name,
+    ...(part.displayName !== undefined && { displayName: part.displayName }),
+    ...(part.description !== undefined && { description: part.description }),
+    ...(part.authorization?.url !== undefined &&
+      httpUrlPattern.test(part.authorization.url) && {
+        url: part.authorization.url,
+      }),
+    ...(part.authorization?.userCode !== undefined && {
+      userCode: part.authorization.userCode,
+    }),
+    ...(part.authorization?.instructions !== undefined && {
+      instructions: part.authorization.instructions,
+    }),
+    ...(part.authorization?.expiresAt !== undefined && {
+      expiresAt: part.authorization.expiresAt,
+    }),
+    ...(part.outcome !== undefined && { outcome: part.outcome }),
+    ...(part.reason !== undefined && { reason: part.reason }),
+  },
+});
+
+const convertFilePart = (
+  part: Extract<EveMessagePart, { type: "file" }>,
+): FileMessagePart | null => {
+  if (part.url === undefined) return null;
+  return {
+    type: "file",
+    data: part.url,
+    mimeType: part.mediaType ?? "unknown/unknown",
+    ...(part.filename && { filename: part.filename }),
+    ...(httpUrlPattern.test(part.url) && { sourceType: "url" as const }),
+  };
+};
+
 const convertAssistantPart = (
   part: EveMessagePart,
 ): ThreadAssistantMessagePart | null => {
@@ -189,6 +301,12 @@ const convertAssistantPart = (
     case "dynamic-tool":
       return convertDynamicToolPart(part);
 
+    case "authorization":
+      return convertAuthorizationPart(part);
+
+    case "file":
+      return convertFilePart(part);
+
     default:
       return null;
   }
@@ -201,6 +319,9 @@ const convertUserPart = (
     case "text":
       return { type: "text", text: part.text };
 
+    case "file":
+      return convertFilePart(part);
+
     default:
       return null;
   }
@@ -213,6 +334,35 @@ const toUserContent = (
   return content.length > 0 ? content : [{ type: "text", text: "" }];
 };
 
+const toUserAttachments = (
+  parts: readonly EveMessagePart[],
+): CompleteAttachment[] => {
+  const attachments: CompleteAttachment[] = [];
+  for (const part of parts) {
+    if (part.type !== "file") continue;
+    const file = convertFilePart(part);
+    if (file === null) continue;
+    const isImage = file.mimeType.startsWith("image/");
+    attachments.push({
+      id: String(attachments.length),
+      type: isImage ? "image" : "file",
+      name: part.filename ?? "file",
+      content: [
+        isImage
+          ? {
+              type: "image",
+              image: file.data,
+              ...(part.filename && { filename: part.filename }),
+            }
+          : file,
+      ],
+      contentType: file.mimeType,
+      status: { type: "complete" },
+    });
+  }
+  return attachments;
+};
+
 /**
  * Converts a single Eve message into an assistant-ui thread message.
  */
@@ -237,7 +387,7 @@ export const convertEveMessage = (
           id: message.id,
           createdAt,
           content: toUserContent(message.parts),
-          attachments: [],
+          attachments: toUserAttachments(message.parts),
           metadata,
         }
       : {
@@ -280,7 +430,7 @@ export const getEveMessageContent = (
     ...(message.attachments?.flatMap((attachment) => attachment.content) ?? []),
   ];
 
-  const parts = content.map((part) => {
+  const parts = content.flatMap((part) => {
     const type = part.type;
     switch (type) {
       case "text":
@@ -302,10 +452,25 @@ export const getEveMessageContent = (
           ...(part.filename && { filename: part.filename }),
         };
 
+      case "audio": {
+        // A data URL's own media type wins over `mediaType` downstream, so the
+        // envelope is rebuilt from the typed format rather than forwarded.
+        const mediaType = `audio/${part.audio.format}`;
+        const data = part.audio.data;
+        return {
+          type: "file" as const,
+          data: httpUrlPattern.test(data)
+            ? data
+            : `data:${mediaType};base64,${parseDataUrl(data)?.data ?? data}`,
+          mediaType,
+        };
+      }
+
+      case "data":
+        return [];
+
       default: {
         const _exhaustiveCheck:
-          | "audio"
-          | "data"
           | "generative-ui"
           | "reasoning"
           | "source"

package/src/index.ts

@@ -4,7 +4,11 @@ export {
   convertEveMessage,
   convertEveMessages,
   getEveMessageContent,
+  toEveInputResponse,
+} from "./convertEveMessages";
+export type {
+  ConvertEveMessagesOptions,
+  EveAuthorizationData,
 } from "./convertEveMessages";
-export type { ConvertEveMessagesOptions } from "./convertEveMessages";
 export { useEveAgentRuntime } from "./useEveAgentRuntime";
 export type { UseEveAgentRuntimeOptions } from "./useEveAgentRuntime";

package/src/useEveAgentRuntime.test.tsx

@@ -0,0 +1,408 @@
+// @vitest-environment jsdom
+
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+const { mockUseEveAgent } = vi.hoisted(() => ({
+  mockUseEveAgent: vi.fn(),
+}));
+
+vi.mock("eve/react", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("eve/react")>()),
+  useEveAgent: mockUseEveAgent,
+}));
+
+import type { EveMessageData } from "eve/react";
+import { useEveAgentRuntime } from "./useEveAgentRuntime";
+
+const stuckStreamingData: EveMessageData = {
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      metadata: { status: "streaming" },
+      parts: [{ type: "text", text: "Let me th" }],
+    },
+  ],
+};
+
+const createAgent = (overrides: Record<string, unknown>) => ({
+  data: stuckStreamingData,
+  error: undefined,
+  events: [],
+  session: undefined,
+  status: "ready",
+  send: vi.fn(),
+  stop: vi.fn(),
+  reset: vi.fn(),
+  ...overrides,
+});
+
+describe("useEveAgentRuntime status forwarding", () => {
+  it("maps the session error onto the interrupted assistant message", () => {
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ status: "error", error: new Error("boom") }) as never,
+    );
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+      type: "incomplete",
+      reason: "error",
+      error: { code: "unknown", message: "boom" },
+    });
+  });
+
+  it("settles an aborted turn to cancelled once the agent is idle", () => {
+    mockUseEveAgent.mockReturnValue(createAgent({ status: "ready" }) as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+      type: "incomplete",
+      reason: "cancelled",
+    });
+  });
+
+  it("recomputes statuses when only the session error changes", () => {
+    const idle = createAgent({ status: "ready" });
+    mockUseEveAgent.mockReturnValue(idle as never);
+
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+      type: "incomplete",
+      reason: "cancelled",
+    });
+
+    mockUseEveAgent.mockReturnValue({
+      ...idle,
+      status: "error",
+      error: new Error("boom"),
+    } as never);
+    rerender();
+
+    expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+      type: "incomplete",
+      reason: "error",
+      error: { code: "unknown", message: "boom" },
+    });
+  });
+
+  it("keeps the last assistant message running while streaming", () => {
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ status: "streaming" }) as never,
+    );
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    expect(result.current.thread.getState().messages.at(-1)?.status).toEqual({
+      type: "running",
+    });
+  });
+});
+
+const settledData: EveMessageData = {
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "earlier" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [{ type: "text", text: "earlier answer" }],
+    },
+  ],
+};
+
+const getText = (runtime: ReturnType<typeof useEveAgentRuntime>) =>
+  runtime.thread
+    .getState()
+    .messages.map((message) =>
+      message.content
+        .flatMap((part) => (part.type === "text" ? [part.text] : []))
+        .join(""),
+    );
+
+const stageMessage = async (
+  runtime: ReturnType<typeof useEveAgentRuntime>,
+  text: string,
+) => {
+  await act(async () => {
+    runtime.thread.append({
+      role: "user",
+      content: [{ type: "text", text }],
+      startRun: false,
+    });
+  });
+};
+
+describe("useEveAgentRuntime staged messages", () => {
+  it("stages a user message without submitting when startRun is false", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "staged draft");
+
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "staged draft",
+      ]);
+    });
+    expect(agent.send).not.toHaveBeenCalled();
+  });
+
+  it("renders new turns and refloats staged drafts after a normal send", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "staged draft");
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      });
+    });
+    expect(agent.send).toHaveBeenCalledWith({
+      message: "hello",
+    });
+
+    mockUseEveAgent.mockReturnValue(
+      createAgent({
+        data: {
+          messages: [
+            ...settledData.messages,
+            {
+              id: "u2",
+              role: "user",
+              parts: [{ type: "text", text: "hello" }],
+            },
+            {
+              id: "a2",
+              role: "assistant",
+              parts: [{ type: "text", text: "hi there" }],
+            },
+          ],
+        },
+        send: agent.send,
+      }) as never,
+    );
+    rerender();
+
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "hello",
+        "hi there",
+        "staged draft",
+      ]);
+    });
+  });
+
+  it("keeps both drafts when two appends stage in the same batch", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first staged" }],
+        startRun: false,
+      });
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "second staged" }],
+        startRun: false,
+      });
+    });
+
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "first staged",
+        "second staged",
+      ]);
+    });
+    expect(agent.send).not.toHaveBeenCalled();
+  });
+
+  it("restores staged drafts when a promoted send rejects and promotes them all on retry", async () => {
+    const send = vi
+      .fn()
+      .mockRejectedValueOnce(
+        new Error("eve session is already processing a turn."),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "first staged");
+    await stageMessage(result.current, "second staged");
+
+    const secondStagedId = result.current.thread.getState().messages[3]!.id;
+    await expect(
+      Promise.resolve(
+        result.current.thread.startRun({
+          parentId: secondStagedId,
+          sourceId: null,
+          runConfig: {},
+        }),
+      ),
+    ).rejects.toThrow("eve session is already processing a turn.");
+
+    expect(send).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "first staged",
+        "second staged",
+      ]);
+    });
+
+    await act(async () => {
+      await result.current.thread.startRun({
+        parentId: secondStagedId,
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+
+    expect(send).toHaveBeenCalledTimes(3);
+    expect(send).toHaveBeenNthCalledWith(2, { message: "first staged" });
+    expect(send).toHaveBeenNthCalledWith(3, { message: "second staged" });
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
+    });
+  });
+
+  it("keeps later staged messages visible after promoting one staged parent", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "first staged");
+    await stageMessage(result.current, "second staged");
+
+    const firstStagedId = result.current.thread.getState().messages[2]!.id;
+    await act(async () => {
+      await result.current.thread.startRun({
+        parentId: firstStagedId,
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+
+    expect(agent.send).toHaveBeenCalledTimes(1);
+    expect(agent.send).toHaveBeenCalledWith({
+      message: "first staged",
+    });
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "second staged",
+      ]);
+    });
+  });
+
+  it("promotes the staged prefix sequentially when reloading the last staged message", async () => {
+    let resolveFirstSend!: () => void;
+    const send = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "first staged");
+    await stageMessage(result.current, "second staged");
+
+    const secondStagedId = result.current.thread.getState().messages[3]!.id;
+    act(() => {
+      void result.current.thread.startRun({
+        parentId: secondStagedId,
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+    expect(send).toHaveBeenNthCalledWith(1, {
+      message: "first staged",
+    });
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
+    expect(send).toHaveBeenNthCalledWith(2, {
+      message: "second staged",
+    });
+
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
+    });
+
+    await expect(
+      Promise.resolve(
+        result.current.thread.startRun({
+          parentId: secondStagedId,
+          sourceId: null,
+          runConfig: {},
+        }),
+      ),
+    ).rejects.toThrow("Runtime does not support reloading messages.");
+    expect(send).toHaveBeenCalledTimes(2);
+  });
+
+  it("keeps staged drafts when the session collapses to empty", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "staged draft");
+
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ data: { messages: [] }, send: agent.send }) as never,
+    );
+    rerender();
+
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual(["staged draft"]);
+    });
+  });
+
+  it("still rejects reloading a non-staged message", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await stageMessage(result.current, "staged draft");
+
+    await expect(
+      Promise.resolve(
+        result.current.thread.startRun({
+          parentId: "a1",
+          sourceId: null,
+          runConfig: {},
+        }),
+      ),
+    ).rejects.toThrow("Runtime does not support reloading messages.");
+    expect(agent.send).not.toHaveBeenCalled();
+  });
+});