@assistant-ui/react 0.5.91 → 0.5.93

package/src/runtimes/core/ThreadManagerRuntimeCore.tsx

@@ -0,0 +1,27 @@
+import { Unsubscribe } from "../../types";
+import { ThreadRuntimeCore } from "./ThreadRuntimeCore";
+
+export type ThreadManagerMetadata = {
+  threadId: string;
+  title?: string;
+};
+
+export type ThreadManagerRuntimeCore = {
+  mainThread: ThreadRuntimeCore;
+
+  threads: readonly ThreadManagerMetadata[];
+  archivedThreads: readonly ThreadManagerMetadata[];
+
+  switchToThread(threadId: string): void;
+  switchToNewThread(): void;
+
+  // getLoadThreadsPromise(): Promise<void>;
+  // getLoadArchivedThreadsPromise(): Promise<void>;
+  // create(): Promise<ThreadMetadata>;
+  rename(threadId: string, newTitle: string): Promise<void>;
+  archive(threadId: string): Promise<void>;
+  unarchive(threadId: string): Promise<void>;
+  delete(threadId: string): Promise<void>;
+
+  subscribe(callback: () => void): Unsubscribe;
+};

package/src/runtimes/core/ThreadRuntimeCore.tsx

@@ -0,0 +1,96 @@
+import { AppendMessage, ModelConfig, ThreadMessage } from "../../types";
+import type { Unsubscribe } from "../../types/Unsubscribe";
+import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
+import { ExportedMessageRepository } from "../utils/MessageRepository";
+import {
+  ComposerRuntimeCore,
+  ThreadComposerRuntimeCore,
+} from "./ComposerRuntimeCore";
+
+export type RuntimeCapabilities = Readonly<{
+  switchToBranch: boolean;
+  edit: boolean;
+  reload: boolean;
+  cancel: boolean;
+  unstable_copy: boolean;
+  speech: boolean;
+  attachments: boolean;
+  feedback: boolean;
+}>;
+
+export type AddToolResultOptions = {
+  messageId: string;
+  toolName: string;
+  toolCallId: string;
+  result: any;
+};
+
+export type SubmitFeedbackOptions = {
+  messageId: string;
+  type: "negative" | "positive";
+};
+
+export type ThreadSuggestion = {
+  prompt: string;
+};
+
+export type SpeechState = Readonly<{
+  messageId: string;
+  status: SpeechSynthesisAdapter.Status;
+}>;
+
+export type SubmittedFeedback = Readonly<{
+  type: "negative" | "positive";
+}>;
+
+export type ThreadRuntimeEventType =
+  | "switched-to"
+  | "switched-away"
+  | "run-start"
+  | "model-config-update";
+
+export type ThreadRuntimeCore = Readonly<{
+  getMessageById: (messageId: string) =>
+    | {
+        parentId: string | null;
+        message: ThreadMessage;
+      }
+    | undefined;
+
+  getBranches: (messageId: string) => readonly string[];
+  switchToBranch: (branchId: string) => void;
+
+  append: (message: AppendMessage) => void;
+  startRun: (parentId: string | null) => void;
+  cancelRun: () => void;
+
+  addToolResult: (options: AddToolResultOptions) => void;
+
+  speak: (messageId: string) => void;
+  stopSpeaking: () => void;
+
+  getSubmittedFeedback: (messageId: string) => SubmittedFeedback | undefined;
+  submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+
+  getModelConfig: () => ModelConfig;
+
+  composer: ThreadComposerRuntimeCore;
+  getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
+  beginEdit: (messageId: string) => void;
+
+  speech: SpeechState | undefined;
+
+  capabilities: Readonly<RuntimeCapabilities>;
+  threadId: string;
+  isDisabled: boolean;
+  messages: readonly ThreadMessage[];
+  suggestions: readonly ThreadSuggestion[];
+  extras: unknown;
+
+  subscribe: (callback: () => void) => Unsubscribe;
+
+  import(repository: ExportedMessageRepository): void;
+  export(): ExportedMessageRepository;
+
+  unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+}>;

package/src/runtimes/core/index.ts

@@ -0,0 +1,7 @@
+export type {
+  AddToolResultOptions,
+  SubmitFeedbackOptions,
+  ThreadSuggestion,
+} from "./ThreadRuntimeCore";
+
+export { subscribeToMainThread } from "./subscribeToMainThread";

package/src/runtimes/core/subscribeToMainThread.ts

