@assistant-ui/react 0.11.21 → 0.11.23

package/src/client/ThreadMessageClient.tsx

@@ -0,0 +1,161 @@
+"use client";
+import {
+  resource,
+  tapMemo,
+  tapState,
+  tapInlineResource,
+} from "@assistant-ui/tap";
+import { AttachmentClientApi } from "./types/Attachment";
+import { MessageClientState, MessageClientApi } from "./types/Message";
+import { MessagePartClientState, MessagePartClientApi } from "./types/Part";
+import { tapLookupResources } from "./util-hooks/tapLookupResources";
+import { tapApi } from "../utils/tap-store";
+import {
+  ThreadAssistantMessagePart,
+  ThreadUserMessagePart,
+  Attachment,
+  ThreadMessage,
+} from "../types";
+import { NoOpComposerClient } from "./NoOpComposerClient";
+
+const ThreadMessagePartClient = resource(
+  ({ part }: { part: ThreadAssistantMessagePart | ThreadUserMessagePart }) => {
+    const state = tapMemo<MessagePartClientState>(() => {
+      return {
+        ...part,
+        status: { type: "complete" },
+      };
+    }, [part]);
+
+    return tapApi<MessagePartClientApi>(
+      {
+        getState: () => state,
+        addToolResult: () => {
+          throw new Error("Not supported");
+        },
+        resumeToolCall: () => {
+          throw new Error("Not supported");
+        },
+      },
+      {
+        key:
+          state.type === "tool-call"
+            ? "toolCallId-" + state.toolCallId
+            : undefined,
+      },
+    );
+  },
+);
+const ThreadMessageAttachmentClient = resource(
+  ({ attachment }: { attachment: Attachment }) => {
+    return tapApi<AttachmentClientApi>(
+      {
+        getState: () => attachment,
+        remove: () => {
+          throw new Error("Not supported");
+        },
+      },
+      {
+        key: attachment.id,
+      },
+    );
+  },
+);
+export type ThreadMessageClientProps = {
+  message: ThreadMessage;
+  isLast?: boolean;
+  branchNumber?: number;
+  branchCount?: number;
+};
+export const ThreadMessageClient = resource(
+  ({
+    message,
+    isLast = true,
+    branchNumber = 1,
+    branchCount = 1,
+  }: ThreadMessageClientProps) => {
+    const [isCopiedState, setIsCopied] = tapState(false);
+    const [isHoveringState, setIsHovering] = tapState(false);
+
+    const parts = tapLookupResources(
+      message.content.map((_, idx) =>
+        ThreadMessagePartClient({ part: message.content[idx]! }, { key: idx }),
+      ),
+    );
+
+    const attachments = tapLookupResources(
+      message.attachments?.map((_, idx) =>
+        ThreadMessageAttachmentClient(
+          { attachment: message.attachments![idx]! },
+          { key: idx },
+        ),
+      ) ?? [],
+    );
+
+    const composerState = tapInlineResource(
+      NoOpComposerClient({ type: "edit" }),
+    );
+
+    const state = tapMemo<MessageClientState>(() => {
+      return {
+        ...message,
+        parts: parts.state,
+        composer: composerState.state,
+        parentId: null,
+        isLast,
+        branchNumber,
+        branchCount,
+        speech: undefined,
+        submittedFeedback: undefined,
+        isCopied: isCopiedState,
+        isHovering: isHoveringState,
+      };
+    }, [message, isCopiedState, isHoveringState, isLast]);
+
+    return tapApi<MessageClientApi>({
+      getState: () => state,
+      composer: composerState.api,
+      part: (selector) => {
+        if ("index" in selector) {
+          return parts.api({ index: selector.index });
+        } else {
+          return parts.api({ key: "toolCallId-" + selector.toolCallId });
+        }
+      },
+      attachment: (selector) => {
+        if ("id" in selector) {
+          return attachments.api({ key: selector.id });
+        } else {
+          return attachments.api(selector);
+        }
+      },
+      reload: () => {
+        throw new Error("Not supported in ThreadMessageProvider");
+      },
+      speak: () => {
+        throw new Error("Not supported in ThreadMessageProvider");
+      },
+      stopSpeaking: () => {
+        throw new Error("Not supported in ThreadMessageProvider");
+      },
+      submitFeedback: () => {
+        throw new Error("Not supported in ThreadMessageProvider");
+      },
+      switchToBranch: () => {
+        throw new Error("Not supported in ThreadMessageProvider");
+      },
+      getCopyText: () => {
+        return message.content
+          .map((part) => {
+            if ("text" in part && typeof part.text === "string") {
+              return part.text;
+            }
+            return "";
+          })
+          .join("\n");
+      },
+      setIsCopied,
+      setIsHovering,
+    });
+  },
+);

