@assistant-ui/react 0.12.10 → 0.12.12

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

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

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

@@ -1,151 +0,0 @@
-import {
-  withKey,
-  resource,
-  tapInlineResource,
-  tapMemo,
-  tapState,
-} from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  tapClientLookup,
-  tapClientResource,
-} from "@assistant-ui/store";
-import { MessageRuntime } from "../runtime/MessageRuntime";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-import { ComposerClient } from "./ComposerRuntimeClient";
-import { MessagePartClient } from "./MessagePartRuntimeClient";
-import { RefObject } from "react";
-import { MessageState } from "../../types/scopes";
-import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
-
-const MessageAttachmentClientByIndex = resource(
-  ({ runtime, index }: { runtime: MessageRuntime; index: number }) => {
-    const attachmentRuntime = tapMemo(
-      () => runtime.getAttachmentByIndex(index),
-      [runtime, index],
-    );
-    return tapInlineResource(
-      AttachmentRuntimeClient({ runtime: attachmentRuntime }),
-    );
-  },
-);
-
-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,
-    threadIdRef,
-  }: {
-    runtime: MessageRuntime;
-    threadIdRef: 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 {
-      state,
-      methods: {
-        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/legacy-runtime/client/ThreadListItemRuntimeClient.ts

@@ -1,59 +0,0 @@
-import { resource, tapEffect } from "@assistant-ui/tap";
-import { type ClientOutput, tapAssistantEmit } from "@assistant-ui/store";
-import {
-  ThreadListItemEventType,
-  ThreadListItemRuntime,
-} from "../runtime/ThreadListItemRuntime";
-import { Unsubscribe } from "../../types";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-
-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 {
-      state,
-      methods: {
-        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,
-      },
-    };
-  },
-);

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

@@ -1,100 +0,0 @@
-import {
-  withKey,
-  resource,
-  tapInlineResource,
-  tapMemo,
-} from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  tapClientLookup,
-  tapClientResource,
-} from "@assistant-ui/store";
-import { ThreadListRuntime } from "../runtime/ThreadListRuntime";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-import { ThreadListItemClient } from "./ThreadListItemRuntimeClient";
-import { ThreadClient } from "./ThreadRuntimeClient";
-import { ThreadsState } from "../../types/scopes";
-import type { AssistantRuntime } from "../runtime/AssistantRuntime";
-
-const ThreadListItemClientById = resource(
-  ({ runtime, id }: { runtime: ThreadListRuntime; id: string }) => {
-    const threadListItemRuntime = tapMemo(
-      () => runtime.getItemById(id),
-      [runtime, id],
-    );
-    return tapInlineResource(
-      ThreadListItemClient({
-        runtime: threadListItemRuntime,
-      }),
-    );
-  },
-);
-
-export const ThreadListClient = resource(
-  ({
-    runtime,
-    __internal_assistantRuntime,
-  }: {
-    runtime: ThreadListRuntime;
-    __internal_assistantRuntime: AssistantRuntime;
-  }): ClientOutput<"threads"> => {
-    const runtimeState = tapSubscribable(runtime);
-
-    const main = tapClientResource(
-      ThreadClient({
-        runtime: runtime.main,
-      }),
-    );
-
-    const threadItems = tapClientLookup(
-      () =>
-        Object.keys(runtimeState.threadItems).map((id) =>
-          withKey(id, ThreadListItemClientById({ runtime, id })),
-        ),
-      [runtimeState.threadItems, runtime],
-    );
-
-    const state = tapMemo<ThreadsState>(() => {
-      return {
-        mainThreadId: runtimeState.mainThreadId,
-        newThreadId: runtimeState.newThreadId ?? null,
-        isLoading: runtimeState.isLoading,
-        threadIds: runtimeState.threadIds,
-        archivedThreadIds: runtimeState.archivedThreadIds,
-        threadItems: threadItems.state,
-
-        main: main.state,
-      };
-    }, [runtimeState, threadItems.state, main.state]);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        thread: () => main.methods,
-        item: (threadIdOrOptions) => {
-          if (threadIdOrOptions === "main") {
-            return threadItems.get({ key: state.mainThreadId });
-          }
-
-          if ("id" in threadIdOrOptions) {
-            return threadItems.get({ key: threadIdOrOptions.id });
-          }
-
-          const { index, archived = false } = threadIdOrOptions;
-          const id = archived
-            ? state.archivedThreadIds[index]!
-            : state.threadIds[index]!;
-          return threadItems.get({ key: id });
-        },
-        switchToThread: async (threadId) => {
-          await runtime.switchToThread(threadId);
-        },
-        switchToNewThread: async () => {
-          await runtime.switchToNewThread();
-        },
-        __internal_getAssistantRuntime: () => __internal_assistantRuntime,
-      },
-    };
-  },
-);

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

