@assistant-ui/react-ai-sdk 0.10.16 → 0.11.0

package/src/converters/toLanguageModelMessages.ts

@@ -1,185 +0,0 @@
-import {
-  LanguageModelV1FilePart,
-  LanguageModelV1ImagePart,
-  LanguageModelV1Message,
-  LanguageModelV1TextPart,
-  LanguageModelV1ToolCallPart,
-  LanguageModelV1ToolResultPart,
-} from "@ai-sdk/provider";
-import {
-  TextMessagePart,
-  ThreadMessage,
-  ToolCallMessagePart,
-} from "@assistant-ui/react";
-
-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 {
-    addTextMessagePart: (part: TextMessagePart) => {
-      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: ToolCallMessagePart) => {
-      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];
-    },
-  };
-};
-
-/**
- * @deprecated This is an internal API and may change without notice.
- */
-export function toLanguageModelMessages(
-  message: 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 message 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.addTextMessagePart(part);
-              break;
-            }
-            case "tool-call": {
-              splitter.addToolCallPart(part);
-              break;
-            }
-            default: {
-              const unhandledType: never = type;
-              throw new Error(`Unhandled message part type: ${unhandledType}`);
-            }
-          }
-        }
-        return splitter.getMessages();
-      }
-
-      default: {
-        const unhandledRole: never = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  });
-}

package/src/converters/toLanguageModelTools.ts

@@ -1,21 +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 "@assistant-ui/react";
-
-/**
- * @deprecated This is an internal API and may change without notice.
- */
-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,
-  }));
-};

package/src/dangerous-in-browser/DangerousInBrowserAdapter.ts

@@ -1,41 +0,0 @@
-import { asAsyncIterableStream } from "assistant-stream/utils";
-import {
-  AssistantMessageAccumulator,
-  unstable_toolResultStream,
-} from "assistant-stream";
-import { ChatModelAdapter, ChatModelRunOptions } from "@assistant-ui/react";
-import {
-  CreateEdgeRuntimeAPIOptions,
-  getEdgeRuntimeStream,
-} from "./createEdgeRuntimeAPI";
-
-export type DangerousInBrowserAdapterOptions = CreateEdgeRuntimeAPIOptions;
-
-export class DangerousInBrowserAdapter implements ChatModelAdapter {
-  constructor(private options: DangerousInBrowserAdapterOptions) {}
-
-  async *run({ messages, abortSignal, context }: ChatModelRunOptions) {
-    const res = await getEdgeRuntimeStream({
-      options: {
-        ...this.options,
-        ...(context.tools && { tools: context.tools }),
-      },
-      abortSignal,
-      requestData: {
-        system: context.system,
-        messages: messages,
-        ...Object.fromEntries(
-          Object.entries({ ...context.callSettings, ...context.config }).filter(
-            ([_, v]) => v !== undefined,
-          ),
-        ),
-      },
-    });
-
-    const stream = res
-      .pipeThrough(unstable_toolResultStream(context.tools, abortSignal))
-      .pipeThrough(new AssistantMessageAccumulator());
-
-    yield* asAsyncIterableStream(stream);
-  }
-}

package/src/dangerous-in-browser/createEdgeRuntimeAPI.ts

