@assistant-ui/core 0.1.0

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

@@ -0,0 +1,200 @@
+import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+
+const EMPTY_THREAD_ERROR = new Error(
+  "This is the empty thread, a placeholder for the main thread. You cannot perform any actions on this thread instance. This error is probably because you tried to call a thread method in your render function. Call the method inside a `useEffect` hook instead.",
+);
+export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
+  getMessageById() {
+    return undefined;
+  },
+
+  getBranches() {
+    return [];
+  },
+
+  switchToBranch() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  append() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  startRun() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  resumeRun() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  cancelRun() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  addToolResult() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  resumeToolCall() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  speak() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  stopSpeaking() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  submitFeedback() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  getModelContext() {
+    return {};
+  },
+
+  exportExternalState() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  importExternalState() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  unstable_loadExternalState() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  composer: {
+    attachments: [],
+    attachmentAccept: "*",
+
+    async addAttachment() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    async removeAttachment() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    isEditing: true,
+
+    canCancel: false,
+    isEmpty: true,
+
+    text: "",
+
+    setText() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    role: "user",
+
+    setRole() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    runConfig: {},
+
+    setRunConfig() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    async reset() {
+      // noop
+    },
+
+    async clearAttachments() {
+      // noop
+    },
+
+    send() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    cancel() {
+      // noop
+    },
+
+    dictation: undefined,
+
+    startDictation() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    stopDictation() {
+      // noop
+    },
+
+    quote: undefined,
+
+    setQuote() {
+      throw EMPTY_THREAD_ERROR;
+    },
+
+    subscribe() {
+      return () => {};
+    },
+
+    unstable_on() {
+      return () => {};
+    },
+  },
+
+  getEditComposer() {
+    return undefined;
+  },
+
+  beginEdit() {
+    throw EMPTY_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,
+  },
+
+  isDisabled: false,
+  isLoading: false,
+
+  messages: [],
+
+  state: null,
+
+  suggestions: [],
+
+  extras: undefined,
+
+  subscribe() {
+    return () => {};
+  },
+
+  import() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  export() {
+    return { messages: [] };
+  },
+
+  reset() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
+  unstable_on() {
+    return () => {};
+  },
+};

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

@@ -0,0 +1,89 @@
+import { BaseSubscribable } from "../../subscribable/subscribable";
+
+type Transform<TState, TResult> = {
+  execute: () => Promise<TResult>;
+
+  /** transform the state after the promise resolves */
+  then?: (state: TState, result: TResult) => TState;
+
+  /** transform the state during resolution and afterwards */
+  optimistic?: (state: TState) => TState;
+
+  /** transform the state only while loading */
+  loading?: (state: TState, task: Promise<TResult>) => TState;
+};
+
+type PendingTransform<TState, TResult> = Transform<TState, TResult> & {
+  task: Promise<TResult>;
+};
+
+const pipeTransforms = <TState, TExtra>(
+  initialState: TState,
+  extraParam: TExtra,
+  transforms: (((state: TState, extra: TExtra) => TState) | undefined)[],
+): TState => {
+  return transforms.reduce((state, transform) => {
+    return transform?.(state, extraParam) ?? state;
+  }, initialState);
+};
+
+export class OptimisticState<TState> extends BaseSubscribable {
+  private readonly _pendingTransforms: Array<PendingTransform<TState, any>> =
+    [];
+  private _baseValue: TState;
+  private _cachedValue: TState;
+
+  public constructor(initialState: TState) {
+    super();
+    this._baseValue = initialState;
+    this._cachedValue = initialState;
+  }
+
+  private _updateState(): void {
+    this._cachedValue = this._pendingTransforms.reduce((state, transform) => {
+      return pipeTransforms(state, transform.task, [
+        transform.loading,
+        transform.optimistic,
+      ]);
+    }, this._baseValue);
+
+    this._notifySubscribers();
+  }
+
+  public get baseValue(): TState {
+    return this._baseValue;
+  }
+
+  public get value(): TState {
+    return this._cachedValue;
+  }
+
+  public update(state: TState): void {
+    this._baseValue = state;
+    this._updateState();
+  }
+
+  public async optimisticUpdate<TResult>(
+    transform: Transform<TState, TResult>,
+  ): Promise<TResult> {
+    const task = transform.execute();
+    const pendingTransform = { ...transform, task };
+    try {
+      this._pendingTransforms.push(pendingTransform);
+      this._updateState();
+
+      const result = await task;
+      this._baseValue = pipeTransforms(this._baseValue, result, [
+        transform.optimistic,
+        transform.then,
+      ]);
+      return result;
+    } finally {
+      const index = this._pendingTransforms.indexOf(pendingTransform);
+      if (index > -1) {
+        this._pendingTransforms.splice(index, 1);
+      }
+      this._updateState();
+    }
+  }
+}

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

