@assistant-ui/core 0.1.5 → 0.1.7

package/src/react/index.ts

@@ -1,11 +1,119 @@
 /// <reference path="./types/store-augmentation.ts" />
 
-export * from "./model-context";
-export * from "./client";
-export * from "./types";
-export * from "./providers";
+// model-context
+export {
+  makeAssistantTool,
+  type AssistantTool,
+} from "./model-context/makeAssistantTool";
+export {
+  type AssistantToolUI,
+  makeAssistantToolUI,
+} from "./model-context/makeAssistantToolUI";
+export {
+  type AssistantDataUI,
+  makeAssistantDataUI,
+} from "./model-context/makeAssistantDataUI";
+export { useAssistantInstructions } from "./model-context/useAssistantInstructions";
+export {
+  useAssistantTool,
+  type AssistantToolProps,
+} from "./model-context/useAssistantTool";
+export {
+  useAssistantToolUI,
+  type AssistantToolUIProps,
+} from "./model-context/useAssistantToolUI";
+export {
+  useAssistantDataUI,
+  type AssistantDataUIProps,
+} from "./model-context/useAssistantDataUI";
+export { useInlineRender } from "./model-context/useInlineRender";
+export type { Toolkit, ToolDefinition } from "./model-context/toolbox";
+
+// client
+export { Tools } from "./client/Tools";
+export { DataRenderers } from "./client/DataRenderers";
+
+// types
+export type {
+  EmptyMessagePartComponent,
+  EmptyMessagePartProps,
+  TextMessagePartComponent,
+  TextMessagePartProps,
+  ReasoningMessagePartComponent,
+  ReasoningMessagePartProps,
+  SourceMessagePartComponent,
+  SourceMessagePartProps,
+  ImageMessagePartComponent,
+  ImageMessagePartProps,
+  FileMessagePartComponent,
+  FileMessagePartProps,
+  Unstable_AudioMessagePartComponent,
+  Unstable_AudioMessagePartProps,
+  DataMessagePartComponent,
+  DataMessagePartProps,
+  ToolCallMessagePartComponent,
+  ToolCallMessagePartProps,
+  ReasoningGroupProps,
+  ReasoningGroupComponent,
+  QuoteMessagePartComponent,
+  QuoteMessagePartProps,
+} from "./types/MessagePartComponentTypes";
+export type {
+  ToolsState,
+  ToolsMethods,
+  ToolsClientSchema,
+} from "./types/scopes/tools";
+export type {
+  DataRenderersState,
+  DataRenderersMethods,
+  DataRenderersClientSchema,
+} from "./types/scopes/dataRenderers";
+
+// providers
+export {
+  MessageAttachmentByIndexProvider,
+  ComposerAttachmentByIndexProvider,
+} from "./providers/AttachmentByIndexProvider";
+export { ThreadListItemRuntimeProvider } from "./providers/ThreadListItemRuntimeProvider";
+export { MessageByIndexProvider } from "./providers/MessageByIndexProvider";
+export { PartByIndexProvider } from "./providers/PartByIndexProvider";
+export { TextMessagePartProvider } from "./providers/TextMessagePartProvider";
+export { ChainOfThoughtByIndicesProvider } from "./providers/ChainOfThoughtByIndicesProvider";
+export { ThreadListItemByIndexProvider } from "./providers/ThreadListItemByIndexProvider";
+export { ChainOfThoughtPartByIndexProvider } from "./providers/ChainOfThoughtPartByIndexProvider";
+export {
+  SuggestionByIndexProvider,
+  type SuggestionByIndexProviderProps,
+} from "./providers/SuggestionByIndexProvider";
+export { ReadonlyThreadProvider } from "./providers/ReadonlyThreadProvider";
+
+// RuntimeAdapter
 export { RuntimeAdapter } from "./RuntimeAdapter";