@@ -0,0 +1,30 @@
+import { Unsubscribe } from "../../types";
+import { AssistantRuntimeCore } from "./AssistantRuntimeCore";
+
+/**
+ * @deprecated Use `runtime.thread.subscribe` instead. This will be removed in 0.6.0.
+ */
+export const subscribeToMainThread = (
+  runtime: AssistantRuntimeCore,
+  callback: () => void,
+) => {
+  let first = true;
+  let cleanup: Unsubscribe | undefined;
+  const inner = () => {
+    cleanup?.();
+    cleanup = runtime.threadManager.mainThread.subscribe(callback);
+
+    if (!first) {
+      callback();
+    }
+    first = false;
+  };
+
+  const unsubscribe = runtime.threadManager.mainThread.subscribe(inner);
+  inner();
+
+  return () => {
+    unsubscribe();
+    cleanup?.();
+  };
+};

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

@@ -0,0 +1,42 @@
+import {
+  ChatModelAdapter,
+  ChatModelRunOptions,
+} from "../local/ChatModelAdapter";
+import { toCoreMessages } from "../edge/converters/toCoreMessages";
+import { toLanguageModelTools } from "../edge/converters/toLanguageModelTools";
+import { EdgeRuntimeRequestOptions } from "../edge/EdgeRuntimeRequestOptions";
+import { runResultStream } from "../edge/streams/runResultStream";
+import { toolResultStream } from "../edge/streams/toolResultStream";
+import { asAsyncIterable } from "../edge/EdgeChatAdapter";
+import {
+  CreateEdgeRuntimeAPIOptions,
+  getEdgeRuntimeStream,
+} from "../edge/createEdgeRuntimeAPI";
+
+export type DangerousInBrowserAdapterOptions = CreateEdgeRuntimeAPIOptions;
+
+export class DangerousInBrowserAdapter implements ChatModelAdapter {
+  constructor(private options: DangerousInBrowserAdapterOptions) {}
+
+  async *run({ messages, abortSignal, config }: ChatModelRunOptions) {
+    const res = await getEdgeRuntimeStream({
+      options: this.options,
+      abortSignal,
+      requestData: {
+        system: config.system,
+        messages: toCoreMessages(messages),
+        tools: config.tools ? toLanguageModelTools(config.tools) : [],
+        ...config.callSettings,
+        ...config.config,
+      } satisfies EdgeRuntimeRequestOptions,
+    });
+
+    const stream = res
+      .pipeThrough(toolResultStream(config.tools, abortSignal))
+      .pipeThrough(runResultStream());
+
+    for await (const update of asAsyncIterable(stream)) {
+      yield update;
+    }
+  }
+}

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

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

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

@@ -0,0 +1,19 @@
+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/EdgeChatAdapter.ts

@@ -0,0 +1,93 @@
+import {
+  ChatModelAdapter,
+  ChatModelRunOptions,
+} from "../local/ChatModelAdapter";
+import { ChatModelRunResult } from "../local/ChatModelAdapter";
+import { toCoreMessages } from "./converters/toCoreMessages";
+import { toLanguageModelTools } from "./converters/toLanguageModelTools";
+import { EdgeRuntimeRequestOptions } from "./EdgeRuntimeRequestOptions";
+import { assistantDecoderStream } from "./streams/assistantDecoderStream";
+import { streamPartDecoderStream } from "./streams/utils/streamPartDecoderStream";
+import { runResultStream } from "./streams/runResultStream";
+import { toolResultStream } from "./streams/toolResultStream";
+
+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 };
+        },
+      };
+    },
+  };
+}
+export type EdgeChatAdapterOptions = {
+  api: string;
+
+  credentials?: RequestCredentials;
+  headers?: Record<string, string> | Headers;
+  body?: object;
+
+  /**
+   * When enabled, the adapter will not strip `id` from messages in the messages array.
+   */
+  unstable_sendMessageIds?: boolean;
+};
+
+export class EdgeChatAdapter implements ChatModelAdapter {
+  constructor(private options: EdgeChatAdapterOptions) {}
+
+  async *run({
+    messages,
+    abortSignal,
+    config,
+    unstable_assistantMessageId,
+  }: ChatModelRunOptions) {
+    const headers = new Headers(this.options.headers);
+    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: config.system,
+        messages: toCoreMessages(messages, {
+          unstable_includeId: this.options.unstable_sendMessageIds,
+        }),
+        tools: config.tools ? toLanguageModelTools(config.tools) : [],
+        unstable_assistantMessageId,
+        ...config.callSettings,
+        ...config.config,
+
+        ...this.options.body,
+      } satisfies EdgeRuntimeRequestOptions),
+      signal: abortSignal,
+    });
+
+    if (!result.ok) {
+      throw new Error(`Status ${result.status}: ${await result.text()}`);
+    }
+
+    const stream = result
+      .body!.pipeThrough(streamPartDecoderStream())
+      .pipeThrough(assistantDecoderStream())
+      .pipeThrough(toolResultStream(config.tools, abortSignal))
+      .pipeThrough(runResultStream());
+
+    let update: ChatModelRunResult | undefined;
+    for await (update of asAsyncIterable(stream)) {
+      yield update;
+    }
+
+    if (update === undefined)
+      throw new Error("No data received from Edge Runtime");
+  }
+}