@@ -1,145 +0,0 @@
-import {
-  LanguageModelV1,
-  LanguageModelV1ToolChoice,
-  LanguageModelV1FunctionTool,
-  LanguageModelV1Prompt,
-  LanguageModelV1CallOptions,
-} from "@ai-sdk/provider";
-import { toLanguageModelMessages } from "../converters/toLanguageModelMessages";
-import { toLanguageModelTools } from "../converters/toLanguageModelTools";
-import { AssistantStreamChunk } from "assistant-stream";
-import { LanguageModelV1StreamDecoder } from "assistant-stream/ai-sdk";
-import { ThreadMessage, Tool } from "@assistant-ui/react";
-
-export type LanguageModelV1CallSettings = {
-  maxTokens?: number;
-  temperature?: number;
-  topP?: number;
-  presencePenalty?: number;
-  frequencyPenalty?: number;
-  seed?: number;
-  headers?: Record<string, string>;
-};
-
-export type LanguageModelConfig = {
-  apiKey?: string;
-  baseUrl?: string;
-  modelName?: string;
-};
-
-export type EdgeRuntimeRequestOptions = {
-  system?: string | undefined;
-  messages: readonly ThreadMessage[];
-  runConfig?: {
-    custom?: Record<string, unknown>;
-  };
-  tools?: any[];
-  unstable_assistantMessageId?: string;
-  state?: unknown;
-} & LanguageModelV1CallSettings &
-  LanguageModelConfig;
-
-type LanguageModelCreator = (
-  config: LanguageModelConfig,
-) => Promise<LanguageModelV1> | LanguageModelV1;
-
-type ThreadStep = {
-  readonly messageId?: string;
-  readonly usage?:
-    | {
-        readonly promptTokens: number;
-        readonly completionTokens: number;
-      }
-    | undefined;
-};
-
-type FinishResult = {
-  messages: readonly ThreadMessage[];
-  metadata: {
-    steps: readonly ThreadStep[];
-  };
-};
-
-export type CreateEdgeRuntimeAPIOptions = LanguageModelV1CallSettings & {
-  model: LanguageModelV1 | LanguageModelCreator;
-  system?: string;
-  tools?: Record<string, Tool<any, any>>;
-  toolChoice?: LanguageModelV1ToolChoice;
-  onFinish?: (result: FinishResult) => void;
-};
-
-type GetEdgeRuntimeStreamOptions = {
-  abortSignal: AbortSignal;
-  requestData: EdgeRuntimeRequestOptions;
-  options: CreateEdgeRuntimeAPIOptions;
-};
-
-export const getEdgeRuntimeStream = async ({
-  abortSignal,
-  requestData: request,
-  options: {
-    model: modelOrCreator,
-    system: serverSystem,
-    tools: serverTools = {},
-    toolChoice,
-    onFinish,
-    ...unsafeSettings
-  },
-}: GetEdgeRuntimeStreamOptions): Promise<
-  ReadableStream<AssistantStreamChunk>
-> => {
-  const model =
-    typeof modelOrCreator === "function"
-      ? await modelOrCreator(request)
-      : modelOrCreator;
-
-  const messages: LanguageModelV1Prompt = toLanguageModelMessages(
-    request.messages,
-  );
-
-  if (serverSystem || request.system) {
-    messages.unshift({
-      role: "system",
-      content: serverSystem || request.system!,
-    });
-  }
-
-  const allTools = serverTools || {};
-  const tools: LanguageModelV1FunctionTool[] = toLanguageModelTools(allTools);
-  const callOptions: LanguageModelV1CallOptions = {
-    inputFormat: "messages",
-    mode:
-      tools.length > 0
-        ? {
-            type: "regular",
-            tools,
-            ...(toolChoice && { toolChoice }),
-          }
-        : { type: "regular" },
-    prompt: messages,
-    ...(request.maxTokens !== undefined && { maxTokens: request.maxTokens }),
-    ...(request.temperature !== undefined && {
-      temperature: request.temperature,
-    }),
-    ...(request.topP !== undefined && { topP: request.topP }),
-    ...(request.presencePenalty !== undefined && {
-      presencePenalty: request.presencePenalty,
-    }),
-    ...(request.frequencyPenalty !== undefined && {
-      frequencyPenalty: request.frequencyPenalty,
-    }),
-    ...(request.seed !== undefined && { seed: request.seed }),
-    ...(request.headers && {
-      headers: Object.fromEntries(
-        Object.entries(request.headers).filter(([_, v]) => v !== undefined),
-      ) as Record<string, string>,
-    }),
-    abortSignal,
-    ...Object.fromEntries(
-      Object.entries(unsafeSettings).filter(([_, v]) => v !== undefined),
-    ),
-  };
-
-  const result = await model.doStream(callOptions);
-  return result.stream.pipeThrough(new LanguageModelV1StreamDecoder());
-};

package/src/dangerous-in-browser/index.ts

@@ -1,4 +0,0 @@
-export {
-  useDangerousInBrowserRuntime,
-  type DangerousInBrowserRuntimeOptions,
-} from "./useDangerousInBrowserRuntime";

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