-export * from "./runtimes";
+
+// runtimes
+export {
+  RuntimeAdapterProvider,
+  useRuntimeAdapters,
+  type RuntimeAdapters,
+} from "./runtimes/RuntimeAdapterProvider";
+export {
+  useToolInvocations,
+  type ToolExecutionStatus,
+  type AssistantTransportState,
+  type AddToolResultCommand,
+} from "./runtimes/useToolInvocations";
+export { useExternalStoreRuntime } from "./runtimes/useExternalStoreRuntime";
+export {
+  useExternalMessageConverter,
+  convertExternalMessages,
+} from "./runtimes/external-message-converter";
+export { createMessageConverter } from "./runtimes/createMessageConverter";
+export { RemoteThreadListHookInstanceManager } from "./runtimes/RemoteThreadListHookInstanceManager";
+export { RemoteThreadListThreadListRuntimeCore } from "./runtimes/RemoteThreadListThreadListRuntimeCore";
+export { useRemoteThreadListRuntime } from "./runtimes/useRemoteThreadListRuntime";
+export { useCloudThreadListAdapter } from "./runtimes/cloud/useCloudThreadListAdapter";
+export { useAssistantCloudThreadHistoryAdapter } from "./runtimes/cloud/AssistantCloudThreadHistoryAdapter";
+export { CloudFileAttachmentAdapter } from "./runtimes/cloud/CloudFileAttachmentAdapter";
 
 // AssistantProvider base
 export {
@@ -25,7 +133,9 @@ export {
   MessagePartComponent,
   MessagePrimitivePartByIndex,
   defaultComponents as messagePartsDefaultComponents,
+  type EnrichedPartState,
 } from "./primitives/message/MessageParts";
+export { MessagePrimitiveQuote } from "./primitives/message/MessageQuote";
 export {
   MessagePrimitiveAttachments,
   MessagePrimitiveAttachmentByIndex,
@@ -39,6 +149,10 @@ export {
   ThreadListPrimitiveItemByIndex,
 } from "./primitives/threadList/ThreadListItems";
 export { ChainOfThoughtPrimitiveParts } from "./primitives/chainOfThought/ChainOfThoughtParts";
+export {
+  PartPrimitiveMessages,
+  PartPrimitiveMessagesImpl,
+} from "./primitives/part/PartMessages";
 export { ThreadListItemPrimitiveTitle } from "./primitives/threadListItem/ThreadListItemTitle";
 export {
   ThreadPrimitiveSuggestions,
@@ -49,18 +163,51 @@ export {
   ComposerPrimitiveIf,
   type UseComposerIfProps,
 } from "./primitives/composer/ComposerIf";
+export { getMessageQuote } from "./utils/getMessageQuote";
 
 // Primitive hooks (shared behavior logic)
-export * from "./primitive-hooks";
+export { useThreadMessages } from "./primitive-hooks/useThreadMessages";
+export { useThreadIsRunning } from "./primitive-hooks/useThreadIsRunning";
+export { useThreadIsEmpty } from "./primitive-hooks/useThreadIsEmpty";
+export { useComposerSend } from "./primitive-hooks/useComposerSend";
+export { useComposerCancel } from "./primitive-hooks/useComposerCancel";
+export { useComposerDictate } from "./primitive-hooks/useComposerDictate";
+export { useComposerAddAttachment } from "./primitive-hooks/useComposerAddAttachment";
+export { useMessageReload } from "./primitive-hooks/useMessageReload";
+export { useMessageBranching } from "./primitive-hooks/useMessageBranching";
+export {
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+} from "./primitive-hooks/useActionBarCopy";
+export { useActionBarEdit } from "./primitive-hooks/useActionBarEdit";
+export { useActionBarReload } from "./primitive-hooks/useActionBarReload";
+export {
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+} from "./primitive-hooks/useActionBarFeedback";
+export { useActionBarSpeak } from "./primitive-hooks/useActionBarSpeak";
+export { useActionBarStopSpeaking } from "./primitive-hooks/useActionBarStopSpeaking";
+export { useBranchPickerNext } from "./primitive-hooks/useBranchPickerNext";
+export { useBranchPickerPrevious } from "./primitive-hooks/useBranchPickerPrevious";
+export {
+  useSuggestionTrigger,
+  type UseSuggestionTriggerOptions,
+} from "./primitive-hooks/useSuggestionTrigger";
+export { useThreadListItemArchive } from "./primitive-hooks/useThreadListItemArchive";
+export { useThreadListItemDelete } from "./primitive-hooks/useThreadListItemDelete";
+export { useThreadListItemUnarchive } from "./primitive-hooks/useThreadListItemUnarchive";
+export { useThreadListItemTrigger } from "./primitive-hooks/useThreadListItemTrigger";
+export { useThreadListNew } from "./primitive-hooks/useThreadListNew";
+export { useEditComposerCancel } from "./primitive-hooks/useEditComposerCancel";
+export { useEditComposerSend } from "./primitive-hooks/useEditComposerSend";
+export { useMessageError } from "./primitive-hooks/useMessageError";
 
 // Shared AssistantRuntimeProvider
-export {
-  AssistantRuntimeProvider,
-  useAssistantRuntime,
-} from "./AssistantRuntimeProvider";
+export { AssistantRuntimeProvider } from "./AssistantRuntimeProvider";
 
 // Shared runtimes
 export {
   useLocalRuntime,
+  splitLocalRuntimeOptions,
   type LocalRuntimeOptions,
 } from "./runtimes/useLocalRuntime";

package/src/react/model-context/useInlineRender.ts

@@ -1,5 +1,5 @@
 import { FC, useCallback, useEffect, useState } from "react";
-import { ToolCallMessagePartProps } from "../types";
+import { ToolCallMessagePartProps } from "../types/MessagePartComponentTypes";
 import { create } from "zustand";
 
 export const useInlineRender = <TArgs, TResult>(

package/src/react/primitive-hooks/useActionBarSpeak.ts

@@ -0,0 +1,20 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarSpeak = () => {
+  const aui = useAui();
+
+  const disabled = useAuiState((s) => {
+    return !(
+      (s.message.role !== "assistant" ||
+        s.message.status?.type !== "running") &&
+      s.message.parts.some((c) => c.type === "text" && c.text.length > 0)
+    );
+  });
+
+  const speak = useCallback(async () => {
+    aui.message().speak();
+  }, [aui]);
+
+  return { speak, disabled };
+};

package/src/react/primitive-hooks/useActionBarStopSpeaking.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarStopSpeaking = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.message.speech == null);
+
+  const stopSpeaking = useCallback(() => {
+    aui.message().stopSpeaking();
+  }, [aui]);
+
+  return { stopSpeaking, disabled };
+};

package/src/react/primitive-hooks/useBranchPickerNext.ts

@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useBranchPickerNext = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => {
+    if (s.message.branchNumber >= s.message.branchCount) return true;
+    if (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun) {
+      return true;
+    }
+    return false;
+  });
+
+  const next = useCallback(() => {
+    aui.message().switchToBranch({ position: "next" });
+  }, [aui]);
+
+  return { next, disabled };
+};

