@assistant-ui/react 0.0.28 → 0.1.0

package/dist/experimental.d.mts

@@ -0,0 +1,120 @@
+import { h as ModelConfigProvider, b as ThreadMessage, M as ModelConfig, e as AssistantContentPart, d as AppendMessage } from './ModelConfigTypes-B9UY4zxv.mjs';
+export { I as ImageContentPart, a as ToolCallContentPart, U as UIContentPart } from './ModelConfigTypes-B9UY4zxv.mjs';
+import { U as Unsubscribe, a as ThreadState, A as AssistantRuntime } from './AssistantRuntime-CBMSAJqH.mjs';
+import { ReactNode } from 'react';
+import { UseBoundStore, StoreApi } from 'zustand';
+import 'zod';
+
+type AssistantModelConfigState = {
+    getModelConfig: ModelConfigProvider;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => () => void;
+};
+
+type ContentPartState = Readonly<{
+    status: "in_progress" | "done" | "error";
+    part: ThreadMessage["content"][number];
+}>;
+
+type MessageState = Readonly<{
+    message: Readonly<ThreadMessage>;
+    parentId: string | null;
+    branches: readonly string[];
+    isLast: boolean;
+    inProgressIndicator: ReactNode | null;
+    setInProgressIndicator: (value: ReactNode | null) => void;
+    isCopied: boolean;
+    setIsCopied: (value: boolean) => void;
+    isHovering: boolean;
+    setIsHovering: (value: boolean) => void;
+}>;
+
+type BaseComposerState = Readonly<{
+    value: string;
+    setValue: (value: string) => void;
+}>;
+
+type EditComposerState = BaseComposerState & Readonly<{
+    isEditing: boolean;
+    edit: () => void;
+    send: () => void;
+    cancel: () => boolean;
+}>;
+
+type ComposerState = BaseComposerState & Readonly<{
+    isEditing: true;
+    send: () => void;
+    cancel: () => boolean;
+}>;
+
+type ThreadViewportState = {
+    isAtBottom: boolean;
+    scrollToBottom: () => void;
+    onScrollToBottom: (callback: () => void) => Unsubscribe;
+};
+
+type AssistantContextValue = {
+    useModelConfig: UseBoundStore<StoreApi<AssistantModelConfigState>>;
+};
+declare const useAssistantContext: () => AssistantContextValue;
+
+type ThreadContextValue = {
+    useThread: UseBoundStore<StoreApi<ThreadState>>;
+    useComposer: UseBoundStore<StoreApi<ComposerState>>;
+    useViewport: UseBoundStore<StoreApi<ThreadViewportState>>;
+};
+declare const useThreadContext: () => ThreadContextValue;
+
+type ComposerContextValue = {
+    useComposer: UseBoundStore<StoreApi<EditComposerState | ComposerState>>;
+    type: "edit" | "new";
+};
+declare const useComposerContext: () => ComposerContextValue;
+
+type MessageContextValue = {
+    useMessage: UseBoundStore<StoreApi<MessageState>>;
+    useComposer: UseBoundStore<StoreApi<EditComposerState>>;
+};
+declare const useMessageContext: () => MessageContextValue;
+
+type ContentPartContextValue = {
+    useContentPart: UseBoundStore<StoreApi<ContentPartState>>;
+};
+declare const useContentPartContext: () => ContentPartContextValue;
+
+type ChatModelRunResult = {
+    content: AssistantContentPart[];
+};
+type ChatModelRunOptions = {
+    messages: ThreadMessage[];
+    abortSignal: AbortSignal;
+    config: ModelConfig;
+    onUpdate: (result: ChatModelRunResult) => void;
+};
+type ChatModelAdapter = {
+    run: (options: ChatModelRunOptions) => Promise<ChatModelRunResult>;
+};
+
+declare class LocalRuntime implements AssistantRuntime {
+    adapter: ChatModelAdapter;
+    private _subscriptions;
+    private _configProviders;
+    private abortController;
+    private repository;
+    get messages(): ThreadMessage[];
+    get isRunning(): boolean;
+    constructor(adapter: ChatModelAdapter);
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    private notifySubscribers;
+    subscribe(callback: () => void): Unsubscribe;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => boolean;
+}
+
+declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
+
+declare const useAssistantInstructions: (instruction: string) => void;
+
+export { type AssistantContextValue, type AssistantModelConfigState, type ChatModelAdapter, type ChatModelRunOptions, type ComposerContextValue, type ComposerState, type ContentPartContextValue, type ContentPartState, type EditComposerState, type MessageContextValue, type MessageState, ModelConfigProvider, type ThreadContextValue, ThreadState, type ThreadViewportState, useAssistantContext, useAssistantInstructions, useComposerContext, useContentPartContext, useLocalRuntime, useMessageContext, useThreadContext };

