@assistant-ui/react 0.12.10 → 0.12.11

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();
-    };
-  }
-}

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

@@ -1,44 +0,0 @@
-import { Unsubscribe } from "../../../types";
-import { BaseSubject } from "./BaseSubject";
-import { EventSubscribable } from "./Subscribable";
-
-export class EventSubscriptionSubject<
-  TEvent extends string,
-> extends BaseSubject {
-  constructor(private config: EventSubscribable<TEvent>) {
-    super();
-  }
-
-  public getState() {
-    return this.config.binding.getState();
-  }
-
-  public outerSubscribe(callback: () => void) {
-    return this.config.binding.subscribe(callback);
-  }
-
-  protected _connect(): Unsubscribe {
-    const callback = () => {
-      this.notifySubscribers();
-    };
-
-    let lastState = this.config.binding.getState();
-    let innerUnsubscribe = lastState?.unstable_on(this.config.event, callback);
-    const onRuntimeUpdate = () => {
-      const newState = this.config.binding.getState();
-      if (newState === lastState) return;
-      lastState = newState;
-
-      innerUnsubscribe?.();
-      innerUnsubscribe = this.config.binding
-        .getState()
-        ?.unstable_on(this.config.event, callback);
-    };
-
-    const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
-    return () => {
-      outerUnsubscribe?.();
-      innerUnsubscribe?.();
-    };
-  }
-}

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

@@ -1,42 +0,0 @@
-import { BaseSubject } from "./BaseSubject";
-import { SKIP_UPDATE } from "./SKIP_UPDATE";
-import { SubscribableWithState } from "./Subscribable";
-
-export class LazyMemoizeSubject<TState extends object, TPath>
-  extends BaseSubject
-  implements SubscribableWithState<TState, TPath>
-{
-  public get path() {
-    return this.binding.path;
-  }
-
-  constructor(
-    private binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>,
-  ) {
-    super();
-  }
-
-  private _previousStateDirty = true;
-  private _previousState: TState | undefined;
-  public getState = () => {
-    if (!this.isConnected || this._previousStateDirty) {
-      const newState = this.binding.getState();
-      if (newState !== SKIP_UPDATE) {
-        this._previousState = newState;
-      }
-      this._previousStateDirty = false;
-    }
-    if (this._previousState === undefined)
-      throw new Error("Entry not available in the store");
-    return this._previousState;
-  };
-
-  protected _connect() {
-    const callback = () => {
-      this._previousStateDirty = true;
-      this.notifySubscribers();
-    };
-
-    return this.binding.subscribe(callback);
-  }
-}

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

@@ -1,58 +0,0 @@
-import { Unsubscribe } from "../../../types";
-import { BaseSubject } from "./BaseSubject";
-import {
-  NestedSubscribable,
-  Subscribable,
-  SubscribableWithState,
-} from "./Subscribable";
-
-export class NestedSubscriptionSubject<
-    TState extends Subscribable | undefined,
-    TPath,
-  >
-  extends BaseSubject
-  implements
-    SubscribableWithState<TState, TPath>,
-    NestedSubscribable<TState, TPath>
-{
-  public get path() {
-    return this.binding.path;
-  }
-
-  constructor(private binding: NestedSubscribable<TState, TPath>) {
-    super();
-  }
-
-  public getState() {
-    return this.binding.getState();
-  }
-
-  public outerSubscribe(callback: () => void) {
-    return this.binding.subscribe(callback);
-  }
-
-  protected _connect(): Unsubscribe {
-    const callback = () => {
-      this.notifySubscribers();
-    };
-
-    let lastState = this.binding.getState();
-    let innerUnsubscribe = lastState?.subscribe(callback);
-    const onRuntimeUpdate = () => {
-      const newState = this.binding.getState();
-      if (newState === lastState) return;
-      lastState = newState;
-
-      innerUnsubscribe?.();
-      innerUnsubscribe = this.binding.getState()?.subscribe(callback);
-
-      callback();
-    };
-
-    const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
-    return () => {
-      outerUnsubscribe?.();
-      innerUnsubscribe?.();
-    };
-  }
-}

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

@@ -1,2 +0,0 @@
-export const SKIP_UPDATE = Symbol("skip-update");
-export type SKIP_UPDATE = typeof SKIP_UPDATE;

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

