@assistant-ui/react 0.8.20 → 0.9.0

package/src/runtimes/edge/converters/fromCoreMessage.ts

@@ -1,76 +0,0 @@
-import { generateId } from "../../../internal";
-import {
-  ThreadMessage,
-  CoreMessage,
-  ToolCallContentPart,
-  MessageStatus,
-  CompleteAttachment,
-} from "../../../types";
-
-export const fromCoreMessages = (
-  message: readonly CoreMessage[],
-): ThreadMessage[] => {
-  return message.map((message) => fromCoreMessage(message));
-};
-
-export const fromCoreMessage = (
-  message: CoreMessage,
-  {
-    id = generateId(),
-    status = { type: "complete", reason: "unknown" } as MessageStatus,
-    attachments = [] as readonly CompleteAttachment[],
-  } = {},
-): ThreadMessage => {
-  const commonProps = {
-    id,
-    createdAt: new Date(),
-  };
-
-  const role = message.role;
-  switch (role) {
-    case "assistant":
-      return {
-        ...commonProps,
-        role,
-        content: message.content.map((part) => {
-          if (part.type === "tool-call") {
-            return {
-              ...part,
-              argsText: JSON.stringify(part.args),
-            } satisfies ToolCallContentPart;
-          }
-          return part;
-        }),
-        status,
-
-        metadata: {
-          unstable_annotations: [],
-          unstable_data: [],
-          steps: [],
-          custom: {},
-        },
-      } satisfies ThreadMessage;
-
-    case "user":
-      return {
-        ...commonProps,
-        role,
-        content: message.content,
-        attachments,
-        metadata: { custom: {} },
-      } satisfies ThreadMessage;
-
-    case "system":
-      return {
-        ...commonProps,
-        role,
-        content: message.content,
-        metadata: { custom: {} },
-      } satisfies ThreadMessage;
-
-    default: {
-      const unsupportedRole: never = role;
-      throw new Error(`Unknown message role: ${unsupportedRole}`);
-    }
-  }
-};

package/src/runtimes/edge/converters/fromLanguageModelMessages.ts