@@ -1,148 +0,0 @@
-import { ThreadRuntimeEventType } from "../runtime-cores/core/ThreadRuntimeCore";
-import { ThreadRuntime } from "../runtime/ThreadRuntime";
-import {
-  resource,
-  tapInlineResource,
-  tapMemo,
-  tapEffect,
-  type tapRef,
-  withKey,
-} from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  tapAssistantEmit,
-  tapClientLookup,
-  tapClientResource,
-} from "@assistant-ui/store";
-import { ComposerClient } from "./ComposerRuntimeClient";
-import { MessageClient } from "./MessageRuntimeClient";
-import { tapSubscribable } from "../util-hooks/tapSubscribable";
-import { Unsubscribe } from "../../types";
-import { ThreadState } from "../../types/scopes";
-
-const MessageClientById = resource(
-  ({
-    runtime,
-    id,
-    threadIdRef,
-  }: {
-    runtime: ThreadRuntime;
-    id: string;
-    threadIdRef: tapRef.RefObject<string>;
-  }) => {
-    const messageRuntime = tapMemo(
-      () => runtime.getMessageById(id),
-      [runtime, id],
-    );
-
-    return tapInlineResource(
-      MessageClient({ runtime: messageRuntime, threadIdRef }),
-    );
-  },
-);
-
-export const ThreadClient = resource(
-  ({ runtime }: { runtime: ThreadRuntime }): ClientOutput<"thread"> => {
-    const runtimeState = tapSubscribable(runtime);
-    const emit = tapAssistantEmit();
-
-    // Bind thread events to event manager
-    tapEffect(() => {
-      const unsubscribers: Unsubscribe[] = [];
-
-      // Subscribe to thread events
-      const threadEvents: ThreadRuntimeEventType[] = [
-        "runStart",
-        "runEnd",
-        "initialize",
-        "modelContextUpdate",
-      ];
-
-      for (const event of threadEvents) {
-        const unsubscribe = runtime.unstable_on(event, () => {
-          const threadId = runtime.getState()?.threadId || "unknown";
-          emit(`thread.${event}`, {
-            threadId,
-          });
-        });
-        unsubscribers.push(unsubscribe);
-      }
-
-      return () => {
-        for (const unsub of unsubscribers) unsub();
-      };
-    }, [runtime, emit]);
-
-    const threadIdRef = tapMemo(
-      () => ({
-        get current() {
-          return runtime.getState()!.threadId;
-        },
-      }),
-      [runtime],
-    );
-
-    const composer = tapClientResource(
-      ComposerClient({
-        runtime: runtime.composer,
-        threadIdRef,
-      }),
-    );
-
-    const messages = tapClientLookup(
-      () =>
-        runtimeState.messages.map((m) =>
-          withKey(m.id, MessageClientById({ runtime, id: m.id, threadIdRef })),
-        ),
-      [runtimeState.messages, runtime, threadIdRef],
-    );
-
-    const state = tapMemo<ThreadState>(() => {
-      return {
-        isEmpty: messages.state.length === 0 && !runtimeState.isLoading,
-        isDisabled: runtimeState.isDisabled,
-        isLoading: runtimeState.isLoading,
-        isRunning: runtimeState.isRunning,
-        capabilities: runtimeState.capabilities,
-        state: runtimeState.state,
-        suggestions: runtimeState.suggestions,
-        extras: runtimeState.extras,
-        speech: runtimeState.speech,
-
-        composer: composer.state,
-        messages: messages.state,
-      };
-    }, [runtimeState, messages, composer.state]);
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        composer: composer.methods,
-        append: runtime.append,
-        startRun: runtime.startRun,
-        unstable_resumeRun: runtime.unstable_resumeRun,
-        cancelRun: runtime.cancelRun,
-        getModelContext: runtime.getModelContext,
-        export: runtime.export,
-        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) {
-            return messages.get({ key: selector.id });
-          } else {
-            return messages.get(selector);
-          }
-        },
-        __internal_getRuntime: () => runtime,
-      },
-    };
-  },
-);

