@assistant-ui/react 0.11.0 → 0.11.1

package/src/client/AssistantRuntimeClient.ts

@@ -1,197 +0,0 @@
-import {
-  tapMemo,
-  resource,
-  tapState,
-  Unsubscribe,
-  tapInlineResource,
-} from "@assistant-ui/tap";
-import { ThreadListClientState } from "./ThreadListClient";
-import { ThreadListClientActions } from "./ThreadListClient";
-import { AssistantRuntime } from "../api/AssistantRuntime";
-import { ThreadListClient } from "./ThreadListClient";
-import { ModelContextProvider } from "../model-context";
-import { asStore, Store, tapApi } from "../utils/tap-store";
-import { useResource } from "@assistant-ui/tap/react";
-import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
-import { StoreApi } from "../utils/tap-store/tap-store-api";
-import { useMemo } from "react";
-import {
-  AssistantEventSelector,
-  AssistantEvents,
-  checkEventScope,
-  normalizeEventSelector,
-} from "../types/EventTypes";
-import { EventManagerClient } from "./EventManagerClient";
-import {
-  AssistantApi,
-  createAssistantApiField,
-} from "../context/react/AssistantApiContext";
-
-export type AssistantToolUIState = Record<
-  string,
-  ToolCallMessagePartComponent[]
->;
-export type AssistantToolUIActions = {
-  setToolUI(
-    toolName: string,
-    render: ToolCallMessagePartComponent,
-  ): Unsubscribe;
-};
-
-export const AssistantToolUIClient = resource(() => {
-  const [state, setState] = tapState<AssistantToolUIState>(() => ({}));
-
-  const api = tapApi<AssistantToolUIState, AssistantToolUIActions>(state, {
-    setToolUI: (toolName, render) => {
-      setState((prev) => {
-        return {
-          ...prev,
-          [toolName]: [...(prev[toolName] ?? []), render],
-        };
-      });
-
-      return () => {
-        setState((prev) => {
-          return {
-            ...prev,
-            [toolName]: prev[toolName]?.filter((r) => r !== render) ?? [],
-          };
-        });
-      };
-    },
-  });
-
-  return {
-    state,
-    api,
-  };
-});
-
-export type AssistantClientState = {
-  readonly threads: ThreadListClientState;
-  readonly toolUIs: AssistantToolUIState;
-};
-
-export type AssistantClientActions = {
-  readonly threads: StoreApi<ThreadListClientState, ThreadListClientActions>;
-  readonly toolUIs: StoreApi<AssistantToolUIState, AssistantToolUIActions>;
-
-  on<TEvent extends keyof AssistantEvents>(
-    event: keyof AssistantEvents,
-    callback: (e: AssistantEvents[TEvent]) => void,
-  ): Unsubscribe;
-
-  registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
-  /** @internal */
-  __internal_getRuntime(): AssistantRuntime | null;
-};
-
-export type AssistantClient = Store<
-  AssistantClientState,
-  AssistantClientActions
->;
-
-export const AssistantClient = resource(
-  ({ runtime }: { runtime: AssistantRuntime }) => {
-    const events = tapInlineResource(EventManagerClient());
-
-    const threads = tapInlineResource(
-      ThreadListClient({
-        runtime: runtime.threads,
-        events,
-      }),
-    );
-    const toolUIs = tapInlineResource(AssistantToolUIClient());
-
-    const state = tapMemo<AssistantClientState>(() => {
-      return {
-        threads: threads.state,
-        toolUIs: toolUIs.state,
-      };
-    }, [threads.state, toolUIs.state]);
-
-    const api = tapApi<AssistantClientState, AssistantClientActions>(state, {
-      threads: threads.api,
-      registerModelContextProvider: (provider: ModelContextProvider) => {
-        return runtime.registerModelContextProvider(provider);
-      },
-      toolUIs: toolUIs.api,
-      on: events.on,
-
-      __internal_getRuntime: () => runtime,
-    });
-
-    return {
-      state,
-      api,
-    };
-  },
-);
-
-export const useAssistantRuntimeClient = (runtime: AssistantRuntime) => {
-  const client = useResource(asStore(AssistantClient({ runtime: runtime })));
-  const api = useMemo(() => {
-    const getItem = () => {
-      return client.getApi().threads.item("main");
-    };
-    return {
-      threads: createAssistantApiField({
-        source: "root",
-        query: {},
-        get: () => client.getApi().threads,
-      }),
-      toolUIs: createAssistantApiField({
-        source: "root",
-        query: {},
-        get: () => client.getApi().toolUIs,
-      }),
-      thread: createAssistantApiField({
-        source: "threads",
-        query: { type: "main" },
-        get: () => client.getApi().threads.thread("main"),
-      }),
-      threadListItem: createAssistantApiField({
-        source: "threads",
-        query: { type: "main" },
-        get: () => getItem(),
-      }),
-      composer: createAssistantApiField({
-        source: "thread",
-        query: {},
-        get: () => client.getApi().threads.thread("main").composer,
-      }),
-      registerModelContextProvider(provider: ModelContextProvider) {
-        return client.getApi().registerModelContextProvider(provider);
-      },
-      __internal_getRuntime() {
-        return client.getApi().__internal_getRuntime();
-      },
-      on<TEvent extends keyof AssistantEvents>(
-        selector: AssistantEventSelector<TEvent>,
-        callback: (e: AssistantEvents[TEvent]) => void,
-      ): Unsubscribe {
-        const { event, scope } = normalizeEventSelector(selector);
-        if (scope === "*") return client.getApi().on(event, callback);
-
-        if (
-          checkEventScope("thread", scope, event) ||
-          checkEventScope("thread-list-item", scope, event) ||
-          checkEventScope("composer", scope, event)
-        ) {
-          return client.getApi().on(event, (e) => {
-            if (e.threadId !== getItem().getState().id) return;
-            callback(e);
-          });
-        }
-
-        throw new Error(
-          `Event scope is not available in this component: ${scope}`,
-        );
-      },
-      subscribe: client.subscribe,
-      flushSync: client.flushSync,
-    } satisfies Partial<AssistantApi>;
-  }, [client]);
-
-  return api;
-};

