@ulearning/ai-sdk-adapter 0.0.0-stage → 1.0.0-next.0

package/src/converters/toCreateMessage.ts

@@ -0,0 +1,110 @@
+import type { AppendMessage } from "@ulearning/ai-core";
+import {
+  resolveFileMediaType,
+  resolveFilePartSource,
+  resolveImageMediaType,
+  toMediaWireUrl,
+} from "@ulearning/ai-core/internal";
+import type {
+  CreateUIMessage,
+  UIDataTypes,
+  UIMessage,
+  UIMessagePart,
+  UITools,
+} from "ai";
+
+type InputPart = AppendMessage["content"][number] & {
+  readonly contentType?: string | undefined;
+  readonly filename?: string | undefined;
+};
+
+export const toCreateMessage = <UI_MESSAGE extends UIMessage = UIMessage>(
+  message: AppendMessage,
+): CreateUIMessage<UI_MESSAGE> => {
+  const inputParts: InputPart[] = [
+    ...message.content,
+    ...(message.attachments?.flatMap((a) =>
+      a.content.map((c) => ({
+        ...c,
+        filename: a.name,
+        contentType: a.contentType,
+      })),
+    ) ?? []),
+  ];
+
+  const parts = inputParts.map((part): UIMessagePart<UIDataTypes, UITools> => {
+    switch (part.type) {
+      case "text":
+        return {
+          type: "text",
+          text: part.text,
+          ...(part.providerMetadata != null && {
+            providerMetadata: part.providerMetadata,
+          }),
+        };
+      case "image": {
+        const mediaType = resolveImageMediaType(part.image, part.contentType);
+        return {
+          type: "file",
+          url: toMediaWireUrl(part.image, mediaType),
+          ...(part.filename && { filename: part.filename }),
+          mediaType,
+          ...(part.providerMetadata != null && {
+            providerMetadata: part.providerMetadata,
+          }),
+        };
+      }
+      case "file": {
+        // `mimeType` is a plain string, and an adapter reading `file.type` on a
+        // file the OS cannot type yields "". Same ladder as images: declared,
+        // then the envelope, then the floor.
+        const mediaType = resolveFileMediaType(part.data, part.mimeType);
+        return {
+          type: "file",
+          // An `id` reference is an opaque provider handle, not base64, and
+          // this adapter has no way to send one. Left unwrapped so it fails
+          // loudly upstream rather than shipping a corrupt payload.
+          url:
+            part.sourceType === "id"
+              ? part.data
+              : toMediaWireUrl(part.data, mediaType),
+          mediaType,
+          ...(part.filename && { filename: part.filename }),
+          ...(part.providerMetadata != null && {
+            providerMetadata: part.providerMetadata,
+          }),
+        };
+      }
+      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;
+        const source = resolveFilePartSource({ data, mimeType: mediaType });
+        return {
+          type: "file",
+          url:
+            source.kind === "url"
+              ? source.url
+              : `data:${mediaType};base64,${source.data}`,
+          mediaType,
+          ...(part.filename && { filename: part.filename }),
+        };
+      }
+      case "data":
+        return {
+          type: `data-${part.name}`,
+          data: part.data,
+          ...(part.id !== undefined && { id: part.id }),
+        };
+      default:
+        throw new Error(`Unsupported part type: ${part.type}`);
+    }
+  });
+
+  return {
+    role: message.role,
+    parts,
+    metadata: message.metadata,
+  } satisfies CreateUIMessage<UIMessage> as CreateUIMessage<UI_MESSAGE>;
+};

package/src/converters/toolApprovalAnswers.ts

@@ -0,0 +1,27 @@
+import type { ToolApprovalAnswer } from "@ulearning/ai-core";
+
+export const normalizeToolApprovalAnswers = (
+  answers: unknown,
+): Readonly<Record<string, ToolApprovalAnswer>> | undefined => {
+  if (!answers || typeof answers !== "object" || Array.isArray(answers))
+    return undefined;
+
+  return Object.fromEntries(
+    Object.entries(answers).flatMap(([id, value]) => {
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+      const { optionIds, text } = value as Record<string, unknown>;
+      const answer: ToolApprovalAnswer = {
+        ...(Array.isArray(optionIds) && {
+          optionIds: optionIds.filter(
+            (optionId): optionId is string => typeof optionId === "string",
+          ),
+        }),
+        ...(typeof text === "string" && { text }),
+      };
+      return answer.optionIds?.length || answer.text !== undefined
+        ? [[id, answer]]
+        : [];
+    }),
+  );
+};

