@assistant-ui/ai-sdk 0.0.1

package/src/converters/convertMessage.ts

@@ -0,0 +1,457 @@
+import {
+  isToolUIPart,
+  isReasoningFileUIPart,
+  isCustomContentUIPart,
+  getToolName,
+  type UIMessage,
+} from "ai";
+import {
+  createMessageConverter as unstable_createMessageConverter,
+  type useExternalMessageConverter,
+} from "@assistant-ui/core/react";
+import {
+  isMcpAppUri,
+  type ReasoningMessagePart,
+  type ToolCallMessagePart,
+  type TextMessagePart,
+  type DataMessagePart,
+  type PartProviderMetadata,
+  type SourceMessagePart,
+  type SourceProviderMetadata,
+  type FileMessagePart,
+  type ThreadMessageLike,
+  type McpAppMetadata,
+  type MessagePartStreamStatus,
+} from "@assistant-ui/core";
+import { stableStringifyToolArgs } from "@assistant-ui/core/internal";
+import {
+  parsePartialJsonObject,
+  type ReadonlyJSONObject,
+} from "assistant-stream/utils";
+import { unwrapModelContentEnvelope } from "./modelContentEnvelope";
+
+type MessageMetadata = ThreadMessageLike["metadata"];
+export type AISDKMessageConverterMetadata =
+  useExternalMessageConverter.Metadata & {
+    toolArgsKeyOrderCache?: Map<string, Map<string, string[]>>;
+    toolLastInputCache?: Map<string, ReadonlyJSONObject>;
+    mcpAppMetadataCache?: Map<string, McpAppMetadata>;
+    /** Id of the currently-streaming message, flagged optimistic (#4037). */
+    optimisticMessageId?: string | undefined;
+  };
+
+function stripClosingDelimiters(json: string): string {
+  return json.replace(/[}\]"]+$/, "");
+}
+
+const MCP_APP_METADATA_CACHE_MAX = 100;
+
+function extractMcpAppMetadata(
+  part: unknown,
+  cache: Map<string, McpAppMetadata> | undefined,
+): McpAppMetadata | undefined {
+  if (!part || typeof part !== "object") return undefined;
+  const meta = (part as { callProviderMetadata?: unknown })
+    .callProviderMetadata;
+  const mcp =
+    meta && typeof meta === "object"
+      ? (meta as { mcp?: unknown }).mcp
+      : undefined;
+  const app =
+    mcp && typeof mcp === "object" ? (mcp as { app?: unknown }).app : undefined;
+  let a: Record<string, unknown>;
+  if (app && typeof app === "object") {
+    a = app as Record<string, unknown>;
+  } else {
+    // MCP-UI tools surface the pointer on result._meta: canonical nested
+    // `ui.resourceUri`, or the deprecated flat `"ui/resourceUri"` key.
+    const output = (part as { output?: unknown }).output;
+    const outMeta =
+      output && typeof output === "object"
+        ? (output as { _meta?: unknown })._meta
+        : undefined;
+    const ui =
+      outMeta && typeof outMeta === "object"
+        ? (outMeta as Record<string, unknown>)["ui"]
+        : undefined;
+    if (
+      ui &&
+      typeof ui === "object" &&
+      typeof (ui as Record<string, unknown>)["resourceUri"] === "string" &&
+      isMcpAppUri((ui as Record<string, unknown>)["resourceUri"] as string)
+    ) {
+      // Only the spec'd ui fields cross from the result body; serverId is a
+      // routing key and stays transport-derived via callProviderMetadata.
+      const uiMeta = ui as Record<string, unknown>;
+      a = {
+        resourceUri: uiMeta["resourceUri"],
+        ...(Array.isArray(uiMeta["visibility"])
+          ? { visibility: uiMeta["visibility"] }
+          : {}),
+      };
+    } else {
+      const flat =
+        outMeta && typeof outMeta === "object"
+          ? (outMeta as Record<string, unknown>)["ui/resourceUri"]
+          : undefined;
+      if (typeof flat !== "string" || !isMcpAppUri(flat)) return undefined;
+      a = { resourceUri: flat };
+    }
+  }
+  if (typeof a["resourceUri"] !== "string") return undefined;
+  if (!isMcpAppUri(a["resourceUri"])) return undefined;
+  const cacheKey = `${typeof a["serverId"] === "string" ? a["serverId"] : ""} ${a["resourceUri"]}`;
+  const cached = cache?.get(cacheKey);
+  if (cached) {
+    cache!.delete(cacheKey);
+    cache!.set(cacheKey, cached);
+    return cached;
+  }
+  const out: { -readonly [K in keyof McpAppMetadata]: McpAppMetadata[K] } = {
+    resourceUri: a["resourceUri"],
+  };
+  if (typeof a["mimeType"] === "string") out.mimeType = a["mimeType"];
+  if (Array.isArray(a["visibility"])) {
+    out.visibility = a["visibility"].filter(
+      (v): v is "model" | "app" => v === "model" || v === "app",
+    );
+  }
+  if (typeof a["serverId"] === "string" && a["serverId"].length > 0)
+    out.serverId = a["serverId"];
+  if (cache) {
+    if (cache.size >= MCP_APP_METADATA_CACHE_MAX) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== undefined) cache.delete(oldest);
+    }
+    cache.set(cacheKey, out);
+  }
+  return out;
+}
+
+function getToolApprovalAndInterrupt(
+  part: {
+    approval?:
+      | {
+          id: string;
+          approved?: boolean;
+          reason?: string;
+          isAutomatic?: boolean;
+        }
+      | undefined;
+  },
+  toolStatus: { type: string; payload?: unknown } | undefined,
+): {
+  approval?: NonNullable<ToolCallMessagePart["approval"]>;
+  interrupt?: NonNullable<ToolCallMessagePart["interrupt"]>;
+} {
+  if (part.approval && typeof part.approval.id === "string") {
+    const { id, approved, reason, isAutomatic } = part.approval;
+    return {
+      approval: {
+        id,
+        ...(typeof approved === "boolean" && { approved }),
+        ...(typeof reason === "string" && { reason }),
+        ...(isAutomatic === true && { isAutomatic: true }),
+      },
+    };
+  }
+
+  if (toolStatus?.type === "interrupt") {
+    return {
+      interrupt: toolStatus.payload as NonNullable<
+        ToolCallMessagePart["interrupt"]
+      >,
+    };
+  }
+
+  return {};
+}
+
+type MessageContent = Exclude<ThreadMessageLike["content"], string>;
+
+const uiPartStateToStatus = (
+  state: "streaming" | "done" | undefined,
+): MessagePartStreamStatus | undefined => {
+  if (state === "streaming") return { type: "running" };
+  if (state === "done") return { type: "complete" };
+  return undefined;
+};
+
+function convertParts(
+  message: UIMessage,
+  metadata: AISDKMessageConverterMetadata,
+): MessageContent {
+  if (!message.parts || message.parts.length === 0) {
+    return [];
+  }
+
+  const converted = message.parts
+    .filter(
+      (p) =>
+        p.type !== "step-start" &&
+        (message.role !== "user" || p.type !== "file"),
+    )
+    .map((part) => {
+      if (part.type === "text") {
+        const status = uiPartStateToStatus(part.state);
+        return {
+          type: "text",
+          text: part.text,
+          ...(status != null ? { status } : undefined),
+          ...(part.providerMetadata != null
+            ? {
+                providerMetadata: part.providerMetadata as PartProviderMetadata,
+              }
+            : undefined),
+        } satisfies TextMessagePart;
+      }
+
+      if (part.type === "reasoning") {
+        const status = uiPartStateToStatus(part.state);
+        return {
+          type: "reasoning",
+          text: part.text,
+          ...(status != null ? { status } : undefined),
+          ...(part.providerMetadata != null
+            ? {
+                providerMetadata: part.providerMetadata as PartProviderMetadata,
+              }
+            : undefined),
+        } satisfies ReasoningMessagePart;
+      }
+
+      if (isToolUIPart(part)) {
+        const toolName = getToolName(part);
+        const toolCallId = part.toolCallId;
+        const argsKeyOrderCacheKey = `${message.id}:${toolCallId}`;
+
+        const rawInput = part.input as ReadonlyJSONObject | null | undefined;
+        let args: ReadonlyJSONObject;
+        if (
+          rawInput != null &&
+          typeof rawInput === "object" &&
+          !Array.isArray(rawInput)
+        ) {
+          args = rawInput;
+          metadata.toolLastInputCache?.set(argsKeyOrderCacheKey, args);
+        } else {
+          args = metadata.toolLastInputCache?.get(argsKeyOrderCacheKey) ?? {};
+        }
+
+        let result: unknown;
+        let modelContent: ToolCallMessagePart["modelContent"];
+        let isError = false;
+
+        if (part.state === "output-available") {
+          const unwrapped = unwrapModelContentEnvelope(part.output);
+          result = unwrapped.result;
+          modelContent = unwrapped.modelContent;
+        } else if (part.state === "output-error") {
+          isError = true;
+          result = { error: part.errorText };
+        } else if (part.state === "output-denied") {
+          isError = true;
+          result = {
+            error:
+              (part as { approval?: { reason?: string } }).approval?.reason ||
+              "Tool approval denied",
+          };
+        }
+
+        let argsText = stableStringifyToolArgs(
+          metadata.toolArgsKeyOrderCache,
+          argsKeyOrderCacheKey,
+          args,
+        );
+        if (part.state === "input-streaming") {
+          // strip closing delimiters added by the AI SDK's fix-json
+          argsText = stripClosingDelimiters(argsText);
+          // Re-parse so args carries the partial-JSON meta that marks which
+          // field is still mid-arrival, like every argsText-based runtime.
+          // The key-order cache appends new keys last, so the trailing field
+          // of the stripped text is the streaming frontier.
+          args = parsePartialJsonObject(argsText) ?? args;
+        } else {
+          metadata.toolArgsKeyOrderCache?.delete(argsKeyOrderCacheKey);
+          if (
+            part.state === "output-available" ||
+            part.state === "output-error" ||
+            part.state === "output-denied"
+          ) {
+            metadata.toolLastInputCache?.delete(argsKeyOrderCacheKey);
+          }
+        }
+
+        const toolStatus = metadata.toolStatuses?.[toolCallId];
+        const mcpApp = extractMcpAppMetadata(
+          part,
+          metadata.mcpAppMetadataCache,
+        );
+        return {
+          type: "tool-call",
+          toolName,
+          toolCallId,
+          argsText,
+          args,
+          result,
+          isError,
+          ...(modelContent !== undefined && { modelContent }),
+          ...(mcpApp && { mcp: { app: mcpApp } }),
+          ...(part.callProviderMetadata != null
+            ? {
+                providerMetadata:
+                  part.callProviderMetadata as PartProviderMetadata,
+              }
+            : undefined),
+          ...getToolApprovalAndInterrupt(part, toolStatus),
+        } satisfies ToolCallMessagePart;
+      }
+
+      if (part.type === "source-url") {
+        return {
+          type: "source",
+          sourceType: "url",
+          id: part.sourceId,
+          url: part.url,
+          ...(part.title != null ? { title: part.title } : undefined),
+          ...(part.providerMetadata != null
+            ? {
+                providerMetadata:
+                  part.providerMetadata as SourceProviderMetadata,
+              }
+            : undefined),
+        } satisfies SourceMessagePart;
+      }
+
+      if (part.type === "file") {
+        return {
+          type: "file",
+          data: part.url,
+          mimeType: part.mediaType,
+          ...(part.filename != null && { filename: part.filename }),
+        } satisfies FileMessagePart;
+      }
+
+      if (part.type === "source-document") {
+        return {
+          type: "source",
+          sourceType: "document",
+          id: part.sourceId,
+          title: part.title,
+          mediaType: part.mediaType,
+          ...(part.filename != null ? { filename: part.filename } : undefined),
+          ...(part.providerMetadata != null
+            ? {
+                providerMetadata:
+                  part.providerMetadata as SourceProviderMetadata,
+              }
+            : undefined),
+        } satisfies SourceMessagePart;
+      }
+
+      if (part.type.startsWith("data-")) {
+        return {
+          type: "data",
+          name: part.type.substring(5),
+          data: (part as any).data,
+        } satisfies DataMessagePart;
+      }
+
+      if (isReasoningFileUIPart(part)) {
+        return {
+          type: "file",
+          data: part.url,
+          mimeType: part.mediaType,
+        } satisfies FileMessagePart;
+      }
+
+      if (isCustomContentUIPart(part)) {
+        return {
+          type: "data",
+          name: part.kind,
+          data: part.providerMetadata ?? null,
+        } satisfies DataMessagePart;
+      }
+
+      console.warn(`Unsupported message part type: ${part.type}`);
+      return null;
+    })
+    .filter(Boolean) as MessageContent[number][];
+
+  const seenToolCallIds = new Set<string>();
+  return converted.filter((part) => {
+    if (part.type === "tool-call" && part.toolCallId != null) {
+      if (seenToolCallIds.has(part.toolCallId)) return false;
+      seenToolCallIds.add(part.toolCallId);
+    }
+    return true;
+  });
+}
+
+export const AISDKMessageConverter = unstable_createMessageConverter(
+  (message: UIMessage, metadata: AISDKMessageConverterMetadata) => {
+    const createdAt = new Date();
+    const content = convertParts(message, metadata);
+
+    switch (message.role) {
+      case "user":
+        return {
+          role: "user",
+          id: message.id,
+          createdAt,
+          content,
+          attachments: message.parts
+            ?.filter((p) => p.type === "file")
+            .map((part, idx) => {
+              const mediaType = part.mediaType ?? "unknown/unknown";
+              const isImage = mediaType.startsWith("image/");
+              return {
+                id: idx.toString(),
+                type: isImage ? "image" : "file",
+                name: part.filename ?? "file",
+                content: [
+                  isImage
+                    ? {
+                        type: "image",
+                        image: part.url,
+                        filename: part.filename!,
+                      }
+                    : {
+                        type: "file",
+                        filename: part.filename!,
+                        data: part.url,
+                        mimeType: mediaType,
+                      },
+                ],
+                contentType: mediaType,
+                status: { type: "complete" as const },
+              };
+            }),
+          metadata: message.metadata as MessageMetadata,
+        };
+
+      case "system":
+      case "assistant": {
+        const timing = metadata.messageTiming?.[message.id];
+        const isOptimistic =
+          message.role === "assistant" &&
+          message.id === metadata.optimisticMessageId;
+        return {
+          role: message.role,
+          id: message.id,
+          createdAt,
+          content,
+          metadata: {
+            ...(message.metadata as MessageMetadata),
+            ...(timing && { timing }),
+            ...(isOptimistic && { isOptimistic: true }),
+          },
+        };
+      }
+
+      default:
+        console.warn(`Unsupported message role: ${message.role}`);
+        return [];
+    }
+  },
+);