package/src/client/types/Attachment.ts

@@ -9,5 +9,5 @@ export type AttachmentClientApi = {
   remove(): Promise<void>;
 
   /** @internal */
-  __internal_getRuntime(): AttachmentRuntime | null;
+  __internal_getRuntime?(): AttachmentRuntime;
 };

package/src/client/types/Composer.ts

@@ -30,5 +30,5 @@ export type ComposerClientApi = {
   beginEdit(): void;
 
   /** @internal */
-  __internal_getRuntime(): ComposerRuntime | null;
+  __internal_getRuntime?(): ComposerRuntime;
 };

package/src/client/types/Message.ts

@@ -62,5 +62,5 @@ export type MessageClientApi = {
   setIsHovering(value: boolean): void;
 
   /** @internal */
-  __internal_getRuntime(): MessageRuntime | null;
+  __internal_getRuntime?(): MessageRuntime;
 };

package/src/client/types/Part.ts

@@ -26,6 +26,12 @@ export type MessagePartClientApi = {
    */
   addToolResult(result: any | ToolResponse<any>): void;
 
+  /**
+   * Resume a tool call that is waiting for human input with a payload.
+   * This is useful when a tool has requested human input and is waiting for a response.
+   */
+  resumeToolCall(payload: unknown): void;
+
   /** @internal */
-  __internal_getRuntime(): MessagePartRuntime | null;
+  __internal_getRuntime?(): MessagePartRuntime;
 };

package/src/client/types/Thread.ts

@@ -130,6 +130,16 @@ export type ThreadClientApi = {
    */
   stopSpeaking(): void;
 
+  /**
+   * Start the voice session for the thread. Establishes any necessary media connections.
+   */
+  startVoice(): Promise<void>;
+
+  /**
+   * Stop the currently active voice session.
+   */
+  stopVoice(): Promise<void>;
+
   /** @internal */
-  __internal_getRuntime(): ThreadRuntime | null;
+  __internal_getRuntime?(): ThreadRuntime;
 };

package/src/client/types/ThreadListItem.ts

@@ -22,5 +22,5 @@ export type ThreadListItemClientApi = {
   detach(): void;
 
   /** @internal */
-  __internal_getRuntime(): ThreadListItemRuntime | null;
+  __internal_getRuntime?(): ThreadListItemRuntime;
 };

package/src/context/providers/MessageProvider.tsx

@@ -6,230 +6,12 @@ import {
   AssistantApi,
   createAssistantApiField,
 } from "../react/AssistantApiContext";
-import {
-  MessageClientApi,
-  MessageClientState,
-} from "../../client/types/Message";
-import {
-  resource,
-  tapInlineResource,
-  tapMemo,
-  tapState,
-} from "@assistant-ui/tap";
 import { useResource } from "@assistant-ui/tap/react";