@@ -0,0 +1,123 @@
+import type { RemoteThreadInitializeResponse } from "./types";
+
+export type RemoteThreadData =
+  | {
+      readonly id: string;
+      readonly remoteId: undefined;
+      readonly externalId: undefined;
+      readonly status: "new";
+      readonly title: undefined;
+    }
+  | {
+      readonly id: string;
+      readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
+      readonly remoteId: undefined;
+      readonly externalId: undefined;
+      readonly status: "regular" | "archived";
+      readonly title?: string | undefined;
+    }
+  | {
+      readonly id: string;
+      readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
+      readonly remoteId: string;
+      readonly externalId: string | undefined;
+      readonly status: "regular" | "archived";
+      readonly title?: string | undefined;
+    };
+
+export type THREAD_MAPPING_ID = string & { __brand: "THREAD_MAPPING_ID" };
+
+export function createThreadMappingId(id: string): THREAD_MAPPING_ID {
+  return id as THREAD_MAPPING_ID;
+}
+
+export type RemoteThreadState = {
+  readonly isLoading: boolean;
+  readonly newThreadId: string | undefined;
+  readonly threadIds: readonly string[];
+  readonly archivedThreadIds: readonly string[];
+  readonly threadIdMap: Readonly<Record<string, THREAD_MAPPING_ID>>;
+  readonly threadData: Readonly<Record<THREAD_MAPPING_ID, RemoteThreadData>>;
+};
+
+export const getThreadData = (
+  state: RemoteThreadState,
+  threadIdOrRemoteId: string,
+) => {
+  const idx = state.threadIdMap[threadIdOrRemoteId];
+  if (idx === undefined) return undefined;
+  return state.threadData[idx];
+};
+
+export const updateStatusReducer = (
+  state: RemoteThreadState,
+  threadIdOrRemoteId: string,
+  newStatus: "regular" | "archived" | "deleted",
+) => {
+  const data = getThreadData(state, threadIdOrRemoteId);
+  if (!data) return state;
+
+  const { id, remoteId, status: lastStatus } = data;
+  if (lastStatus === newStatus) return state;
+
+  const newState = { ...state };
+
+  // lastStatus
+  switch (lastStatus) {
+    case "new":
+      newState.newThreadId = undefined;
+      break;
+    case "regular":
+      newState.threadIds = newState.threadIds.filter((t) => t !== id);
+      break;
+    case "archived":
+      newState.archivedThreadIds = newState.archivedThreadIds.filter(
+        (t) => t !== id,
+      );
+      break;
+
+    default: {
+      const _exhaustiveCheck: never = lastStatus;
+      throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+    }
+  }
+
+  // newStatus
+  switch (newStatus) {
+    case "regular":
+      newState.threadIds = [id, ...newState.threadIds];
+      break;
+
+    case "archived":
+      newState.archivedThreadIds = [id, ...newState.archivedThreadIds];
+      break;
+
+    case "deleted":
+      newState.threadData = Object.fromEntries(
+        Object.entries(newState.threadData).filter(([key]) => key !== id),
+      );
+      newState.threadIdMap = Object.fromEntries(
+        Object.entries(newState.threadIdMap).filter(
+          ([key]) => key !== id && key !== remoteId,
+        ),
+      );
+      break;
+
+    default: {
+      const _exhaustiveCheck: never = newStatus;
+      throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+    }
+  }
+
+  if (newStatus !== "deleted") {
+    newState.threadData = {
+      ...newState.threadData,
+      [id]: {
+        ...data,
+        status: newStatus,
+      },
+    };
+  }
+
+  return newState;
+};

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