package/src/hooks.test.ts

@@ -0,0 +1,168 @@
+// @vitest-environment jsdom
+import {
+  createApp,
+  defineComponent,
+  h,
+  isProxy,
+  isReadonly,
+  nextTick,
+  version,
+  type App,
+} from "vue";
+import { afterEach, beforeAll, expect, expectTypeOf, it, vi } from "vitest";
+import type { UIMessage } from "ai";
+import type { ThreadMessage } from "@ulearning/ai-core";
+import {
+  AssistantRuntimeImpl,
+  ExternalStoreRuntimeCore,
+} from "@ulearning/ai-core/internal";
+import { AssistantRuntimeProvider } from "@ulearning/ai-core/vue";
+import { flushTapSync } from "@ulearning/ai-tap";
+import { aiSDKExtras, type AISDKChatHelpers } from "./aiSDKExtras";
+import { useAISDKChat, useAISDKError } from "./hooks";
+import { useThreadTokenUsage } from "./usage";
+
+const apps: App[] = [];
+beforeAll(() => {
+  const expected = process.env.AUI_VUE_RUNTIME_ROOT?.replaceAll("\\", "/")
+    .split("/")
+    .at(-1);
+  if (expected) expect(version).toBe(expected);
+});
+afterEach(() => {
+  apps.splice(0).forEach((app) => app.unmount());
+  vi.restoreAllMocks();
+});
+const helpers = (id: string): AISDKChatHelpers => ({
+  id,
+  messages: [],
+  status: "ready",
+  error: undefined,
+  setMessages: vi.fn(),
+  clearError: vi.fn(),
+  sendMessage: vi.fn(async () => {}),
+  regenerate: vi.fn(async () => {}),
+  stop: vi.fn(async () => {}),
+  resumeStream: vi.fn(async () => {}),
+  addToolResult: vi.fn(async () => {}),
+  addToolOutput: vi.fn(async () => {}),
+  addToolApprovalResponse: vi.fn(async () => {}),
+});
+const message = (id: string, input: number, output: number): ThreadMessage => ({
+  id,
+  role: "assistant",
+  content: [{ type: "text", text: id }],
+  createdAt: new Date(0),
+  status: { type: "complete", reason: "stop" },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: { usage: { inputTokens: input, outputTokens: output } },
+  },
+});
+const mount = (core: ExternalStoreRuntimeCore) => {
+  let values!: {
+    chat: ReturnType<typeof useAISDKChat>;
+    error: ReturnType<typeof useAISDKError>;
+    usage: ReturnType<typeof useThreadTokenUsage>;
+  };
+  let renders = 0;
+  const Consumer = defineComponent({
+    setup() {
+      values = {
+        chat: useAISDKChat(),
+        error: useAISDKError(),
+        usage: useThreadTokenUsage(),
+      };
+      expectTypeOf(values.chat.value?.messages).toEqualTypeOf<
+        UIMessage[] | undefined
+      >();
+      return () => {
+        renders++;
+        return h(
+          "p",
+          `${values.chat.value?.id}:${values.error.value?.message}:${values.usage.value?.totalTokens}`,
+        );
+      };
+    },
+  });
+  const runtime = new AssistantRuntimeImpl(core);
+  const app = createApp(
+    defineComponent({
+      setup: () => () =>
+        h(
+          AssistantRuntimeProvider,
+          { runtime },
+          { default: () => h(Consumer) },
+        ),
+    }),
+  );
+  apps.push(app);
+  const element = document.createElement("div");
+  app.mount(element);
+  return {
+    element,
+    get values() {
+      return values;
+    },
+    get renders() {
+      return renders;
+    },
+    unmount: () => app.unmount(),
+  };
+};
+
+it("returns explicit undefined Ref values for a runtime without AI SDK extras or usage", () => {
+  const view = mount(
+    new ExternalStoreRuntimeCore({ messages: [], onNew: async () => {} }),
+  );
+  expect(view.values.chat.value).toBeUndefined();
+  expect(view.values.error.value).toBeUndefined();
+  expect(view.values.usage.value).toBeUndefined();
+  expect(isReadonly(view.values.chat)).toBe(true);
+});
+
+it("updates advanced helpers, errors and usage through the real Core/Store bridge", async () => {
+  const first = helpers("first");
+  const next = helpers("next");
+  const onNew = async () => {};
+  const core = new ExternalStoreRuntimeCore({
+    messages: [message("one", 4, 2)],
+    onNew,
+    extras: aiSDKExtras.provide({ chat: first, error: undefined }),
+  });
+  const view = mount(core);
+  expect(view.values.chat.value).toBe(first);
+  expect(isProxy(view.values.chat.value)).toBe(false);
+  expect(view.values.chat.value?.resumeStream).toBe(first.resumeStream);
+  expect(view.values.usage.value).toEqual({
+    inputTokens: 4,
+    outputTokens: 2,
+    totalTokens: 6,
+  });
+  const failure = new Error("transport failed");
+  flushTapSync(() =>
+    core.setAdapter({
+      messages: [message("one", 4, 2), message("two", 8, 3)],
+      onNew,
+      extras: aiSDKExtras.provide({ chat: next, error: failure }),
+    }),
+  );
+  await nextTick();
+  expect(view.values.chat.value).toBe(next);
+  expect(view.values.error.value).toBe(failure);
+  expect(view.element.textContent).toBe("next:transport failed:11");
+  const renders = view.renders;
+  view.unmount();
+  flushTapSync(() =>
+    core.setAdapter({
+      messages: [],
+      onNew,
+      extras: aiSDKExtras.provide({ chat: first, error: undefined }),
+    }),
+  );
+  await nextTick();
+  expect(view.renders).toBe(renders);
+});

