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

package/dist/useChatRuntime.js

@@ -1,10 +1,104 @@
+"use client";
+
 // src/useChatRuntime.ts
-import { useEdgeRuntime } from "@assistant-ui/react-edge";
+import { toLanguageModelMessages } from "./converters/index.js";
+import {
+  INTERNAL,
+  useLocalRuntime
+} from "@assistant-ui/react";
+import { z } from "zod";
+import zodToJsonSchema from "zod-to-json-schema";
+import {
+  AssistantMessageAccumulator,
+  DataStreamDecoder,
+  unstable_toolResultStream
+} from "assistant-stream";
+import { asAsyncIterableStream } from "assistant-stream/utils";
+var { splitLocalRuntimeOptions } = INTERNAL;
+var toAISDKTools = (tools) => {
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, tool]) => [
+      name,
+      {
+        ...tool.description ? { description: tool.description } : void 0,
+        parameters: tool.parameters instanceof z.ZodType ? zodToJsonSchema(tool.parameters) : tool.parameters
+      }
+    ])
+  );
+};
+var getEnabledTools = (tools) => {
+  return Object.fromEntries(
+    Object.entries(tools).filter(
+      ([, tool]) => !tool.disabled && tool.type !== "backend"
+    )
+  );
+};
+var ChatRuntimeAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async *run({
+    messages,
+    runConfig,
+    abortSignal,
+    context,
+    unstable_assistantMessageId,
+    unstable_getMessage
+  }) {
+    const headersValue = typeof this.options.headers === "function" ? await this.options.headers() : this.options.headers;
+    abortSignal.addEventListener(
+      "abort",
+      () => {
+        if (!abortSignal.reason?.detach) this.options.onCancel?.();
+      },
+      { once: true }
+    );
+    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: toLanguageModelMessages(messages, {
+          unstable_includeId: this.options.sendExtraMessageFields
+        }),
+        tools: toAISDKTools(
+          getEnabledTools(context.tools ?? {})
+        ),
+        ...unstable_assistantMessageId ? { unstable_assistantMessageId } : {},
+        runConfig,
+        state: unstable_getMessage().metadata.unstable_state || void 0,
+        ...context.callSettings,
+        ...context.config,
+        ...this.options.body
+      }),
+      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(unstable_toolResultStream(context.tools, abortSignal)).pipeThrough(new AssistantMessageAccumulator());
+      yield* asAsyncIterableStream(stream);
+      this.options.onFinish?.(unstable_getMessage());
+    } catch (error) {
+      this.options.onError?.(error);
+      throw error;
+    }
+  }
+};
 var useChatRuntime = (options) => {
-  return useEdgeRuntime({
-    ...options,
-    unstable_AISDKInterop: "v2"
-  });
+  const { localRuntimeOptions, otherOptions } = splitLocalRuntimeOptions(options);
+  return useLocalRuntime(
+    new ChatRuntimeAdapter(otherOptions),
+    localRuntimeOptions
+  );
 };
 export {
   useChatRuntime

package/dist/useChatRuntime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/useChatRuntime.ts"],"sourcesContent":["import { EdgeRuntimeOptions, useEdgeRuntime } from \"@assistant-ui/react-edge\";\n\nexport type UseChatRuntimeOptions = Omit<\n  EdgeRuntimeOptions,\n  \"unstable_AISDKInterop\"\n>;\n\nexport const useChatRuntime = (options: UseChatRuntimeOptions) => {\n  return useEdgeRuntime({\n    ...options,\n    unstable_AISDKInterop: \"v2\",\n  });\n};\n"],"mappings":";AAAA,SAA6B,sBAAsB;AAO5C,IAAM,iBAAiB,CAAC,YAAmC;AAChE,SAAO,eAAe;AAAA,IACpB,GAAG;AAAA,IACH,uBAAuB;AAAA,EACzB,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../src/useChatRuntime.ts"],"sourcesContent":["\"use client\";\n\nimport { toLanguageModelMessages } from \"./converters\";\nimport {\n  AssistantRuntime,\n  ChatModelAdapter,\n  ChatModelRunOptions,\n  INTERNAL,\n  LocalRuntimeOptions,\n  ThreadMessage,\n  Tool,\n  useLocalRuntime,\n} from \"@assistant-ui/react\";\nimport { z } from \"zod\";\nimport zodToJsonSchema from \"zod-to-json-schema\";\nimport { JSONSchema7 } from \"json-schema\";\nimport {\n  AssistantMessageAccumulator,\n  DataStreamDecoder,\n  unstable_toolResultStream,\n} from \"assistant-stream\";\nimport { asAsyncIterableStream } from \"assistant-stream/utils\";\n\nconst { splitLocalRuntimeOptions } = INTERNAL;\n\ntype HeadersValue = Record<string, string> | Headers;\n\nexport type UseChatRuntimeOptions = {\n  api: string;\n  onResponse?: (response: Response) => void | Promise<void>;\n  onFinish?: (message: ThreadMessage) => void;\n  onError?: (error: Error) => void;\n  onCancel?: () => void;\n  credentials?: RequestCredentials;\n  headers?: HeadersValue | (() => Promise<HeadersValue>);\n  body?: object;\n  sendExtraMessageFields?: boolean;\n} & LocalRuntimeOptions;\n\ntype ChatRuntimeRequestOptions = {\n  messages: any[];\n  tools: any;\n  system?: string | undefined;\n  runConfig?: any;\n  unstable_assistantMessageId?: string;\n  state?: any;\n};\n\nconst toAISDKTools = (tools: Record<string, Tool>) => {\n  return Object.fromEntries(\n    Object.entries(tools).map(([name, tool]) => [\n      name,\n      {\n        ...(tool.description ? { description: tool.description } : undefined),\n        parameters: (tool.parameters instanceof z.ZodType\n          ? zodToJsonSchema(tool.parameters)\n          : tool.parameters) as JSONSchema7,\n      },\n    ]),\n  );\n};\n\nconst getEnabledTools = (tools: Record<string, Tool>) => {\n  return Object.fromEntries(\n    Object.entries(tools).filter(\n      ([, tool]) => !tool.disabled && tool.type !== \"backend\",\n    ),\n  );\n};\n\nclass ChatRuntimeAdapter implements ChatModelAdapter {\n  constructor(\n    private options: Omit<UseChatRuntimeOptions, keyof LocalRuntimeOptions>,\n  ) {}\n\n  async *run({\n    messages,\n    runConfig,\n    abortSignal,\n    context,\n    unstable_assistantMessageId,\n    unstable_getMessage,\n  }: ChatModelRunOptions) {\n    const headersValue =\n      typeof this.options.headers === \"function\"\n        ? await this.options.headers()\n        : this.options.headers;\n\n    abortSignal.addEventListener(\n      \"abort\",\n      () => {\n        if (!abortSignal.reason?.detach) this.options.onCancel?.();\n      },\n      { once: true },\n    );\n\n    const headers = new Headers(headersValue);\n    headers.set(\"Content-Type\", \"application/json\");\n\n    const result = await fetch(this.options.api, {\n      method: \"POST\",\n      headers,\n      credentials: this.options.credentials ?? \"same-origin\",\n      body: JSON.stringify({\n        system: context.system,\n        messages: toLanguageModelMessages(messages, {\n          unstable_includeId: this.options.sendExtraMessageFields,\n        }) as ChatRuntimeRequestOptions[\"messages\"],\n        tools: toAISDKTools(\n          getEnabledTools(context.tools ?? {}),\n        ) as unknown as ChatRuntimeRequestOptions[\"tools\"],\n        ...(unstable_assistantMessageId ? { unstable_assistantMessageId } : {}),\n        runConfig,\n        state: unstable_getMessage().metadata.unstable_state || undefined,\n        ...context.callSettings,\n        ...context.config,\n        ...this.options.body,\n      } satisfies ChatRuntimeRequestOptions),\n      signal: abortSignal,\n    });\n\n    await this.options.onResponse?.(result);\n\n    try {\n      if (!result.ok) {\n        throw new Error(`Status ${result.status}: ${await result.text()}`);\n      }\n      if (!result.body) {\n        throw new Error(\"Response body is null\");\n      }\n\n      const stream = result.body\n        .pipeThrough(new DataStreamDecoder())\n        .pipeThrough(unstable_toolResultStream(context.tools, abortSignal))\n        .pipeThrough(new AssistantMessageAccumulator());\n\n      yield* asAsyncIterableStream(stream);\n\n      this.options.onFinish?.(unstable_getMessage());\n    } catch (error: unknown) {\n      this.options.onError?.(error as Error);\n      throw error;\n    }\n  }\n}\n\nexport const useChatRuntime = (\n  options: UseChatRuntimeOptions,\n): AssistantRuntime => {\n  const { localRuntimeOptions, otherOptions } =\n    splitLocalRuntimeOptions(options);\n\n  return useLocalRuntime(\n    new ChatRuntimeAdapter(otherOptions),\n    localRuntimeOptions,\n  );\n};\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-ai-sdk",
-  "version": "0.10.15",
+  "version": "0.10.16",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -18,16 +18,19 @@
   ],
   "sideEffects": false,
   "dependencies": {
+    "@ai-sdk/provider": "^1.1.3",
     "@ai-sdk/react": "*",
     "@ai-sdk/ui-utils": "*",
     "@radix-ui/react-use-callback-ref": "^1.1.1",
     "@types/json-schema": "^7.0.15",
+    "assistant-stream": "^0.2.19",
+    "json-schema": "^0.4.0",
     "zod": "^3.25.67",
-    "zustand": "^5.0.6",
-    "@assistant-ui/react-edge": "0.2.13"
+    "zod-to-json-schema": "^3.24.6",
+    "zustand": "^5.0.6"
   },
   "peerDependencies": {
-    "@assistant-ui/react": "^0.10.25",
+    "@assistant-ui/react": "^0.10.26",
     "@types/react": "*",
     "react": "^18 || ^19 || ^19.0.0-rc"
   },
