@assistant-ui/react 0.1.4 → 0.1.5

package/dist/experimental.mjs

@@ -0,0 +1,69 @@
+import {
+  useAssistantContext,
+  useComposerContext,
+  useContentPartContext,
+  useMessageContext,
+  useThreadContext
+} from "./chunk-KIP3YFVM.mjs";
+
+// src/model-config/useAssistantInstructions.tsx
+import { useEffect } from "react";
+var useAssistantInstructions = (instruction) => {
+  const { useModelConfig } = useAssistantContext();
+  const registerModelConfigProvider = useModelConfig(
+    (s) => s.registerModelConfigProvider
+  );
+  useEffect(() => {
+    const config = {
+      system: instruction
+    };
+    return registerModelConfigProvider(() => config);
+  }, [registerModelConfigProvider, instruction]);
+};
+
+// src/model-config/useAssistantTool.tsx
+import { useEffect as useEffect2 } from "react";
+var useAssistantTool = (tool) => {
+  const { useModelConfig, useToolRenderers } = useAssistantContext();
+  const registerModelConfigProvider = useModelConfig(
+    (s) => s.registerModelConfigProvider
+  );
+  const setToolRenderer = useToolRenderers((s) => s.setToolRenderer);
+  useEffect2(() => {
+    const { name, render, ...rest } = tool;
+    const config = {
+      tools: {
+        [tool.name]: rest
+      }
+    };
+    const unsub1 = registerModelConfigProvider(() => config);
+    const unsub2 = render ? setToolRenderer(name, render) : void 0;
+    return () => {
+      unsub1();
+      unsub2?.();
+    };
+  }, [registerModelConfigProvider, setToolRenderer, tool]);
+};
+
+// src/model-config/useAssistantToolRenderer.tsx
+import { useEffect as useEffect3 } from "react";
+var useAssistantToolRenderer = (tool) => {
+  const { useToolRenderers } = useAssistantContext();
+  const setToolRenderer = useToolRenderers((s) => s.setToolRenderer);
+  useEffect3(() => {
+    if (!tool) return;
+    const { name, render } = tool;
+    return setToolRenderer(name, render);
+  }, [setToolRenderer, tool]);
+};
+export {
+  useAssistantContext,
+  useAssistantInstructions,
+  useAssistantTool,
+  useAssistantToolRenderer,
+  useComposerContext,
+  useContentPartContext,
+  useMessageContext,
+  useThreadContext
+};
+//# sourceMappingURL=experimental.mjs.map