package/dist/experimental.d.ts

@@ -0,0 +1,120 @@
+import { h as ModelConfigProvider, b as ThreadMessage, M as ModelConfig, e as AssistantContentPart, d as AppendMessage } from './ModelConfigTypes-B9UY4zxv.js';
+export { I as ImageContentPart, a as ToolCallContentPart, U as UIContentPart } from './ModelConfigTypes-B9UY4zxv.js';
+import { U as Unsubscribe, a as ThreadState, A as AssistantRuntime } from './AssistantRuntime-C_BvM7ZT.js';
+import { ReactNode } from 'react';
+import { UseBoundStore, StoreApi } from 'zustand';
+import 'zod';
+
+type AssistantModelConfigState = {
+    getModelConfig: ModelConfigProvider;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => () => void;
+};
+
+type ContentPartState = Readonly<{
+    status: "in_progress" | "done" | "error";
+    part: ThreadMessage["content"][number];
+}>;
+
+type MessageState = Readonly<{
+    message: Readonly<ThreadMessage>;
+    parentId: string | null;
+    branches: readonly string[];
+    isLast: boolean;
+    inProgressIndicator: ReactNode | null;
+    setInProgressIndicator: (value: ReactNode | null) => void;
+    isCopied: boolean;
+    setIsCopied: (value: boolean) => void;
+    isHovering: boolean;
+    setIsHovering: (value: boolean) => void;
+}>;
+
+type BaseComposerState = Readonly<{
+    value: string;
+    setValue: (value: string) => void;
+}>;
+
+type EditComposerState = BaseComposerState & Readonly<{
+    isEditing: boolean;
+    edit: () => void;
+    send: () => void;
+    cancel: () => boolean;
+}>;
+
+type ComposerState = BaseComposerState & Readonly<{
+    isEditing: true;
+    send: () => void;
+    cancel: () => boolean;
+}>;
+
+type ThreadViewportState = {
+    isAtBottom: boolean;
+    scrollToBottom: () => void;
+    onScrollToBottom: (callback: () => void) => Unsubscribe;
+};
+
+type AssistantContextValue = {
+    useModelConfig: UseBoundStore<StoreApi<AssistantModelConfigState>>;
+};
+declare const useAssistantContext: () => AssistantContextValue;
+
+type ThreadContextValue = {
+    useThread: UseBoundStore<StoreApi<ThreadState>>;
+    useComposer: UseBoundStore<StoreApi<ComposerState>>;
+    useViewport: UseBoundStore<StoreApi<ThreadViewportState>>;
+};
+declare const useThreadContext: () => ThreadContextValue;
+
+type ComposerContextValue = {
+    useComposer: UseBoundStore<StoreApi<EditComposerState | ComposerState>>;
+    type: "edit" | "new";
+};
+declare const useComposerContext: () => ComposerContextValue;
+
+type MessageContextValue = {
+    useMessage: UseBoundStore<StoreApi<MessageState>>;
+    useComposer: UseBoundStore<StoreApi<EditComposerState>>;
+};
+declare const useMessageContext: () => MessageContextValue;
+
+type ContentPartContextValue = {
+    useContentPart: UseBoundStore<StoreApi<ContentPartState>>;
+};
+declare const useContentPartContext: () => ContentPartContextValue;
+
+type ChatModelRunResult = {
+    content: AssistantContentPart[];
+};
+type ChatModelRunOptions = {
+    messages: ThreadMessage[];
+    abortSignal: AbortSignal;
+    config: ModelConfig;
+    onUpdate: (result: ChatModelRunResult) => void;
+};
+type ChatModelAdapter = {
+    run: (options: ChatModelRunOptions) => Promise<ChatModelRunResult>;
+};
+
+declare class LocalRuntime implements AssistantRuntime {
+    adapter: ChatModelAdapter;
+    private _subscriptions;
+    private _configProviders;
+    private abortController;
+    private repository;
+    get messages(): ThreadMessage[];
+    get isRunning(): boolean;
+    constructor(adapter: ChatModelAdapter);
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    private notifySubscribers;
+    subscribe(callback: () => void): Unsubscribe;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => boolean;
+}
+
+declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
+
+declare const useAssistantInstructions: (instruction: string) => void;
+
+export { type AssistantContextValue, type AssistantModelConfigState, type ChatModelAdapter, type ChatModelRunOptions, type ComposerContextValue, type ComposerState, type ContentPartContextValue, type ContentPartState, type EditComposerState, type MessageContextValue, type MessageState, ModelConfigProvider, type ThreadContextValue, ThreadState, type ThreadViewportState, useAssistantContext, useAssistantInstructions, useComposerContext, useContentPartContext, useLocalRuntime, useMessageContext, useThreadContext };