@@ -0,0 +1,48 @@
+import type { ThreadMessage } from "../../types";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+import { AssistantStream } from "assistant-stream";
+
+export type RemoteThreadInitializeResponse = {
+  remoteId: string;
+  externalId: string | undefined;
+};
+
+export type RemoteThreadMetadata = {
+  readonly status: "regular" | "archived";
+  readonly remoteId: string;
+  readonly externalId?: string | undefined;
+  readonly title?: string | undefined;
+};
+
+export type RemoteThreadListResponse = {
+  threads: RemoteThreadMetadata[];
+};
+
+export type RemoteThreadListAdapter = {
+  list(): Promise<RemoteThreadListResponse>;
+
+  rename(remoteId: string, newTitle: string): Promise<void>;
+  archive(remoteId: string): Promise<void>;
+  unarchive(remoteId: string): Promise<void>;
+  delete(remoteId: string): Promise<void>;
+  initialize(threadId: string): Promise<RemoteThreadInitializeResponse>;
+  generateTitle(
+    remoteId: string,
+    unstable_messages: readonly ThreadMessage[],
+  ): Promise<AssistantStream>;
+  fetch(threadId: string): Promise<RemoteThreadMetadata>;
+
+  unstable_Provider?: ((...args: any[]) => unknown) | undefined;
+};
+
+export type RemoteThreadListOptions = {
+  runtimeHook: () => AssistantRuntime;
+  adapter: RemoteThreadListAdapter;
+
+  /**
+   * When true, if this runtime is used inside another RemoteThreadListRuntime,
+   * it becomes a no-op and simply calls the runtimeHook directly.
+   * This allows wrapping runtimes that internally use RemoteThreadListRuntime.
+   */
+  allowNesting?: boolean | undefined;
+};

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

@@ -0,0 +1,40 @@
+import { resource, tapMemo, tapState } from "@assistant-ui/tap";
+import type { ClientOutput } from "../types/client";
+import type {
+  ChainOfThoughtState,
+  ChainOfThoughtPart,
+} from "../scopes/chain-of-thought";
+import type { MessagePartStatus } from "../../types";
+import type { PartMethods } from "../scopes/part";
+
+const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
+  type: "complete",
+});
+
+export const ChainOfThoughtClient = resource(
+  ({
+    parts,
+    getMessagePart,
+  }: {
+    parts: readonly ChainOfThoughtPart[];
+    getMessagePart: (selector: { index: number }) => PartMethods;
+  }): ClientOutput<"chainOfThought"> => {
+    const [collapsed, setCollapsed] = tapState(true);
+
+    const status = tapMemo(() => {
+      const lastPart = parts[parts.length - 1];
+      return lastPart?.status ?? COMPLETE_STATUS;
+    }, [parts]);
+
+    const state = tapMemo<ChainOfThoughtState>(
+      () => ({ parts, collapsed, status }),
+      [parts, collapsed, status],
+    );
+
+    return {
+      getState: () => state,
+      setCollapsed,
+      part: getMessagePart,
+    };
+  },
+);

package/src/store/clients/index.ts

@@ -0,0 +1,8 @@
+export { NoOpComposerClient } from "./no-op-composer-client";
+export { Suggestions, type SuggestionConfig } from "./suggestions";
+export { ChainOfThoughtClient } from "./chain-of-thought-client";
+export {
+  ThreadMessageClient,
+  type ThreadMessageClientProps,
+} from "./thread-message-client";
+export { ModelContext } from "./model-context-client";

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

@@ -0,0 +1,20 @@
+import { resource, tapMemo, tapState } from "@assistant-ui/tap";
+import type { ClientOutput } from "../types/client";
+import { CompositeContextProvider } from "../../utils";
+import type { ModelContextState } from "../scopes";
+
+const version = 1;
+
+export const ModelContext = resource((): ClientOutput<"modelContext"> => {
+  const [state] = tapState<ModelContextState>(
+    () => ({ version: version + 1 }) as unknown as ModelContextState,
+  );
+  const composite = tapMemo(() => new CompositeContextProvider(), []);
+
+  return {
+    getState: () => state,
+    getModelContext: () => composite.getModelContext(),
+    subscribe: (callback) => composite.subscribe(callback),
+    register: (provider) => composite.registerModelContextProvider(provider),
+  };
+});

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