package/src/react/primitive-hooks/useBranchPickerPrevious.ts

@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useBranchPickerPrevious = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => {
+    if (s.message.branchNumber <= 1) return true;
+    if (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun) {
+      return true;
+    }
+    return false;
+  });
+
+  const previous = useCallback(() => {
+    aui.message().switchToBranch({ position: "previous" });
+  }, [aui]);
+
+  return { previous, disabled };
+};

package/src/react/primitive-hooks/useComposerDictate.ts

@@ -0,0 +1,18 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useComposerDictate = () => {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) =>
+      s.composer.dictation != null ||
+      !s.thread.capabilities.dictation ||
+      !s.composer.isEditing,
+  );
+
+  const startDictation = useCallback(() => {
+    aui.composer().startDictation();
+  }, [aui]);
+
+  return { startDictation, disabled };
+};

package/src/react/primitive-hooks/useMessageError.ts

@@ -0,0 +1,10 @@
+import { useAuiState } from "@assistant-ui/store";
+
+export const useMessageError = () => {
+  return useAuiState((s) =>
+    s.message.status?.type === "incomplete" &&
+    s.message.status.reason === "error"
+      ? (s.message.status.error ?? "An error occurred")
+      : undefined,
+  );
+};

package/src/react/primitive-hooks/useSuggestionTrigger.ts