package/dist/experimental.js

@@ -0,0 +1,407 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/experimental.ts
+var experimental_exports = {};
+__export(experimental_exports, {
+  useAssistantContext: () => useAssistantContext,
+  useAssistantInstructions: () => useAssistantInstructions,
+  useComposerContext: () => useComposerContext,
+  useContentPartContext: () => useContentPartContext,
+  useLocalRuntime: () => useLocalRuntime,
+  useMessageContext: () => useMessageContext,
+  useThreadContext: () => useThreadContext
+});
+module.exports = __toCommonJS(experimental_exports);
+
+// src/runtime/local/useLocalRuntime.tsx
+var import_react = require("react");
+
+// src/utils/ModelConfigTypes.ts
+var mergeModelConfigs = (configs) => {
+  return configs.reduce((acc, config) => {
+    if (config.system) {
+      if (acc.system) {
+        acc.system += `
+
+${config.system}`;
+      } else {
+        acc.system = config.system;
+      }
+    }
+    if (config.tools) {
+      acc.tools = { ...acc.tools, ...config.tools };
+    }
+    return acc;
+  }, {});
+};
+
+// src/runtime/utils/idUtils.tsx
+var import_non_secure = require("nanoid/non-secure");
+var generateId = (0, import_non_secure.customAlphabet)(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+var optimisticPrefix = "__optimistic__";
+var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
+
+// src/runtime/utils/MessageRepository.tsx
+var findHead = (message) => {
+  if (message.next) return findHead(message.next);
+  return message;
+};
+var MessageRepository = class {
+  messages = /* @__PURE__ */ new Map();
+  // message_id -> item
+  head = null;
+  root = {
+    children: []
+  };
+  performOp(newParent, child, operation) {
+    const parentOrRoot = child.prev ?? this.root;
+    const newParentOrRoot = newParent ?? this.root;
+    if (operation === "relink" && parentOrRoot === newParentOrRoot) return;
+    if (operation !== "link") {
+      parentOrRoot.children = parentOrRoot.children.filter(
+        (m) => m !== child.current.id
+      );
+      if (child.prev?.next === child) {
+        const fallbackId = child.prev.children.at(-1);
+        const fallback = fallbackId ? this.messages.get(fallbackId) : null;
+        if (fallback === void 0) {
+          throw new Error(
+            "MessageRepository(performOp/cut): Fallback sibling message not found. This is likely an internal bug in assistant-ui."
+          );
+        }
+        child.prev.next = fallback;
+      }
+    }
+    if (operation !== "cut") {
+      newParentOrRoot.children = [
+        ...newParentOrRoot.children,
+        child.current.id
+      ];
+      if (newParent && (findHead(child) === this.head || newParent.next === null)) {
+        newParent.next = child;
+      }
+      child.prev = newParent;
+    }
+  }
+  getMessages() {
+    const messages = new Array(this.head?.level ?? 0);
+    for (let current = this.head; current; current = current.prev) {
+      messages[current.level] = current.current;
+    }
+    return messages;
+  }
+  addOrUpdateMessage(parentId, message) {
+    const existingItem = this.messages.get(message.id);
+    const prev = parentId ? this.messages.get(parentId) : null;
+    if (prev === void 0)
+      throw new Error(
+        "MessageRepository(addOrUpdateMessage): Parent message not found. This is likely an internal bug in assistant-ui."
+      );
+    if (existingItem) {
+      existingItem.current = message;
+      this.performOp(prev, existingItem, "relink");
+      return;
+    }
+    const newItem = {
+      prev,
+      current: message,
+      next: null,
+      children: [],
+      level: prev ? prev.level + 1 : 0
+    };
+    this.messages.set(message.id, newItem);
+    this.performOp(prev, newItem, "link");
+    if (this.head === prev) {
+      this.head = newItem;
+    }
+  }
+  appendOptimisticMessage(parentId, message) {
+    let optimisticId;
+    do {
+      optimisticId = generateOptimisticId();
+    } while (this.messages.has(optimisticId));
+    this.addOrUpdateMessage(parentId, {
+      ...message,
+      id: optimisticId,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...message.role === "assistant" ? { status: "in_progress" } : void 0
+    });
+    return optimisticId;
+  }
+  deleteMessage(messageId, replacementId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(deleteMessage): Optimistic message not found. This is likely an internal bug in assistant-ui."
+      );
+    const replacement = replacementId === void 0 ? message.prev : replacementId === null ? null : this.messages.get(replacementId);
+    if (replacement === void 0)
+      throw new Error(
+        "MessageRepository(deleteMessage): Replacement not found. This is likely an internal bug in assistant-ui."
+      );
+    for (const child of message.children) {
+      const childMessage = this.messages.get(child);
+      if (!childMessage)
+        throw new Error(
+          "MessageRepository(deleteMessage): Child message not found. This is likely an internal bug in assistant-ui."
+        );
+      this.performOp(replacement, childMessage, "relink");
+    }
+    this.performOp(null, message, "cut");
+    this.messages.delete(messageId);
+    if (this.head === message) {
+      this.head = replacement ? findHead(replacement) : null;
+    }
+  }
+  getBranches(messageId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(getBranches): Message not found. This is likely an internal bug in assistant-ui."
+      );
+    const { children } = message.prev ?? this.root;
+    return children;
+  }
+  switchToBranch(messageId) {
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(switchToBranch): Branch not found. This is likely an internal bug in assistant-ui."
+      );
+    if (message.prev) {
+      message.prev.next = message;
+    }
+    this.head = findHead(message);
+  }
+  resetHead(messageId) {
+    if (messageId === null) {
+      this.head = null;
+      return;
+    }
+    const message = this.messages.get(messageId);
+    if (!message)
+      throw new Error(
+        "MessageRepository(resetHead): Branch not found. This is likely an internal bug in assistant-ui."
+      );
+    this.head = message;
+    for (let current = message; current; current = current.prev) {
+      if (current.prev) {
+        current.prev.next = current;
+      }
+    }
+  }
+};
+
+// src/runtime/local/LocalRuntime.tsx
+var LocalRuntime = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  _configProviders = /* @__PURE__ */ new Set();
+  abortController = null;
+  repository = new MessageRepository();
+  get messages() {
+    return this.repository.getMessages();
+  }
+  get isRunning() {
+    return this.abortController != null;
+  }
+  getBranches(messageId) {
+    return this.repository.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    this.repository.switchToBranch(branchId);
+    this.notifySubscribers();
+  }
+  async append(message) {
+    const userMessageId = generateId();
+    const userMessage = {
+      id: userMessageId,
+      role: "user",
+      content: message.content,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.repository.addOrUpdateMessage(message.parentId, userMessage);
+    await this.startRun(userMessageId);
+  }
+  async startRun(parentId) {
+    const id = generateId();
+    this.repository.resetHead(parentId);
+    const messages = this.repository.getMessages();
+    const message = {
+      id,
+      role: "assistant",
+      status: "in_progress",
+      content: [{ type: "text", text: "" }],
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.repository.addOrUpdateMessage(parentId, { ...message });
+    this.abortController?.abort();
+    this.abortController = new AbortController();
+    this.notifySubscribers();
+    try {
+      const updateHandler = ({ content }) => {
+        message.content = content;
+        this.repository.addOrUpdateMessage(parentId, { ...message });
+        this.notifySubscribers();
+      };
+      const result = await this.adapter.run({
+        messages,
+        abortSignal: this.abortController.signal,
+        config: mergeModelConfigs([...this._configProviders].map((p) => p())),
+        onUpdate: updateHandler
+      });
+      updateHandler(result);
+      message.status = "done";
+      this.repository.addOrUpdateMessage(parentId, { ...message });
+    } catch (e) {
+      message.status = "error";
+      this.repository.addOrUpdateMessage(parentId, { ...message });
+      console.error(e);
+    } finally {
+      this.abortController = null;
+      this.notifySubscribers();
+    }
+  }
+  cancelRun() {
+    if (!this.abortController) return;
+    this.abortController.abort();
+    this.abortController = null;
+    this.notifySubscribers();
+  }
+  notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  registerModelConfigProvider(provider) {
+    this._configProviders.add(provider);
+    return () => this._configProviders.delete(provider);
+  }
+};
+
+// src/runtime/local/useLocalRuntime.tsx
+var useLocalRuntime = (adapter) => {
+  const [runtime] = (0, import_react.useState)(() => new LocalRuntime(adapter));
+  (0, import_react.useInsertionEffect)(() => {
+    runtime.adapter = adapter;
+  });
+  return runtime;
+};
+
+// src/context/AssistantContext.ts
+var import_react2 = require("react");
+var AssistantContext = (0, import_react2.createContext)(
+  null
+);
+var useAssistantContext = () => {
+  const context = (0, import_react2.useContext)(AssistantContext);
+  if (!context)
+    throw new Error(
+      "This component must be used within an AssistantRuntimeProvider."
+    );
+  return context;
+};
+
+// src/context/ThreadContext.ts
+var import_react3 = require("react");
+var ThreadContext = (0, import_react3.createContext)(null);
+var useThreadContext = () => {
+  const context = (0, import_react3.useContext)(ThreadContext);
+  if (!context)
+    throw new Error("This component must be used within an AssistantRuntimeProvider.");
+  return context;
+};
+
+// src/context/ComposerContext.ts
+var import_react5 = require("react");
+
+// src/context/MessageContext.ts
+var import_react4 = require("react");
+var MessageContext = (0, import_react4.createContext)(null);
+var useMessageContext = () => {
+  const context = (0, import_react4.useContext)(MessageContext);
+  if (!context)
+    throw new Error(
+      "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
+    );
+  return context;
+};
+
+// src/context/ComposerContext.ts
+var useComposerContext = () => {
+  const { useComposer } = useThreadContext();
+  const { useComposer: useEditComposer } = (0, import_react5.useContext)(MessageContext) ?? {};
+  return (0, import_react5.useMemo)(
+    () => ({
+      useComposer: useEditComposer ?? useComposer,
+      type: useEditComposer ? "edit" : "new"
+    }),
+    [useEditComposer, useComposer]
+  );
+};
+
+// src/context/ContentPartContext.ts
+var import_react6 = require("react");
+var ContentPartContext = (0, import_react6.createContext)(
+  null
+);
+var useContentPartContext = () => {
+  const context = (0, import_react6.useContext)(ContentPartContext);
+  if (!context)
+    throw new Error(
+      "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
+    );
+  return context;
+};
+
+// src/model-config/useAssistantInstructions.tsx
+var import_react7 = require("react");
+var useAssistantInstructions = (instruction) => {
+  const { useModelConfig } = useAssistantContext();
+  const addContextProvider = useModelConfig(
+    (s) => s.registerModelConfigProvider
+  );
+  (0, import_react7.useEffect)(
+    () => addContextProvider(() => {
+      return {
+        system: instruction
+      };
+    }),
+    [addContextProvider, instruction]
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAssistantContext,
+  useAssistantInstructions,
+  useComposerContext,
+  useContentPartContext,
+  useLocalRuntime,
+  useMessageContext,
+  useThreadContext
+});
+//# sourceMappingURL=experimental.js.map