@@ -1,26 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import {
-  DangerousInBrowserAdapter,
-  DangerousInBrowserAdapterOptions,
-} from "./DangerousInBrowserAdapter";
-import {
-  INTERNAL,
-  LocalRuntimeOptions,
-  useLocalRuntime,
-} from "@assistant-ui/react";
-
-const { splitLocalRuntimeOptions } = INTERNAL;
-
-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/rsc/RSCDisplay.tsx

@@ -1,23 +0,0 @@
-"use client";
-import {
-  useThread,
-  useMessage,
-  getExternalStoreMessage,
-} from "@assistant-ui/react";
-import {
-  RSCThreadExtras,
-  symbolInternalRSCExtras,
-} from "./utils/RSCThreadExtras";
-import { FC } from "react";
-
-export const RSCDisplay: FC = () => {
-  const convertFn = useThread((t) => {
-    const extras = (t.extras as RSCThreadExtras)?.[symbolInternalRSCExtras];
-    if (!extras)
-      throw new Error(
-        "This function can only be used inside a Vercel RSC runtime.",
-      );
-    return extras.convertFn;
-  });
-  return useMessage((m) => convertFn(getExternalStoreMessage(m)).display);
-};

package/src/rsc/VercelRSCAdapter.tsx

@@ -1,21 +0,0 @@
-import type { AppendMessage, ExternalStoreAdapter } from "@assistant-ui/react";
-import type { VercelRSCMessage } from "./VercelRSCMessage";
-
-type RSCMessageConverter<T> = {
-  convertMessage: (message: T) => VercelRSCMessage;
-};
-
-type VercelRSCAdapterBase<T> = {
-  isRunning?: boolean | undefined;
-  messages: T[];
-
-  onNew?: (message: AppendMessage) => Promise<void>;
-  onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
-  onReload?: ((parentId: string | null) => Promise<void>) | undefined;
-  convertMessage?: ((message: T) => VercelRSCMessage) | undefined;
-
-  adapters?: ExternalStoreAdapter["adapters"] | undefined;
-};
-
-export type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> &
-  (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);

package/src/rsc/VercelRSCMessage.tsx

@@ -1,9 +0,0 @@
-"use client";
-import type { ReactNode } from "react";
-
-export type VercelRSCMessage = {
-  id?: string | undefined;
-  role: "user" | "assistant";
-  display: ReactNode;
-  createdAt?: Date | undefined;
-};

package/src/rsc/index.ts

@@ -1,4 +0,0 @@
-export { useVercelRSCRuntime } from "./useVercelRSCRuntime";
-export type { VercelRSCAdapter } from "./VercelRSCAdapter";
-export type { VercelRSCMessage } from "./VercelRSCMessage";
-export { RSCDisplay } from "./RSCDisplay";

package/src/rsc/useVercelRSCRuntime.tsx

@@ -1,70 +0,0 @@
-"use client";
-
-import type { VercelRSCAdapter } from "./VercelRSCAdapter";
-import {
-  ExternalStoreAdapter,
-  ThreadMessageLike,
-  useExternalMessageConverter,
-  useExternalStoreRuntime,
-} from "@assistant-ui/react";
-import { VercelRSCMessage } from "./VercelRSCMessage";
-import { useCallback, useMemo } from "react";
-import { symbolInternalRSCExtras } from "./utils/RSCThreadExtras";
-
-const vercelToThreadMessage = <T,>(
-  converter: (message: T) => VercelRSCMessage,
-  rawMessage: T,
-): ThreadMessageLike => {
-  const message = converter(rawMessage);
-
-  return {
-    id: message.id,
-    role: message.role,
-    content: [{ type: "text", text: "[Developer: Please set up RSCDisplay]" }],
-    createdAt: message.createdAt,
-  };
-};
-
-export const useVercelRSCRuntime = <T extends WeakKey>(
-  adapter: VercelRSCAdapter<T>,
-) => {
-  const onNew = adapter.onNew;
-  if (!onNew)
-    throw new Error("You must pass a onNew function to useVercelRSCRuntime");
-
-  const convertFn = useMemo(() => {
-    return (
-      adapter.convertMessage?.bind(adapter) ?? ((m: T) => m as VercelRSCMessage)
-    );
-  }, [adapter]);
-  const callback = useCallback(
-    (m: T) => {
-      return vercelToThreadMessage(convertFn, m);
-    },
-    [convertFn],
-  );
-
-  const messages = useExternalMessageConverter({
-    callback,
-    isRunning: adapter.isRunning ?? false,
-    messages: adapter.messages,
-  });
-
-  const eAdapter: ExternalStoreAdapter = {
-    isRunning: adapter.isRunning,
-    messages,
-    onNew,
-    onEdit: adapter.onEdit,
-    onReload: adapter.onReload,
-    adapters: adapter.adapters,
-    unstable_capabilities: {
-      copy: false,
-    },
-    extras: {
-      [symbolInternalRSCExtras]: { convertFn },
-    },
-  };
-
-  const runtime = useExternalStoreRuntime(eAdapter);
-  return runtime;
-};

