@assistant-ui/eve 0.0.14 → 0.0.16

package/src/convertEveMessages.ts

@@ -7,15 +7,20 @@ import {
   type FileMessagePart,
   type MessagePartStreamStatus,
   type MessageStatus,
+  type PartProviderMetadata,
   type RespondToToolApprovalOptions,
   type ThreadAssistantMessagePart,
   type ThreadMessage,
   type ThreadMessageLike,
   type ThreadUserMessagePart,
+  type ToolApprovalDisplay,
   type ToolApprovalOption,
   type ToolCallMessagePart,
 } from "@assistant-ui/core";
-import { httpUrlPattern, parseDataUrl } from "@assistant-ui/core/internal";
+import {
+  httpUrlPattern,
+  resolveFilePartSource,
+} from "@assistant-ui/core/internal";
 import type {
   EveAuthorizationOutcome,
   EveAuthorizationPart,
@@ -157,6 +162,44 @@ const toolApprovalOptionsFromInputRequest = (
   }));
 };
 
+/**
+ * Eve resolves a request the moment any response for it arrives, so the answer
+ * shapes it accepts decide both what the renderer may offer and what
+ * {@link toEveInputResponse} may submit. A request with no options and no
+ * `display` takes a typed answer, which is why the absence of both is not the
+ * same as a confirmation.
+ */
+const isDroppedOptionApproval = (inputRequest: EveMessageInputRequest) =>
+  inputRequest.kind === "tool-approval" && !inputRequest.options?.length;
+
+const acceptsFreeformAnswer = (inputRequest: EveMessageInputRequest): boolean =>
+  inputRequest.display !== "confirmation" &&
+  !isDroppedOptionApproval(inputRequest) &&
+  (inputRequest.display === "text" ||
+    inputRequest.allowFreeform === true ||
+    !inputRequest.options?.length);
+
+const toolApprovalDisplay = (
+  inputRequest: EveMessageInputRequest,
+): ToolApprovalDisplay => {
+  // The mapper answers this shape through its approve/cancel branch whatever
+  // the request declares, so the projection has to agree: presenting it as a
+  // question would offer an answer the mapper turns into a decision.
+  if (isDroppedOptionApproval(inputRequest)) return "decision";
+
+  switch (inputRequest.display) {
+    case "confirmation":
+      return "decision";
+    case "select":
+      return "select";
+    case "text":
+      return "text";
+    default:
+      if (inputRequest.kind === "tool-approval") return "decision";
+      return inputRequest.options?.length ? "select" : "text";
+  }
+};
+
 const toApproval = (
   part: EveDynamicToolPart,
 ): ToolCallMessagePart["approval"] | undefined => {
@@ -172,12 +215,16 @@ const toApproval = (
 
   const approval = part.approval;
   if (!approval) return undefined;
-  const options = toolApprovalOptionsFromInputRequest(
-    part.toolMetadata?.eve?.inputRequest,
-  );
+  const inputRequest = part.toolMetadata?.eve?.inputRequest;
+  const options = toolApprovalOptionsFromInputRequest(inputRequest);
 
   return {
     id: approval.id,
+    ...(inputRequest && {
+      prompt: inputRequest.prompt,
+      display: toolApprovalDisplay(inputRequest),
+      ...(acceptsFreeformAnswer(inputRequest) && { allowFreeform: true }),
+    }),
     ...(approval.approved !== undefined && { approved: approval.approved }),
     ...(approval.reason && { reason: approval.reason }),
     ...(approval.isAutomatic !== undefined && {
@@ -187,10 +234,41 @@ const toApproval = (
   };
 };
 
+const toJsonSafeInputRequest = (
+  inputRequest: EveMessageInputRequest,
+): PartProviderMetadata[string] => ({
+  requestId: inputRequest.requestId,
+  prompt: inputRequest.prompt,
+  kind: inputRequest.kind,
+  ...(inputRequest.display !== undefined && { display: inputRequest.display }),
+  ...(inputRequest.allowFreeform !== undefined && {
+    allowFreeform: inputRequest.allowFreeform,
+  }),
+  ...(inputRequest.options && {
+    options: inputRequest.options.map((option) => ({
+      id: option.id,
+      label: option.label,
+      ...(option.description !== undefined && {
+        description: option.description,
+      }),
+      ...(option.style !== undefined && { style: option.style }),
+    })),
+  }),
+});
+
+const toToolProviderMetadata = (
+  part: EveDynamicToolPart,
+): PartProviderMetadata | undefined => {
+  const inputRequest = part.toolMetadata?.eve?.inputRequest;
+  if (!inputRequest) return undefined;
+  return { eve: { inputRequest: toJsonSafeInputRequest(inputRequest) } };
+};
+
 const convertDynamicToolPart = (
   part: EveDynamicToolPart,
 ): ToolCallMessagePart => {
   const approval = toApproval(part);
+  const providerMetadata = toToolProviderMetadata(part);
   const toolCall: ToolCallMessagePart = {
     type: "tool-call",
     toolCallId: part.toolCallId,
@@ -198,6 +276,7 @@ const convertDynamicToolPart = (
     args: toJsonObject(part.input),
     argsText: stringifyArgs(part.input),
     ...(approval && { approval }),
+    ...(providerMetadata && { providerMetadata }),
   };
 
   switch (part.state) {
@@ -493,11 +572,13 @@ export const getEveMessageContent = (
         // envelope is rebuilt from the typed format rather than forwarded.
         const mediaType = `audio/${part.audio.format}`;
         const data = part.audio.data;
+        const source = resolveFilePartSource({ data, mimeType: mediaType });
         return {
           type: "file" as const,
-          data: httpUrlPattern.test(data)
-            ? data
-            : `data:${mediaType};base64,${parseDataUrl(data)?.data ?? data}`,
+          data:
+            source.kind === "url"
+              ? source.url
+              : `data:${mediaType};base64,${source.data}`,
           mediaType,
         };
       }
@@ -525,13 +606,107 @@ export const getEveMessageContent = (
   return parts;
 };
 
+/**
+ * Finds the pending input request answered by the given approval id, so the
+ * response mapping can honor the request's display mode.
+ */
+export const findEveInputRequest = (
+  data: EveMessageData,
+  approvalId: string,
+): EveMessageInputRequest | undefined => {
+  for (const message of data.messages) {
+    for (const part of message.parts) {
+      if (part.type === "dynamic-tool" && part.approval?.id === approvalId) {
+        return part.toolMetadata?.eve?.inputRequest;
+      }
+    }
+  }
+  return undefined;
+};
+
 /**
  * Converts an assistant-ui tool approval response into an Eve input response.
+ *
+ * When `inputRequest` is known, every returned response carries either an
+ * option the request declares or a free-form answer. A literal option match
+ * wins, then the `"approve"` / `"cancel"` option the response's boolean decision
+ * names, then the response's `text` (or its `reason`, for a caller that
+ * predates the first-class answer field) when the request takes a free-form
+ * answer (`display: "text"`, `allowFreeform`, or no options at all, and never
+ * `display: "confirmation"`) and the response is not a refusal.
+ * A one-argument call, or a part with no request, still forwards a caller
+ * `optionId` as it always has, including ids the request never declared.
+ *
+ * A response the known request cannot record as the answer it asked for throws
+ * instead of being submitted, because eve resolves a request the moment any
+ * response for it arrives, and an empty one is recorded as an answer with no
+ * content. Not sending leaves the request pending, so the caller can retry or
+ * the user can answer it as an ordinary message.
+ *
+ * With no request to map against — a one-argument call, or a part carrying no
+ * `toolMetadata.eve.inputRequest` — the response maps as it always has, to the
+ * literal `"approve"` / `"cancel"` option every eve approval declares. Guessing
+ * a display mode is what this mapper stopped doing; an unknown request is not
+ * a guess about one.
  */
 export const toEveInputResponse = (
   response: RespondToToolApprovalOptions,
-): InputResponse => ({
-  requestId: response.approvalId,
-  optionId: response.optionId ?? (response.approved ? "approve" : "cancel"),
-  ...(response.reason && { text: response.reason }),
-});
+  inputRequest?: EveMessageInputRequest,
+): InputResponse => {
+  const requestId = response.approvalId;
+  const options = inputRequest?.options;
+  const text = response.text ?? response.reason;
+
+  if (response.optionId !== undefined) {
+    if (
+      !inputRequest ||
+      options?.some((option) => option.id === response.optionId)
+    ) {
+      return {
+        requestId,
+        optionId: response.optionId,
+        ...(text && { text }),
+      };
+    }
+    throw new Error(
+      `Eve input request "${requestId}" has no option with id "${response.optionId}"; respond with one of: ${
+        options?.length
+          ? options.map((option) => option.id).join(", ")
+          : "(the request carries no options)"
+      }`,
+    );
+  }
+
+  const decisionOptionId = response.approved ? "approve" : "cancel";
+  // Eve's harness always declares `approve`/`cancel` on a `tool-approval`
+  // request, so honoring the kind when the options were dropped keeps a
+  // non-spec approval payload answerable rather than stuck. A tool-approval
+  // that declares its own options still requires one of them.
+  if (
+    !inputRequest ||
+    (inputRequest.kind === "tool-approval" && !options?.length) ||
+    options?.some((option) => option.id === decisionOptionId)
+  ) {
+    return { requestId, optionId: decisionOptionId, ...(text && { text }) };
+  }
+
+  // Eve recognises an approval by its literal two-option `approve`/`cancel`
+  // shape, so past this point the request is a question and the boolean
+  // carries no decision eve would act on.
+  const acceptsText = acceptsFreeformAnswer(inputRequest);
+  if (acceptsText && text && response.approved !== false) {
+    return { requestId, text };
+  }
+
+  throw new Error(
+    `Eve input request "${requestId}" (${inputRequest.prompt}) was not answered by this response; ${
+      options?.length
+        ? `respond with one of: ${options.map((option) => option.id).join(", ")}`
+        : !acceptsText
+          ? "the request declares no options to respond with"
+          : response.approved === false
+            ? "a refusal carries no answer for a free-form request; resend with `approved` unset or true and the answer in the response text"
+            : "pass the answer as the response text, because the request takes a free-form answer"
+    }`,
+  );
+};

package/src/useEveAgentRuntime.refetch.test.tsx

@@ -0,0 +1,89 @@
+// @vitest-environment jsdom
+
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { HandleMessageStreamEvent } from "eve/client";
+
+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);
+
+describe("useEveAgentRuntime against a durable eve session", () => {
+  it("surfaces a turn the server appended out of band after reloadMainThread", async () => {
+    const stream = vi.fn(async function* () {
+      yield* [...knownTurn, ...outOfBandTurn];
+    });
+    const session = {
+      state: { sessionId: "s1" },
+      stream,
+      send: () => {
+        throw new Error("the refetch test must not send");
+      },
+    } as never;
+
+    const { result } = renderHook(() =>
+      useEveAgentRuntime({ initialEvents: knownTurn as never, session }),
+    );
+    expect(
+      result.current.thread.getState().messages.map((m) => m.role),
+    ).toEqual(["user", "assistant"]);
+
+    await act(async () => {
+      await result.current.threads.reloadMainThread();
+    });
+
+    expect(stream).toHaveBeenCalled();
+    const messages = result.current.thread.getState().messages;
+    expect(messages.map((m) => m.role)).toEqual([
+      "user",
+      "assistant",
+      "user",
+      "assistant",
+    ]);
+    expect(messages[3]?.content).toMatchObject([
+      { type: "text", text: "done" },
+    ]);
+    expect(result.current.thread.getState().isRunning).toBe(false);
+  });
+});