package/src/client/AttachmentClient.ts

@@ -1,11 +0,0 @@
-import { AttachmentRuntime } from "../api";
-import { Attachment } from "../types";
-
-export type AttachmentClientState = Attachment;
-
-export type AttachmentClientActions = {
-  readonly remove: () => Promise<void>;
-
-  /** @internal */
-  __internal_getRuntime(): AttachmentRuntime;
-};

package/src/client/ComposerClient.ts

@@ -1,133 +0,0 @@
-import { resource, tapMemo, tapEffect, RefObject } from "@assistant-ui/tap";
-import { ComposerRuntime, EditComposerRuntime } from "../api/ComposerRuntime";
-import { Attachment, Unsubscribe } from "../types";
-import { MessageRole, RunConfig } from "../types/AssistantTypes";
-import { tapSubscribable } from "./util-hooks/tapSubscribable";
-import { tapApi } from "../utils/tap-store";
-import {
-  AttachmentClientActions,
-  AttachmentClientState,
-} from "./AttachmentClient";
-import { StoreApi } from "../utils/tap-store/tap-store-api";
-import { EventManagerActions } from "./EventManagerClient";
-import { ComposerRuntimeEventType } from "../runtimes/core/ComposerRuntimeCore";
-
-export type ComposerClientState = {
-  readonly text: string;
-  readonly role: MessageRole;
-  readonly attachments: readonly Attachment[];
-  readonly runConfig: RunConfig;
-  readonly isEditing: boolean;
-  readonly canCancel: boolean;
-  readonly attachmentAccept: string;
-  readonly isEmpty: boolean;
-  readonly type: "thread" | "edit";
-};
-
-export type ComposerClientActions = {
-  setText(text: string): void;
-  setRole(role: MessageRole): void;
-  setRunConfig(runConfig: RunConfig): void;
-  addAttachment(file: File): Promise<void>;
-  clearAttachments(): Promise<void>;
-  attachment(selector: {
-    index: number;
-  }): StoreApi<AttachmentClientState, AttachmentClientActions>;
-  reset(): Promise<void>;
-  send(): void;
-  cancel(): void;
-  beginEdit(): void;
-
-  /** @internal */
-  __internal_getRuntime(): ComposerRuntime;
-};
-
-export const ComposerClient = resource(
-  ({
-    threadIdRef,
-    messageIdRef,
-    events,
-    runtime,
-  }: {
-    threadIdRef: RefObject<string>;
-    messageIdRef?: RefObject<string>;
-    runtime: ComposerRuntime;
-    events: EventManagerActions;
-  }) => {
-    const runtimeState = tapSubscribable(runtime);
-
-    // Bind composer events to event manager
-    tapEffect(() => {
-      const unsubscribers: Unsubscribe[] = [];
-
-      // Subscribe to composer events
-      const composerEvents: ComposerRuntimeEventType[] = [
-        "send",
-        "attachment-add",
-      ];
-
-      for (const event of composerEvents) {
-        const unsubscribe = runtime.unstable_on(event, () => {
-          events.emit(`composer.${event}`, {
-            threadId: threadIdRef.current,
-            ...(messageIdRef && { messageId: messageIdRef.current }),
-          });
-        });
-        unsubscribers.push(unsubscribe);
-      }
-
-      return () => {
-        for (const unsub of unsubscribers) unsub();
-      };
-    }, [runtime, events, threadIdRef, messageIdRef]);
-
-    const state = tapMemo<ComposerClientState>(() => {
-      return {
-        text: runtimeState.text,
-        role: runtimeState.role,
-        attachments: runtimeState.attachments,
-        runConfig: runtimeState.runConfig,
-        isEditing: runtimeState.isEditing,
-        canCancel: runtimeState.canCancel,
-        attachmentAccept: runtimeState.attachmentAccept,
-        isEmpty: runtimeState.isEmpty,
-        type: runtimeState.type ?? "thread",
-      };
-    }, [runtimeState]);
-
-    const api = tapApi<ComposerClientState, ComposerClientActions>(state, {
-      setText: runtime.setText,
-      setRole: runtime.setRole,
-      setRunConfig: runtime.setRunConfig,
-      addAttachment: runtime.addAttachment,
-      reset: runtime.reset,
-
-      clearAttachments: runtime.clearAttachments,
-      send: runtime.send,
-      cancel: runtime.cancel,
-      beginEdit:
-        (runtime as EditComposerRuntime).beginEdit ??
-        (() => {
-          throw new Error("beginEdit is not supported in this runtime");
-        }),
-
-      attachment: ({ index }) => {
-        const attachmentRuntime = runtime.getAttachmentByIndex(index);
-        return {
-          getState: attachmentRuntime.getState,
-
-          remove: attachmentRuntime.remove,
-
-          __internal_getRuntime: () => runtime.getAttachmentByIndex(index),
-        };
-      },
-
-      __internal_getRuntime: () => runtime,
-    });
-
-    return {
-      state,
-      api,
-    };
-  },
-);