package/src/rsc/utils/RSCThreadExtras.tsx

@@ -1,11 +0,0 @@
-"use client";
-import { VercelRSCMessage } from "../VercelRSCMessage";
-
-export const symbolInternalRSCExtras = Symbol("internal-rsc-extras");
-export type RSCThreadExtras =
-  | {
-      [symbolInternalRSCExtras]?: {
-        convertFn: (message: any) => VercelRSCMessage;
-      };
-    }
-  | undefined;

package/src/ui/use-assistant/useVercelUseAssistantRuntime.tsx

@@ -1,60 +0,0 @@
-"use client";
-
-import type { useAssistant } from "@ai-sdk/react";
-import { useExternalStoreRuntime } from "@assistant-ui/react";
-import { useInputSync } from "../utils/useInputSync";
-import { toCreateMessage } from "../utils/toCreateMessage";
-import { vercelAttachmentAdapter } from "../utils/vercelAttachmentAdapter";
-import { ExternalStoreAdapter } from "@assistant-ui/react";
-import { AISDKMessageConverter } from "../utils/convertMessage";
-
-export type VercelUseChatAdapter = {
-  adapters?:
-    | Omit<NonNullable<ExternalStoreAdapter["adapters"]>, "attachments">
-    | undefined;
-};
-
-export const useVercelUseAssistantRuntime = (
-  assistantHelpers: ReturnType<typeof useAssistant>,
-  adapter: VercelUseChatAdapter = {},
-) => {
-  const messages = AISDKMessageConverter.useThreadMessages({
-    messages: assistantHelpers.messages,
-    isRunning: assistantHelpers.status === "in_progress",
-  });
-
-  const runtime = useExternalStoreRuntime({
-    isRunning: assistantHelpers.status === "in_progress",
-    messages,
-    onCancel: async () => assistantHelpers.stop(),
-    onNew: async (message) => {
-      await assistantHelpers.append(await toCreateMessage(message));
-    },
-    adapters: {
-      attachments: vercelAttachmentAdapter,
-      ...adapter.adapters,
-      threadList: new Proxy(adapter.adapters?.threadList ?? {}, {
-        get(target, prop, receiver) {
-          if (prop === "onSwitchToNewThread") {
-            return () => {
-              assistantHelpers.messages = [];
-              assistantHelpers.input = "";
-              assistantHelpers.setMessages([]);
-              assistantHelpers.setInput("");
-
-              if (typeof target.onSwitchToNewThread === "function") {
-                return target.onSwitchToNewThread.call(target);
-              }
-            };
-          }
-
-          return Reflect.get(target, prop, receiver);
-        },
-      }),
-    },
-  });
-
-  useInputSync(assistantHelpers, runtime);
-
-  return runtime;
-};

package/src/ui/utils/useInputSync.tsx

@@ -1,26 +0,0 @@
-"use client";
-
-import { useEffect } from "react";
-import { useAssistant, useChat } from "@ai-sdk/react";
-import { AssistantRuntime } from "@assistant-ui/react";
-
-type VercelHelpers =
-  | ReturnType<typeof useChat>
-  | ReturnType<typeof useAssistant>;
-
-export const useInputSync = (
-  { setInput, input }: VercelHelpers,
-  runtime: AssistantRuntime,
-) => {
-  // sync input from vercel to assistant-ui
-  useEffect(() => {
-    runtime.thread.composer.setText(input);
-  }, [runtime, input]);
-
-  // sync input from assistant-ui to vercel
-  useEffect(() => {
-    return runtime.thread.composer.subscribe(() => {
-      setInput(runtime.thread.composer.getState().text);
-    });
-  }, [runtime, setInput]);
-};