package/src/runtimes/edge/EdgeRuntimeRequestOptions.ts

@@ -0,0 +1,93 @@
+import { JSONSchema7 } from "json-schema";
+import {
+  LanguageModelConfigSchema,
+  LanguageModelV1CallSettingsSchema,
+} from "../../types/ModelConfigTypes";
+import { z } from "zod";
+
+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 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()),
+  result: z.unknown().optional(),
+  isError: z.boolean().optional(),
+});
+// args is required but unknown;
+
+const CoreUserMessageSchema = z.object({
+  role: z.literal("user"),
+  content: z
+    .array(
+      z.discriminatedUnion("type", [
+        TextContentPartSchema,
+        ImageContentPartSchema,
+        Unstable_AudioContentPart,
+      ]),
+    )
+    .min(1),
+});
+
+const CoreAssistantMessageSchema = z.object({
+  role: z.literal("assistant"),
+  content: z
+    .array(
+      z.discriminatedUnion("type", [
+        TextContentPartSchema,
+        CoreToolCallContentPartSchema,
+      ]),
+    )
+    .min(1),
+});
+
+const CoreSystemMessageSchema = z.object({
+  role: z.literal("system"),
+  content: z.tuple([TextContentPartSchema]),
+});
+
+const CoreMessageSchema = z.discriminatedUnion("role", [
+  CoreSystemMessageSchema,
+  CoreUserMessageSchema,
+  CoreAssistantMessageSchema,
+]);
+
+export const EdgeRuntimeRequestOptionsSchema = z
+  .object({
+    system: z.string().optional(),
+    messages: z.array(CoreMessageSchema).min(1),
+    tools: z.array(LanguageModelV1FunctionToolSchema).optional(),
+    unstable_assistantMessageId: z.string().optional(),
+  })
+  .merge(LanguageModelV1CallSettingsSchema)
+  .merge(LanguageModelConfigSchema);
+
+export type EdgeRuntimeRequestOptions = z.infer<
+  typeof EdgeRuntimeRequestOptionsSchema
+>;

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

@@ -0,0 +1,67 @@
+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,
+      } satisfies ThreadMessage;
+
+    case "user":
+      return {
+        ...commonProps,
+        role,
+        content: message.content,
+        attachments,
+      } satisfies ThreadMessage;
+
+    case "system":
+      return {
+        ...commonProps,
+        role,
+        content: message.content,
+      } satisfies ThreadMessage;
+
+    default: {
+      const unsupportedRole: never = role;
+      throw new Error(`Unknown message role: ${unsupportedRole}`);
+    }
+  }
+};

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

@@ -0,0 +1,125 @@
+import { LanguageModelV1Message } from "@ai-sdk/provider";
+import { CoreMessage, ToolCallContentPart } from "../../../types";
+
+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": {
+                // TODO
+                throw new Error("File content parts are not 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 Record<string, unknown>,
+            } satisfies ToolCallContentPart;
+          }
+          return part;
+        });
+
+        if (mergeSteps) {
+          const previousMessage = messages[messages.length - 1];
+          if (previousMessage?.role === "assistant") {
+            previousMessage.content.push(...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.");
+
+          toolCall.result = tool.result;
+          if (tool.isError) {
+            toolCall.isError = true;
+          }
+        }
+
+        break;
+      }
+
+      default: {
+        const unhandledRole: never = role;
+        throw new Error(`Unknown message role: ${unhandledRole}`);
+      }
+    }
+  }
+
+  return messages;
+};

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

@@ -0,0 +1,16 @@
+import { LanguageModelV1FunctionTool } from "@ai-sdk/provider";
+import { Tool } from "../../../types/ModelConfigTypes";
+
+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

@@ -0,0 +1,41 @@
+/**
+ * @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";