-import { asStore, tapApi } from "../../utils/tap-store";
-import {
-  ThreadAssistantMessagePart,
-  ThreadMessage,
-  ThreadUserMessagePart,
-} from "../../types/AssistantTypes";
+import { asStore } from "../../utils/tap-store";
 import {
-  ComposerClientApi,
-  ComposerClientState,
-} from "../../client/types/Composer";
-import {
-  MessagePartClientApi,
-  MessagePartClientState,
-} from "../../client/types/Part";
-import { tapLookupResources } from "../../client/util-hooks/tapLookupResources";
-import { Attachment } from "../../types";
-import { AttachmentClientApi } from "../../client/types/Attachment";
-
-const NoOpComposerClient = resource(({ type }: { type: "edit" | "thread" }) => {
-  const state = tapMemo<ComposerClientState>(() => {
-    return {
-      isEditing: false,
-      isEmpty: true,
-      text: "",
-      attachmentAccept: "*",
-      attachments: [],
-      role: "user",
-      runConfig: {},
-      canCancel: false,
-      type: type,
-    };
-  }, [type]);
-
-  return tapApi<ComposerClientApi>({
-    getState: () => state,
-    setText: () => {
-      throw new Error("Not supported");
-    },
-    setRole: () => {
-      throw new Error("Not supported");
-    },
-    setRunConfig: () => {
-      throw new Error("Not supported");
-    },
-    addAttachment: () => {
-      throw new Error("Not supported");
-    },
-    clearAttachments: () => {
-      throw new Error("Not supported");
-    },
-    attachment: () => {
-      throw new Error("Not supported");
-    },
-    reset: () => {
-      throw new Error("Not supported");
-    },
-    send: () => {
-      throw new Error("Not supported");
-    },
-    cancel: () => {
-      throw new Error("Not supported");
-    },
-    beginEdit: () => {
-      throw new Error("Not supported");
-    },
-    __internal_getRuntime: () => null,
-  });
-});
-
-const ThreadMessagePartClient = resource(
-  ({ part }: { part: ThreadAssistantMessagePart | ThreadUserMessagePart }) => {
-    const state = tapMemo<MessagePartClientState>(() => {
-      return {
-        ...part,
-        status: { type: "complete" },
-      };
-    }, [part]);
-
-    return tapApi<MessagePartClientApi>(
-      {
-        getState: () => state,
-        addToolResult: () => {
-          throw new Error("Not supported");
-        },
-        __internal_getRuntime: () => null,
-      },
-      {
-        key:
-          state.type === "tool-call"
-            ? "toolCallId-" + state.toolCallId
-            : undefined,
-      },
-    );
-  },
-);
-
-const ThreadMessageAttachmentClient = resource(
-  ({ attachment }: { attachment: Attachment }) => {
-    return tapApi<AttachmentClientApi>(
-      {
-        getState: () => attachment,
-        remove: () => {
-          throw new Error("Not supported");
-        },
-        __internal_getRuntime: () => null,
-      },
-      {
-        key: attachment.id,
-      },
-    );
-  },
-);
-
-type ThreadMessageClientProps = {
-  message: ThreadMessage;
-  isLast?: boolean;
-  branchNumber?: number;
-  branchCount?: number;
-};
-
-const ThreadMessageClient = resource(
-  ({
-    message,
-    isLast = true,
-    branchNumber = 1,
-    branchCount = 1,
-  }: ThreadMessageClientProps) => {
-    const [isCopiedState, setIsCopied] = tapState(false);
-    const [isHoveringState, setIsHovering] = tapState(false);
-
-    const parts = tapLookupResources(
-      message.content.map((_, idx) =>
-        ThreadMessagePartClient({ part: message.content[idx]! }, { key: idx }),
-      ),
-    );
-
-    const attachments = tapLookupResources(
-      message.attachments?.map((_, idx) =>
-        ThreadMessageAttachmentClient(
-          { attachment: message.attachments![idx]! },
-          { key: idx },
-        ),
-      ) ?? [],
-    );
-
-    const composerState = tapInlineResource(
-      NoOpComposerClient({ type: "edit" }),
-    );
-
-    const state = tapMemo<MessageClientState>(() => {
-      return {
-        ...message,
-        parts: parts.state,
-        composer: composerState.state,
-        parentId: null,
-        isLast,
-        branchNumber,
-        branchCount,
-        speech: undefined,
-        submittedFeedback: undefined,
-        isCopied: isCopiedState,
-        isHovering: isHoveringState,
-      };
-    }, [message, isCopiedState, isHoveringState, isLast]);
-
-    return tapApi<MessageClientApi>({
-      getState: () => state,
-      composer: composerState.api,
-      part: (selector) => {
-        if ("index" in selector) {
-          return parts.api({ index: selector.index });
-        } else {
-          return parts.api({ key: "toolCallId-" + selector.toolCallId });
-        }
-      },
-      attachment: (selector) => {
-        if ("id" in selector) {
-          return attachments.api({ key: selector.id });
-        } else {
-          return attachments.api(selector);
-        }
-      },
-      reload: () => {
-        throw new Error("Not supported in ThreadMessageProvider");
-      },
-      speak: () => {
-        throw new Error("Not supported in ThreadMessageProvider");
-      },
-      stopSpeaking: () => {
-        throw new Error("Not supported in ThreadMessageProvider");
-      },
-      submitFeedback: () => {
-        throw new Error("Not supported in ThreadMessageProvider");
-      },
-      switchToBranch: () => {
-        throw new Error("Not supported in ThreadMessageProvider");
-      },
-      getCopyText: () => {
-        return message.content
-          .map((part) => {
-            if ("text" in part && typeof part.text === "string") {
-              return part.text;
-            }
-            return "";
-          })
-          .join("\n");
-      },
-      setIsCopied,
-      setIsHovering,
-      __internal_getRuntime: () => null,
-    });
-  },
-);
+  ThreadMessageClientProps,
+  ThreadMessageClient,
+} from "../../client/ThreadMessageClient";
 
 export const MessageProvider: FC<
   PropsWithChildren<ThreadMessageClientProps>