@@ -1,47 +0,0 @@
-import { shallowEqual } from "./shallowEqual";
-import { BaseSubject } from "./BaseSubject";
-import { SubscribableWithState } from "./Subscribable";
-import { SKIP_UPDATE } from "./SKIP_UPDATE";
-
-export class ShallowMemoizeSubject<TState extends object, TPath>
-  extends BaseSubject
-  implements SubscribableWithState<TState, TPath>
-{
-  public get path() {
-    return this.binding.path;
-  }
-
-  constructor(
-    private binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>,
-  ) {
-    super();
-    const state = binding.getState();
-    if (state === SKIP_UPDATE)
-      throw new Error("Entry not available in the store");
-    this._previousState = state;
-  }
-
-  private _previousState: TState;
-  public getState = () => {
-    if (!this.isConnected) this._syncState();
-    return this._previousState;
-  };
-
-  private _syncState() {
-    const state = this.binding.getState();
-    if (state === SKIP_UPDATE) return false;
-    if (shallowEqual(state, this._previousState)) return false;
-    this._previousState = state;
-    return true;
-  }
-
-  protected _connect() {
-    const callback = () => {
-      if (this._syncState()) {
-        this.notifySubscribers();
-      }
-    };
-
-    return this.binding.subscribe(callback);
-  }
-}

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

@@ -1,26 +0,0 @@
-import { Unsubscribe } from "../../../types";
-
-export type Subscribable = {
-  subscribe: (callback: () => void) => Unsubscribe;
-};
-
-export type SubscribableWithState<TState, TPath> = Subscribable & {
-  path: TPath;
-  getState: () => TState;
-};
-
-export type NestedSubscribable<
-  TState extends Subscribable | undefined,
-  TPath,
-> = SubscribableWithState<TState, TPath>;
-
-export type EventSubscribable<TEvent extends string> = {
-  event: TEvent;
-  binding: SubscribableWithState<
-    | {
-        unstable_on: (event: TEvent, callback: () => void) => Unsubscribe;
-      }
-    | undefined,
-    unknown
-  >;
-};

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

@@ -1,16 +0,0 @@
-export function shallowEqual<T extends object>(
-  objA: T | undefined,
-  objB: T | undefined,
-) {
-  if (objA === undefined && objB === undefined) return true;
-  if (objA === undefined) return false;
-  if (objB === undefined) return false;
-
-  for (const key of Object.keys(objA)) {
-    const valueA = objA[key as keyof T];
-    const valueB = objB[key as keyof T];
-    if (!Object.is(valueA, valueB)) return false;
-  }
-
-  return true;
-}

package/src/legacy-runtime/runtime-cores/adapters/attachment/AttachmentAdapter.ts

@@ -1,71 +0,0 @@
-import {
-  Attachment,
-  PendingAttachment,
-  CompleteAttachment,
-} from "../../../../types/AttachmentTypes";
-
-/**
- * Interface for handling file attachments in the assistant runtime.
- *
- * AttachmentAdapter provides methods for managing file attachments throughout
- * their lifecycle: adding, processing, removing, and sending attachments with messages.
- *
- * @example
- * ```tsx
- * const imageAdapter: AttachmentAdapter = {
- *   accept: "image/*",
- *
- *   async add({ file }) {
- *     return {
- *       id: generateId(),
- *       type: "image",
- *       name: file.name,
- *       file,
- *       status: { type: "uploading" }
- *     };
- *   },
- *
- *   async remove(attachment) {
- *     // Clean up resources
- *   },
- *
- *   async send(attachment) {
- *     const url = await uploadFile(attachment.file);
- *     return { ...attachment, url, status: { type: "complete" } };
- *   }
- * };
- * ```
- */
-export type AttachmentAdapter = {
-  /**
-   * MIME type pattern for accepted file types (e.g., "image/*", "text/plain").
-   */
-  accept: string;
-
-  /**
-   * Processes a file when it's added as an attachment.
-   *
-   * @param state - Object containing the file to process
-   * @param state.file - The File object to be attached
-   * @returns Promise or AsyncGenerator yielding PendingAttachment states
-   */
-  add(state: {
-    file: File;
-  }): Promise<PendingAttachment> | AsyncGenerator<PendingAttachment, void>;
-
-  /**
-   * Removes an attachment and cleans up associated resources.
-   *
-   * @param attachment - The attachment to remove
-   * @returns Promise that resolves when removal is complete
-   */
-  remove(attachment: Attachment): Promise<void>;
-
-  /**
-   * Finalizes an attachment for sending with a message.
-   *
-   * @param attachment - The pending attachment to finalize
-   * @returns Promise resolving to the complete attachment
-   */
-  send(attachment: PendingAttachment): Promise<CompleteAttachment>;
-};