package/dist/experimental.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/model-config/useAssistantInstructions.tsx","../src/model-config/useAssistantTool.tsx","../src/model-config/useAssistantToolRenderer.tsx"],"sourcesContent":["\"use client\";\n\nimport { useEffect } from \"react\";\nimport { useAssistantContext } from \"../context/AssistantContext\";\n\nexport const useAssistantInstructions = (instruction: string) => {\n  const { useModelConfig } = useAssistantContext();\n  const registerModelConfigProvider = useModelConfig(\n    (s) => s.registerModelConfigProvider,\n  );\n  useEffect(() => {\n    const config = {\n      system: instruction,\n    };\n    return registerModelConfigProvider(() => config);\n  }, [registerModelConfigProvider, instruction]);\n};\n","\"use client\";\n\nimport { useEffect } from \"react\";\nimport { useAssistantContext } from \"../context/AssistantContext\";\nimport type { Tool } from \"../utils/ModelConfigTypes\";\nimport type { ToolRenderComponent } from \"./ToolRenderComponent\";\n\nexport type UseAssistantTool<TArgs, TResult> = Tool<TArgs, TResult> & {\n  name: string;\n  render?: ToolRenderComponent<TArgs, TResult>;\n};\n\nexport const useAssistantTool = <TArgs, TResult>(\n  tool: UseAssistantTool<TArgs, TResult>,\n) => {\n  const { useModelConfig, useToolRenderers } = useAssistantContext();\n  const registerModelConfigProvider = useModelConfig(\n    (s) => s.registerModelConfigProvider,\n  );\n  const setToolRenderer = useToolRenderers((s) => s.setToolRenderer);\n  useEffect(() => {\n    const { name, render, ...rest } = tool;\n    const config = {\n      tools: {\n        [tool.name]: rest,\n      },\n    };\n    const unsub1 = registerModelConfigProvider(() => config);\n    const unsub2 = render ? setToolRenderer(name, render) : undefined;\n    return () => {\n      unsub1();\n      unsub2?.();\n    };\n  }, [registerModelConfigProvider, setToolRenderer, tool]);\n};\n","\"use client\";\nimport { useEffect } from \"react\";\nimport { useAssistantContext } from \"../context/AssistantContext\";\nimport type { ToolRenderComponent } from \"./ToolRenderComponent\";\n\ntype UseAssistantToolRenderer<TArgs, TResult> = {\n  name: string;\n  render: ToolRenderComponent<TArgs, TResult>;\n};\n\nexport const useAssistantToolRenderer = (\n  // biome-ignore lint/suspicious/noExplicitAny: intentional any\n  tool: UseAssistantToolRenderer<any, any> | null,\n) => {\n  const { useToolRenderers } = useAssistantContext();\n  const setToolRenderer = useToolRenderers((s) => s.setToolRenderer);\n  useEffect(() => {\n    if (!tool) return;\n    const { name, render } = tool;\n    return setToolRenderer(name, render);\n  }, [setToolRenderer, tool]);\n};\n"],"mappings":";;;;;;;;;AAEA,SAAS,iBAAiB;AAGnB,IAAM,2BAA2B,CAAC,gBAAwB;AAC/D,QAAM,EAAE,eAAe,IAAI,oBAAoB;AAC/C,QAAM,8BAA8B;AAAA,IAClC,CAAC,MAAM,EAAE;AAAA,EACX;AACA,YAAU,MAAM;AACd,UAAM,SAAS;AAAA,MACb,QAAQ;AAAA,IACV;AACA,WAAO,4BAA4B,MAAM,MAAM;AAAA,EACjD,GAAG,CAAC,6BAA6B,WAAW,CAAC;AAC/C;;;ACdA,SAAS,aAAAA,kBAAiB;AAUnB,IAAM,mBAAmB,CAC9B,SACG;AACH,QAAM,EAAE,gBAAgB,iBAAiB,IAAI,oBAAoB;AACjE,QAAM,8BAA8B;AAAA,IAClC,CAAC,MAAM,EAAE;AAAA,EACX;AACA,QAAM,kBAAkB,iBAAiB,CAAC,MAAM,EAAE,eAAe;AACjE,EAAAC,WAAU,MAAM;AACd,UAAM,EAAE,MAAM,QAAQ,GAAG,KAAK,IAAI;AAClC,UAAM,SAAS;AAAA,MACb,OAAO;AAAA,QACL,CAAC,KAAK,IAAI,GAAG;AAAA,MACf;AAAA,IACF;AACA,UAAM,SAAS,4BAA4B,MAAM,MAAM;AACvD,UAAM,SAAS,SAAS,gBAAgB,MAAM,MAAM,IAAI;AACxD,WAAO,MAAM;AACX,aAAO;AACP,eAAS;AAAA,IACX;AAAA,EACF,GAAG,CAAC,6BAA6B,iBAAiB,IAAI,CAAC;AACzD;;;ACjCA,SAAS,aAAAC,kBAAiB;AASnB,IAAM,2BAA2B,CAEtC,SACG;AACH,QAAM,EAAE,iBAAiB,IAAI,oBAAoB;AACjD,QAAM,kBAAkB,iBAAiB,CAAC,MAAM,EAAE,eAAe;AACjE,EAAAC,WAAU,MAAM;AACd,QAAI,CAAC,KAAM;AACX,UAAM,EAAE,MAAM,OAAO,IAAI;AACzB,WAAO,gBAAgB,MAAM,MAAM;AAAA,EACrC,GAAG,CAAC,iBAAiB,IAAI,CAAC;AAC5B;","names":["useEffect","useEffect","useEffect","useEffect"]}

package/dist/index.d.mts