package/src/hooks.ts

@@ -0,0 +1,26 @@
+"use client";
+
+import type { ShallowRef } from "vue";
+import type { UIMessage } from "ai";
+import { aiSDKExtras, type AISDKChatHelpers } from "./aiSDKExtras";
+
+/**
+ * Read the last AI SDK chat error object from the runtime extras.
+ * The readonly Ref contains `undefined` when there is no error or the current thread is not backed by
+ * the AI SDK runtime.
+ */
+export const useAISDKError = () => aiSDKExtras.use((e) => e.error, undefined);
+
+/**
+ * The underlying `useChat` helpers object, for advanced views — reach
+ * `resumeStream`, `clearError`, or the raw `sendMessage` without forking the
+ * runtime hook. Read `.value`; it is `undefined` when the thread is not backed by the AI
+ * SDK runtime.
+ */
+export const useAISDKChat = <
+  UI_MESSAGE extends UIMessage = UIMessage,
+>(): Readonly<ShallowRef<AISDKChatHelpers<UI_MESSAGE> | undefined>> =>
+  aiSDKExtras.use(
+    (e) => e.chat as unknown as AISDKChatHelpers<UI_MESSAGE>,
+    undefined,
+  );

package/src/index.ts

@@ -0,0 +1,29 @@
+/// <reference types="@ulearning/ai-core/vue" preserve="true" />
+
+export { useAISDKRuntime } from "./runtime/useAISDKRuntime";
+export { useChatRuntime } from "./runtime/useChatRuntime";
+export type { UseChatRuntimeOptions } from "./runtime/useChatRuntime";
+export { AssistantChatTransport } from "./transport/AssistantChatTransport";
+export {
+  RESUMABLE_STREAM_ID_HEADER,
+  createResumableSessionStorage,
+} from "./transport/resumable";
+export type {
+  AssistantChatResumableOptions,
+  ResumableClientStorage,
+} from "./transport/resumable";
+export { frontendTools, type FrontendTools } from "@ulearning/ai-stream/ai-sdk";
+export { injectQuoteContext } from "./model-context/injectQuoteContext";
+export { unstable_injectInteractableContext } from "./model-context/injectInteractableContext";
+export type { ThreadTokenUsage, TokenUsageExtractableMessage } from "./usage";
+export { getThreadMessageTokenUsage, useThreadTokenUsage } from "./usage";
+export { useAISDKChat, useAISDKError } from "./hooks";
+export {
+  AISDKToolkit,
+  generativeTools,
+  type AISDKToolkitOptions,
+  type AISDKToolkitToolsOptions,
+  type GenerativeToolsOptions,
+} from "./tools/generativeTools";
+export { AISDKChat, type AISDKChatOptions } from "./runtime/AISDKChat";
+export { AISDKThreads, type AISDKThreadsOptions } from "./runtime/AISDKThreads";