package/src/legacy-runtime/cloud/AssistantCloudThreadHistoryAdapter.tsx

@@ -1,182 +0,0 @@
-import { RefObject, useState } from "react";
-import { ThreadHistoryAdapter } from "../runtime-cores/adapters/thread-history/ThreadHistoryAdapter";
-import { ExportedMessageRepositoryItem } from "../runtime-cores/utils/MessageRepository";
-import { AssistantCloud } from "assistant-cloud";
-import { auiV0Decode, auiV0Encode } from "./auiV0";
-import {
-  MessageFormatAdapter,
-  MessageFormatItem,
-  MessageFormatRepository,
-  MessageStorageEntry,
-} from "../runtime-cores/adapters/thread-history/MessageFormatAdapter";
-import { GenericThreadHistoryAdapter } from "../runtime-cores/adapters/thread-history/ThreadHistoryAdapter";
-import { ReadonlyJSONObject } from "assistant-stream/utils";
-import { AssistantClient, useAui } from "@assistant-ui/store";
-import { ThreadListItemMethods } from "../../types/scopes";
-
-// Global WeakMap to store message ID mappings across adapter instances
-const globalMessageIdMapping = new WeakMap<
-  ThreadListItemMethods,
-  Record<string, string | Promise<string>>
->();
-
-class FormattedThreadHistoryAdapter<TMessage, TStorageFormat>
-  implements GenericThreadHistoryAdapter<TMessage>
-{
-  constructor(
-    private parent: AssistantCloudThreadHistoryAdapter,
-    private formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
-  ) {}
-
-  async append(item: MessageFormatItem<TMessage>) {
-    // Encode the message using the format adapter
-    const encoded = this.formatAdapter.encode(item);
-    const messageId = this.formatAdapter.getId(item.message);
-
-    // Delegate to parent's internal append method with the encoded format
-    return this.parent._appendWithFormat(
-      item.parentId,
-      messageId,
-      this.formatAdapter.format,
-      encoded,
-    );
-  }
-
-  async load(): Promise<MessageFormatRepository<TMessage>> {
-    // Delegate to parent's internal load method with format filter
-    return this.parent._loadWithFormat(
-      this.formatAdapter.format,
-      (message: MessageStorageEntry<TStorageFormat>) =>
-        this.formatAdapter.decode(message),
-    );
-  }
-}
-
-class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
-  constructor(
-    private cloudRef: RefObject<AssistantCloud>,
-    private aui: AssistantClient,
-  ) {}
-
-  private get _getIdForLocalId(): Record<string, string | Promise<string>> {
-    if (!globalMessageIdMapping.has(this.aui.threadListItem())) {
-      globalMessageIdMapping.set(this.aui.threadListItem(), {});
-    }
-    return globalMessageIdMapping.get(this.aui.threadListItem())!;
-  }
-
-  withFormat<TMessage, TStorageFormat>(
-    formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
-  ): GenericThreadHistoryAdapter<TMessage> {
-    return new FormattedThreadHistoryAdapter(this, formatAdapter);
-  }
-
-  async append({ parentId, message }: ExportedMessageRepositoryItem) {
-    const { remoteId } = await this.aui.threadListItem().initialize();
-    const task = this.cloudRef.current.threads.messages
-      .create(remoteId, {
-        parent_id: parentId
-          ? ((await this._getIdForLocalId[parentId]) ?? parentId)
-          : null,
-        format: "aui/v0",
-        content: auiV0Encode(message),
-      })
-      .then(({ message_id }) => {
-        this._getIdForLocalId[message.id] = message_id;
-        return message_id;
-      });
-
-    this._getIdForLocalId[message.id] = task;
-
-    return task.then(() => {});
-  }
-
-  async load() {
-    const remoteId = this.aui.threadListItem().getState().remoteId;
-    if (!remoteId) return { messages: [] };
-    const { messages } = await this.cloudRef.current.threads.messages.list(
-      remoteId,
-      {
-        format: "aui/v0",
-      },
-    );
-    const payload = {
-      messages: messages
-        .filter(
-          (m): m is typeof m & { format: "aui/v0" } => m.format === "aui/v0",
-        )
-        .map(auiV0Decode)
-        .reverse(),
-    };
-    return payload;
-  }
-
-  // Internal methods for FormattedThreadHistoryAdapter
-  async _appendWithFormat<T>(
-    parentId: string | null,
-    messageId: string,
-    format: string,
-    content: T,
-  ) {
-    const { remoteId } = await this.aui.threadListItem().initialize();
-
-    const task = this.cloudRef.current.threads.messages
-      .create(remoteId, {
-        parent_id: parentId
-          ? ((await this._getIdForLocalId[parentId]) ?? parentId)
-          : null,
-        format,
-        content: content as ReadonlyJSONObject,
-      })
-      .then(({ message_id }) => {
-        this._getIdForLocalId[messageId] = message_id;
-        return message_id;
-      });
-
-    this._getIdForLocalId[messageId] = task;
-
-    return task.then(() => {});
-  }
-
-  async _loadWithFormat<TMessage, TStorageFormat>(
-    format: string,
-    decoder: (
-      message: MessageStorageEntry<TStorageFormat>,
-    ) => MessageFormatItem<TMessage>,
-  ): Promise<MessageFormatRepository<TMessage>> {
-    const remoteId = this.aui.threadListItem().getState().remoteId;
-    if (!remoteId) return { messages: [] };
-
-    const { messages } = await this.cloudRef.current.threads.messages.list(
-      remoteId,
-      {
-        format,
-      },
-    );
-
-    return {
-      messages: messages
-        .filter((m) => m.format === format)
-        .map((m) =>
-          decoder({
-            id: m.id,
-            parent_id: m.parent_id,
-            format: m.format,
-            content: m.content as TStorageFormat,
-          }),
-        )
-        .reverse(),
-    };
-  }
-}
-
-export const useAssistantCloudThreadHistoryAdapter = (
-  cloudRef: RefObject<AssistantCloud>,
-): ThreadHistoryAdapter => {
-  const aui = useAui();
-  const [adapter] = useState(
-    () => new AssistantCloudThreadHistoryAdapter(cloudRef, aui),
-  );
-
-  return adapter;
-};

package/src/legacy-runtime/runtime/subscribable/BaseSubject.ts

@@ -1,36 +0,0 @@
-import { Unsubscribe } from "../../../types/Unsubscribe";
-
-export abstract class BaseSubject {
-  private _subscriptions = new Set<() => void>();
-  private _connection: Unsubscribe | undefined;
-
-  protected get isConnected() {
-    return !!this._connection;
-  }
-
-  protected abstract _connect(): Unsubscribe;
-
-  protected notifySubscribers() {
-    for (const callback of this._subscriptions) callback();
-  }
-
-  private _updateConnection() {
-    if (this._subscriptions.size > 0) {
-      if (this._connection) return;
-      this._connection = this._connect();
-    } else {
-      this._connection?.();
-      this._connection = undefined;
-    }
-  }
-
-  public subscribe(callback: () => void) {
-    this._subscriptions.add(callback);
-    this._updateConnection();
-
-    return () => {
-      this._subscriptions.delete(callback);
-      this._updateConnection();
-    };
-  }
-}