@@ -0,0 +1,334 @@
+import * as react from 'react';
+import { FC, ReactNode, PropsWithChildren, ComponentType } from 'react';
+import { TextareaAutosizeProps } from 'react-textarea-autosize';
+import { T as TextContentPart, I as ImageContentPart, U as UIContentPart, a as ToolCallContentPart, b as ThreadState, c as Unsubscribe, M as ModelConfigProvider, d as ThreadMessage, e as ModelConfig, A as AssistantContentPart, f as AppendMessage } from './Thread-DcmnmkmV.mjs';
+export { j as AppendContentPart, g as AssistantMessage, i as UserContentPart, h as UserMessage } from './Thread-DcmnmkmV.mjs';
+import { ComponentPropsWithoutRef, Primitive } from '@radix-ui/react-primitive';
+import 'zod';
+
+declare const useCopyMessage: ({ copiedDuration }: {
+    copiedDuration?: number | undefined;
+}) => (() => void) | null;
+
+declare const useReloadMessage: () => (() => void) | null;
+
+declare const useBeginMessageEdit: () => (() => void) | null;
+
+declare const useGoToNextBranch: () => (() => void) | null;
+
+declare const useGoToPreviousBranch: () => (() => void) | null;
+
+declare const ThreadRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & react.RefAttributes<HTMLDivElement>>;
+
+type ThreadEmptyProps = {
+    children: ReactNode;
+};
+declare const ThreadEmpty: FC<ThreadEmptyProps>;
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
+type ThreadIfFilters = {
+    empty: boolean | undefined;
+    running: boolean | undefined;
+};
+type ThreadIfProps = PropsWithChildren<RequireAtLeastOne<ThreadIfFilters>>;
+declare const ThreadIf: FC<ThreadIfProps>;
+
+declare const ThreadViewport: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    autoScroll?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+type ThreadMessagesProps = {
+    components: {
+        Message: ComponentType;
+        UserMessage?: ComponentType;
+        EditComposer?: ComponentType;
+        AssistantMessage?: ComponentType;
+    } | {
+        Message?: ComponentType;
+        UserMessage: ComponentType;
+        EditComposer?: ComponentType;
+        AssistantMessage: ComponentType;
+    };
+};
+declare const ThreadMessages: FC<ThreadMessagesProps>;
+
+declare const ThreadScrollToBottom: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ThreadSuggestion: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & {
+    prompt: string;
+    method: "replace";
+    autoSend?: boolean;
+} & react.RefAttributes<HTMLButtonElement>>;
+
+declare namespace index$5 {
+  export { ThreadEmpty as Empty, ThreadIf as If, ThreadMessages as Messages, ThreadRoot as Root, ThreadScrollToBottom as ScrollToBottom, ThreadSuggestion as Suggestion, ThreadViewport as Viewport };
+}
+
+declare const ComposerRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
+    ref?: ((instance: HTMLFormElement | null) => void) | react.RefObject<HTMLFormElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.FormHTMLAttributes<HTMLFormElement>> & react.RefAttributes<HTMLFormElement>>;
+
+declare const ComposerInput: react.ForwardRefExoticComponent<TextareaAutosizeProps & {
+    asChild?: boolean;
+} & react.RefAttributes<HTMLTextAreaElement>>;
+
+declare const ComposerSend: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ComposerCancel: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+type ComposerIfFilters = {
+    editing: boolean | undefined;
+};
+type ComposerIfProps = PropsWithChildren<RequireAtLeastOne<ComposerIfFilters>>;
+declare const ComposerIf: FC<ComposerIfProps>;
+
+declare namespace index$4 {
+  export { ComposerCancel as Cancel, ComposerIf as If, ComposerInput as Input, ComposerRoot as Root, ComposerSend as Send };
+}
+
+declare const MessageRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & react.RefAttributes<HTMLDivElement>>;
+
+type MessageIfFilters = {
+    user: boolean | undefined;
+    assistant: boolean | undefined;
+    hasBranches: boolean | undefined;
+    copied: boolean | undefined;
+    lastOrHover: boolean | undefined;
+};
+type MessageIfProps = RequireAtLeastOne<MessageIfFilters> & {
+    children: ReactNode;
+};
+declare const MessageIf: FC<MessageIfProps>;
+
+type MessageContentProps = {
+    components?: {
+        Text?: ComponentType<{
+            part: TextContentPart;
+            status: "done" | "in_progress" | "error";
+        }>;
+        Image?: ComponentType<{
+            part: ImageContentPart;
+            status: "done" | "in_progress" | "error";
+        }>;
+        UI?: ComponentType<{
+            part: UIContentPart;
+            status: "done" | "in_progress" | "error";
+        }>;
+        tools?: {
+            by_name?: Record<string, ComponentType<{
+                part: ToolCallContentPart;
+                status: "done" | "in_progress" | "error";
+            }>>;
+            Fallback?: ComponentType<{
+                part: ToolCallContentPart;
+                status: "done" | "in_progress" | "error";
+            }>;
+        };
+    };
+};
+declare const MessageContent: FC<MessageContentProps>;
+
+declare const MessageInProgress: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    ref?: ((instance: HTMLSpanElement | null) => void) | react.RefObject<HTMLSpanElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.HTMLAttributes<HTMLSpanElement>> & react.RefAttributes<HTMLSpanElement>>;
+
+declare namespace index$3 {
+  export { MessageContent as Content, MessageIf as If, MessageInProgress as InProgress, MessageRoot as Root };
+}
+
+declare const BranchPickerNext: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const BranchPickerPrevious: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const BranchPickerCount: FC;
+
+declare const BranchPickerNumber: FC;
+
+declare const BranchPickerRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    hideWhenSingleBranch?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare namespace index$2 {
+  export { BranchPickerCount as Count, BranchPickerNext as Next, BranchPickerNumber as Number, BranchPickerPrevious as Previous, BranchPickerRoot as Root };
+}
+
+declare const ActionBarRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    hideWhenRunning?: boolean;
+    autohide?: "always" | "not-last" | "never";
+    autohideFloat?: "always" | "single-branch" | "never";
+} & react.RefAttributes<HTMLDivElement>>;
+
+type ActionBarCopyProps = {
+    copiedDuration?: number;
+};
+declare const ActionBarCopy: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & ActionBarCopyProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ActionBarReload: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ActionBarEdit: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare namespace index$1 {
+  export { ActionBarCopy as Copy, ActionBarEdit as Edit, ActionBarReload as Reload, ActionBarRoot as Root };
+}
+
+declare const ContentPartInProgressIndicator: FC;
+
+type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
+type ContentPartTextProps = Omit<PrimitiveSpanProps, "children">;
+declare const ContentPartText: react.ForwardRefExoticComponent<ContentPartTextProps & react.RefAttributes<HTMLSpanElement>>;
+
+declare const ContentPartImage: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & {
+    ref?: ((instance: HTMLImageElement | null) => void) | react.RefObject<HTMLImageElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ImgHTMLAttributes<HTMLImageElement>> & react.RefAttributes<HTMLImageElement>>;
+
+declare const ContentPartDisplay: FC;
+
+declare namespace index {
+  export { ContentPartDisplay as Display, ContentPartImage as Image, ContentPartInProgressIndicator as InProgressIndicator, ContentPartText as Text };
+}
+
+type ThreadRuntime = Readonly<ThreadState & {
+    subscribe: (callback: () => void) => Unsubscribe;
+}>;
+
+type AssistantRuntime = ThreadRuntime & {
+    registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+};
+
+type ReactThreadRuntime = ThreadRuntime & {
+    unstable_synchronizer?: ComponentType;
+};
+
+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;
+
+type AssistantRuntimeProviderProps = {
+    runtime: AssistantRuntime;
+};
+declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
+
+declare class ProxyConfigProvider {
+    private _providers;
+    getModelConfig(): ModelConfig;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+}
+
+declare class MessageRepository {
+    private messages;
+    private head;
+    private root;
+    private performOp;
+    getMessages(): ThreadMessage[];
+    addOrUpdateMessage(parentId: string | null, message: ThreadMessage): void;
+    appendOptimisticMessage(parentId: string | null, message: Omit<ThreadMessage, "id" | "createdAt">): string;
+    deleteMessage(messageId: string, replacementId?: string | null | undefined): void;
+    getBranches(messageId: string): string[];
+    switchToBranch(messageId: string): void;
+    resetHead(messageId: string | null): void;
+}
+
+type internal_MessageRepository = MessageRepository;
+declare const internal_MessageRepository: typeof MessageRepository;
+type internal_ProxyConfigProvider = ProxyConfigProvider;
+declare const internal_ProxyConfigProvider: typeof ProxyConfigProvider;
+declare namespace internal {
+  export { internal_MessageRepository as MessageRepository, internal_ProxyConfigProvider as ProxyConfigProvider };
+}
+
+export { index$1 as ActionBarPrimitive, AppendMessage, AssistantContentPart, type AssistantRuntime, AssistantRuntimeProvider, index$2 as BranchPickerPrimitive, type ChatModelAdapter, type ChatModelRunOptions, index$4 as ComposerPrimitive, index as ContentPartPrimitive, internal as INTERNAL, index$3 as MessagePrimitive, type ReactThreadRuntime, TextContentPart, ThreadMessage, index$5 as ThreadPrimitive, type ThreadRuntime, Unsubscribe, useBeginMessageEdit, useCopyMessage, useGoToNextBranch, useGoToPreviousBranch, useLocalRuntime, useReloadMessage };