@@ -1,149 +0,0 @@
-import { LanguageModelV1Message } from "@ai-sdk/provider";
-import { CoreMessage, ToolCallContentPart } from "../../../types";
-import { Writable } from "stream";
-import { ReadonlyJSONObject } from "../../../utils/json/json-value";
-
-type fromLanguageModelMessagesOptions = {
-  mergeSteps?: boolean;
-};
-
-export const fromLanguageModelMessages = (
-  lm: LanguageModelV1Message[],
-  { mergeSteps }: fromLanguageModelMessagesOptions = {},
-): CoreMessage[] => {
-  const messages: CoreMessage[] = [];
-
-  for (const lmMessage of lm) {
-    const role = lmMessage.role;
-    switch (role) {
-      case "system": {
-        messages.push({
-          role: "system",
-          content: [
-            {
-              type: "text",
-              text: lmMessage.content,
-            },
-          ],
-        });
-        break;
-      }
-      case "user": {
-        messages.push({
-          role: "user",
-          content: lmMessage.content.map((part) => {
-            const type = part.type;
-            switch (type) {
-              case "text": {
-                return {
-                  type: "text",
-                  text: part.text,
-                };
-              }
-              case "image": {
-                if (part.image instanceof URL) {
-                  return {
-                    type: "image",
-                    image: part.image.href,
-                  };
-                }
-                throw new Error("Only images with URL data are supported");
-              }
-              case "file": {
-                if (part.data instanceof URL) {
-                  return {
-                    type: "file",
-                    data: part.data.href,
-                    mimeType: part.mimeType,
-                  };
-                }
-                throw new Error("Only files with URL data are supported");
-              }
-
-              default: {
-                const unhandledType: never = type;
-                throw new Error(`Unknown content part type: ${unhandledType}`);
-              }
-            }
-          }),
-        });
-        break;
-      }
-      case "assistant": {
-        const newContent = lmMessage.content
-          .map((part) => {
-            if (part.type === "tool-call") {
-              return {
-                type: "tool-call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                argsText: JSON.stringify(part.args),
-                args: part.args as ReadonlyJSONObject,
-              } satisfies ToolCallContentPart;
-            }
-            // TODO handle these
-            if (
-              part.type === "redacted-reasoning" ||
-              part.type === "file" ||
-              part.type === "reasoning"
-            ) {
-              return null;
-            }
-            return part;
-          })
-          .filter((p) => !!p);
-
-        if (mergeSteps) {
-          const previousMessage = messages[messages.length - 1];
-          if (previousMessage?.role === "assistant") {
-            previousMessage.content = [
-              ...previousMessage.content,
-              ...newContent,
-            ];
-            break;
-          }
-        }
-
-        messages.push({
-          role: "assistant",
-          content: newContent,
-        });
-        break;
-      }
-      case "tool": {
-        const previousMessage = messages[messages.length - 1];
-        if (previousMessage?.role !== "assistant")
-          throw new Error(
-            "A tool message must be preceded by an assistant message.",
-          );
-
-        for (const tool of lmMessage.content) {
-          const toolCall = previousMessage.content.find(
-            (c): c is ToolCallContentPart =>
-              c.type === "tool-call" && c.toolCallId === tool.toolCallId,
-          );
-          if (!toolCall)
-            throw new Error("Received tool result for an unknown tool call.");
-          if (toolCall.toolName !== tool.toolName)
-            throw new Error("Tool call name mismatch.");
-
-          type Writable<T> = { -readonly [P in keyof T]: T[P] };
-          const writable = toolCall as Writable<ToolCallContentPart>;
-          writable.result = tool.result;
-          if (tool.isError) {
-            writable.isError = true;
-          }
-        }
-
-        break;
-      }
-
-      default: {
-        const unhandledRole: never = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  }
-
-  return messages;
-};

package/src/runtimes/edge/converters/fromLanguageModelTools.ts

@@ -1,16 +0,0 @@
-import { LanguageModelV1FunctionTool } from "@ai-sdk/provider";
-import { Tool } from "../../../model-context/ModelContextTypes";
-
-export const fromLanguageModelTools = (
-  tools: LanguageModelV1FunctionTool[],
-): Record<string, Tool<any, any>> => {
-  return Object.fromEntries(
-    tools.map((tool) => [
-      tool.name,
-      {
-        description: tool.description,
-        parameters: tool.parameters,
-      },
-    ]),
-  );
-};

package/src/runtimes/edge/converters/index.ts

@@ -1,41 +0,0 @@
-/**
- * @deprecated This is an internal API and may change without notice.
- */
-export { toLanguageModelMessages } from "./toLanguageModelMessages";
-
-/**
- * @deprecated This is an internal API and may change without notice.
- */
-export { fromLanguageModelMessages } from "./fromLanguageModelMessages";
-
-export {
-  /**
-   * @deprecated This is an internal API and may change without notice.
-   */
-  fromCoreMessages,
-  /**
-   * @deprecated This is an internal API and may change without notice.
-   */
-  fromCoreMessage,
-} from "./fromCoreMessage";
-
-export {
-  /**
-   * @deprecated This is an internal API and may change without notice.
-   */
-  toCoreMessages,
-  /**
-   * @deprecated This is an internal API and may change without notice.
-   */
-  toCoreMessage,
-} from "./toCoreMessages";
-
-/**
- * @deprecated This is an internal API and may change without notice.
- */
-export { fromLanguageModelTools } from "./fromLanguageModelTools";
-
-/**
- * @deprecated This is an internal API and may change without notice.
- */
-export { toLanguageModelTools } from "./toLanguageModelTools";

package/src/runtimes/edge/converters/toCoreMessages.ts

@@ -1,64 +0,0 @@
-import { ThreadMessage, CoreMessage } from "../../../types";
-
-type CoreMessageWithConditionalId<T extends boolean> = T extends false
-  ? CoreMessage
-  : CoreMessage & { unstable_id?: string };
-
-export const toCoreMessages = <T extends boolean = false>(
-  messages: readonly ThreadMessage[],
-  options: { unstable_includeId?: T | undefined } = {},
-): CoreMessageWithConditionalId<T>[] => {
-  return messages.map((message) => toCoreMessage(message, options));
-};
-
-export const toCoreMessage = <T extends boolean = false>(
-  message: ThreadMessage,
-  options: { unstable_includeId?: T | undefined } = {},
-): CoreMessageWithConditionalId<T> => {
-  const includeId = options.unstable_includeId ?? false;
-  const role = message.role;
-  switch (role) {
-    case "assistant":
-      return {
-        role,
-        content: message.content
-          .map((part) => {
-            if (
-              part.type === "reasoning" ||
-              part.type === "source" ||
-              part.type === "file"
-            )
-              return null; // reasoning, source, and file parts are omitted
-            if (part.type === "tool-call") {
-              const { argsText, ...rest } = part;
-              return rest;
-            }
-            return part;
-          })
-          .filter((c) => !!c),
-        ...(includeId ? { unstable_id: message.id } : {}),
-      };
-
-    case "user":
-      return {
-        role,
-        content: [
-          ...message.content,
-          ...message.attachments.map((a) => a.content).flat(),
-        ],
-        ...(includeId ? { unstable_id: message.id } : {}),
-      };
-
-    case "system":
-      return {
-        role,
-        content: message.content,
-        ...(includeId ? { unstable_id: message.id } : {}),
-      };
-
-    default: {
-      const unsupportedRole: never = role;
-      throw new Error(`Unknown message role: ${unsupportedRole}`);
-    }
-  }
-};

package/src/runtimes/edge/converters/toLanguageModelMessages.ts

@@ -1,184 +0,0 @@
-import {
-  LanguageModelV1FilePart,
-  LanguageModelV1ImagePart,
-  LanguageModelV1Message,
-  LanguageModelV1TextPart,
-  LanguageModelV1ToolCallPart,
-  LanguageModelV1ToolResultPart,
-} from "@ai-sdk/provider";
-import {
-  CoreMessage,
-  ThreadMessage,
-  TextContentPart,
-  CoreToolCallContentPart,
-  ToolCallContentPart,
-} from "../../../types/AssistantTypes";
-
-const assistantMessageSplitter = () => {
-  const stash: LanguageModelV1Message[] = [];
-  let assistantMessage = {
-    role: "assistant" as const,
-    content: [] as (LanguageModelV1TextPart | LanguageModelV1ToolCallPart)[],
-  };
-  let toolMessage = {
-    role: "tool" as const,
-    content: [] as LanguageModelV1ToolResultPart[],
-  };
-
-  return {
-    addTextContentPart: (part: TextContentPart) => {
-      if (toolMessage.content.length > 0) {
-        stash.push(assistantMessage);
-        stash.push(toolMessage);
-
-        assistantMessage = {
-          role: "assistant" as const,
-          content: [] as (
-            | LanguageModelV1TextPart
-            | LanguageModelV1ToolCallPart
-          )[],
-        };
-
-        toolMessage = {
-          role: "tool" as const,
-          content: [] as LanguageModelV1ToolResultPart[],
-        };
-      }
-
-      assistantMessage.content.push(part);
-    },
-    addToolCallPart: (part: CoreToolCallContentPart | ToolCallContentPart) => {
-      assistantMessage.content.push({
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        args: part.args,
-      });
-
-      toolMessage.content.push({
-        type: "tool-result",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        ...("artifact" in part ? { artifact: part.artifact } : {}),
-        result:
-          part.result === undefined
-            ? "Error: tool is has no configured code to run"
-            : part.result,
-        isError: part.isError ?? part.result === undefined,
-      });
-    },
-    getMessages: () => {
-      if (toolMessage.content.length > 0) {
-        return [...stash, assistantMessage, toolMessage];
-      }
-
-      return [...stash, assistantMessage];
-    },
-  };
-};
-
-export function toLanguageModelMessages(
-  message: readonly CoreMessage[] | readonly ThreadMessage[],
-  options: { unstable_includeId?: boolean | undefined } = {},
-): LanguageModelV1Message[] {
-  const includeId = options.unstable_includeId ?? false;
-  return message.flatMap((message) => {
-    const role = message.role;
-    switch (role) {
-      case "system": {
-        return [
-          {
-            ...(includeId
-              ? { unstable_id: (message as ThreadMessage).id }
-              : {}),
-            role: "system",
-            content: message.content[0].text,
-          },
-        ];
-      }
-
-      case "user": {
-        const attachments = "attachments" in message ? message.attachments : [];
-        const content = [
-          ...message.content,
-          ...attachments.map((a) => a.content).flat(),
-        ];
-        const msg: LanguageModelV1Message = {
-          ...(includeId ? { unstable_id: (message as ThreadMessage).id } : {}),
-          role: "user",
-          content: content.map(
-            (
-              part,
-            ):
-              | LanguageModelV1TextPart
-              | LanguageModelV1ImagePart
-              | LanguageModelV1FilePart => {
-              const type = part.type;
-              switch (type) {
-                case "text": {
-                  return part;
-                }
-
-                case "image": {
-                  return {
-                    type: "image",
-                    image: new URL(part.image),
-                  };
-                }
-
-                case "file": {
-                  return {
-                    type: "file",
-                    data: new URL(part.data),
-                    mimeType: part.mimeType,
-                  };
-                }
-
-                default: {
-                  const unhandledType: "audio" = type;
-                  throw new Error(
-                    `Unspported content part type: ${unhandledType}`,
-                  );
-                }
-              }
-            },
-          ),
-        };
-        return [msg];
-      }
-
-      case "assistant": {
-        const splitter = assistantMessageSplitter();
-        for (const part of message.content) {
-          const type = part.type;
-          switch (type) {
-            case "reasoning":
-            case "source":
-            case "file": {
-              break; // reasoning, source, and file parts are omitted
-            }
-
-            case "text": {
-              splitter.addTextContentPart(part);
-              break;
-            }
-            case "tool-call": {
-              splitter.addToolCallPart(part);
-              break;
-            }
-            default: {
-              const unhandledType: never = type;
-              throw new Error(`Unhandled content part type: ${unhandledType}`);
-            }
-          }
-        }
-        return splitter.getMessages();
-      }
-
-      default: {
-        const unhandledRole: never = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  });
-}

package/src/runtimes/edge/converters/toLanguageModelTools.ts

@@ -1,18 +0,0 @@
-import { LanguageModelV1FunctionTool } from "@ai-sdk/provider";
-import { JSONSchema7 } from "json-schema";
-import { z } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-import { Tool } from "../../../model-context/ModelContextTypes";
-
-export const toLanguageModelTools = (
-  tools: Record<string, Tool<any, any>>,
-): LanguageModelV1FunctionTool[] => {
-  return Object.entries(tools).map(([name, tool]) => ({
-    type: "function",
-    name,
-    ...(tool.description ? { description: tool.description } : undefined),
-    parameters: (tool.parameters instanceof z.ZodType
-      ? zodToJsonSchema(tool.parameters)
-      : tool.parameters) as JSONSchema7,
-  }));
-};