@assistant-ui/eve 0.0.14 → 0.0.15

package/src/convertEveMessages.test.ts

@@ -1,13 +1,38 @@
 import { describe, expect, it } from "vitest";
-import type { EveMessageData } from "eve/react";
+import type { EveMessageData, EveMessageInputRequest } from "eve/react";
 import { defaultMessageReducer, type EveAgentReducerEvent } from "eve/client";
 import {
   convertEveMessages,
+  findEveInputRequest,
   getEveMessageContent,
   toEveInputResponse,
 } from "./convertEveMessages";
 import type { AppendMessage } from "@assistant-ui/core";
 
+const withApprovalPart = (eve?: {
+  kind: "tool-call";
+  name: string;
+  inputRequest?: EveMessageInputRequest;
+}): EveMessageData => ({
+  messages: [
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [
+        {
+          type: "dynamic-tool",
+          state: "approval-requested",
+          toolCallId: "call_1",
+          toolName: "send_email",
+          input: {},
+          approval: { id: "req_1" },
+          ...(eve && { toolMetadata: { eve } }),
+        },
+      ],
+    },
+  ],
+});
+
 const eventMeta = (sequence: number) => ({
   at: "2026-01-01T00:00:00.000Z",
   id: `evt_${sequence}`,
@@ -182,6 +207,62 @@ describe("convertEveMessages", () => {
     });
   });
 
