@assistant-ui/react 0.11.20 → 0.11.22

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) {

package/src/legacy-runtime/runtime/MessagePartRuntime.ts

@@ -30,6 +30,12 @@ export type MessagePartRuntime = {
    */
   addToolResult(result: any | ToolResponse<any>): void;
 
+  /**
+   * Resume an interrupted tool call with a payload.
+   * This is useful when a tool has interrupted its execution and is waiting for user input.
+   */
+  resumeToolCall(payload: unknown): void;
+
   readonly path: MessagePartRuntimePath;
   getState(): MessagePartState;
   subscribe(callback: () => void): Unsubscribe;
@@ -50,6 +56,7 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
 
   protected __internal_bindMethods() {
     this.addToolResult = this.addToolResult.bind(this);
+    this.resumeToolCall = this.resumeToolCall.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
   }
@@ -88,6 +95,22 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
     });
   }
 
+  public resumeToolCall(payload: unknown) {
+    const state = this.contentBinding.getState();
+    if (!state) throw new Error("Message part is not available");
+
+    if (state.type !== "tool-call")
+      throw new Error("Tried to resume tool call on non-tool message part");
+
+    if (!this.threadApi) throw new Error("Thread API is not available");
+
+    const toolCallId = state.toolCallId;
+    this.threadApi.getState().resumeToolCall({
+      toolCallId,
+      payload,
+    });
+  }
+
   public subscribe(callback: () => void) {
     return this.contentBinding.subscribe(callback);
   }

package/src/legacy-runtime/runtime-cores/assistant-transport/types.ts

@@ -2,6 +2,7 @@ import { ReadonlyJSONValue } from "assistant-stream/utils";
 import { ThreadMessage } from "../../../types";
 import { AttachmentAdapter, ThreadHistoryAdapter } from "..";
 import { UserCommands } from "../../../augmentations";
+import type { ToolExecutionStatus } from "./useToolInvocations";
 
 // Message part types
 export type TextPart = {
@@ -56,6 +57,7 @@ export type AssistantTransportState = {
 export type AssistantTransportConnectionMetadata = {
   pendingCommands: AssistantTransportCommand[];
   isSending: boolean;
+  toolStatuses: Record<string, ToolExecutionStatus>;
 };
 
 export type AssistantTransportStateConverter<T> = (

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import {
-  ReadonlyJSONObject,
-  ReadonlyJSONValue,
+  type ReadonlyJSONObject,
+  type ReadonlyJSONValue,
   asAsyncIterableStream,
 } from "assistant-stream/utils";
 import { AppendMessage } from "../../../types";
@@ -26,7 +26,7 @@ import {
 import { useCommandQueue } from "./commandQueue";
 import { useRunManager } from "./runManager";
 import { useConvertedState } from "./useConvertedState";
-import { useToolInvocations } from "./useToolInvocations";
+import { ToolExecutionStatus, useToolInvocations } from "./useToolInvocations";
 import { toAISDKTools, getEnabledTools, createRequestHeaders } from "./utils";
 import { useRemoteThreadListRuntime } from "../remote-thread-list/useRemoteThreadListRuntime";
 import { InMemoryThreadListAdapter } from "../remote-thread-list/adapter/in-memory";
@@ -177,6 +177,11 @@ const useAssistantTransportThreadRuntime = <T,>(
     },
   });
 
+  // Tool execution status state
+  const [toolStatuses, setToolStatuses] = useState<
+    Record<string, ToolExecutionStatus>
+  >({});
+
   // Reactive conversion of agent state + connection metadata → UI state
   const pendingCommands = useMemo(
     () => [...commandQueue.state.inTransit, ...commandQueue.state.queued],
@@ -187,6 +192,7 @@ const useAssistantTransportThreadRuntime = <T,>(
     agentStateRef.current,
     pendingCommands,
     runManager.isRunning,
+    toolStatuses,
   );
 
   // Create runtime
@@ -266,6 +272,7 @@ const useAssistantTransportThreadRuntime = <T,>(
     state: converted,
     getTools: () => runtime.thread.getModelContext().tools,
     onResult: commandQueue.enqueue,
+    setToolStatuses,
   });
 
   return runtime;

package/src/legacy-runtime/runtime-cores/assistant-transport/useConvertedState.ts

@@ -4,15 +4,17 @@ import type {
   AssistantTransportState,
   AssistantTransportStateConverter,
 } from "./types";
+import type { ToolExecutionStatus } from "./useToolInvocations";
 
 export function useConvertedState<T>(
   converter: AssistantTransportStateConverter<T>,
   agentState: T,
   pendingCommands: AssistantTransportCommand[],
   isSending: boolean,
+  toolStatuses: Record<string, ToolExecutionStatus>,
 ): AssistantTransportState {
   return useMemo(
-    () => converter(agentState, { pendingCommands, isSending }),
-    [converter, agentState, pendingCommands, isSending],
+    () => converter(agentState, { pendingCommands, isSending, toolStatuses }),
+    [converter, agentState, pendingCommands, isSending, toolStatuses],
   );
 }