@assistant-ui/react 0.8.20 → 0.9.1

package/src/runtimes/dangerous-in-browser/useDangerousInBrowserRuntime.ts

@@ -1,21 +0,0 @@
-"use client";
-
-import { LocalRuntimeOptions, useLocalRuntime } from "..";
-import { useState } from "react";
-import {
-  DangerousInBrowserAdapter,
-  DangerousInBrowserAdapterOptions,
-} from "./DangerousInBrowserAdapter";
-import { splitLocalRuntimeOptions } from "../local/LocalRuntimeOptions";
-
-export type DangerousInBrowserRuntimeOptions =
-  DangerousInBrowserAdapterOptions & LocalRuntimeOptions;
-
-export const useDangerousInBrowserRuntime = (
-  options: DangerousInBrowserRuntimeOptions,
-) => {
-  const { localRuntimeOptions, otherOptions } =
-    splitLocalRuntimeOptions(options);
-  const [adapter] = useState(() => new DangerousInBrowserAdapter(otherOptions));
-  return useLocalRuntime(adapter, localRuntimeOptions);
-};

package/src/runtimes/edge/EdgeModelAdapter.ts

@@ -1,188 +0,0 @@
-import {
-  ChatModelAdapter,
-  ChatModelRunOptions,
-} from "../local/ChatModelAdapter";
-import { toCoreMessages } from "./converters/toCoreMessages";
-import { toLanguageModelTools } from "./converters/toLanguageModelTools";
-import { EdgeRuntimeRequestOptions } from "./EdgeRuntimeRequestOptions";
-import { toolResultStream } from "./streams/toolResultStream";
-import { toLanguageModelMessages } from "./converters";
-import { ThreadMessage } from "../../types";
-import { Tool } from "../../model-context";
-import { z } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-import { JSONSchema7 } from "json-schema";
-import {
-  AssistantMessageAccumulator,
-  DataStreamDecoder,
-} from "assistant-stream";
-
-export function asAsyncIterable<T>(
-  source: ReadableStream<T>,
-): AsyncIterable<T> {
-  return {
-    [Symbol.asyncIterator]: () => {
-      const reader = source.getReader();
-      return {
-        async next(): Promise<IteratorResult<T, undefined>> {
-          const { done, value } = await reader.read();
-          return done
-            ? { done: true, value: undefined }
-            : { done: false, value };
-        },
-      };
-    },
-  };
-}
-
-type HeadersValue = Record<string, string> | Headers;
-
-export type EdgeModelAdapterOptions = {
-  api: string;
-
-  // experimental_prepareRequestBody?: (options: {
-  //   id: string;
-  //   messages: UIMessage[];
-  //   requestData?: JSONValue;
-  //   requestBody?: object;
-  // }) => unknown;
-
-  // onToolCall?: ({
-  //   toolCall,
-  // }: {
-  //   toolCall: UIMessageToolInvocation;
-  // }) => void | Promise<unknown> | unknown;
-
-  /**
-   * Callback function to be called when the API response is received.
-   */
-  onResponse?: (response: Response) => void | Promise<void>;
-  /**
-   * Optional callback function that is called when the assistant message is finished streaming.
-   */
-  onFinish?: (message: ThreadMessage) => void;
-  /**
-   * Callback function to be called when an error is encountered.
-   */
-  onError?: (error: Error) => void;
-
-  credentials?: RequestCredentials;
-
-  /**
-   * Headers to be sent with the request.
-   * Can be a static headers object or a function that returns a Promise of headers.
-   */
-  headers?: HeadersValue | (() => Promise<HeadersValue>);
-
-  body?: object;
-
-  /**
-   * @deprecated Renamed to `sendExtraMessageFields`.
-   */
-  unstable_sendMessageIds?: boolean;
-
-  /**
-   * When enabled, the adapter will not strip `id` from messages in the messages array.
-   */
-  sendExtraMessageFields?: boolean;
-
-  /**
-   * When enabled, the adapter will send messages in the format expected by the Vercel AI SDK Core.
-   * This feature will be removed in the future in favor of a better solution.
-   *
-   * `v2` sends frontend tools in a format that can be directly passed to `stremaText`
-   */
-  unstable_AISDKInterop?: boolean | "v2" | undefined;
-};
-
-const toAISDKTools = (tools: Record<string, Tool<any, any>>) => {
-  return Object.fromEntries(
-    Object.entries(tools).map(([name, tool]) => [
-      name,
-      {
-        ...(tool.description ? { description: tool.description } : undefined),
-        parameters: (tool.parameters instanceof z.ZodType
-          ? zodToJsonSchema(tool.parameters)
-          : tool.parameters) as JSONSchema7,
-      },
-    ]),
-  );
-};
-
-export class EdgeModelAdapter implements ChatModelAdapter {
-  constructor(private options: EdgeModelAdapterOptions) {}
-
-  async *run({
-    messages,
-    runConfig,
-    abortSignal,
-    context,
-    unstable_assistantMessageId,
-    unstable_getMessage,
-  }: ChatModelRunOptions) {
-    const headersValue =
-      typeof this.options.headers === "function"
-        ? await this.options.headers()
-        : this.options.headers;
-
-    const headers = new Headers(headersValue);
-    headers.set("Content-Type", "application/json");
-
-    const result = await fetch(this.options.api, {
-      method: "POST",
-      headers,
-      credentials: this.options.credentials ?? "same-origin",
-      body: JSON.stringify({
-        system: context.system,
-        messages: this.options.unstable_AISDKInterop
-          ? (toLanguageModelMessages(messages, {
-              unstable_includeId:
-                this.options.unstable_sendMessageIds ||
-                this.options.sendExtraMessageFields,
-            }) as EdgeRuntimeRequestOptions["messages"]) // TODO figure out a better way to do this
-          : toCoreMessages(messages, {
-              unstable_includeId:
-                this.options.unstable_sendMessageIds ||
-                this.options.sendExtraMessageFields,
-            }),
-        tools: context.tools
-          ? this.options.unstable_AISDKInterop === "v2"
-            ? (toAISDKTools(context.tools) as any)
-            : toLanguageModelTools(context.tools)
-          : [],
-        unstable_assistantMessageId,
-        runConfig,
-        ...context.callSettings,
-        ...context.config,
-
-        ...this.options.body,
-      } satisfies EdgeRuntimeRequestOptions),
-      signal: abortSignal,
-    });
-
-    await this.options.onResponse?.(result);
-
-    try {
-      if (!result.ok) {
-        throw new Error(`Status ${result.status}: ${await result.text()}`);
-      }
-      if (!result.body) {
-        throw new Error("Response body is null");
-      }
-
-      const stream = result.body
-        .pipeThrough(new DataStreamDecoder())
-        .pipeThrough(toolResultStream(context.tools, abortSignal))
-        .pipeThrough(new AssistantMessageAccumulator());
-
-      for await (const update of asAsyncIterable(stream)) {
-        yield update;
-      }
-
-      this.options.onFinish?.(unstable_getMessage());
-    } catch (error: unknown) {
-      this.options.onError?.(error as Error);
-      throw error;
-    }
-  }
-}