+  it.each([
+    [
+      "the full input request",
+      {
+        requestId: "req_1",
+        prompt: "Which environment?",
+        kind: "question",
+        display: "select",
+        allowFreeform: true,
+        options: [
+          { id: "staging", label: "Staging", description: "Safe" },
+          { id: "production", label: "Production", style: "danger" },
+        ],
+      },
+    ],
+    [
+      "only the fields the request defines",
+      {
+        requestId: "req_1",
+        prompt: "What should the subject line be?",
+        kind: "question",
+      },
+    ],
+  ] satisfies [string, EveMessageInputRequest][])(
+    "projects %s onto providerMetadata.eve",
+    (_label, inputRequest) => {
+      const [message] = convertEveMessages(
+        withApprovalPart({
+          kind: "tool-call",
+          name: "send_email",
+          inputRequest,
+        }),
+      );
+      const part = message!.content[0];
+
+      expect(part).toMatchObject({ type: "tool-call" });
+      expect((part as { providerMetadata?: unknown }).providerMetadata).toEqual(
+        {
+          eve: { inputRequest },
+        },
+      );
+    },
+  );
+
+  it.each([
+    [
+      "eve metadata without an input request",
+      { kind: "tool-call" as const, name: "send_email" },
+    ],
+    ["no eve metadata at all", undefined],
+  ])("omits providerMetadata for a tool part with %s", (_label, eve) => {
+    const [message] = convertEveMessages(withApprovalPart(eve));
+
+    expect(message!.content[0]).not.toHaveProperty("providerMetadata");
+  });
+
   it("handles denied tool parts without an approval reason", () => {
     const data = {
       messages: [
@@ -1238,6 +1319,58 @@ describe("convertEveMessages", () => {
         ).toEqual({ type: "requires-action", reason: "interrupt" });
       });
 
+      it("projects the input request onto the approval part it gates", () => {
+        const events: readonly EveAgentReducerEvent[] = [
+          ...midStreamEvents,
+          {
+            type: "input.requested",
+            data: {
+              turnId: "turn_1",
+              stepIndex: 0,
+              sequence: 3,
+              requests: [
+                {
+                  requestId: "req_1",
+                  prompt: "What should the subject line be?",
+                  kind: "question",
+                  display: "text",
+                  action: {
+                    kind: "tool-call",
+                    callId: "call_1",
+                    toolName: "ask_question",
+                    input: {},
+                  },
+                },
+              ],
+            },
+            meta: eventMeta(3),
+          },
+        ];
+
+        // Rehydration replays the *stored* event log, which has been through
+        // the wire and back, so the reloaded case is the serialized payload
+        // rather than the same objects a second time.
+        const rehydrated = JSON.parse(
+          JSON.stringify(events),
+        ) as readonly EveAgentReducerEvent[];
+
+        for (const state of [replay(events), replay(rehydrated)]) {
+          const part = state.messages
+            .find((message) => message.role === "assistant")
+            ?.parts.find((candidate) => candidate.type === "dynamic-tool");
+
+          expect(part).toMatchObject({
+            state: "approval-requested",
+            approval: { id: "req_1" },
+          });
+          expect(findEveInputRequest(state, "req_1")).toMatchObject({
+            requestId: "req_1",
+            prompt: "What should the subject line be?",
+            display: "text",
+          });
+        }
+      });
+
       it("leaves a reasoning part unsettled when a tool call follows it", () => {
         const state = replay([
           ...midStreamEvents.slice(0, 3),
@@ -1713,18 +1846,282 @@ describe("getEveMessageContent", () => {
   });
 });
 
+const approveCancel = [
+  { id: "approve", label: "Approve" },
+  { id: "cancel", label: "Cancel" },
+];
+const environments = [
+  { id: "staging", label: "Staging" },
+  { id: "production", label: "Production" },
+];
+
+const withInputRequest = (
+  overrides: Partial<EveMessageInputRequest> = {},
+): EveMessageInputRequest => ({
+  requestId: "req_1",
+  prompt: "Send the email?",
+  kind: "question",
+  ...overrides,
+});
+
 describe("toEveInputResponse", () => {
   it("maps assistant-ui approval responses to eve input responses", () => {
+    expect(
+      toEveInputResponse(
+        {
+          approvalId: "req_1",
+          approved: false,
+          reason: "Not yet",
+        },
+        withInputRequest({ display: "confirmation", options: approveCancel }),
+      ),
+    ).toEqual({
+      requestId: "req_1",
+      optionId: "cancel",
+      text: "Not yet",
+    });
+  });
+
+  it("keeps the shipped one-argument mapping when no request is available", () => {
+    expect(toEveInputResponse({ approvalId: "req_1", approved: true })).toEqual(
+      {
+        requestId: "req_1",
+        optionId: "approve",
+      },
+    );
+
     expect(
       toEveInputResponse({
         approvalId: "req_1",
         approved: false,
         reason: "Not yet",
       }),
+    ).toEqual({ requestId: "req_1", optionId: "cancel", text: "Not yet" });
+
+    expect(
+      toEveInputResponse({
+        approvalId: "req_1",
+        approved: true,
+        optionId: "staging",
+      }),
+    ).toEqual({ requestId: "req_1", optionId: "staging" });
+  });
+
+  it("keeps the confirmation mapping when the request carries approve/cancel options", () => {
+    expect(
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true },
+        withInputRequest({ display: "confirmation", options: approveCancel }),
+      ),
+    ).toEqual({ requestId: "req_1", optionId: "approve" });
+  });
+
+  it("maps a select response to the chosen option id", () => {
+    expect(
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true, optionId: "staging" },
+        withInputRequest({ display: "select", options: environments }),
+      ),
+    ).toEqual({ requestId: "req_1", optionId: "staging" });
+  });
+
+  it.each([
+    ["a text display", { display: "text", allowFreeform: true }],
+    ["allowFreeform and no options", { allowFreeform: true }],
+    ["neither a display nor allowFreeform", {}],
+    [
+      "a select display that allows freeform",
+      { display: "select", allowFreeform: true, options: environments },
+    ],
+  ] satisfies [string, Partial<EveMessageInputRequest>][])(
+    "answers a request with %s as free-form text, not a fabricated option id",
+    (_label, overrides) => {
+      const response = toEveInputResponse(
+        { approvalId: "req_1", approved: true, reason: "Quarterly results" },
+        withInputRequest(overrides),
+      );
+
+      expect(response).toEqual({
+        requestId: "req_1",
+        text: "Quarterly results",
+      });
+      expect(response).not.toHaveProperty("optionId");
+    },
+  );
+
+  it("keeps a denial off the free-form path, which carries no answer", () => {
+    expect(() =>
+      toEveInputResponse(
+        { approvalId: "req_1", approved: false, reason: "not this one" },
+        withInputRequest(),
+      ),
+    ).toThrow(/a refusal carries no answer for a free-form request/);
+  });
+
+  it("never fabricates approve for a text-display request without an answer", () => {
+    expect(() =>
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true },
+        withInputRequest({ display: "text" }),
+      ),
+    ).toThrow(/pass the answer as the response reason/);
+  });
+
+  it("never fabricates approve for a select request without a chosen option", () => {
+    expect(() =>
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true },
+        withInputRequest({ display: "select", options: environments }),
+      ),
+    ).toThrow(/respond with one of: staging, production/);
+  });
+
+  it("throws when the response names an option the request does not carry", () => {
+    expect(() =>
+      toEveInputResponse(
+        { approvalId: "req_1", approved: false, optionId: "sandbox" },
+        withInputRequest({ display: "select", options: environments }),
+      ),
+    ).toThrow(/no option with id "sandbox".*staging, production/s);
+
+    // A named option the request does not carry outranks the decision, even
+    // when the decision names an option the request does carry: substituting
+    // the literal deny here would discard the choice the caller made.
+    expect(() =>
+      toEveInputResponse(
+        { approvalId: "req_1", approved: false, optionId: "schedule-later" },
+        withInputRequest({ display: "confirmation", options: approveCancel }),
+      ),
+    ).toThrow(/no option with id "schedule-later"/);
+  });
+
+  it("prefers a literal approve option over the free-form path on a text-display request", () => {
+    const inputRequest = withInputRequest({
+      display: "text",
+      options: approveCancel,
+    });
+
+    expect(
+      toEveInputResponse({ approvalId: "req_1", approved: true }, inputRequest),
+    ).toEqual({ requestId: "req_1", optionId: "approve" });
+
+    expect(
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true, reason: "Quarterly results" },
+        inputRequest,
+      ),
     ).toEqual({
       requestId: "req_1",
-      optionId: "cancel",
-      text: "Not yet",
+      optionId: "approve",
+      text: "Quarterly results",
+    });
+  });
+
+  it("answers a tool-approval by kind even when its options are missing", () => {
+    const inputRequest = withInputRequest({
+      kind: "tool-approval",
+      display: "confirmation",
+    });
+
+    expect(
+      toEveInputResponse({ approvalId: "req_1", approved: true }, inputRequest),
+    ).toEqual({ requestId: "req_1", optionId: "approve" });
+
+    expect(
+      toEveInputResponse(
+        { approvalId: "req_1", approved: false, reason: "not now" },
+        inputRequest,
+      ),
+    ).toEqual({ requestId: "req_1", optionId: "cancel", text: "not now" });
+  });
+
+  it("still requires a declared option when a tool-approval carries its own", () => {
+    const inputRequest = withInputRequest({
+      kind: "tool-approval",
+      display: "confirmation",
+      options: [{ id: "schedule-later", label: "Schedule later" }],
+    });
+
+    expect(() =>
+      toEveInputResponse({ approvalId: "req_1", approved: true }, inputRequest),
+    ).toThrow(/respond with one of: schedule-later/);
+
+    expect(
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true, optionId: "schedule-later" },
+        inputRequest,
+      ),
+    ).toEqual({ requestId: "req_1", optionId: "schedule-later" });
+  });
+
+  it("never answers an optionless confirmation as free-form text", () => {
+    const inputRequest = withInputRequest({ display: "confirmation" });
+
+    for (const response of [
+      { approvalId: "req_1", approved: true },
+      { approvalId: "req_1", approved: false, reason: "not now" },
+      { approvalId: "req_1", approved: true, reason: "go ahead" },
+    ]) {
+      expect(() => toEveInputResponse(response, inputRequest)).toThrow(
+        /declares no options to respond with/,
+      );
+    }
+  });
+});
+
+describe("findEveInputRequest", () => {
+  const data = {
+    messages: [
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            state: "approval-requested",
+            toolCallId: "call_1",
+            toolName: "ask_question",
+            input: {},
+            approval: { id: "req_1" },
+            toolMetadata: {
+              eve: {
+                kind: "tool-call",
+                name: "ask_question",
+                inputRequest: {
+                  requestId: "req_1",
+                  prompt: "What should the subject line be?",
+                  kind: "question",
+                  display: "text",
+                  allowFreeform: true,
+                },
+              },
+            },
+          },
+        ],
+      },
+    ],
+  } satisfies EveMessageData;
+
+  it("finds the input request by approval id", () => {
+    expect(findEveInputRequest(data, "req_1")).toMatchObject({
+      requestId: "req_1",
+      display: "text",
     });
   });