package/src/client/EventManagerClient.ts

@@ -1,63 +0,0 @@
-import { resource, tapState } from "@assistant-ui/tap";
-import { tapApi } from "../utils/tap-store";
-import { AssistantEvents, Unsubscribe } from "../types";
-
-type EventCallback<TEvent extends keyof AssistantEvents> = (
-  payload: AssistantEvents[TEvent],
-) => void;
-
-export type EventManagerActions = {
-  on<TEvent extends keyof AssistantEvents>(
-    event: TEvent,
-    callback: EventCallback<TEvent>,
-  ): Unsubscribe;
-  emit<TEvent extends keyof AssistantEvents>(
-    event: TEvent,
-    payload: AssistantEvents[TEvent],
-  ): void;
-};
-
-export const EventManagerClient = resource(() => {
-  // Map of event name to set of callbacks
-  const [listeners] = tapState<Map<string, Set<EventCallback<any>>>>(
-    () => new Map(),
-  );
-
-  const api = tapApi<Record<string, never>, EventManagerActions>(
-    {},
-    {
-      on: <TEvent extends keyof AssistantEvents>(
-        event: TEvent,
-        callback: EventCallback<TEvent>,
-      ): Unsubscribe => {
-        if (!listeners.has(event)) {
-          listeners.set(event, new Set());
-        }
-
-        const eventListeners = listeners.get(event)!;
-        eventListeners.add(callback);
-
-        return () => {
-          eventListeners.delete(callback);
-          if (eventListeners.size === 0) {
-            listeners.delete(event);
-          }
-        };
-      },
-
-      emit: (event: keyof AssistantEvents, payload: any) => {
-        const eventListeners = listeners.get(event);
-        if (!eventListeners) return;
-
-        // make sure state updates flush
-        queueMicrotask(() => {
-          for (const callback of eventListeners) {
-            callback(payload);
-          }
-        });
-      },
-    },
-  );
-
-  return api;
-});

