@assistant-ui/core 0.1.0

package/src/store/clients/thread-message-client.ts

@@ -0,0 +1,170 @@
+import type {
+  ThreadAssistantMessagePart,
+  ThreadUserMessagePart,
+  Attachment,
+  ThreadMessage,
+} from "../../types";
+import {
+  resource,
+  tapMemo,
+  tapState,
+  tapResource,
+  withKey,
+} from "@assistant-ui/tap";
+import type { ClientOutput } from "../types/client";
+import { tapClientLookup } from "../utils/tap-client-lookup";
+import type { MessageState, PartState } from "../scopes";
+import { NoOpComposerClient } from "./no-op-composer-client";
+
+const ThreadMessagePartClient = resource(
+  ({
+    part,
+  }: {
+    part: ThreadAssistantMessagePart | ThreadUserMessagePart;
+  }): ClientOutput<"part"> => {
+    const state = tapMemo<PartState>(() => {
+      return {
+        ...part,
+        status: { type: "complete" },
+      };
+    }, [part]);
+
+    return {
+      getState: () => state,
+      addToolResult: () => {
+        throw new Error("Not supported");
+      },
+      resumeToolCall: () => {
+        throw new Error("Not supported");
+      },
+    };
+  },
+);
+
+const ThreadMessageAttachmentClient = resource(
+  ({ attachment }: { attachment: Attachment }): ClientOutput<"attachment"> => {
+    return {
+      getState: () => attachment,
+      remove: () => {
+        throw new Error("Not supported");
+      },
+    };
+  },
+);
+export type ThreadMessageClientProps = {
+  message: ThreadMessage;
+  index: number;
+  isLast?: boolean;
+  branchNumber?: number;
+  branchCount?: number;
+};
+
+export const ThreadMessageClient = resource(
+  ({
+    message,
+    index,
+    isLast = true,
+    branchNumber = 1,
+    branchCount = 1,
+  }: ThreadMessageClientProps): ClientOutput<"message"> => {
+    const [isCopiedState, setIsCopied] = tapState(false);
+    const [isHoveringState, setIsHovering] = tapState(false);
+
+    const parts = tapClientLookup(
+      () =>
+        message.content.map((part, idx) =>
+          withKey(
+            "toolCallId" in part && part.toolCallId != null
+              ? `toolCallId-${part.toolCallId}`
+              : `index-${idx}`,
+            ThreadMessagePartClient({ part }),
+          ),
+        ),
+      [message.content],
+    );
+
+    const attachments = tapClientLookup(
+      () =>
+        (message.attachments ?? []).map((attachment) =>
+          withKey(attachment.id, ThreadMessageAttachmentClient({ attachment })),
+        ),
+      [message.attachments],
+    );
+
+    const composer = tapResource(NoOpComposerClient({ type: "edit" }));
+    const composerState = composer.getState();
+
+    const state = tapMemo<MessageState>(() => {
+      return {
+        ...message,
+        parts: parts.state,
+        composer: composerState,
+        parentId: null,
+        index,
+        isLast,
+        branchNumber,
+        branchCount,
+        speech: undefined,
+        submittedFeedback: message.metadata.submittedFeedback,
+        isCopied: isCopiedState,
+        isHovering: isHoveringState,
+      };
+    }, [
+      message,
+      index,
+      isCopiedState,
+      isHoveringState,
+      isLast,
+      parts.state,
+      composerState,
+      branchNumber,
+      branchCount,
+    ]);
+
+    return {
+      getState: () => state,
+      composer: () => composer,
+      part: (selector) => {
+        if ("index" in selector) {
+          return parts.get({ index: selector.index });
+        } else {
+          return parts.get({ key: `toolCallId-${selector.toolCallId}` });
+        }
+      },
+      attachment: (selector) => {
+        if ("id" in selector) {
+          return attachments.get({ key: selector.id });
+        } else {
+          return attachments.get(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/store/index.ts

@@ -0,0 +1,44 @@
+// resources
+export { Derived } from "./utils/derived";
+export type { DerivedElement } from "./utils/derived";
+export { attachTransformScopes } from "./utils/attach-transform-scopes";
+export type { ScopesConfig } from "./utils/attach-transform-scopes";
+
+// tap hooks
+export {
+  tapAssistantClientRef,
+  tapAssistantEmit,
+} from "./utils/tap-assistant-context";
+export { tapClientResource } from "./utils/tap-client-resource";
+export { tapClientLookup } from "./utils/tap-client-lookup";
+export { tapClientList } from "./utils/tap-client-list";
+
+// types
+export type {
+  ScopeRegistry,
+  ClientOutput,
+  AssistantClient,
+  AssistantState,
+  ClientMethods,
+  ClientSchema,
+  ClientNames,
+  ClientEvents,
+  ClientMeta,
+  ClientElement,
+  Unsubscribe,
+  AssistantClientAccessor,
+} from "./types/client";
+export type {
+  AssistantEventName,
+  AssistantEventCallback,
+  AssistantEventPayload,
+  AssistantEventSelector,
+  AssistantEventScope,
+} from "./types/events";
+export { normalizeEventSelector } from "./types/events";
+
+// scopes
+export * from "./scopes";
+
+// clients
+export * from "./clients";

package/src/store/internal.ts

@@ -0,0 +1,32 @@
+// Internal utilities — consumed by @assistant-ui/store, not public API.
+
+export {
+  BaseProxyHandler,
+  handleIntrospectionProp,
+} from "./utils/base-proxy-handler";
+export {
+  SYMBOL_CLIENT_INDEX,
+  getClientIndex,
+  type ClientStack,
+  tapClientStack,
+  tapWithClientStack,
+} from "./utils/tap-client-stack-context";
+export {
+  type AssistantTapContextValue,
+  withAssistantTapContextProvider,
+} from "./utils/tap-assistant-context";
+export { NotificationManager } from "./utils/notification-manager";
+export {
+  PROXIED_ASSISTANT_STATE_SYMBOL,
+  createProxiedAssistantState,
+  getProxiedAssistantState,
+} from "./utils/proxied-assistant-state";
+export {
+  type RootClients,
+  type DerivedClients,
+  tapSplitClients,
+} from "./utils/split-clients";
+export { getClientState, ClientResource } from "./utils/tap-client-resource";
+export { wrapperResource } from "./utils/wrapper-resource";
+export { getTransformScopes } from "./utils/attach-transform-scopes";
+export * from "./runtime-clients";

package/src/store/runtime-clients/attachment-runtime-client.ts

@@ -0,0 +1,16 @@
+import { resource } from "@assistant-ui/tap";
+import { type ClientOutput } from "../";
+import { AttachmentRuntime } from "../../runtime";
+import { tapSubscribable } from "./tap-subscribable";
+
+export const AttachmentRuntimeClient = resource(
+  ({ runtime }: { runtime: AttachmentRuntime }): ClientOutput<"attachment"> => {
+    const state = tapSubscribable(runtime);
+
+    return {
+      getState: () => state,
+      remove: runtime.remove,
+      __internal_getRuntime: () => runtime,
+    };
+  },
+);

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -0,0 +1,131 @@
+import type { Unsubscribe } from "../../types";
+import {
+  resource,
+  tapMemo,
+  tapEffect,
+  tapResource,
+  type tapRef,
+  withKey,
+} from "@assistant-ui/tap";
+import { type ClientOutput, tapAssistantEmit, tapClientLookup } from "../";
+import {
+  ComposerRuntime,
+  EditComposerRuntime,
+  ComposerRuntimeEventType,
+} from "../../runtime";
+import { ComposerState } from "../scopes";
+import { AttachmentRuntimeClient } from "./attachment-runtime-client";
+import { tapSubscribable } from "./tap-subscribable";
+
+const ComposerAttachmentClientByIndex = resource(
+  ({ runtime, index }: { runtime: ComposerRuntime; index: number }) => {
+    const attachmentRuntime = tapMemo(
+      () => runtime.getAttachmentByIndex(index),
+      [runtime, index],
+    );
+
+    return tapResource(
+      AttachmentRuntimeClient({
+        runtime: attachmentRuntime,
+      }),
+    );
+  },
+);
+
+export const ComposerClient = resource(
+  ({
+    threadIdRef,
+    messageIdRef,
+    runtime,
+  }: {
+    threadIdRef: tapRef.RefObject<string>;
+    messageIdRef?: tapRef.RefObject<string>;
+    runtime: ComposerRuntime;
+  }): ClientOutput<"composer"> => {
+    const runtimeState = tapSubscribable(runtime);
+    const emit = tapAssistantEmit();
+
+    // Bind composer events to event manager
+    tapEffect(() => {
+      const unsubscribers: Unsubscribe[] = [];
+
+      // Subscribe to composer events
+      const composerEvents: ComposerRuntimeEventType[] = [
+        "send",
+        "attachmentAdd",
+      ];
+
+      for (const event of composerEvents) {
+        const unsubscribe = runtime.unstable_on(event, () => {
+          emit(`composer.${event}`, {
+            threadId: threadIdRef.current,
+            ...(messageIdRef && { messageId: messageIdRef.current }),
+          });
+        });
+        unsubscribers.push(unsubscribe);
+      }
+
+      return () => {
+        for (const unsub of unsubscribers) unsub();
+      };
+    }, [runtime, emit, threadIdRef, messageIdRef]);
+
+    const attachments = tapClientLookup(
+      () =>
+        runtimeState.attachments.map((attachment, idx) =>
+          withKey(
+            attachment.id,
+            ComposerAttachmentClientByIndex({
+              runtime,
+              index: idx,
+            }),
+          ),
+        ),
+      [runtimeState.attachments, runtime],
+    );
+
+    const state = tapMemo<ComposerState>(() => {
+      return {
+        text: runtimeState.text,
+        role: runtimeState.role,
+        attachments: attachments.state,
+        runConfig: runtimeState.runConfig,
+        isEditing: runtimeState.isEditing,
+        canCancel: runtimeState.canCancel,
+        attachmentAccept: runtimeState.attachmentAccept,
+        isEmpty: runtimeState.isEmpty,
+        type: runtimeState.type ?? "thread",
+        dictation: runtimeState.dictation,
+        quote: runtimeState.quote,
+      };
+    }, [runtimeState, attachments.state]);
+
+    return {
+      getState: () => 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");
+        }),
+      startDictation: runtime.startDictation,
+      stopDictation: runtime.stopDictation,
+      setQuote: runtime.setQuote,
+      attachment: (selector) => {
+        if ("id" in selector) {
+          return attachments.get({ key: selector.id });
+        } else {
+          return attachments.get(selector);
+        }
+      },
+      __internal_getRuntime: () => runtime,
+    };
+  },
+);

package/src/store/runtime-clients/index.ts

@@ -0,0 +1,7 @@
+export { AttachmentRuntimeClient } from "./attachment-runtime-client";
+export { MessagePartClient } from "./message-part-runtime-client";
+export { ComposerClient } from "./composer-runtime-client";
+export { MessageClient } from "./message-runtime-client";
+export { ThreadClient } from "./thread-runtime-client";
+export { ThreadListItemClient } from "./thread-list-item-runtime-client";
+export { ThreadListClient } from "./thread-list-runtime-client";

package/src/store/runtime-clients/message-part-runtime-client.ts

@@ -0,0 +1,17 @@
+import { resource } from "@assistant-ui/tap";
+import { type ClientOutput } from "../";
+import { MessagePartRuntime } from "../../runtime";
+import { tapSubscribable } from "./tap-subscribable";
+
+export const MessagePartClient = resource(
+  ({ runtime }: { runtime: MessagePartRuntime }): ClientOutput<"part"> => {
+    const state = tapSubscribable(runtime);
+
+    return {
+      getState: () => state,
+      addToolResult: (result) => runtime.addToolResult(result),
+      resumeToolCall: (payload) => runtime.resumeToolCall(payload),
+      __internal_getRuntime: () => runtime,
+    };
+  },
+);

package/src/store/runtime-clients/message-runtime-client.ts

@@ -0,0 +1,141 @@
+import {
+  withKey,
+  resource,
+  tapResource,
+  tapMemo,
+  tapState,
+  type tapRef,
+} from "@assistant-ui/tap";
+import { type ClientOutput, tapClientLookup, tapClientResource } from "../";
+import { MessageRuntime } from "../../runtime";
+import { tapSubscribable } from "./tap-subscribable";
+import { ComposerClient } from "./composer-runtime-client";
+import { MessagePartClient } from "./message-part-runtime-client";
+import { MessageState } from "../scopes";
+import { AttachmentRuntimeClient } from "./attachment-runtime-client";
+
+const MessageAttachmentClientByIndex = resource(
+  ({ runtime, index }: { runtime: MessageRuntime; index: number }) => {
+    const attachmentRuntime = tapMemo(
+      () => runtime.getAttachmentByIndex(index),
+      [runtime, index],
+    );
+    return tapResource(AttachmentRuntimeClient({ runtime: attachmentRuntime }));
+  },
+);
+
+const MessagePartByIndex = resource(
+  ({ runtime, index }: { runtime: MessageRuntime; index: number }) => {
+    const partRuntime = tapMemo(
+      () => runtime.getMessagePartByIndex(index),
+      [runtime, index],
+    );
+    return tapResource(MessagePartClient({ runtime: partRuntime }));
+  },
+);
+
+export const MessageClient = resource(
+  ({
+    runtime,
+    threadIdRef,
+  }: {
+    runtime: MessageRuntime;
+    threadIdRef: tapRef.RefObject<string>;
+  }): ClientOutput<"message"> => {
+    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 = tapClientResource(
+      ComposerClient({
+        runtime: runtime.composer,
+        threadIdRef,
+        messageIdRef,
+      }),
+    );
+    const parts = tapClientLookup(
+      () =>
+        runtimeState.content.map((part, idx) =>
+          withKey(
+            "toolCallId" in part && part.toolCallId != null
+              ? `toolCallId-${part.toolCallId}`
+              : `index-${idx}`,
+            MessagePartByIndex({ runtime, index: idx }),
+          ),
+        ),
+      [runtimeState.content, runtime],
+    );
+
+    const attachments = tapClientLookup(
+      () =>
+        (runtimeState.attachments ?? []).map((attachment, idx) =>
+          withKey(
+            attachment.id,
+            MessageAttachmentClientByIndex({ runtime, index: idx }),
+          ),
+        ),
+      [runtimeState.attachments, runtime],
+    );
+
+    const state = tapMemo<MessageState>(() => {
+      return {
+        ...(runtimeState as MessageState),
+
+        parts: parts.state,
+        composer: composer.state,
+
+        isCopied: isCopiedState,
+        isHovering: isHoveringState,
+      };
+    }, [
+      runtimeState,
+      parts.state,
+      composer.state,
+      isCopiedState,
+      isHoveringState,
+    ]);
+
+    return {
+      getState: () => state,
+
+      composer: () => composer.methods,
+
+      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.get({ index: selector.index });
+        } else {
+          return parts.get({ key: `toolCallId-${selector.toolCallId}` });
+        }
+      },
+
+      attachment: (selector) => {
+        if ("id" in selector) {
+          return attachments.get({ key: selector.id });
+        } else {
+          return attachments.get(selector);
+        }
+      },
+
+      setIsCopied,
+      setIsHovering,
+
+      __internal_getRuntime: () => runtime,
+    };
+  },
+);

package/src/store/runtime-clients/tap-subscribable.ts

@@ -0,0 +1,16 @@
+import { tapState, tapEffect } from "@assistant-ui/tap";
+import type { SubscribableWithState } from "../../subscribable";
+
+export const tapSubscribable = <T>(
+  subscribable: Omit<SubscribableWithState<T, any>, "path">,
+) => {
+  const [, setState] = tapState(subscribable.getState);
+  tapEffect(() => {
+    setState(subscribable.getState());
+    return subscribable.subscribe(() => {
+      setState(subscribable.getState());
+    });
+  }, [subscribable]);
+
+  return subscribable.getState();
+};

package/src/store/runtime-clients/thread-list-item-runtime-client.ts

@@ -0,0 +1,53 @@
+import type { Unsubscribe } from "../../types";
+import { resource, tapEffect } from "@assistant-ui/tap";
+import { type ClientOutput, tapAssistantEmit } from "../";
+import { ThreadListItemEventType, ThreadListItemRuntime } from "../../runtime";
+import { tapSubscribable } from "./tap-subscribable";
+
+export const ThreadListItemClient = resource(
+  ({
+    runtime,
+  }: {
+    runtime: ThreadListItemRuntime;
+  }): ClientOutput<"threadListItem"> => {
+    const state = tapSubscribable(runtime);
+    const emit = tapAssistantEmit();
+
+    // Bind thread list item events to event manager
+    tapEffect(() => {
+      const unsubscribers: Unsubscribe[] = [];
+
+      // Subscribe to thread list item events
+      const threadListItemEvents: ThreadListItemEventType[] = [
+        "switchedTo",
+        "switchedAway",
+      ];
+
+      for (const event of threadListItemEvents) {
+        const unsubscribe = runtime.unstable_on(event, () => {
+          emit(`threadListItem.${event}`, {
+            threadId: runtime.getState()!.id,
+          });
+        });
+        unsubscribers.push(unsubscribe);
+      }
+
+      return () => {
+        for (const unsub of unsubscribers) unsub();
+      };
+    }, [runtime, emit]);
+
+    return {
+      getState: () => state,
+      switchTo: runtime.switchTo,
+      rename: runtime.rename,
+      archive: runtime.archive,
+      unarchive: runtime.unarchive,
+      delete: runtime.delete,
+      generateTitle: runtime.generateTitle,
+      initialize: runtime.initialize,
+      detach: runtime.detach,
+      __internal_getRuntime: () => runtime,
+    };
+  },
+);