@assistant-ui/eve 0.0.15 → 0.0.17

package/src/convertEveMessages.test.ts

@@ -207,6 +207,143 @@ describe("convertEveMessages", () => {
     });
   });
 
+  it.each([
+    [
+      "a confirmation request",
+      {
+        requestId: "req_1",
+        kind: "tool-approval",
+        prompt: "Send the email?",
+        display: "confirmation",
+        options: [
+          { id: "approve", label: "Approve" },
+          { id: "cancel", label: "Cancel" },
+        ],
+      },
+      { prompt: "Send the email?", display: "decision" },
+    ],
+    [
+      "a select question that also takes a typed answer",
+      {
+        requestId: "req_1",
+        kind: "question",
+        prompt: "Which environment?",
+        display: "select",
+        allowFreeform: true,
+        options: [{ id: "staging", label: "Staging" }],
+      },
+      {
+        prompt: "Which environment?",
+        display: "select",
+        allowFreeform: true,
+      },
+    ],
+    [
+      "a text question",
+      {
+        requestId: "req_1",
+        kind: "question",
+        prompt: "What should the subject line be?",
+        display: "text",
+      },
+      {
+        prompt: "What should the subject line be?",
+        display: "text",
+        allowFreeform: true,
+      },
+    ],
+    [
+      "a question with neither a display nor options",
+      { requestId: "req_1", kind: "question", prompt: "Anything else?" },
+      { prompt: "Anything else?", display: "text", allowFreeform: true },
+    ],
+  ] satisfies [string, EveMessageInputRequest, object][])(
+    "describes %s on the approval itself",
+    (_label, inputRequest, expected) => {
+      const [message] = convertEveMessages(
+        withApprovalPart({
+          kind: "tool-call",
+          name: "send_email",
+          inputRequest,
+        }),
+      );
+
+      expect(message!.content[0]).toMatchObject({ approval: expected });
+    },
+  );
+
+  it.each([
+    ["no display", undefined],
+    ["a text display", "text" as const],
+    ["a select display", "select" as const],
+  ])(
+    "projects a tool approval whose options were dropped as a decision, with %s",
+    (_label, display) => {
+      const [message] = convertEveMessages(
+        withApprovalPart({
+          kind: "tool-call",
+          name: "send_email",
+          inputRequest: {
+            requestId: "req_1",
+            kind: "tool-approval",
+            prompt: "Send the email?",
+            ...(display && { display }),
+          },
+        }),
+      );
+
+      expect(message!.content[0]).toMatchObject({
+        approval: { display: "decision" },
+      });
+      expect(
+        (message!.content[0] as { approval?: object }).approval,
+      ).not.toHaveProperty("allowFreeform");
+    },
+  );
+
+  it("does not offer a typed answer on a tool approval whose options were dropped", () => {
+    const [message] = convertEveMessages(
+      withApprovalPart({
+        kind: "tool-call",
+        name: "send_email",
+        inputRequest: {
+          requestId: "req_1",
+          kind: "tool-approval",
+          prompt: "Send the email?",
+        },
+      }),
+    );
+
+    // The mapper answers this shape with its approve/cancel branch before it
+    // ever reads a text answer, so the renderer must not offer one.
+    expect(
+      (message!.content[0] as { approval?: object }).approval,
+    ).not.toHaveProperty("allowFreeform");
+  });
+
+  it("does not offer a typed answer on a confirmation request", () => {
+    const [message] = convertEveMessages(
+      withApprovalPart({
+        kind: "tool-call",
+        name: "send_email",
+        inputRequest: {
+          requestId: "req_1",
+          kind: "tool-approval",
+          prompt: "Send the email?",
+          display: "confirmation",
+          options: [
+            { id: "approve", label: "Approve" },
+            { id: "cancel", label: "Cancel" },
+          ],
+        },
+      }),
+    );
+
+    expect(
+      (message!.content[0] as { approval?: object }).approval,
+    ).not.toHaveProperty("allowFreeform");
+  });
+
   it.each([
     [
       "the full input request",
@@ -1376,6 +1513,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents.slice(0, 3),
           {
             type: "reasoning.appended",
+            meta: eventMeta(2),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1386,6 +1524,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "actions.requested",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1425,6 +1564,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents.slice(0, 3),
           {
             type: "reasoning.appended",
+            meta: eventMeta(2),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1435,6 +1575,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "actions.requested",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1451,6 +1592,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "reasoning.completed",
+            meta: eventMeta(4),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1485,6 +1627,7 @@ describe("convertEveMessages", () => {
           ...midStreamEvents.slice(0, 3),
           {
             type: "message.appended",
+            meta: eventMeta(2),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1495,6 +1638,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "message.completed",
+            meta: eventMeta(3),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1505,6 +1649,7 @@ describe("convertEveMessages", () => {
           },
           {
             type: "step.completed",
+            meta: eventMeta(4),
             data: {
               turnId: "turn_1",
               stepIndex: 0,
@@ -1514,10 +1659,17 @@ describe("convertEveMessages", () => {
           },
           {
             type: "step.started",
-            data: { turnId: "turn_1", stepIndex: 1, sequence: 5 },
+            meta: eventMeta(5),
+            data: {
+              turnId: "turn_1",
+              stepIndex: 1,
+              sequence: 5,
+              modelId: "test-model",
+            },
           },
           {
             type: "message.appended",
+            meta: eventMeta(6),
             data: {
               turnId: "turn_1",
               stepIndex: 1,
@@ -1958,13 +2110,36 @@ describe("toEveInputResponse", () => {
     ).toThrow(/a refusal carries no answer for a free-form request/);
   });
 
+  it("submits the response text as the free-form answer", () => {
+    expect(
+      toEveInputResponse(
+        { approvalId: "req_1", approved: true, text: "staging" },
+        withInputRequest({ display: "text" }),
+      ),
+    ).toEqual({ requestId: "req_1", text: "staging" });
+  });
+
+  it("prefers the response text over the reason it used to be smuggled in", () => {
+    expect(
+      toEveInputResponse(
+        {
+          approvalId: "req_1",
+          approved: true,
+          text: "staging",
+          reason: "picked the safe one",
+        },
+        withInputRequest({ display: "text" }),
+      ),
+    ).toEqual({ requestId: "req_1", text: "staging" });
+  });
+
   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/);
+    ).toThrow(/pass the answer as the response text/);
   });
 
   it("never fabricates approve for a select request without a chosen option", () => {

package/src/convertEveMessages.ts

@@ -13,6 +13,7 @@ import {
   type ThreadMessage,
   type ThreadMessageLike,
   type ThreadUserMessagePart,
+  type ToolApprovalDisplay,
   type ToolApprovalOption,
   type ToolCallMessagePart,
 } from "@assistant-ui/core";
@@ -161,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 => {
@@ -176,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 && {
@@ -587,7 +630,8 @@ export const findEveInputRequest = (
  * 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
+ * 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
@@ -611,7 +655,7 @@ export const toEveInputResponse = (
 ): InputResponse => {
   const requestId = response.approvalId;
   const options = inputRequest?.options;
-  const text = response.reason;
+  const text = response.text ?? response.reason;
 
   if (response.optionId !== undefined) {
     if (
@@ -649,11 +693,7 @@ export const toEveInputResponse = (
   // 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);
+  const acceptsText = acceptsFreeformAnswer(inputRequest);
   if (acceptsText && text && response.approved !== false) {
     return { requestId, text };
   }
@@ -665,8 +705,8 @@ export const toEveInputResponse = (
         : !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"
+            ? "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/deriveCreatedAt.test.ts

@@ -0,0 +1,190 @@
+import { describe, expect, it } from "vitest";
+import type { MessageStreamEvent } from "eve/client";
+
+import {
+  collectTurnTimestamps,
+  createTurnTimestampCache,
+} from "./deriveCreatedAt";
+
+const TURN = "turn_1";
+
+const turnStarted = (at: string, turnId = TURN) =>
+  ({
+    type: "turn.started",
+    data: { sequence: 1, turnId },
+    meta: { at, id: `evt_${at}` },
+  }) as const satisfies MessageStreamEvent;
+
+const messageReceived = (at: string, turnId = TURN) =>
+  ({
+    type: "message.received",
+    data: { message: "hi", sequence: 2, turnId },
+    meta: { at, id: `evt_${at}` },
+  }) as const satisfies MessageStreamEvent;
+
+const compactionRequested = (at: string, turnId = TURN) =>
+  ({
+    type: "compaction.requested",
+    data: {
+      modelId: "m",
+      sequence: 3,
+      sessionId: "s",
+      turnId,
+      usageInputTokens: null,
+    },
+    meta: { at, id: `evt_${at}` },
+  }) as const satisfies MessageStreamEvent;
+
+const messageAppended = (at: string, turnId = TURN) =>
+  ({
+    type: "message.appended",
+    data: {
+      messageDelta: "he",
+      messageSoFar: "he",
+      sequence: 4,
+      stepIndex: 0,
+      turnId,
+    },
+    meta: { at, id: `evt_${at}` },
+  }) as const satisfies MessageStreamEvent;
+
+const stepStarted = (at: string, turnId = TURN) =>
+  ({
+    type: "step.started",
+    data: { modelId: "m", sequence: 4, stepIndex: 0, turnId },
+    meta: { at, id: `evt_${at}` },
+  }) as const satisfies MessageStreamEvent;
+
+describe("collectTurnTimestamps", () => {
+  it("stamps the user at message.received and the assistant at step.started, skipping the turn's other events", () => {
+    const timestamps = collectTurnTimestamps(
+      [
+        turnStarted("2026-01-02T10:00:00.000Z"),
+        messageReceived("2026-01-02T10:00:01.000Z"),
+        compactionRequested("2026-01-02T10:00:02.000Z"),
+        stepStarted("2026-01-02T10:02:00.000Z"),
+        stepStarted("2026-01-02T10:03:00.000Z"),
+      ],
+      createTurnTimestampCache(),
+    );
+
+    expect(timestamps.get(TURN)?.user).toEqual(
+      new Date("2026-01-02T10:00:01.000Z"),
+    );
+    expect(timestamps.get(TURN)?.assistant).toEqual(
+      new Date("2026-01-02T10:02:00.000Z"),
+    );
+    expect(timestamps.get("turn_other")?.user).toBe(undefined);
+  });
+
+  it("resumes the scan at appended events and keeps the map identity when they teach nothing", () => {
+    const cache = createTurnTimestampCache();
+    const events = [
+      turnStarted("2026-01-02T10:00:00.000Z"),
+      messageReceived("2026-01-02T10:00:01.000Z"),
+    ];
+    const first = collectTurnTimestamps(events, cache);
+    expect(first.get(TURN)?.assistant).toBe(undefined);
+
+    const quiet = [
+      ...events,
+      turnStarted("2026-01-02T10:00:02.000Z", "turn_2"),
+    ];
+    expect(collectTurnTimestamps(quiet, cache)).toBe(first);
+
+    const timestamps = collectTurnTimestamps(
+      [...quiet, stepStarted("2026-01-02T10:02:00.000Z")],
+      cache,
+    );
+    expect(timestamps.get(TURN)?.user).toEqual(
+      new Date("2026-01-02T10:00:01.000Z"),
+    );
+    expect(timestamps.get(TURN)?.assistant).toEqual(
+      new Date("2026-01-02T10:02:00.000Z"),
+    );
+  });
+
+  it("stamps an assistant created by a turn ending before its first step", () => {
+    const timestamps = collectTurnTimestamps(
+      [
+        messageReceived("2026-01-02T10:00:01.000Z"),
+        {
+          type: "turn.cancelled",
+          data: { sequence: 3, turnId: TURN },
+          meta: { at: "2026-01-02T10:00:05.000Z", id: "evt_cancel" },
+        },
+      ],
+      createTurnTimestampCache(),
+    );
+
+    expect(timestamps.get(TURN)?.assistant).toEqual(
+      new Date("2026-01-02T10:00:05.000Z"),
+    );
+  });
+
+  it("stamps the assistant from the turn's first message-creating event when no step.started precedes it", () => {
+    const timestamps = collectTurnTimestamps(
+      [
+        turnStarted("2026-01-02T10:00:00.000Z"),
+        messageReceived("2026-01-02T10:00:01.000Z"),
+        compactionRequested("2026-01-02T10:00:02.000Z"),
+        messageAppended("2026-01-02T10:02:00.000Z"),
+      ],
+      createTurnTimestampCache(),
+    );
+
+    expect(timestamps.get(TURN)?.assistant).toEqual(
+      new Date("2026-01-02T10:02:00.000Z"),
+    );
+  });
+
+  it("skips malformed events without throwing", () => {
+    const events = [
+      { type: "message.received", data: null, meta: { at: "x", id: "e1" } },
+      { type: "step.started", meta: { at: "2026-01-01T00:00:00Z", id: "e2" } },
+      {
+        type: "message.received",
+        data: { turnId: 42 },
+        meta: { at: "x", id: "e3" },
+      },
+      {
+        type: "message.received",
+        data: { message: "hi", sequence: 2, turnId: TURN },
+        meta: { at: "not a date", id: "e4" },
+      },
+      { type: "step.started", data: { stepIndex: 0, turnId: TURN } },
+      stepStarted("2026-01-02T10:02:00.000Z"),
+    ] as never as readonly MessageStreamEvent[];
+
+    const timestamps = collectTurnTimestamps(
+      events,
+      createTurnTimestampCache(),
+    );
+
+    expect(timestamps.get(TURN)?.user).toBe(undefined);
+    expect(timestamps.get(TURN)?.assistant).toEqual(
+      new Date("2026-01-02T10:02:00.000Z"),
+    );
+  });
+
+  it("re-derives from scratch when the log is replaced, so a recurring turn id serves the new session's stamps", () => {
+    const cache = createTurnTimestampCache();
+    collectTurnTimestamps(
+      [
+        messageReceived("2026-01-02T10:00:01.000Z"),
+        stepStarted("2026-01-02T10:02:00.000Z"),
+      ],
+      cache,
+    );
+
+    const timestamps = collectTurnTimestamps(
+      [messageReceived("2026-03-01T09:00:01.000Z")],
+      cache,
+    );
+
+    expect(timestamps.get(TURN)?.user).toEqual(
+      new Date("2026-03-01T09:00:01.000Z"),
+    );
+    expect(timestamps.get(TURN)?.assistant).toBe(undefined);
+  });
+});

package/src/deriveCreatedAt.ts

@@ -0,0 +1,96 @@
+import type { MessageStreamEvent } from "eve/client";
+
+export type TurnTimestamps = {
+  readonly user?: Date;
+  readonly assistant?: Date;
+};
+
+export type TurnTimestampCache = {
+  lastEvents: readonly MessageStreamEvent[];
+  timestamps: ReadonlyMap<string, TurnTimestamps>;
+};
+
+/**
+ * The reducer cases eve projects into a message: `message.received` creates
+ * `${turnId}:user`, and every assistant entry reaches `updateAssistantMessage`,
+ * which creates `${turnId}:assistant` for a turn that has none. It enumerates
+ * that reducer across the `>=0.32.0` peer range rather than stating a rule
+ * about turn ids, because `turn.started` and the compaction events carry one
+ * before the model runs. An event eve adds to the creating set later is absent
+ * here and falls back to the wall clock instead of stamping a wrong time.
+ */
+const ROLE_BY_EVENT_TYPE: Partial<
+  Record<MessageStreamEvent["type"], keyof TurnTimestamps>
+> = {
+  "message.received": "user",
+  "step.started": "assistant",
+  "reasoning.appended": "assistant",
+  "reasoning.completed": "assistant",
+  "action.input.appended": "assistant",
+  "actions.requested": "assistant",
+  "input.requested": "assistant",
+  "action.result": "assistant",
+  "action.partial": "assistant",
+  "authorization.required": "assistant",
+  "authorization.completed": "assistant",
+  "message.appended": "assistant",
+  "message.completed": "assistant",
+  "result.completed": "assistant",
+  "turn.completed": "assistant",
+  "turn.cancelled": "assistant",
+};
+
+export const createTurnTimestampCache = (): TurnTimestampCache => ({
+  lastEvents: [],
+  timestamps: new Map(),
+});
+
+/**
+ * Eve appends to its log (`[...events, event]`), so a snapshot that keeps the
+ * previous scan's last element by identity shares the whole prefix and the
+ * scan resumes there. Any other snapshot is re-derived into a fresh map: turn
+ * ids are per-session sequence numbers that recur after `reset()`, so entries
+ * must not outlive the log that produced them. Re-derivation is also what
+ * makes the render-phase cache writes safe when React discards a render.
+ */
+export const collectTurnTimestamps = (
+  events: readonly MessageStreamEvent[],
+  cache: TurnTimestampCache,
+): ReadonlyMap<string, TurnTimestamps> => {
+  if (events === cache.lastEvents) return cache.timestamps;
+
+  const scanned = cache.lastEvents;
+  const resumesScan =
+    scanned.length === 0 ||
+    events[scanned.length - 1] === scanned[scanned.length - 1];
+
+  let timestamps = cache.timestamps;
+  let draft: Map<string, TurnTimestamps> | undefined;
+  if (!resumesScan) {
+    draft = new Map();
+    timestamps = draft;
+  }
+  for (let i = resumesScan ? scanned.length : 0; i < events.length; i++) {
+    const event = events[i]!;
+    const role = ROLE_BY_EVENT_TYPE[event.type];
+    if (role === undefined) continue;
+    const data: unknown = (event as { readonly data?: unknown }).data;
+    if (typeof data !== "object" || data === null) continue;
+    const turnId = (data as { readonly turnId?: unknown }).turnId;
+    if (typeof turnId !== "string") continue;
+    const known = timestamps.get(turnId);
+    if (known?.[role] !== undefined) continue;
+    const at: unknown = (event as { readonly meta?: { readonly at?: unknown } })
+      .meta?.at;
+    if (typeof at !== "string") continue;
+    const date = new Date(at);
+    if (Number.isNaN(date.getTime())) continue;
+    draft ??= new Map(timestamps);
+    draft.set(turnId, { ...known, [role]: date });
+    timestamps = draft;
+  }
+
+  cache.lastEvents = events;
+  cache.timestamps = timestamps;
+  return timestamps;
+};