package/src/model-context/injectInteractableContext.test.ts

@@ -0,0 +1,167 @@
+import type { UIMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import { unstable_injectInteractableContext } from "./injectInteractableContext";
+import { injectQuoteContext } from "./injectQuoteContext";
+
+type Interactable = {
+  name: string;
+  id: string;
+  state: unknown;
+  partial?: boolean;
+};
+
+const userMsg = (
+  interactables?: Interactable[],
+  extraCustom?: Record<string, unknown>,
+): UIMessage =>
+  ({
+    id: "m1",
+    role: "user",
+    parts: [{ type: "text", text: "hello" }],
+    ...(interactables || extraCustom
+      ? {
+          metadata: {
+            custom: {
+              ...extraCustom,
+              ...(interactables ? { interactables } : {}),
+            },
+          },
+        }
+      : {}),
+  }) as UIMessage;
+
+const textOf = (part: unknown) => (part as { text?: string }).text;
+const isStateText = (part: unknown) =>
+  (part as { type?: string }).type === "text" &&
+  (textOf(part) ?? "").startsWith("[Current state of");
+
+describe("unstable_injectInteractableContext", () => {
+  it("returns the message unchanged when there is no interactable metadata", () => {
+    const input = [userMsg()];
+    const out = unstable_injectInteractableContext(input);
+    expect(out[0]).toBe(input[0]);
+  });
+
+  it("skips non-user messages", () => {
+    const input = [
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [{ type: "text", text: "hi" }],
+        metadata: {
+          custom: {
+            interactables: [{ name: "note", id: "n1", state: { v: 1 } }],
+          },
+        },
+      } as UIMessage,
+    ];
+    const out = unstable_injectInteractableContext(input);
+    expect(out[0]).toBe(input[0]);
+  });
+
+  it("prepends a text part using the default format (id included for update_* addressing)", () => {
+    const out = unstable_injectInteractableContext([
+      userMsg([{ name: "note", id: "n1", state: { title: "Hi" } }]),
+    ]);
+    expect(textOf(out[0]!.parts[0])).toBe(
+      '[Current state of "note" (id: "n1"): {"title":"Hi"}]\n\n',
+    );
+    expect(textOf(out[0]!.parts[1])).toBe("hello");
+  });
+
+  it("formats a partial snapshot as changed fields", () => {
+    const out = unstable_injectInteractableContext([
+      userMsg([
+        { name: "note", id: "n1", state: { title: "Hi" }, partial: true },
+      ]),
+    ]);
+    expect(textOf(out[0]!.parts[0])).toBe(
+      '[State of "note" (id: "n1") changed — updated fields: {"title":"Hi"}; fields not listed are unchanged]\n\n',
+    );
+  });
+
+  it("joins multiple interactables with a newline", () => {
+    const out = unstable_injectInteractableContext([
+      userMsg([
+        { name: "note", id: "n1", state: { v: 1 } },
+        { name: "board", id: "b1", state: { v: 2 } },
+      ]),
+    ]);
+    expect(textOf(out[0]!.parts[0])).toBe(
+      '[Current state of "note" (id: "n1"): {"v":1}]\n' +
+        '[Current state of "board" (id: "b1"): {"v":2}]\n\n',
+    );
+  });
+
+  it("respects a custom format function", () => {
+    const out = unstable_injectInteractableContext(
+      [userMsg([{ name: "note", id: "n1", state: { v: 1 } }])],
+      (item) => `X:${item.name}`,
+    );
+    expect(textOf(out[0]!.parts[0])).toBe("X:note\n\n");
+  });
+
+  it("leaves messages with an empty interactables array unchanged", () => {
+    const input = [userMsg([])];
+    expect(unstable_injectInteractableContext(input)[0]).toBe(input[0]);
+  });
+
+  it("does not throw when a user message has no parts", () => {
+    const input = [
+      {
+        id: "m1",
+        role: "user",
+        metadata: {
+          custom: {
+            interactables: [{ name: "note", id: "n1", state: { v: 1 } }],
+          },
+        },
+      } as unknown as UIMessage,
+    ];
+    const run = () => unstable_injectInteractableContext(input);
+    expect(run).not.toThrow();
+    expect(textOf(run()[0]!.parts[0])).toBe(
+      '[Current state of "note" (id: "n1"): {"v":1}]\n\n',
+    );
+  });
+
+  it("is idempotent on its own (does not double-inject)", () => {
+    const once = unstable_injectInteractableContext([
+      userMsg([{ name: "note", id: "n1", state: { v: 1 } }]),
+    ]);
+    const twice = unstable_injectInteractableContext(once);
+    expect(twice[0]).toBe(once[0]);
+    expect(twice[0]!.parts.filter(isStateText)).toHaveLength(1);
+  });
+
+  describe("composition with injectQuoteContext", () => {
+    const both = () =>
+      userMsg([{ name: "note", id: "n1", state: { v: 1 } }], {
+        quote: { text: "quoted" },
+      });
+
+    it("stacks both injections in a fixed order over source messages", () => {
+      // Apply interactable first, then quote — quote ends up outermost.
+      const out = injectQuoteContext(
+        unstable_injectInteractableContext([both()]),
+      );
+      const parts = out[0]!.parts;
+      expect(textOf(parts[0])).toBe("> quoted\n\n");
+      expect(isStateText(parts[1])).toBe(true);
+      expect(textOf(parts[2])).toBe("hello");
+    });
+
+    it("is NOT idempotent across re-application: run injectors once over un-injected messages", () => {
+      // Each injector's `alreadyInjected` guard only inspects parts[0]. Once the
+      // other injector sits at parts[0], the guard misses and re-prepends. So the
+      // composition must run once over source messages, never re-run over output.
+      const once = injectQuoteContext(
+        unstable_injectInteractableContext([both()]),
+      );
+      const twice = injectQuoteContext(
+        unstable_injectInteractableContext(once),
+      );
+      expect(twice[0]!.parts.filter(isStateText)).toHaveLength(2);
+    });
+  });
+});