package/src/context/providers/TextMessagePartProvider.tsx

@@ -30,7 +30,9 @@ const TextMessagePartClient = resource(
       addToolResult: () => {
         throw new Error("Not supported");
       },
-      __internal_getRuntime: () => null,
+      resumeToolCall: () => {
+        throw new Error("Not supported");
+      },
     });
   },
 );

package/src/context/react/AssistantApiContext.tsx

@@ -46,6 +46,10 @@ import {
 } from "../../client/types/ThreadList";
 import { ThreadViewportProvider } from "../providers/ThreadViewportProvider";
 import { DevToolsProviderApi } from "../../devtools/DevToolsHooks";
+import {
+  AssistantClientProps,
+  useAssistantClient,
+} from "../../client/AssistantClient";
 
 export type AssistantState = {
   readonly threads: ThreadListClientState;
@@ -132,7 +136,7 @@ export type AssistantApi = {
   // temp
   registerModelContextProvider(provider: ModelContextProvider): void;
   /** @internal */
-  __internal_getRuntime(): AssistantRuntime | null;
+  __internal_getRuntime?(): AssistantRuntime;
 };
 
 export const createAssistantApiField = <
@@ -231,15 +235,33 @@ const AssistantApiContext = createContext<AssistantApi>({
       "Registering model context providers is only available inside <AssistantProvider />",
     );
   },
-  __internal_getRuntime: () => {
-    return null;
-  },
 });
 