@@ -0,0 +1,43 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export type UseSuggestionTriggerOptions = {
+  prompt: string;
+  send?: boolean | undefined;
+  clearComposer?: boolean | undefined;
+};
+
+export const useSuggestionTrigger = ({
+  prompt,
+  send,
+  clearComposer = true,
+}: UseSuggestionTriggerOptions) => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.thread.isDisabled);
+  const resolvedSend = send ?? false;
+
+  const trigger = useCallback(() => {
+    const isRunning = aui.thread().getState().isRunning;
+
+    if (resolvedSend && !isRunning) {
+      aui.thread().append({
+        content: [{ type: "text", text: prompt }],
+        runConfig: aui.composer().getState().runConfig,
+      });
+      if (clearComposer) {
+        aui.composer().setText("");
+      }
+    } else {
+      if (clearComposer) {
+        aui.composer().setText(prompt);
+      } else {
+        const currentText = aui.composer().getState().text;
+        aui
+          .composer()
+          .setText(currentText.trim() ? `${currentText} ${prompt}` : prompt);
+      }
+    }
+  }, [aui, resolvedSend, clearComposer, prompt]);
+
+  return { trigger, disabled };
+};

package/src/react/primitive-hooks/useThreadListItemArchive.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useThreadListItemArchive = () => {
+  const aui = useAui();
+
+  const archive = useCallback(() => {
+    aui.threadListItem().archive();
+  }, [aui]);
+
+  return { archive };
+};

package/src/react/primitive-hooks/useThreadListItemDelete.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useThreadListItemDelete = () => {
+  const aui = useAui();
+
+  const deleteThread = useCallback(() => {
+    aui.threadListItem().delete();
+  }, [aui]);
+
+  return { delete: deleteThread };
+};

package/src/react/primitive-hooks/useThreadListItemTrigger.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useThreadListItemTrigger = () => {
+  const aui = useAui();
+
+  const switchTo = useCallback(() => {
+    aui.threadListItem().switchTo();
+  }, [aui]);
+
+  return { switchTo };
+};

package/src/react/primitive-hooks/useThreadListItemUnarchive.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useThreadListItemUnarchive = () => {
+  const aui = useAui();
+
+  const unarchive = useCallback(() => {
+    aui.threadListItem().unarchive();
+  }, [aui]);
+
+  return { unarchive };
+};

package/src/react/primitive-hooks/useThreadListNew.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useThreadListNew = () => {
+  const aui = useAui();
+
+  const switchToNewThread = useCallback(() => {
+    aui.threads().switchToNewThread();
+  }, [aui]);
+
+  return { switchToNewThread };
+};

package/src/react/primitives/chainOfThought/ChainOfThoughtParts.tsx

@@ -2,34 +2,73 @@ import {
   type ComponentType,
   type FC,
   type PropsWithChildren,
+  type ReactNode,
   useMemo,
 } from "react";