package/src/model-context/injectInteractableContext.ts

@@ -0,0 +1,64 @@
+import type { UIMessage } from "ai";
+import {
+  unstable_formatInteractableSnapshot,
+  unstable_getInteractableSnapshots,
+  type Unstable_InteractableSnapshotEntry,
+} from "@ulearning/ai-core";
+
+/**
+ * Injects interactable state snapshots into messages as model-visible text.
+ *
+ * Mirrors {@link injectQuoteContext}: reads the frozen snapshot stamped on a user
+ * message's `metadata.custom.interactables` (by the interactables scope at send
+ * time) and prepends a text part. Run this in your route handler before
+ * `convertToModelMessages`, which otherwise ignores `metadata.custom`.
+ *
+ * Wording is consumer-owned — pass `format` to control how each snapshot reads.
+ * A snapshot may originate from a user edit or an agent `update_*` call, so the
+ * default phrasing is neutral. Keep the instance id visible in custom wording:
+ * the model needs it to address the `update_*` tool's `id` parameter. A custom
+ * `format` must also handle entries with `partial: true`, whose `state` carries
+ * only the fields that changed since the model's last known state.
+ *
+ * @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release.
+ *
+ * @example
+ * ```ts
+ * import { convertToModelMessages, streamText } from "ai";
+ * import { unstable_injectInteractableContext } from "@ulearning/ai-sdk-adapter";
+ *
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = streamText({
+ *     abortSignal: req.signal,
+ *     model: myModel,
+ *     messages: await convertToModelMessages(unstable_injectInteractableContext(messages)),
+ *   });
+ *   return result.toUIMessageStreamResponse();
+ * }
+ * ```
+ */
+export function unstable_injectInteractableContext(
+  messages: UIMessage[],
+  format: (
+    item: Unstable_InteractableSnapshotEntry,
+  ) => string = unstable_formatInteractableSnapshot,
+): UIMessage[] {
+  return messages.map((msg) => {
+    if (msg.role !== "user") return msg;
+
+    const items = unstable_getInteractableSnapshots(msg);
+    if (!items?.length) return msg;
+
+    const text = `${items.map(format).join("\n")}\n\n`;
+
+    const alreadyInjected =
+      msg.parts?.[0]?.type === "text" && msg.parts[0].text === text;
+    if (alreadyInjected) return msg;
+
+    return {
+      ...msg,
+      parts: [{ type: "text" as const, text }, ...(msg.parts ?? [])],
+    };
+  });
+}