package/src/client/MessageClient.ts

@@ -1,196 +0,0 @@
-import {
-  resource,
-  tapInlineResource,
-  tapMemo,
-  tapState,
-} from "@assistant-ui/tap";
-import { tapApi } from "../utils/tap-store";
-import { MessageRuntime } from "../api/MessageRuntime";
-import { tapSubscribable } from "./util-hooks/tapSubscribable";
-import {
-  ComposerClient,
-  ComposerClientActions,
-  ComposerClientState,
-} from "./ComposerClient";
-import {
-  MessagePartClient,
-  MessagePartClientActions,
-  MessagePartClientState,
-} from "./MessagePartClient";
-import { ThreadMessage } from "../types";
-import {
-  SpeechState,
-  SubmittedFeedback,
-} from "../runtimes/core/ThreadRuntimeCore";
-import { RunConfig } from "../types/AssistantTypes";
-import { tapLookupResources } from "./util-hooks/tapLookupResources";
-import {
-  AttachmentClientActions,
-  AttachmentClientState,
-} from "./AttachmentClient";
-import { StoreApi } from "../utils/tap-store/tap-store-api";
-import { EventManagerActions } from "./EventManagerClient";
-import { RefObject } from "react";
-
-export type MessageClientState = ThreadMessage & {
-  readonly parentId: string | null;
-  readonly isLast: boolean;
-
-  readonly branchNumber: number;
-  readonly branchCount: number;
-
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  readonly speech: SpeechState | undefined;
-  readonly submittedFeedback: SubmittedFeedback | undefined;
-
-  readonly composer: ComposerClientState;
-  readonly parts: readonly MessagePartClientState[];
-
-  readonly isCopied: boolean;
-  readonly isHovering: boolean;
-};
-
-export type MessageClientActions = {
-  readonly composer: StoreApi<ComposerClientState, ComposerClientActions>;
-
-  reload(config?: { runConfig?: RunConfig }): void;
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  speak(): void;
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  stopSpeaking(): void;
-  submitFeedback(feedback: { type: "positive" | "negative" }): void;
-  switchToBranch(options: {
-    position?: "previous" | "next";
-    branchId?: string;
-  }): void;
-  getCopyText(): string;
-
-  part: (
-    selector: { index: number } | { toolCallId: string },
-  ) => StoreApi<MessagePartClientState, MessagePartClientActions>;
-  attachment(selector: {
-    index: number;
-  }): StoreApi<AttachmentClientState, AttachmentClientActions>;
-
-  setIsCopied(value: boolean): void;
-  setIsHovering(value: boolean): void;
-
-  /** @internal */
-  __internal_getRuntime(): MessageRuntime;
-};
-
-const MessagePartByIndex = resource(
-  ({ runtime, index }: { runtime: MessageRuntime; index: number }) => {
-    const partRuntime = tapMemo(
-      () => runtime.getMessagePartByIndex(index),
-      [runtime, index],
-    );
-    return tapInlineResource(MessagePartClient({ runtime: partRuntime }));
-  },
-);
-
-export const MessageClient = resource(
-  ({
-    runtime,
-    events,
-    threadIdRef,
-  }: {
-    runtime: MessageRuntime;
-    events: EventManagerActions;
-    threadIdRef: RefObject<string>;
-  }) => {
-    const runtimeState = tapSubscribable(runtime);
-
-    const [isCopiedState, setIsCopied] = tapState(false);
-    const [isHoveringState, setIsHovering] = tapState(false);
-
-    const messageIdRef = tapMemo(
-      () => ({
-        get current() {
-          return runtime.getState().id;
-        },
-      }),
-      [runtime],
-    );
-
-    const composer = tapInlineResource(
-      ComposerClient({
-        runtime: runtime.composer,
-        events,
-        threadIdRef,
-        messageIdRef,
-      }),
-    );
-
-    const parts = tapLookupResources(
-      runtimeState.content.map((_, idx) =>
-        MessagePartByIndex({ runtime, index: idx }, { key: idx }),
-      ),
-    );
-
-    const state = tapMemo<MessageClientState>(() => {
-      return {
-        ...(runtimeState as MessageClientState),
-
-        parts: parts.state,
-        composer: composer.state,
-
-        isCopied: isCopiedState,
-        isHovering: isHoveringState,
-      };
-    }, [
-      runtimeState,
-      parts.state,
-      composer.state,
-      isCopiedState,
-      isHoveringState,
-    ]);
-
-    const api = tapApi<MessageClientState, MessageClientActions>(state, {
-      composer: composer.api,
-
-      reload: (config) => runtime.reload(config),
-      speak: () => runtime.speak(),
-      stopSpeaking: () => runtime.stopSpeaking(),
-      submitFeedback: (feedback) => runtime.submitFeedback(feedback),
-      switchToBranch: (options) => runtime.switchToBranch(options),
-      getCopyText: () => runtime.unstable_getCopyText(),
-
-      part: (selector) => {
-        if ("index" in selector) {
-          return parts.api({ index: selector.index });
-        } else {
-          return parts.api({ key: "toolCallId-" + selector.toolCallId });
-        }
-      },
-
-      attachment: ({ index }) => {
-        const attachmentRuntime = runtime.getAttachmentByIndex(index);
-        return {
-          getState: attachmentRuntime.getState,
-
-          remove: attachmentRuntime.remove,
-
-          __internal_getRuntime: () => attachmentRuntime,
-        };
-      },
-
-      setIsCopied,
-      setIsHovering,
-
-      __internal_getRuntime: () => runtime,
-    });
-
-    return {
-      key: runtimeState.id,
-      state,
-      api,
-    };
-  },
-);