+
+  it("returns undefined for unknown approval ids", () => {
+    expect(findEveInputRequest(data, "req_404")).toBeUndefined();
+  });
+
+  it.each([
+    ["carries no input request", { eve: { kind: "tool-call", name: "ask" } }],
+    ["carries no eve tool metadata at all", undefined],
+  ])("returns undefined when the matching part %s", (_label, toolMetadata) => {
+    const part = { ...data.messages[0]!.parts[0]!, toolMetadata };
+    const bare = { messages: [{ ...data.messages[0]!, parts: [part] }] };
+
+    expect(
+      findEveInputRequest(bare as EveMessageData, "req_1"),
+    ).toBeUndefined();
+  });
 });

package/src/convertEveMessages.ts

@@ -7,6 +7,7 @@ import {
   type FileMessagePart,
   type MessagePartStreamStatus,
   type MessageStatus,
+  type PartProviderMetadata,
   type RespondToToolApprovalOptions,
   type ThreadAssistantMessagePart,
   type ThreadMessage,
@@ -15,7 +16,10 @@ import {
   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,
@@ -187,10 +191,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 +233,7 @@ const convertDynamicToolPart = (
     args: toJsonObject(part.input),
     argsText: stringifyArgs(part.input),
     ...(approval && { approval }),
+    ...(providerMetadata && { providerMetadata }),
   };
 
   switch (part.state) {
@@ -493,11 +529,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 +563,110 @@ 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 `reason` text 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.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 =
+    inputRequest.display !== "confirmation" &&
+    (inputRequest.display === "text" ||
+      inputRequest.allowFreeform === true ||
+      !options?.length);
+  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 reason"
+            : "pass the answer as the response reason, because the request takes a free-form answer"
+    }`,
+  );
+};