package/src/runtimes/edge/EdgeRuntimeRequestOptions.ts

@@ -1,109 +0,0 @@
-import { JSONSchema7 } from "json-schema";
-import {
-  LanguageModelConfigSchema,
-  LanguageModelV1CallSettingsSchema,
-} from "../../model-context/ModelContextTypes";
-import { z } from "zod";
-import { ReadonlyJSONObject } from "../../utils/json/json-value";
-
-const LanguageModelV1FunctionToolSchema = z.object({
-  type: z.literal("function"),
-  name: z.string(),
-  description: z.string().optional(),
-  parameters: z.custom<JSONSchema7>(
-    (val) => typeof val === "object" && val !== null,
-  ),
-});
-
-const TextContentPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-});
-
-const ImageContentPartSchema = z.object({
-  type: z.literal("image"),
-  image: z.string(),
-});
-
-const FileContentPartSchema = z.object({
-  type: z.literal("file"),
-  data: z.string(),
-  mimeType: z.string(),
-});
-
-const Unstable_AudioContentPart = z.object({
-  type: z.literal("audio"),
-  audio: z.object({
-    data: z.string(),
-    format: z.union([z.literal("mp3"), z.literal("wav")]),
-  }),
-});
-
-const CoreToolCallContentPartSchema = z.object({
-  type: z.literal("tool-call"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z
-    .record(z.unknown())
-    .refine((c): c is ReadonlyJSONObject => c !== undefined),
-  result: z.unknown().optional(),
-  isError: z.boolean().optional(),
-});
-
-const CoreUserMessageSchema = z.object({
-  role: z.literal("user"),
-  content: z
-    .array(
-      z.discriminatedUnion("type", [
-        TextContentPartSchema,
-        ImageContentPartSchema,
-        FileContentPartSchema,
-        Unstable_AudioContentPart,
-      ]),
-    )
-    .min(1)
-    .readonly(),
-});
-
-const CoreAssistantMessageSchema = z.object({
-  role: z.literal("assistant"),
-  content: z
-    .array(
-      z.discriminatedUnion("type", [
-        TextContentPartSchema,
-        CoreToolCallContentPartSchema,
-      ]),
-    )
-    .min(1)
-    .readonly(),
-});
-
-const CoreSystemMessageSchema = z.object({
-  role: z.literal("system"),
-  content: z.tuple([TextContentPartSchema]).readonly(),
-});
-
-const CoreMessageSchema = z.discriminatedUnion("role", [
-  CoreSystemMessageSchema,
-  CoreUserMessageSchema,
-  CoreAssistantMessageSchema,
-]);
-
-export const EdgeRuntimeRequestOptionsSchema = z
-  .object({
-    system: z.string().optional(),
-    messages: z.array(CoreMessageSchema).min(1).readonly(),
-    runConfig: z
-      .object({
-        custom: z.record(z.unknown()).optional(),
-      })
-      .optional(),
-    tools: z.array(LanguageModelV1FunctionToolSchema).readonly().optional(),
-    unstable_assistantMessageId: z.string().optional(),
-  })
-  .merge(LanguageModelV1CallSettingsSchema)
-  .merge(LanguageModelConfigSchema);
-
-export type EdgeRuntimeRequestOptions = z.infer<
-  typeof EdgeRuntimeRequestOptionsSchema
->;

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}`);
-    }
-  }
-};