package/src/client/MessagePartClient.ts

@@ -1,53 +0,0 @@
-import { resource } from "@assistant-ui/tap";
-import { tapApi } from "../utils/tap-store";
-import { MessagePartRuntime } from "../api/MessagePartRuntime";
-import { tapSubscribable } from "./util-hooks/tapSubscribable";
-import {
-  ThreadAssistantMessagePart,
-  ThreadUserMessagePart,
-  MessagePartStatus,
-  ToolCallMessagePartStatus,
-} from "../types/AssistantTypes";
-import { ToolResponse } from "assistant-stream";
-
-export type MessagePartClientState = (
-  | ThreadUserMessagePart
-  | ThreadAssistantMessagePart
-) & {
-  readonly status: MessagePartStatus | ToolCallMessagePartStatus;
-};
-
-export type MessagePartClientActions = {
-  /**
-   * Add tool result to a tool call message part that has no tool result yet.
-   * This is useful when you are collecting a tool result via user input ("human tool calls").
-   */
-  addToolResult(result: any | ToolResponse<any>): void;
-
-  /** @internal */
-  __internal_getRuntime(): MessagePartRuntime;
-};
-
-export const MessagePartClient = resource(
-  ({ runtime }: { runtime: MessagePartRuntime }) => {
-    const runtimeState = tapSubscribable(runtime);
-
-    const api = tapApi<MessagePartClientState, MessagePartClientActions>(
-      runtimeState,
-      {
-        addToolResult: (result) => runtime.addToolResult(result),
-
-        __internal_getRuntime: () => runtime,
-      },
-    );
-
-    return {
-      key:
-        runtimeState.type === "tool-call"
-          ? "toolCallId-" + runtimeState.toolCallId
-          : undefined,
-      state: runtimeState,
-      api,
-    };
-  },
-);