-export const useAssistantApi = (): AssistantApi => {
+const useAssistantApiImpl = (): AssistantApi => {
   return useContext(AssistantApiContext);
 };
 
+const useExtendedAssistantApiImpl = (
+  config: AssistantClientProps,
+): AssistantApi => {
+  const api = useAssistantApiImpl();
+  const api2 = useAssistantClient(config);
+  const extendedApi = useMemo(() => extendApi(api, api2), [api, api2]);
+  return extendedApi;
+};
+
+export function useAssistantApi(): AssistantApi;
+export function useAssistantApi(config: AssistantClientProps): AssistantApi;
+export function useAssistantApi(config?: AssistantClientProps): AssistantApi {
+  if (config) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useExtendedAssistantApiImpl(config);
+  } else {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useAssistantApiImpl();
+  }
+}
+
 const mergeFns = <TArgs extends Array<unknown>>(
   fn1: (...args: TArgs) => void,
   fn2: (...args: TArgs) => void,

package/src/index.ts

@@ -9,3 +9,6 @@ export * from "./types";
 export * from "./devtools";
 
 export * as INTERNAL from "./internal";
+export type { ToolExecutionStatus } from "./internal";
+
+export type { Assistant } from "./augmentations";

package/src/internal.ts

@@ -14,5 +14,9 @@ export {
 export { fromThreadMessageLike } from "./legacy-runtime/runtime-cores/external-store/ThreadMessageLike";
 export { getAutoStatus } from "./legacy-runtime/runtime-cores/external-store/auto-status";
 export { splitLocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+export {
+  useToolInvocations,
+  type ToolExecutionStatus,
+} from "./legacy-runtime/runtime-cores/assistant-transport/useToolInvocations";
 
 export * from "./utils/smooth";

package/src/legacy-runtime/client/MessagePartRuntimeClient.ts

@@ -7,20 +7,19 @@ export const MessagePartClient = resource(
   ({ runtime }: { runtime: MessagePartRuntime }) => {
     const runtimeState = tapSubscribable(runtime);
 
-    return tapApi<MessagePartClientApi>(
-      {
-        getState: () => runtimeState,
+    const api: MessagePartClientApi = {
+      getState: () => runtimeState,
 
-        addToolResult: (result) => runtime.addToolResult(result),
+      addToolResult: (result) => runtime.addToolResult(result),
+      resumeToolCall: (payload) => runtime.resumeToolCall(payload),
+      __internal_getRuntime: () => runtime,
+    };
 
-        __internal_getRuntime: () => runtime,
-      },
-      {
-        key:
-          runtimeState.type === "tool-call"
-            ? "toolCallId-" + runtimeState.toolCallId
-            : undefined,
-      },
-    );
+    return tapApi<MessagePartClientApi>(api, {
+      key:
+        runtimeState.type === "tool-call"
+          ? "toolCallId-" + runtimeState.toolCallId
+          : undefined,
+    });
   },
 );

package/src/legacy-runtime/client/ThreadRuntimeClient.ts

@@ -125,6 +125,12 @@ export const ThreadClient = resource(
       import: runtime.import,
       reset: runtime.reset,
       stopSpeaking: runtime.stopSpeaking,
+      startVoice: async () => {
+        throw new Error("startVoice is not supported in this runtime");
+      },
+      stopVoice: async () => {
+        throw new Error("stopVoice is not supported in this runtime");
+      },
 
       message: (selector) => {
         if ("id" in selector) {

package/src/legacy-runtime/hooks/AssistantContext.ts

@@ -38,7 +38,7 @@ export function useAssistantRuntime(options?: {
   optional?: boolean | undefined;
 }) {
   const api = useAssistantApi();
-  const runtime = api.__internal_getRuntime();
+  const runtime = api.__internal_getRuntime?.() ?? null;
 
   if (!runtime && !options?.optional) {
     throw new Error("AssistantRuntime is not available");

package/src/legacy-runtime/hooks/AttachmentContext.ts

@@ -15,7 +15,9 @@ export function useAttachmentRuntime(options?: {
 }): AttachmentRuntime | null {
   const api = useAssistantApi();
   const runtime = useAssistantState(() =>
-    api.attachment.source ? api.attachment().__internal_getRuntime() : null,
+    api.attachment.source
+      ? (api.attachment().__internal_getRuntime?.() ?? null)
+      : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("AttachmentRuntime is not available");

package/src/legacy-runtime/hooks/ComposerContext.ts

@@ -53,7 +53,9 @@ export function useComposerRuntime(options?: {
 }): ComposerRuntime | null {
   const api = useAssistantApi();
   const runtime = useAssistantState(() =>
-    api.composer.source ? api.composer().__internal_getRuntime() : null,
+    api.composer.source
+      ? (api.composer().__internal_getRuntime?.() ?? null)
+      : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("ComposerRuntime is not available");

package/src/legacy-runtime/hooks/MessageContext.ts

@@ -48,7 +48,9 @@ export function useMessageRuntime(options?: {
 }) {
   const api = useAssistantApi();
   const runtime = useAssistantState(() =>
-    api.message.source ? api.message().__internal_getRuntime() : null,
+    api.message.source
+      ? (api.message().__internal_getRuntime?.() ?? null)
+      : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("MessageRuntime is not available");

package/src/legacy-runtime/hooks/MessagePartContext.ts

@@ -15,7 +15,7 @@ export function useMessagePartRuntime(options?: {
 }) {
   const api = useAssistantApi();
   const runtime = useAssistantState(() =>
-    api.part.source ? api.part().__internal_getRuntime() : null,
+    api.part.source ? (api.part().__internal_getRuntime?.() ?? null) : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("MessagePartRuntime is not available");

package/src/legacy-runtime/hooks/ThreadContext.ts

@@ -43,7 +43,7 @@ export function useThreadRuntime(options?: {
 export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
   const api = useAssistantApi();
   const runtime = useAssistantState(() =>
-    api.thread.source ? api.thread().__internal_getRuntime() : null,
+    api.thread.source ? (api.thread().__internal_getRuntime?.() ?? null) : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("ThreadRuntime is not available");

package/src/legacy-runtime/hooks/ThreadListItemContext.ts

@@ -16,7 +16,7 @@ export function useThreadListItemRuntime(options?: {
   const api = useAssistantApi();
   const runtime = useAssistantState(() =>
     api.threadListItem.source
-      ? api.threadListItem().__internal_getRuntime()
+      ? (api.threadListItem().__internal_getRuntime?.() ?? null)
       : null,
   );
   if (!runtime && !options?.optional) {