package/src/model-context/injectQuoteContext.test.ts

@@ -0,0 +1,33 @@
+import type { UIMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import { injectQuoteContext } from "./injectQuoteContext";
+
+const textOf = (part: unknown) => (part as { text?: string }).text;
+
+describe("injectQuoteContext", () => {
+  it("prepends the quote as a markdown blockquote", () => {
+    const out = injectQuoteContext([
+      {
+        id: "m1",
+        role: "user",
+        parts: [{ type: "text", text: "hello" }],
+        metadata: { custom: { quote: { text: "quoted" } } },
+      } as unknown as UIMessage,
+    ]);
+    expect(textOf(out[0]!.parts[0])).toBe("> quoted\n\n");
+    expect(textOf(out[0]!.parts[1])).toBe("hello");
+  });
+
+  it("does not throw when a user message has no parts", () => {
+    const input = [
+      {
+        id: "m1",
+        role: "user",
+        metadata: { custom: { quote: { text: "quoted" } } },
+      } as unknown as UIMessage,
+    ];
+    const run = () => injectQuoteContext(input);
+    expect(run).not.toThrow();
+    expect(textOf(run()[0]!.parts[0])).toBe("> quoted\n\n");
+  });
+});

package/src/model-context/injectQuoteContext.ts

@@ -0,0 +1,63 @@
+import type { UIMessage } from "ai";
+
+const getQuoteText = (metadata: unknown): string | undefined => {
+  if (!metadata || typeof metadata !== "object") return undefined;
+
+  const custom = (metadata as Record<string, unknown>).custom;
+  if (!custom || typeof custom !== "object") return undefined;
+
+  const quote = (custom as Record<string, unknown>).quote;
+  if (!quote || typeof quote !== "object") return undefined;
+
+  const text = (quote as Record<string, unknown>).text;
+  return typeof text === "string" ? text : undefined;
+};
+
+/**
+ * Injects quote context into messages as markdown blockquotes.
+ *
+ * Use this in your route handler before `convertToModelMessages` so the LLM
+ * sees the quoted text that the user is referring to.
+ *
+ * @example
+ * ```ts
+ * import { convertToModelMessages, streamText } from "ai";
+ * import { injectQuoteContext } from "@ulearning/ai-sdk-adapter";
+ *
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = streamText({
+ *     abortSignal: req.signal,
+ *     model: myModel,
+ *     messages: await convertToModelMessages(injectQuoteContext(messages)),
+ *   });
+ *   return result.toUIMessageStreamResponse();
+ * }
+ * ```
+ */
+export function injectQuoteContext(messages: UIMessage[]): UIMessage[] {
+  return messages.map((msg) => {
+    if (msg.role !== "user") return msg;
+
+    const text = getQuoteText(msg.metadata);
+    if (!text) return msg;
+
+    const blockquote = text
+      .split(/\r?\n/)
+      .map((line) => `> ${line}`)
+      .join("\n");
+
+    const alreadyInjected =
+      msg.parts?.[0]?.type === "text" &&
+      msg.parts[0].text === `${blockquote}\n\n`;
+    if (alreadyInjected) return msg;
+
+    return {
+      ...msg,
+      parts: [
+        { type: "text" as const, text: `${blockquote}\n\n` },
+        ...(msg.parts ?? []),
+      ],
+    };
+  });
+}