package/src/converters/modelContentEnvelope.ts

@@ -0,0 +1,41 @@
+import type { ToolModelContentPart } from "assistant-stream";
+
+const ENVELOPE_KEY = "__aui_modelContent";
+
+export type ModelContentEnvelope<TResult = unknown> = {
+  readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];
+  readonly value: TResult;
+};
+
+export function isModelContentEnvelope<TResult = unknown>(
+  value: TResult | ModelContentEnvelope<TResult>,
+): value is ModelContentEnvelope<TResult> {
+  return (
+    value != null &&
+    typeof value === "object" &&
+    ENVELOPE_KEY in value &&
+    Array.isArray((value as Record<string, unknown>)[ENVELOPE_KEY])
+  );
+}
+
+export function wrapModelContentEnvelope<TResult>(
+  result: TResult,
+  modelContent: readonly ToolModelContentPart[],
+): ModelContentEnvelope<TResult> {
+  return { [ENVELOPE_KEY]: modelContent, value: result };
+}
+
+export function unwrapModelContentEnvelope<TResult>(
+  output: TResult | ModelContentEnvelope<TResult>,
+): {
+  result: TResult;
+  modelContent?: readonly ToolModelContentPart[];
+} {
+  if (isModelContentEnvelope(output)) {
+    return {
+      result: output.value,
+      modelContent: output[ENVELOPE_KEY],
+    };
+  }
+  return { result: output };
+}