-import { useAuiState } from "@assistant-ui/store";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
+import type { PartState } from "../../../store/scopes/part";
 import { ChainOfThoughtPartByIndexProvider } from "../../providers/ChainOfThoughtPartByIndexProvider";
 import { MessagePartComponent } from "../message/MessageParts";
 import type {
   ReasoningMessagePartComponent,
   ToolCallMessagePartComponent,
-} from "../../types";
+} from "../../types/MessagePartComponentTypes";
+
+type ChainOfThoughtPartsComponentConfig = {
+  /** Component for rendering reasoning parts */
+  Reasoning?: ReasoningMessagePartComponent | undefined;
+  /** Fallback component for tool-call parts */
+  tools?: {
+    Fallback?: ToolCallMessagePartComponent | undefined;
+  };
+  /** Layout component to wrap the rendered parts when expanded */
+  Layout?: ComponentType<PropsWithChildren> | undefined;
+};
 
 export namespace ChainOfThoughtPrimitiveParts {
-  export type Props = {
-    /**
-     * Component configuration for rendering chain of thought parts.
-     */
-    components?: {
-      /** Component for rendering reasoning parts */
-      Reasoning?: ReasoningMessagePartComponent | undefined;
-      /** Fallback component for tool-call parts */
-      tools?: {
-        Fallback?: ToolCallMessagePartComponent | undefined;
+  export type Props =
+    | {
+        /**
+         * @deprecated Use the children render function instead.
+         */
+        components?: ChainOfThoughtPartsComponentConfig;
+        children?: never;
+      }
+    | {
+        /** Render function called for each part. Receives the part. */
+        children: (value: { part: PartState }) => ReactNode;
+        components?: never;
       };
-      /** Layout component to wrap the rendered parts when expanded */
-      Layout?: ComponentType<PropsWithChildren> | undefined;
-    };
-  };
 }
 
+const ChainOfThoughtPrimitivePartsInner: FC<{
+  children: (value: { part: PartState }) => ReactNode;
+}> = ({ children }) => {
+  const partsLength = useAuiState((s) => s.chainOfThought.parts.length);
+
+  return useMemo(
+    () =>
+      Array.from({ length: partsLength }, (_, index) => (
+        <ChainOfThoughtPartByIndexProvider key={index} index={index}>
+          <RenderChildrenWithAccessor
+            getItemState={(aui) =>
+              aui.chainOfThought().part({ index }).getState()
+            }
+          >
+            {(getItem) =>
+              children({
+                get part() {
+                  return getItem();
+                },
+              })
+            }
+          </RenderChildrenWithAccessor>
+        </ChainOfThoughtPartByIndexProvider>
+      )),
+    [partsLength, children],
+  );
+};
+
 /**
  * Renders the parts within a chain of thought, with support for collapsed/expanded states.
  *
@@ -38,9 +77,16 @@ export namespace ChainOfThoughtPrimitiveParts {
  */
 export const ChainOfThoughtPrimitiveParts: FC<
   ChainOfThoughtPrimitiveParts.Props
-> = ({ components }) => {
-  const partsLength = useAuiState((s) => s.chainOfThought.parts.length);
+> = ({ components, children }) => {
+  if (children) {
+    return (
+      <ChainOfThoughtPrimitivePartsInner>
+        {children}
+      </ChainOfThoughtPrimitivePartsInner>
+    );
+  }
 
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   const messageComponents = useMemo(
     () => ({
       Reasoning: components?.Reasoning,
@@ -53,21 +99,19 @@ export const ChainOfThoughtPrimitiveParts: FC<
 
   const Layout = components?.Layout;
 
-  const elements = useMemo(() => {
-    return Array.from({ length: partsLength }, (_, index) => (
-      <ChainOfThoughtPartByIndexProvider key={index} index={index}>
-        {Layout ? (
+  return (
+    <ChainOfThoughtPrimitivePartsInner>
+      {() =>
+        Layout ? (
           <Layout>
             <MessagePartComponent components={messageComponents} />
           </Layout>
         ) : (
           <MessagePartComponent components={messageComponents} />
-        )}
-      </ChainOfThoughtPartByIndexProvider>
-    ));
-  }, [partsLength, messageComponents, Layout]);
-
-  return <>{elements}</>;
+        )
+      }
+    </ChainOfThoughtPrimitivePartsInner>
+  );
 };
 
 ChainOfThoughtPrimitiveParts.displayName = "ChainOfThoughtPrimitive.Parts";