@@ -43,6 +46,7 @@
     "eslint-config-next": "15.3.4",
     "react": "^19.1.0",
     "tsx": "^4.20.3",
+    "@assistant-ui/react": "0.10.26",
     "@assistant-ui/x-buildutils": "0.0.1"
   },
   "publishConfig": {

package/src/converters/fromLanguageModelTools.ts

@@ -0,0 +1,19 @@
+import { LanguageModelV1FunctionTool } from "@ai-sdk/provider";
+import { Tool } from "@assistant-ui/react";
+
+/**
+ * @deprecated This is an internal API and may change without notice.
+ */
+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/converters/index.ts

@@ -0,0 +1,3 @@
+export { toLanguageModelMessages } from "./toLanguageModelMessages";
+export { fromLanguageModelTools } from "./fromLanguageModelTools";
+export { toLanguageModelTools } from "./toLanguageModelTools";

package/src/converters/toLanguageModelMessages.ts

@@ -0,0 +1,185 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,145 @@
+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

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

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

@@ -0,0 +1,26 @@
+"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/index.ts

@@ -2,12 +2,6 @@ export * from "./rsc";
 export * from "./ui";
 export * from "./useChatRuntime";
 export * from "./useCloudRuntime";
-
-export {
-  toLanguageModelMessages,
-  toLanguageModelTools,
-  fromLanguageModelMessages,
-  fromLanguageModelTools,
-  useDangerousInBrowserRuntime,
-} from "@assistant-ui/react-edge";
+export * from "./converters";
+export * from "./dangerous-in-browser";
 export { frontendTools } from "./frontendTools";