@assistant-ui/core 0.1.0

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

@@ -0,0 +1,86 @@
+import { withKey, resource, tapResource, tapMemo } from "@assistant-ui/tap";
+import { type ClientOutput, tapClientLookup, tapClientResource } from "../";
+import { ThreadListRuntime, AssistantRuntime } from "../../runtime";
+import { tapSubscribable } from "./tap-subscribable";
+import { ThreadListItemClient } from "./thread-list-item-runtime-client";
+import { ThreadClient } from "./thread-runtime-client";
+import { ThreadsState } from "../scopes";
+
+const ThreadListItemClientById = resource(
+  ({ runtime, id }: { runtime: ThreadListRuntime; id: string }) => {
+    const threadListItemRuntime = tapMemo(
+      () => runtime.getItemById(id),
+      [runtime, id],
+    );
+    return tapResource(
+      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 {
+      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/store/runtime-clients/thread-runtime-client.ts

@@ -0,0 +1,141 @@
+import type { Unsubscribe } from "../../types";
+import { ThreadRuntimeEventType, ThreadRuntime } from "../../runtime";
+import {
+  resource,
+  tapResource,
+  tapMemo,
+  tapEffect,
+  type tapRef,
+  withKey,
+} from "@assistant-ui/tap";
+import {
+  type ClientOutput,
+  tapAssistantEmit,
+  tapClientLookup,
+  tapClientResource,
+} from "../";
+import { ComposerClient } from "./composer-runtime-client";
+import { MessageClient } from "./message-runtime-client";
+import { tapSubscribable } from "./tap-subscribable";
+import { ThreadState } from "../scopes";
+
+const MessageClientById = resource(
+  ({
+    runtime,
+    id,
+    threadIdRef,
+  }: {
+    runtime: ThreadRuntime;
+    id: string;
+    threadIdRef: tapRef.RefObject<string>;
+  }) => {
+    const messageRuntime = tapMemo(
+      () => runtime.getMessageById(id),
+      [runtime, id],
+    );
+
+    return tapResource(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 {
+      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/store/scopes/attachment.ts

@@ -0,0 +1,20 @@
+import type { Attachment } from "../../types";
+import type { AttachmentRuntime } from "../../runtime";
+
+export type AttachmentState = Attachment;
+
+export type AttachmentMethods = {
+  getState(): AttachmentState;
+  remove(): Promise<void>;
+  __internal_getRuntime?(): AttachmentRuntime;
+};
+
+export type AttachmentMeta = {
+  source: "message" | "composer";
+  query: { type: "index"; index: number } | { type: "id"; id: string };
+};
+
+export type AttachmentClientSchema = {
+  methods: AttachmentMethods;
+  meta: AttachmentMeta;
+};

package/src/store/scopes/chain-of-thought.ts

@@ -0,0 +1,38 @@
+import type { MessagePartStatus, ToolCallMessagePartStatus } from "../../types";
+import type { PartMethods, PartState } from "./part";
+
+export type ChainOfThoughtPart = Extract<
+  PartState,
+  { type: "tool-call" } | { type: "reasoning" }
+>;
+
+export type ChainOfThoughtState = {
+  readonly parts: readonly ChainOfThoughtPart[];
+  readonly collapsed: boolean;
+  readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+};
+
+export type ChainOfThoughtMethods = {
+  /**
+   * Get the current state of the chain of thought.
+   */
+  getState(): ChainOfThoughtState;
+  /**
+   * Set the collapsed state of the chain of thought accordion.
+   */
+  setCollapsed(collapsed: boolean): void;
+  /**
+   * Get the part methods for a specific part within this chain of thought.
+   */
+  part(selector: { index: number }): PartMethods;
+};
+
+export type ChainOfThoughtMeta = {
+  source: "message";
+  query: { type: "chainOfThought" };
+};
+
+export type ChainOfThoughtClientSchema = {
+  methods: ChainOfThoughtMethods;
+  meta: ChainOfThoughtMeta;
+};

package/src/store/scopes/composer.ts

@@ -0,0 +1,80 @@
+import type {
+  Attachment,
+  MessageRole,
+  RunConfig,
+  QuoteInfo,
+} from "../../types";
+import type { ComposerRuntime, DictationState } from "../../runtime";
+import type { AttachmentMethods } from "./attachment";
+
+export type ComposerState = {
+  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";
+
+  /**
+   * The current state of dictation.
+   * Undefined when dictation is not active.
+   */
+  readonly dictation: DictationState | undefined;
+
+  /**
+   * The currently quoted text, if any.
+   * Undefined when no quote is set.
+   */
+  readonly quote: QuoteInfo | undefined;
+};
+
+export type ComposerMethods = {
+  getState(): ComposerState;
+  setText(text: string): void;
+  setRole(role: MessageRole): void;
+  setRunConfig(runConfig: RunConfig): void;
+  addAttachment(file: File): Promise<void>;
+  clearAttachments(): Promise<void>;
+  attachment(selector: { index: number } | { id: string }): AttachmentMethods;
+  reset(): Promise<void>;
+  send(): void;
+  cancel(): void;
+  beginEdit(): void;
+
+  /**
+   * Start dictation to convert voice to text input.
+   * Requires a DictationAdapter to be configured.
+   */
+  startDictation(): void;
+
+  /**
+   * Stop the current dictation session.
+   */
+  stopDictation(): void;
+
+  /**
+   * Set a quote for the next message. Pass undefined to clear.
+   */
+  setQuote(quote: QuoteInfo | undefined): void;
+
+  __internal_getRuntime?(): ComposerRuntime;
+};
+
+export type ComposerMeta = {
+  source: "thread" | "message";
+  query: Record<string, never>;
+};
+
+export type ComposerEvents = {
+  "composer.send": { threadId: string; messageId?: string };
+  "composer.attachmentAdd": { threadId: string; messageId?: string };
+};
+
+export type ComposerClientSchema = {
+  methods: ComposerMethods;
+  meta: ComposerMeta;
+  events: ComposerEvents;
+};

package/src/store/scopes/index.ts

@@ -0,0 +1,68 @@
+export type {
+  ThreadsState,
+  ThreadsMethods,
+  ThreadsClientSchema,
+} from "./threads";
+export type {
+  ThreadListItemState,
+  ThreadListItemMethods,
+  ThreadListItemMeta,
+  ThreadListItemEvents,
+  ThreadListItemClientSchema,
+} from "./thread-list-item";
+export type {
+  ThreadState,
+  ThreadMethods,
+  ThreadMeta,
+  ThreadEvents,
+  ThreadClientSchema,
+} from "./thread";
+export type {
+  MessageState,
+  MessageMethods,
+  MessageMeta,
+  MessageClientSchema,
+} from "./message";
+export type {
+  PartState,
+  PartMethods,
+  PartMeta,
+  PartClientSchema,
+} from "./part";
+export type {
+  ComposerState,
+  ComposerMethods,
+  ComposerMeta,
+  ComposerEvents,
+  ComposerClientSchema,
+} from "./composer";
+export type {
+  AttachmentState,
+  AttachmentMethods,
+  AttachmentMeta,
+  AttachmentClientSchema,
+} from "./attachment";
+export type {
+  SuggestionsState,
+  SuggestionsMethods,
+  SuggestionsClientSchema,
+  Suggestion,
+} from "./suggestions";
+export type {
+  SuggestionState,
+  SuggestionMethods,
+  SuggestionMeta,
+  SuggestionClientSchema,
+} from "./suggestion";
+export type {
+  ModelContextState,
+  ModelContextMethods,
+  ModelContextClientSchema,
+} from "./model-context";
+export type {
+  ChainOfThoughtState,
+  ChainOfThoughtMethods,
+  ChainOfThoughtMeta,
+  ChainOfThoughtClientSchema,
+  ChainOfThoughtPart,
+} from "./chain-of-thought";

package/src/store/scopes/message.ts

@@ -0,0 +1,75 @@
+import type { ThreadMessage, RunConfig } from "../../types";
+import type {
+  SpeechState,
+  SubmittedFeedback,
+  MessageRuntime,
+} from "../../runtime";
+import type { ComposerMethods, ComposerState } from "./composer";
+import type { PartMethods, PartState } from "./part";
+import type { AttachmentMethods } from "./attachment";
+
+export type MessageState = 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.
+   *
+   * To enable text-to-speech, provide a `SpeechSynthesisAdapter` to the runtime.
+   *
+   * @example
+   * ```ts
+   * import { WebSpeechSynthesisAdapter } from "@assistant-ui/react";
+   * import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
+   *
+   * const runtime = useChatRuntime({
+   *   adapters: {
+   *     speech: new WebSpeechSynthesisAdapter(),
+   *   },
+   * });
+   */
+  readonly speech: SpeechState | undefined;
+  /** @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0. */
+  readonly submittedFeedback: SubmittedFeedback | undefined;
+  readonly composer: ComposerState;
+  readonly parts: readonly PartState[];
+  readonly isCopied: boolean;
+  readonly isHovering: boolean;
+  /** The position of this message in the thread (0 for first message) */
+  readonly index: number;
+};
+
+export type MessageMethods = {
+  /**
+   * Get the current state of the message.
+   */
+  getState(): MessageState;
+  composer(): ComposerMethods;
+  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 }): PartMethods;
+  attachment(selector: { index: number } | { id: string }): AttachmentMethods;
+  setIsCopied(value: boolean): void;
+  setIsHovering(value: boolean): void;
+  __internal_getRuntime?(): MessageRuntime;
+};
+
+export type MessageMeta = {
+  source: "thread";
+  query: { type: "id"; id: string } | { type: "index"; index: number };
+};
+
+export type MessageClientSchema = {
+  methods: MessageMethods;
+  meta: MessageMeta;
+};

package/src/store/scopes/model-context.ts

@@ -0,0 +1,13 @@
+import type { Unsubscribe } from "../../types";
+import type { ModelContextProvider } from "../../model-context";
+
+export type ModelContextState = Record<string, never>;
+
+export type ModelContextMethods = ModelContextProvider & {
+  getState(): ModelContextState;
+  register: (provider: ModelContextProvider) => Unsubscribe;
+};
+
+export type ModelContextClientSchema = {
+  methods: ModelContextMethods;
+};

package/src/store/scopes/part.ts

@@ -0,0 +1,47 @@
+import type { ToolResponse } from "assistant-stream";
+import type {
+  ThreadUserMessagePart,
+  ThreadAssistantMessagePart,
+  MessagePartStatus,
+  ToolCallMessagePartStatus,
+} from "../../types";
+import type { MessagePartRuntime } from "../../runtime";
+
+export type PartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
+  readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+};
+
+export type PartMethods = {
+  /**
+   * Get the current state of the message part.
+   */
+  getState(): PartState;
+  /**
+   * 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: unknown | ToolResponse<unknown>): void;
+  /**
+   * Resume a tool call that is waiting for human input with a payload.
+   * This is useful when a tool has requested human input and is waiting for a response.
+   */
+  resumeToolCall(payload: unknown): void;
+  __internal_getRuntime?(): MessagePartRuntime;
+};
+
+export type PartMeta =
+  | {
+      source: "message";
+      query:
+        | { type: "index"; index: number }
+        | { type: "toolCallId"; toolCallId: string };
+    }
+  | {
+      source: "chainOfThought";
+      query: { type: "index"; index: number };
+    };
+
+export type PartClientSchema = {
+  methods: PartMethods;
+  meta: PartMeta;
+};

package/src/store/scopes/suggestion.ts

@@ -0,0 +1,19 @@
+export type SuggestionState = {
+  title: string;
+  label: string;
+  prompt: string;
+};
+
+export type SuggestionMethods = {
+  getState(): SuggestionState;
+};
+
+export type SuggestionMeta = {
+  source: "suggestions";
+  query: { index: number };
+};
+
+export type SuggestionClientSchema = {
+  methods: SuggestionMethods;
+  meta: SuggestionMeta;
+};

package/src/store/scopes/suggestions.ts

@@ -0,0 +1,20 @@
+import type { SuggestionMethods } from "./suggestion";
+
+export type Suggestion = {
+  title: string;
+  label: string;
+  prompt: string;
+};
+
+export type SuggestionsState = {
+  suggestions: Suggestion[];
+};
+
+export type SuggestionsMethods = {
+  getState(): SuggestionsState;
+  suggestion(query: { index: number }): SuggestionMethods;
+};
+
+export type SuggestionsClientSchema = {
+  methods: SuggestionsMethods;
+};

package/src/store/scopes/thread-list-item.ts

@@ -0,0 +1,44 @@
+import type {
+  ThreadListItemRuntime,
+  ThreadListItemStatus,
+} from "../../runtime";
+
+export type ThreadListItemState = {
+  readonly id: string;
+  readonly remoteId: string | undefined;
+  readonly externalId: string | undefined;
+  readonly title?: string | undefined;
+  readonly status: ThreadListItemStatus;
+};
+
+export type ThreadListItemMethods = {
+  getState(): ThreadListItemState;
+  switchTo(): void;
+  rename(newTitle: string): void;
+  archive(): void;
+  unarchive(): void;
+  delete(): void;
+  generateTitle(): void;
+  initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;
+  detach(): void;
+  __internal_getRuntime?(): ThreadListItemRuntime;
+};
+
+export type ThreadListItemMeta = {
+  source: "threads";
+  query:
+    | { type: "main" }
+    | { type: "id"; id: string }
+    | { type: "index"; index: number; archived?: boolean };
+};
+
+export type ThreadListItemEvents = {
+  "threadListItem.switchedTo": { threadId: string };
+  "threadListItem.switchedAway": { threadId: string };
+};
+
+export type ThreadListItemClientSchema = {
+  methods: ThreadListItemMethods;
+  meta: ThreadListItemMeta;
+  events: ThreadListItemEvents;
+};