@assistant-ui/core 0.1.5 → 0.1.8

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -0,0 +1,224 @@
+import type { Unsubscribe } from "../../types/unsubscribe";
+import type { ThreadMessage } from "../../types/message";
+import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import { BaseSubscribable } from "../../subscribable/subscribable";
+
+const READONLY_THREAD_ERROR = new Error(
+  "This is a readonly thread. You cannot perform mutations on readonly threads.",
+);
+
+export class ReadonlyThreadRuntimeCore
+  extends BaseSubscribable
+  implements ThreadRuntimeCore
+{
+  private _messages: readonly ThreadMessage[] = [];
+
+  get messages() {
+    return this._messages;
+  }
+
+  setMessages(messages: readonly ThreadMessage[]) {
+    if (this._messages === messages) return;
+    this._messages = messages;
+    this._notifySubscribers();
+  }
+
+  getMessageById(messageId: string) {
+    const idx = this._messages.findIndex((m) => m.id === messageId);
+    if (idx === -1) return undefined;
+    return {
+      parentId: this._messages[idx - 1]?.id ?? null,
+      message: this._messages[idx]!,
+      index: idx,
+    };
+  }
+
+  getBranches(messageId: string) {
+    // no branching in readonly threads
+    const idx = this._messages.findIndex((m) => m.id === messageId);
+    if (idx === -1) return [];
+    return [messageId];
+  }
+
+  switchToBranch(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  append(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  startRun(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  resumeRun(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  cancelRun(): void {
+    // noop - nothing to cancel
+  }
+
+  addToolResult(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  resumeToolCall(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  speak(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  stopSpeaking(): void {
+    // noop
+  }
+
+  submitFeedback(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  getModelContext() {
+    return {};
+  }
+
+  exportExternalState() {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  importExternalState(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  unstable_loadExternalState(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  composer = {
+    attachments: [] as never[],
+    attachmentAccept: "*",
+
+    async addAttachment() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    async removeAttachment() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    isEditing: false as const,
+    canCancel: false,
+    isEmpty: true,
+    text: "",
+
+    setText() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    role: "user" as const,
+
+    setRole() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    runConfig: {},
+
+    setRunConfig() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    async reset() {
+      // noop
+    },
+
+    async clearAttachments() {
+      // noop
+    },
+
+    send() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    cancel() {
+      // noop
+    },
+
+    dictation: undefined,
+
+    startDictation() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    stopDictation() {
+      // noop
+    },
+
+    quote: undefined,
+
+    setQuote() {
+      throw READONLY_THREAD_ERROR;
+    },
+
+    subscribe() {
+      return () => {};
+    },
+
+    unstable_on() {
+      return () => {};
+    },
+  };
+
+  getEditComposer() {
+    return undefined;
+  }
+
+  beginEdit(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  speech = undefined;
+
+  capabilities = {
+    switchToBranch: false,
+    switchBranchDuringRun: false,
+    edit: false,
+    reload: false,
+    cancel: false,
+    unstable_copy: false,
+    speech: false,
+    dictation: false,
+    attachments: false,
+    feedback: false,
+    queue: false,
+  } as const;
+
+  isDisabled = false;
+  isLoading = false;
+
+  state = null;
+  suggestions = [] as never[];
+  extras = undefined;
+
+  import(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  export() {
+    return {
+      messages: this._messages.map((message, idx) => ({
+        message,
+        parentId: this._messages[idx - 1]?.id ?? null,
+      })),
+    };
+  }
+
+  reset(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
+  unstable_on(): Unsubscribe {
+    return () => {};
+  }
+}

package/src/runtimes/remote-thread-list/empty-thread-core.ts

@@ -165,6 +165,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     dictation: false,
     attachments: false,
     feedback: false,
+    queue: false,
   },
 
   isDisabled: false,

package/src/runtimes/remote-thread-list/optimistic-state.ts

@@ -30,6 +30,17 @@ const pipeTransforms = <TState, TExtra>(
 export class OptimisticState<TState> extends BaseSubscribable {
   private readonly _pendingTransforms: Array<PendingTransform<TState, any>> =
     [];
+
+  /**
+   * `optimistic` callbacks from transforms that have already resolved.
+   * Re-applied after every `then` callback so that a wholesale state
+   * replacement (e.g. list()) cannot erase earlier completed effects
+   * (e.g. delete). Cleared when no pending transforms remain.
+   *
+   * Correctness requirement: `optimistic` callbacks must be idempotent.
+   */
+  private readonly _completedOptimistics: Array<(state: TState) => TState> = [];
+
   private _baseValue: TState;
   private _cachedValue: TState;
 
@@ -77,12 +88,28 @@ export class OptimisticState<TState> extends BaseSubscribable {
         transform.optimistic,
         transform.then,
       ]);
+
+      // Re-apply previously completed optimistic callbacks so that a
+      // then() that does wholesale replacement cannot erase their effects.
+      for (const fn of this._completedOptimistics) {
+        this._baseValue = fn(this._baseValue);
+      }
+
+      if (transform.optimistic) {
+        this._completedOptimistics.push(transform.optimistic);
+      }
+
       return result;
     } finally {
       const index = this._pendingTransforms.indexOf(pendingTransform);
       if (index > -1) {
         this._pendingTransforms.splice(index, 1);
       }
+
+      if (this._pendingTransforms.length === 0) {
+        this._completedOptimistics.length = 0;
+      }
+
       this._updateState();
     }
   }

package/src/runtimes/remote-thread-list/types.ts

@@ -1,4 +1,4 @@
-import type { ThreadMessage } from "../../types";
+import type { ThreadMessage } from "../../types/message";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import { AssistantStream } from "assistant-stream";
 

package/src/store/clients/chain-of-thought-client.ts

@@ -4,7 +4,7 @@ import type {
   ChainOfThoughtState,
   ChainOfThoughtPart,
 } from "../scopes/chain-of-thought";
-import type { MessagePartStatus } from "../../types";
+import type { MessagePartStatus } from "../../types/message";
 import type { PartMethods } from "../scopes/part";
 
 const COMPLETE_STATUS: MessagePartStatus = Object.freeze({

package/src/store/clients/model-context-client.ts

@@ -1,7 +1,7 @@
 import { resource, tapMemo, tapState } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
-import { CompositeContextProvider } from "../../utils";
-import type { ModelContextState } from "../scopes";
+import { CompositeContextProvider } from "../../utils/composite-context-provider";
+import type { ModelContextState } from "../scopes/model-context";
 
 const version = 1;
 

package/src/store/clients/no-op-composer-client.ts

@@ -1,6 +1,6 @@
 import { resource, tapMemo } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
-import type { ComposerState } from "../scopes";
+import type { ComposerState } from "../scopes/composer";
 
 export const NoOpComposerClient = resource(
   ({ type }: { type: "edit" | "thread" }): ClientOutput<"composer"> => {
@@ -17,6 +17,7 @@ export const NoOpComposerClient = resource(
         type: type,
         dictation: undefined,
         quote: undefined,
+        queue: [],
       };
     }, [type]);
 
@@ -61,6 +62,9 @@ export const NoOpComposerClient = resource(
       setQuote: () => {
         throw new Error("Not supported");
       },
+      queueItem: () => {
+        throw new Error("Not supported");
+      },
     };
   },
 );

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

@@ -1,6 +1,6 @@
 import { resource, tapEffect, tapResource } from "@assistant-ui/tap";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
-import { ThreadListClient } from "../runtime-clients";
+import { ThreadListClient } from "../runtime-clients/thread-list-runtime-client";
 import {
   tapAssistantClientRef,
   Derived,
@@ -30,38 +30,27 @@ export const RuntimeAdapterResource = resource((runtime: AssistantRuntime) => {
 export const baseRuntimeAdapterTransformScopes = (
   scopes: ScopesConfig,
   parent: AssistantClient,
-): ScopesConfig => {
-  const result = {
-    ...scopes,
-    thread:
-      scopes.thread ??
-      Derived({
-        source: "threads",
-        query: { type: "main" },
-        get: (aui) => aui.threads().thread("main"),
-      }),
-    threadListItem:
-      scopes.threadListItem ??
-      Derived({
-        source: "threads",
-        query: { type: "main" },
-        get: (aui) => aui.threads().item("main"),
-      }),
-    composer:
-      scopes.composer ??
-      Derived({
-        source: "thread",
-        query: {},
-        get: (aui) => aui.threads().thread("main").composer(),
-      }),
-  };
+): void => {
+  scopes.thread ??= Derived({
+    source: "threads",
+    query: { type: "main" },
+    get: (aui) => aui.threads().thread("main"),
+  });
+  scopes.threadListItem ??= Derived({
+    source: "threads",
+    query: { type: "main" },
+    get: (aui) => aui.threads().item("main"),
+  });
+  scopes.composer ??= Derived({
+    source: "thread",
+    query: {},
+    get: (aui) => aui.threads().thread("main").composer(),
+  });
 
-  if (!result.modelContext && parent.modelContext.source === null) {
-    result.modelContext = ModelContext();
+  if (!scopes.modelContext && parent.modelContext.source === null) {
+    scopes.modelContext = ModelContext();
   }
-  if (!result.suggestions && parent.suggestions.source === null) {
-    result.suggestions = Suggestions();
+  if (!scopes.suggestions && parent.suggestions.source === null) {
+    scopes.suggestions = Suggestions();
   }
-
-  return result;
 };

package/src/store/clients/suggestions.ts

@@ -1,7 +1,8 @@
 import { resource, tapState, withKey } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { tapClientLookup } from "@assistant-ui/store";
-import type { SuggestionsState, SuggestionState } from "../scopes";
+import type { SuggestionsState } from "../scopes/suggestions";
+import type { SuggestionState } from "../scopes/suggestion";
 
 export type SuggestionConfig =
   | string

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

@@ -1,9 +1,9 @@
 import type {
   ThreadAssistantMessagePart,
   ThreadUserMessagePart,
-  Attachment,
   ThreadMessage,
-} from "../../types";
+} from "../../types/message";
+import type { Attachment } from "../../types/attachment";
 import {
   resource,
   tapMemo,
@@ -13,7 +13,8 @@ import {
 } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { tapClientLookup } from "@assistant-ui/store";
-import type { MessageState, PartState } from "../scopes";
+import type { MessageState } from "../scopes/message";
+import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
 
 const ThreadMessagePartClient = resource(

package/src/store/index.ts

@@ -1,7 +1,88 @@
 /// <reference path="./scope-registration.ts" />
 
 // scopes
-export * from "./scopes";
+export type {
+  ThreadsState,
+  ThreadsMethods,
+  ThreadsClientSchema,
+} from "./scopes/threads";
+export type {
+  ThreadListItemState,
+  ThreadListItemMethods,
+  ThreadListItemMeta,
+  ThreadListItemEvents,
+  ThreadListItemClientSchema,
+} from "./scopes/thread-list-item";
+export type {
+  ThreadState,
+  ThreadMethods,
+  ThreadMeta,
+  ThreadEvents,
+  ThreadClientSchema,
+} from "./scopes/thread";
+export type {
+  MessageState,
+  MessageMethods,
+  MessageMeta,
+  MessageClientSchema,
+} from "./scopes/message";
+export type {
+  PartState,
+  PartMethods,
+  PartMeta,
+  PartClientSchema,
+} from "./scopes/part";
+export type {
+  ComposerState,
+  ComposerMethods,
+  ComposerSendOptions,
+  ComposerMeta,
+  ComposerEvents,
+  ComposerClientSchema,
+} from "./scopes/composer";
+export type {
+  QueueItemState,
+  QueueItemMethods,
+  QueueItemMeta,
+  QueueItemClientSchema,
+} from "./scopes/queue-item";
+export type {
+  AttachmentState,
+  AttachmentMethods,
+  AttachmentMeta,
+  AttachmentClientSchema,
+} from "./scopes/attachment";
+export type {
+  SuggestionsState,
+  SuggestionsMethods,
+  SuggestionsClientSchema,
+  Suggestion,
+} from "./scopes/suggestions";
+export type {
+  SuggestionState,
+  SuggestionMethods,
+  SuggestionMeta,
+  SuggestionClientSchema,
+} from "./scopes/suggestion";
+export type {
+  ModelContextState,
+  ModelContextMethods,
+  ModelContextClientSchema,
+} from "./scopes/model-context";
+export type {
+  ChainOfThoughtState,
+  ChainOfThoughtMethods,
+  ChainOfThoughtMeta,
+  ChainOfThoughtClientSchema,
+  ChainOfThoughtPart,
+} from "./scopes/chain-of-thought";
 
 // clients
-export * from "./clients";
+export { NoOpComposerClient } from "./clients/no-op-composer-client";
+export { Suggestions, type SuggestionConfig } from "./clients/suggestions";
+export { ChainOfThoughtClient } from "./clients/chain-of-thought-client";
+export {
+  ThreadMessageClient,
+  type ThreadMessageClientProps,
+} from "./clients/thread-message-client";
+export { ModelContext } from "./clients/model-context-client";

package/src/store/internal.ts

@@ -1,4 +1,10 @@
-export * from "./runtime-clients";
+export { AttachmentRuntimeClient } from "./runtime-clients/attachment-runtime-client";
+export { MessagePartClient } from "./runtime-clients/message-part-runtime-client";
+export { ComposerClient } from "./runtime-clients/composer-runtime-client";
+export { MessageClient } from "./runtime-clients/message-runtime-client";
+export { ThreadClient } from "./runtime-clients/thread-runtime-client";
+export { ThreadListItemClient } from "./runtime-clients/thread-list-item-runtime-client";
+export { ThreadListClient } from "./runtime-clients/thread-list-runtime-client";
 export {
   RuntimeAdapterResource,
   baseRuntimeAdapterTransformScopes,

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

@@ -1,6 +1,6 @@
 import { resource } from "@assistant-ui/tap";
 import { type ClientOutput } from "@assistant-ui/store";
-import { AttachmentRuntime } from "../../runtime";
+import { AttachmentRuntime } from "../../runtime/api/attachment-runtime";
 import { tapSubscribable } from "./tap-subscribable";
 
 export const AttachmentRuntimeClient = resource(

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

@@ -1,4 +1,4 @@
-import type { Unsubscribe } from "../../types";
+import type { Unsubscribe } from "../../types/unsubscribe";
 import {
   resource,
   tapMemo,
@@ -15,9 +15,9 @@ import {
 import {
   ComposerRuntime,
   EditComposerRuntime,
-  ComposerRuntimeEventType,
-} from "../../runtime";
-import { ComposerState } from "../scopes";
+} from "../../runtime/api/composer-runtime";
+import { ComposerRuntimeEventType } from "../../runtime/interfaces/composer-runtime-core";
+import { ComposerState } from "../scopes/composer";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 import { tapSubscribable } from "./tap-subscribable";
 
@@ -101,6 +101,7 @@ export const ComposerClient = resource(
         type: runtimeState.type ?? "thread",
         dictation: runtimeState.dictation,
         quote: runtimeState.quote,
+        queue: [],
       };
     }, [runtimeState, attachments.state]);
 
@@ -129,6 +130,9 @@ export const ComposerClient = resource(
           return attachments.get(selector);
         }
       },
+      queueItem: () => {
+        throw new Error("Queue is not supported in this runtime");
+      },
       __internal_getRuntime: () => runtime,
     };
   },

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

@@ -1,6 +1,6 @@
 import { resource } from "@assistant-ui/tap";
 import { type ClientOutput } from "@assistant-ui/store";
-import { MessagePartRuntime } from "../../runtime";
+import { MessagePartRuntime } from "../../runtime/api/message-part-runtime";
 import { tapSubscribable } from "./tap-subscribable";
 
 export const MessagePartClient = resource(

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

@@ -11,11 +11,11 @@ import {
   tapClientLookup,
   tapClientResource,
 } from "@assistant-ui/store";
-import { MessageRuntime } from "../../runtime";
+import { MessageRuntime } from "../../runtime/api/message-runtime";
 import { tapSubscribable } from "./tap-subscribable";
 import { ComposerClient } from "./composer-runtime-client";
 import { MessagePartClient } from "./message-part-runtime-client";
-import { MessageState } from "../scopes";
+import { MessageState } from "../scopes/message";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 
 const MessageAttachmentClientByIndex = resource(

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

@@ -1,5 +1,5 @@
 import { tapState, tapEffect } from "@assistant-ui/tap";
-import type { SubscribableWithState } from "../../subscribable";
+import type { SubscribableWithState } from "../../subscribable/subscribable";
 
 export const tapSubscribable = <T>(
   subscribable: Omit<SubscribableWithState<T, any>, "path">,

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

@@ -1,7 +1,10 @@
-import type { Unsubscribe } from "../../types";
+import type { Unsubscribe } from "../../types/unsubscribe";
 import { resource, tapEffect } from "@assistant-ui/tap";
 import { type ClientOutput, tapAssistantEmit } from "@assistant-ui/store";
-import { ThreadListItemEventType, ThreadListItemRuntime } from "../../runtime";
+import {
+  ThreadListItemEventType,
+  ThreadListItemRuntime,
+} from "../../runtime/api/thread-list-item-runtime";
 import { tapSubscribable } from "./tap-subscribable";
 
 export const ThreadListItemClient = resource(

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

@@ -4,11 +4,12 @@ import {
   tapClientLookup,
   tapClientResource,
 } from "@assistant-ui/store";
-import { ThreadListRuntime, AssistantRuntime } from "../../runtime";
+import { ThreadListRuntime } from "../../runtime/api/thread-list-runtime";
+import { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import { tapSubscribable } from "./tap-subscribable";
 import { ThreadListItemClient } from "./thread-list-item-runtime-client";
 import { ThreadClient } from "./thread-runtime-client";
-import { ThreadsState } from "../scopes";
+import { ThreadsState } from "../scopes/threads";
 
 const ThreadListItemClientById = resource(
   ({ runtime, id }: { runtime: ThreadListRuntime; id: string }) => {

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

@@ -1,5 +1,6 @@
-import type { Unsubscribe } from "../../types";
-import { ThreadRuntimeEventType, ThreadRuntime } from "../../runtime";
+import type { Unsubscribe } from "../../types/unsubscribe";
+import { ThreadRuntimeEventType } from "../../runtime/interfaces/thread-runtime-core";
+import { ThreadRuntime } from "../../runtime/api/thread-runtime";
 import {
   resource,
   tapResource,
@@ -17,7 +18,7 @@ import {
 import { ComposerClient } from "./composer-runtime-client";
 import { MessageClient } from "./message-runtime-client";
 import { tapSubscribable } from "./tap-subscribable";
-import { ThreadState } from "../scopes";
+import { ThreadState } from "../scopes/thread";
 
 const MessageClientById = resource(
   ({
@@ -115,7 +116,8 @@ export const ThreadClient = resource(
       composer: () => composer.methods,
       append: runtime.append,
       startRun: runtime.startRun,
-      unstable_resumeRun: runtime.unstable_resumeRun,
+      resumeRun: runtime.resumeRun,
+      unstable_resumeRun: runtime.resumeRun,
       cancelRun: runtime.cancelRun,
       getModelContext: runtime.getModelContext,
       export: runtime.export,