@@ -0,0 +1,66 @@
+import { resource, tapMemo } from "@assistant-ui/tap";
+import type { ClientOutput } from "../types/client";
+import type { ComposerState } from "../scopes";
+
+export const NoOpComposerClient = resource(
+  ({ type }: { type: "edit" | "thread" }): ClientOutput<"composer"> => {
+    const state = tapMemo<ComposerState>(() => {
+      return {
+        isEditing: false,
+        isEmpty: true,
+        text: "",
+        attachmentAccept: "*",
+        attachments: [],
+        role: "user",
+        runConfig: {},
+        canCancel: false,
+        type: type,
+        dictation: undefined,
+        quote: undefined,
+      };
+    }, [type]);
+
+    return {
+      getState: () => state,
+      setText: () => {
+        throw new Error("Not supported");
+      },
+      setRole: () => {
+        throw new Error("Not supported");
+      },
+      setRunConfig: () => {
+        throw new Error("Not supported");
+      },
+      addAttachment: () => {
+        throw new Error("Not supported");
+      },
+      clearAttachments: () => {
+        throw new Error("Not supported");
+      },
+      attachment: () => {
+        throw new Error("Not supported");
+      },
+      reset: () => {
+        throw new Error("Not supported");
+      },
+      send: () => {
+        throw new Error("Not supported");
+      },
+      cancel: () => {
+        throw new Error("Not supported");
+      },
+      startDictation: () => {
+        throw new Error("Not supported");
+      },
+      stopDictation: () => {
+        throw new Error("Not supported");
+      },
+      beginEdit: () => {
+        throw new Error("Not supported");
+      },
+      setQuote: () => {
+        throw new Error("Not supported");
+      },
+    };
+  },
+);

package/src/store/clients/suggestions.ts

@@ -0,0 +1,69 @@
+import { resource, tapState, withKey } from "@assistant-ui/tap";
+import type { ClientOutput } from "../types/client";
+import { tapClientLookup } from "../utils/tap-client-lookup";
+import type { SuggestionsState, SuggestionState } from "../scopes";
+
+export type SuggestionConfig =
+  | string
+  | { title: string; label: string; prompt: string };
+
+const SuggestionClient = resource(
+  (state: SuggestionState): ClientOutput<"suggestion"> => {
+    return {
+      getState: () => state,
+    };
+  },
+);
+
+const SuggestionsResource = resource(
+  (suggestions?: SuggestionConfig[]): ClientOutput<"suggestions"> => {
+    const [state] = tapState<SuggestionsState>(() => {
+      const normalizedSuggestions = (suggestions ?? []).map((s) => {
+        if (typeof s === "string") {
+          return {
+            title: s,
+            label: "",
+            prompt: s,
+          };
+        }
+        return {
+          title: s.title,
+          label: s.label,
+          prompt: s.prompt,
+        };
+      });
+
+      return {
+        suggestions: normalizedSuggestions,
+      };
+    });
+
+    const suggestionClients = tapClientLookup(
+      () =>
+        state.suggestions.map((suggestion, index) =>
+          withKey(index, SuggestionClient(suggestion)),
+        ),
+      [state.suggestions],
+    );
+
+    return {
+      getState: () => state,
+      suggestion: ({ index }: { index: number }) => {
+        return suggestionClients.get({ index });
+      },
+    };
+  },
+);
+
+export const Suggestions: {
+  (): import("@assistant-ui/tap").ResourceElement<
+    ClientOutput<"suggestions">,
+    undefined
+  >;
+  (
+    suggestions: SuggestionConfig[],
+  ): import("@assistant-ui/tap").ResourceElement<
+    ClientOutput<"suggestions">,
+    SuggestionConfig[]
+  >;
+} = SuggestionsResource as any;