@assistant-ui/react 0.11.0 → 0.11.1

package/dist/legacy-runtime/runtime/ThreadListRuntime.js

@@ -0,0 +1,168 @@
+// src/legacy-runtime/runtime/ThreadListRuntime.ts
+import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject.js";
+import {
+  ThreadListItemRuntimeImpl
+} from "./ThreadListItemRuntime.js";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE.js";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject.js";
+import {
+  ThreadRuntimeImpl
+} from "./ThreadRuntime.js";
+import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject.js";
+var getThreadListState = (threadList) => {
+  return {
+    mainThreadId: threadList.mainThreadId,
+    newThread: threadList.newThreadId,
+    threads: threadList.threadIds,
+    archivedThreads: threadList.archivedThreadIds,
+    isLoading: threadList.isLoading,
+    threadItems: threadList.threadData
+  };
+};
+var getThreadListItemState = (threadList, threadId) => {
+  if (threadId === void 0) return SKIP_UPDATE;
+  const threadData = threadList.getItemById(threadId);
+  if (!threadData) return SKIP_UPDATE;
+  return {
+    id: threadData.id,
+    threadId: threadData.id,
+    // TODO remove in 0.8.0
+    remoteId: threadData.remoteId,
+    externalId: threadData.externalId,
+    title: threadData.title,
+    status: threadData.status,
+    isMain: threadData.id === threadList.mainThreadId
+  };
+};
+var ThreadListRuntimeImpl = class {
+  constructor(_core, _runtimeFactory = ThreadRuntimeImpl) {
+    this._core = _core;
+    this._runtimeFactory = _runtimeFactory;
+    const stateBinding = new LazyMemoizeSubject({
+      path: {},
+      getState: () => getThreadListState(_core),
+      subscribe: (callback) => _core.subscribe(callback)
+    });
+    this._getState = stateBinding.getState.bind(stateBinding);
+    this._mainThreadListItemRuntime = new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[main]`,
+          threadSelector: { type: "main" }
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, this._core.mainThreadId);
+        },
+        subscribe: (callback) => this._core.subscribe(callback)
+      }),
+      this._core
+    );
+    this.main = new _runtimeFactory(
+      new NestedSubscriptionSubject({
+        path: {
+          ref: "threads.main",
+          threadSelector: { type: "main" }
+        },
+        getState: () => _core.getMainThreadRuntimeCore(),
+        subscribe: (callback) => _core.subscribe(callback)
+      }),
+      this._mainThreadListItemRuntime
+      // TODO capture "main" threadListItem from context around useLocalRuntime / useExternalStoreRuntime
+    );
+    this.__internal_bindMethods();
+  }
+  _getState;
+  __internal_bindMethods() {
+    this.switchToThread = this.switchToThread.bind(this);
+    this.switchToNewThread = this.switchToNewThread.bind(this);
+    this.getState = this.getState.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.getById = this.getById.bind(this);
+    this.getItemById = this.getItemById.bind(this);
+    this.getItemByIndex = this.getItemByIndex.bind(this);
+    this.getArchivedItemByIndex = this.getArchivedItemByIndex.bind(this);
+  }
+  switchToThread(threadId) {
+    return this._core.switchToThread(threadId);
+  }
+  switchToNewThread() {
+    return this._core.switchToNewThread();
+  }
+  getState() {
+    return this._getState();
+  }
+  subscribe(callback) {
+    return this._core.subscribe(callback);
+  }
+  _mainThreadListItemRuntime;
+  main;
+  get mainItem() {
+    return this._mainThreadListItemRuntime;
+  }
+  getById(threadId) {
+    return new this._runtimeFactory(
+      new NestedSubscriptionSubject({
+        path: {
+          ref: "threads[threadId=" + JSON.stringify(threadId) + "]",
+          threadSelector: { type: "threadId", threadId }
+        },
+        getState: () => this._core.getThreadRuntimeCore(threadId),
+        subscribe: (callback) => this._core.subscribe(callback)
+      }),
+      this.mainItem
+      // TODO capture "main" threadListItem from context around useLocalRuntime / useExternalStoreRuntime
+    );
+  }
+  getItemByIndex(idx) {
+    return new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[${idx}]`,
+          threadSelector: { type: "index", index: idx }
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, this._core.threadIds[idx]);
+        },
+        subscribe: (callback) => this._core.subscribe(callback)
+      }),
+      this._core
+    );
+  }
+  getArchivedItemByIndex(idx) {
+    return new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `archivedThreadItems[${idx}]`,
+          threadSelector: { type: "archiveIndex", index: idx }
+        },
+        getState: () => {
+          return getThreadListItemState(
+            this._core,
+            this._core.archivedThreadIds[idx]
+          );
+        },
+        subscribe: (callback) => this._core.subscribe(callback)
+      }),
+      this._core
+    );
+  }
+  getItemById(threadId) {
+    return new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[threadId=${threadId}]`,
+          threadSelector: { type: "threadId", threadId }
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, threadId);
+        },
+        subscribe: (callback) => this._core.subscribe(callback)
+      }),
+      this._core
+    );
+  }
+};
+export {
+  ThreadListRuntimeImpl
+};
+//# sourceMappingURL=ThreadListRuntime.js.map

package/dist/legacy-runtime/runtime/ThreadListRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/legacy-runtime/runtime/ThreadListRuntime.ts"],"sourcesContent":["import { LazyMemoizeSubject } from \"./subscribable/LazyMemoizeSubject\";\nimport { ThreadListRuntimeCore } from \"../runtime-cores/core/ThreadListRuntimeCore\";\nimport { Unsubscribe } from \"../../types\";\nimport {\n  ThreadListItemRuntime,\n  ThreadListItemRuntimeImpl,\n  ThreadListItemState,\n} from \"./ThreadListItemRuntime\";\nimport { SKIP_UPDATE } from \"./subscribable/SKIP_UPDATE\";\nimport { ShallowMemoizeSubject } from \"./subscribable/ShallowMemoizeSubject\";\nimport {\n  ThreadListItemRuntimeBinding,\n  ThreadRuntime,\n  ThreadRuntimeCoreBinding,\n  ThreadRuntimeImpl,\n} from \"./ThreadRuntime\";\nimport { NestedSubscriptionSubject } from \"./subscribable/NestedSubscriptionSubject\";\n\nexport type ThreadListState = {\n  readonly mainThreadId: string;\n  readonly newThread: string | undefined;\n  readonly threads: readonly string[];\n  readonly archivedThreads: readonly string[];\n  readonly isLoading: boolean;\n  readonly threadItems: Readonly<\n    Record<string, Omit<ThreadListItemState, \"isMain\" | \"threadId\">>\n  >;\n};\n\nexport type ThreadListRuntime = {\n  getState(): ThreadListState;\n\n  subscribe(callback: () => void): Unsubscribe;\n\n  readonly main: ThreadRuntime;\n  getById(threadId: string): ThreadRuntime;\n\n  readonly mainItem: ThreadListItemRuntime;\n  getItemById(threadId: string): ThreadListItemRuntime;\n  getItemByIndex(idx: number): ThreadListItemRuntime;\n  getArchivedItemByIndex(idx: number): ThreadListItemRuntime;\n\n  switchToThread(threadId: string): Promise<void>;\n  switchToNewThread(): Promise<void>;\n};\n\nconst getThreadListState = (\n  threadList: ThreadListRuntimeCore,\n): ThreadListState => {\n  return {\n    mainThreadId: threadList.mainThreadId,\n    newThread: threadList.newThreadId,\n    threads: threadList.threadIds,\n    archivedThreads: threadList.archivedThreadIds,\n    isLoading: threadList.isLoading,\n    threadItems: threadList.threadData,\n  };\n};\n\nconst getThreadListItemState = (\n  threadList: ThreadListRuntimeCore,\n  threadId: string | undefined,\n): ThreadListItemState | SKIP_UPDATE => {\n  if (threadId === undefined) return SKIP_UPDATE;\n\n  const threadData = threadList.getItemById(threadId);\n  if (!threadData) return SKIP_UPDATE;\n  return {\n    id: threadData.id,\n    threadId: threadData.id, // TODO remove in 0.8.0\n    remoteId: threadData.remoteId,\n    externalId: threadData.externalId,\n    title: threadData.title,\n    status: threadData.status,\n    isMain: threadData.id === threadList.mainThreadId,\n  };\n};\n\nexport type ThreadListRuntimeCoreBinding = ThreadListRuntimeCore;\n\nexport class ThreadListRuntimeImpl implements ThreadListRuntime {\n  private _getState;\n  constructor(\n    private _core: ThreadListRuntimeCoreBinding,\n    private _runtimeFactory: new (\n      binding: ThreadRuntimeCoreBinding,\n      threadListItemBinding: ThreadListItemRuntimeBinding,\n    ) => ThreadRuntime = ThreadRuntimeImpl,\n  ) {\n    const stateBinding = new LazyMemoizeSubject({\n      path: {},\n      getState: () => getThreadListState(_core),\n      subscribe: (callback) => _core.subscribe(callback),\n    });\n\n    this._getState = stateBinding.getState.bind(stateBinding);\n\n    this._mainThreadListItemRuntime = new ThreadListItemRuntimeImpl(\n      new ShallowMemoizeSubject({\n        path: {\n          ref: `threadItems[main]`,\n          threadSelector: { type: \"main\" },\n        },\n        getState: () => {\n          return getThreadListItemState(this._core, this._core.mainThreadId);\n        },\n        subscribe: (callback) => this._core.subscribe(callback),\n      }),\n      this._core,\n    );\n\n    this.main = new _runtimeFactory(\n      new NestedSubscriptionSubject({\n        path: {\n          ref: \"threads.main\",\n          threadSelector: { type: \"main\" },\n        },\n        getState: () => _core.getMainThreadRuntimeCore(),\n        subscribe: (callback) => _core.subscribe(callback),\n      }),\n      this._mainThreadListItemRuntime, // TODO capture \"main\" threadListItem from context around useLocalRuntime / useExternalStoreRuntime\n    );\n\n    this.__internal_bindMethods();\n  }\n\n  protected __internal_bindMethods() {\n    this.switchToThread = this.switchToThread.bind(this);\n    this.switchToNewThread = this.switchToNewThread.bind(this);\n    this.getState = this.getState.bind(this);\n    this.subscribe = this.subscribe.bind(this);\n    this.getById = this.getById.bind(this);\n    this.getItemById = this.getItemById.bind(this);\n    this.getItemByIndex = this.getItemByIndex.bind(this);\n    this.getArchivedItemByIndex = this.getArchivedItemByIndex.bind(this);\n  }\n\n  public switchToThread(threadId: string): Promise<void> {\n    return this._core.switchToThread(threadId);\n  }\n\n  public switchToNewThread(): Promise<void> {\n    return this._core.switchToNewThread();\n  }\n\n  public getState(): ThreadListState {\n    return this._getState();\n  }\n\n  public subscribe(callback: () => void): Unsubscribe {\n    return this._core.subscribe(callback);\n  }\n\n  private _mainThreadListItemRuntime;\n\n  public readonly main: ThreadRuntime;\n\n  public get mainItem() {\n    return this._mainThreadListItemRuntime;\n  }\n\n  public getById(threadId: string) {\n    return new this._runtimeFactory(\n      new NestedSubscriptionSubject({\n        path: {\n          ref: \"threads[threadId=\" + JSON.stringify(threadId) + \"]\",\n          threadSelector: { type: \"threadId\", threadId },\n        },\n        getState: () => this._core.getThreadRuntimeCore(threadId),\n        subscribe: (callback) => this._core.subscribe(callback),\n      }),\n      this.mainItem, // TODO capture \"main\" threadListItem from context around useLocalRuntime / useExternalStoreRuntime\n    );\n  }\n\n  public getItemByIndex(idx: number) {\n    return new ThreadListItemRuntimeImpl(\n      new ShallowMemoizeSubject({\n        path: {\n          ref: `threadItems[${idx}]`,\n          threadSelector: { type: \"index\", index: idx },\n        },\n        getState: () => {\n          return getThreadListItemState(this._core, this._core.threadIds[idx]);\n        },\n        subscribe: (callback) => this._core.subscribe(callback),\n      }),\n      this._core,\n    );\n  }\n\n  public getArchivedItemByIndex(idx: number) {\n    return new ThreadListItemRuntimeImpl(\n      new ShallowMemoizeSubject({\n        path: {\n          ref: `archivedThreadItems[${idx}]`,\n          threadSelector: { type: \"archiveIndex\", index: idx },\n        },\n        getState: () => {\n          return getThreadListItemState(\n            this._core,\n            this._core.archivedThreadIds[idx],\n          );\n        },\n        subscribe: (callback) => this._core.subscribe(callback),\n      }),\n      this._core,\n    );\n  }\n\n  public getItemById(threadId: string) {\n    return new ThreadListItemRuntimeImpl(\n      new ShallowMemoizeSubject({\n        path: {\n          ref: `threadItems[threadId=${threadId}]`,\n          threadSelector: { type: \"threadId\", threadId },\n        },\n        getState: () => {\n          return getThreadListItemState(this._core, threadId);\n        },\n        subscribe: (callback) => this._core.subscribe(callback),\n      }),\n      this._core,\n    );\n  }\n}\n"],"mappings":";AAAA,SAAS,0BAA0B;AAGnC;AAAA,EAEE;AAAA,OAEK;AACP,SAAS,mBAAmB;AAC5B,SAAS,6BAA6B;AACtC;AAAA,EAIE;AAAA,OACK;AACP,SAAS,iCAAiC;AA8B1C,IAAM,qBAAqB,CACzB,eACoB;AACpB,SAAO;AAAA,IACL,cAAc,WAAW;AAAA,IACzB,WAAW,WAAW;AAAA,IACtB,SAAS,WAAW;AAAA,IACpB,iBAAiB,WAAW;AAAA,IAC5B,WAAW,WAAW;AAAA,IACtB,aAAa,WAAW;AAAA,EAC1B;AACF;AAEA,IAAM,yBAAyB,CAC7B,YACA,aACsC;AACtC,MAAI,aAAa,OAAW,QAAO;AAEnC,QAAM,aAAa,WAAW,YAAY,QAAQ;AAClD,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO;AAAA,IACL,IAAI,WAAW;AAAA,IACf,UAAU,WAAW;AAAA;AAAA,IACrB,UAAU,WAAW;AAAA,IACrB,YAAY,WAAW;AAAA,IACvB,OAAO,WAAW;AAAA,IAClB,QAAQ,WAAW;AAAA,IACnB,QAAQ,WAAW,OAAO,WAAW;AAAA,EACvC;AACF;AAIO,IAAM,wBAAN,MAAyD;AAAA,EAE9D,YACU,OACA,kBAGa,mBACrB;AALQ;AACA;AAKR,UAAM,eAAe,IAAI,mBAAmB;AAAA,MAC1C,MAAM,CAAC;AAAA,MACP,UAAU,MAAM,mBAAmB,KAAK;AAAA,MACxC,WAAW,CAAC,aAAa,MAAM,UAAU,QAAQ;AAAA,IACnD,CAAC;AAED,SAAK,YAAY,aAAa,SAAS,KAAK,YAAY;AAExD,SAAK,6BAA6B,IAAI;AAAA,MACpC,IAAI,sBAAsB;AAAA,QACxB,MAAM;AAAA,UACJ,KAAK;AAAA,UACL,gBAAgB,EAAE,MAAM,OAAO;AAAA,QACjC;AAAA,QACA,UAAU,MAAM;AACd,iBAAO,uBAAuB,KAAK,OAAO,KAAK,MAAM,YAAY;AAAA,QACnE;AAAA,QACA,WAAW,CAAC,aAAa,KAAK,MAAM,UAAU,QAAQ;AAAA,MACxD,CAAC;AAAA,MACD,KAAK;AAAA,IACP;AAEA,SAAK,OAAO,IAAI;AAAA,MACd,IAAI,0BAA0B;AAAA,QAC5B,MAAM;AAAA,UACJ,KAAK;AAAA,UACL,gBAAgB,EAAE,MAAM,OAAO;AAAA,QACjC;AAAA,QACA,UAAU,MAAM,MAAM,yBAAyB;AAAA,QAC/C,WAAW,CAAC,aAAa,MAAM,UAAU,QAAQ;AAAA,MACnD,CAAC;AAAA,MACD,KAAK;AAAA;AAAA,IACP;AAEA,SAAK,uBAAuB;AAAA,EAC9B;AAAA,EA3CQ;AAAA,EA6CE,yBAAyB;AACjC,SAAK,iBAAiB,KAAK,eAAe,KAAK,IAAI;AACnD,SAAK,oBAAoB,KAAK,kBAAkB,KAAK,IAAI;AACzD,SAAK,WAAW,KAAK,SAAS,KAAK,IAAI;AACvC,SAAK,YAAY,KAAK,UAAU,KAAK,IAAI;AACzC,SAAK,UAAU,KAAK,QAAQ,KAAK,IAAI;AACrC,SAAK,cAAc,KAAK,YAAY,KAAK,IAAI;AAC7C,SAAK,iBAAiB,KAAK,eAAe,KAAK,IAAI;AACnD,SAAK,yBAAyB,KAAK,uBAAuB,KAAK,IAAI;AAAA,EACrE;AAAA,EAEO,eAAe,UAAiC;AACrD,WAAO,KAAK,MAAM,eAAe,QAAQ;AAAA,EAC3C;AAAA,EAEO,oBAAmC;AACxC,WAAO,KAAK,MAAM,kBAAkB;AAAA,EACtC;AAAA,EAEO,WAA4B;AACjC,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA,EAEO,UAAU,UAAmC;AAClD,WAAO,KAAK,MAAM,UAAU,QAAQ;AAAA,EACtC;AAAA,EAEQ;AAAA,EAEQ;AAAA,EAEhB,IAAW,WAAW;AACpB,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,QAAQ,UAAkB;AAC/B,WAAO,IAAI,KAAK;AAAA,MACd,IAAI,0BAA0B;AAAA,QAC5B,MAAM;AAAA,UACJ,KAAK,sBAAsB,KAAK,UAAU,QAAQ,IAAI;AAAA,UACtD,gBAAgB,EAAE,MAAM,YAAY,SAAS;AAAA,QAC/C;AAAA,QACA,UAAU,MAAM,KAAK,MAAM,qBAAqB,QAAQ;AAAA,QACxD,WAAW,CAAC,aAAa,KAAK,MAAM,UAAU,QAAQ;AAAA,MACxD,CAAC;AAAA,MACD,KAAK;AAAA;AAAA,IACP;AAAA,EACF;AAAA,EAEO,eAAe,KAAa;AACjC,WAAO,IAAI;AAAA,MACT,IAAI,sBAAsB;AAAA,QACxB,MAAM;AAAA,UACJ,KAAK,eAAe,GAAG;AAAA,UACvB,gBAAgB,EAAE,MAAM,SAAS,OAAO,IAAI;AAAA,QAC9C;AAAA,QACA,UAAU,MAAM;AACd,iBAAO,uBAAuB,KAAK,OAAO,KAAK,MAAM,UAAU,GAAG,CAAC;AAAA,QACrE;AAAA,QACA,WAAW,CAAC,aAAa,KAAK,MAAM,UAAU,QAAQ;AAAA,MACxD,CAAC;AAAA,MACD,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEO,uBAAuB,KAAa;AACzC,WAAO,IAAI;AAAA,MACT,IAAI,sBAAsB;AAAA,QACxB,MAAM;AAAA,UACJ,KAAK,uBAAuB,GAAG;AAAA,UAC/B,gBAAgB,EAAE,MAAM,gBAAgB,OAAO,IAAI;AAAA,QACrD;AAAA,QACA,UAAU,MAAM;AACd,iBAAO;AAAA,YACL,KAAK;AAAA,YACL,KAAK,MAAM,kBAAkB,GAAG;AAAA,UAClC;AAAA,QACF;AAAA,QACA,WAAW,CAAC,aAAa,KAAK,MAAM,UAAU,QAAQ;AAAA,MACxD,CAAC;AAAA,MACD,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEO,YAAY,UAAkB;AACnC,WAAO,IAAI;AAAA,MACT,IAAI,sBAAsB;AAAA,QACxB,MAAM;AAAA,UACJ,KAAK,wBAAwB,QAAQ;AAAA,UACrC,gBAAgB,EAAE,MAAM,YAAY,SAAS;AAAA,QAC/C;AAAA,QACA,UAAU,MAAM;AACd,iBAAO,uBAAuB,KAAK,OAAO,QAAQ;AAAA,QACpD;AAAA,QACA,WAAW,CAAC,aAAa,KAAK,MAAM,UAAU,QAAQ;AAAA,MACxD,CAAC;AAAA,MACD,KAAK;AAAA,IACP;AAAA,EACF;AACF;","names":[]}

package/dist/legacy-runtime/runtime/ThreadRuntime.d.ts

@@ -0,0 +1,241 @@
+import { ThreadSuggestion, RuntimeCapabilities, ThreadRuntimeCore, SpeechState, ThreadRuntimeEventType, StartRunConfig, ResumeRunConfig } from "../runtime-cores/core/ThreadRuntimeCore";
+import { ExportedMessageRepository } from "../runtime-cores/utils/MessageRepository";
+import { AppendMessage, ThreadMessage, Unsubscribe } from "../../types";
+import { ThreadMessageLike } from "../runtime-cores/external-store";
+import { MessageRuntime, MessageRuntimeImpl } from "./MessageRuntime";
+import { SubscribableWithState } from "./subscribable/Subscribable";
+import { ThreadComposerRuntime, ThreadComposerRuntimeImpl } from "./ComposerRuntime";
+import { ThreadListItemRuntimePath, ThreadRuntimePath } from "./RuntimePathTypes";
+import type { ThreadListItemState } from "./RuntimeBindings";
+import { RunConfig } from "../../types/AssistantTypes";
+import { ModelContext } from "../../model-context";
+import { ChatModelRunOptions, ChatModelRunResult } from "../runtime-cores";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+export type CreateStartRunConfig = {
+    parentId: string | null;
+    sourceId?: string | null | undefined;
+    runConfig?: RunConfig | undefined;
+};
+export type CreateResumeRunConfig = CreateStartRunConfig & {
+    stream: (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
+};
+export type CreateAppendMessage = string | {
+    parentId?: string | null | undefined;
+    sourceId?: string | null | undefined;
+    role?: AppendMessage["role"] | undefined;
+    content: AppendMessage["content"];
+    attachments?: AppendMessage["attachments"] | undefined;
+    metadata?: AppendMessage["metadata"] | undefined;
+    createdAt?: Date | undefined;
+    runConfig?: AppendMessage["runConfig"] | undefined;
+    startRun?: boolean | undefined;
+};
+export type ThreadRuntimeCoreBinding = SubscribableWithState<ThreadRuntimeCore, ThreadRuntimePath> & {
+    outerSubscribe(callback: () => void): Unsubscribe;
+};
+export type ThreadListItemRuntimeBinding = SubscribableWithState<ThreadListItemState, ThreadListItemRuntimePath>;
+export type ThreadState = {
+    /**
+     * The thread ID.
+     * @deprecated This field is deprecated and will be removed in 0.8.0. Use `useThreadListItem().id` instead.
+     */
+    readonly threadId: string;
+    /**
+     * The thread metadata.
+     *
+     * @deprecated Use `useThreadListItem()` instead. This field is deprecated and will be removed in 0.8.0.
+     */
+    readonly metadata: ThreadListItemState;
+    /**
+     * Whether the thread is disabled. Disabled threads cannot receive new messages.
+     */
+    readonly isDisabled: boolean;
+    /**
+     * Whether the thread is loading its history.
+     */
+    readonly isLoading: boolean;
+    /**
+     * Whether the thread is running. A thread is considered running when there is an active stream connection to the backend.
+     */
+    readonly isRunning: boolean;
+    /**
+     * The capabilities of the thread, such as whether the thread supports editing, branch switching, etc.
+     */
+    readonly capabilities: RuntimeCapabilities;
+    /**
+     * The messages in the currently selected branch of the thread.
+     */
+    readonly messages: readonly ThreadMessage[];
+    /**
+     * The thread state.
+     *
+     * @deprecated This feature is experimental
+     */
+    readonly state: ReadonlyJSONValue;
+    /**
+     * Follow up message suggestions to show the user.
+     */
+    readonly suggestions: readonly ThreadSuggestion[];
+    /**
+     * Custom extra information provided by the runtime.
+     */
+    readonly extras: unknown;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    readonly speech: SpeechState | undefined;
+};
+export declare const getThreadState: (runtime: ThreadRuntimeCore, threadListItemState: ThreadListItemState) => ThreadState;
+export type ThreadRuntime = {
+    /**
+     * The selector for the thread runtime.
+     */
+    readonly path: ThreadRuntimePath;
+    /**
+     * The thread composer runtime.
+     */
+    readonly composer: ThreadComposerRuntime;
+    /**
+     * Gets a snapshot of the thread state.
+     */
+    getState(): ThreadState;
+    /**
+     * Append a new message to the thread.
+     *
+     * @example ```ts
+     * // append a new user message with the text "Hello, world!"
+     * threadRuntime.append("Hello, world!");
+     * ```
+     *
+     * @example ```ts
+     * // append a new assistant message with the text "Hello, world!"
+     * threadRuntime.append({
+     *   role: "assistant",
+     *   content: [{ type: "text", text: "Hello, world!" }],
+     * });
+     * ```
+     */
+    append(message: CreateAppendMessage): void;
+    /**
+     * @deprecated pass an object with `parentId` instead. This will be removed in 0.8.0.
+     */
+    startRun(parentId: string | null): void;
+    /**
+     * Start a new run with the given configuration.
+     * @param config The configuration for starting the run
+     */
+    startRun(config: CreateStartRunConfig): void;
+    /**
+     * Resume a run with the given configuration.
+     * @param config The configuration for resuming the run
+     **/
+    unstable_resumeRun(config: CreateResumeRunConfig): void;
+    subscribe(callback: () => void): Unsubscribe;
+    cancelRun(): void;
+    getModelContext(): ModelContext;
+    /**
+     * @deprecated This method was renamed to `getModelContext`.
+     */
+    getModelConfig(): ModelContext;
+    export(): ExportedMessageRepository;
+    import(repository: ExportedMessageRepository): void;
+    /**
+     * Reset the thread with optional initial messages.
+     *
+     * @param initialMessages - Optional array of initial messages to populate the thread
+     */
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    getMessageByIndex(idx: number): MessageRuntime;
+    getMessageById(messageId: string): MessageRuntime;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    stopSpeaking(): void;
+    unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+};
+export declare class ThreadRuntimeImpl implements ThreadRuntime {
+    get path(): ThreadRuntimePath;
+    get __internal_threadBinding(): import("./subscribable/Subscribable").Subscribable & {
+        path: ThreadRuntimePath;
+        getState: () => Readonly<{
+            getMessageById: (messageId: string) => {
+                parentId: string | null;
+                message: ThreadMessage;
+            } | undefined;
+            getBranches: (messageId: string) => readonly string[];
+            switchToBranch: (branchId: string) => void;
+            append: (message: AppendMessage) => void;
+            startRun: (config: StartRunConfig) => void;
+            resumeRun: (config: ResumeRunConfig) => void;
+            cancelRun: () => void;
+            addToolResult: (options: import("../runtime-cores").AddToolResultOptions) => void;
+            speak: (messageId: string) => void;
+            stopSpeaking: () => void;
+            getSubmittedFeedback: (messageId: string) => import("../runtime-cores/core/ThreadRuntimeCore").SubmittedFeedback | undefined;
+            submitFeedback: (feedback: import("../runtime-cores").SubmitFeedbackOptions) => void;
+            getModelContext: () => ModelContext;
+            composer: import("../runtime-cores/core/ComposerRuntimeCore").ThreadComposerRuntimeCore;
+            getEditComposer: (messageId: string) => Readonly<{
+                isEditing: boolean;
+                canCancel: boolean;
+                isEmpty: boolean;
+                attachments: readonly import("../..").Attachment[];
+                attachmentAccept: string;
+                addAttachment: (file: File) => Promise<void>;
+                removeAttachment: (attachmentId: string) => Promise<void>;
+                text: string;
+                setText: (value: string) => void;
+                role: import("../../types/AssistantTypes").MessageRole;
+                setRole: (role: import("../../types/AssistantTypes").MessageRole) => void;
+                runConfig: RunConfig;
+                setRunConfig: (runConfig: RunConfig) => void;
+                reset: () => Promise<void>;
+                clearAttachments: () => Promise<void>;
+                send: () => void;
+                cancel: () => void;
+                subscribe: (callback: () => void) => Unsubscribe;
+                unstable_on: (event: import("../runtime-cores/core/ComposerRuntimeCore").ComposerRuntimeEventType, callback: () => void) => Unsubscribe;
+            }> | undefined;
+            beginEdit: (messageId: string) => void;
+            speech: SpeechState | undefined;
+            capabilities: Readonly<RuntimeCapabilities>;
+            isDisabled: boolean;
+            isLoading: boolean;
+            messages: readonly ThreadMessage[];
+            state: ReadonlyJSONValue;
+            suggestions: readonly ThreadSuggestion[];
+            extras: unknown;
+            subscribe: (callback: () => void) => Unsubscribe;
+            import(repository: ExportedMessageRepository): void;
+            export(): ExportedMessageRepository;
+            reset(initialMessages?: readonly ThreadMessageLike[]): void;
+            unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+        }>;
+    } & {
+        outerSubscribe(callback: () => void): Unsubscribe;
+    } & {
+        getStateState(): ThreadState;
+    };
+    private readonly _threadBinding;
+    constructor(threadBinding: ThreadRuntimeCoreBinding, threadListItemBinding: ThreadListItemRuntimeBinding);
+    protected __internal_bindMethods(): void;
+    readonly composer: ThreadComposerRuntimeImpl;
+    getState(): ThreadState;
+    append(message: CreateAppendMessage): void;
+    subscribe(callback: () => void): Unsubscribe;
+    getModelContext(): ModelContext;
+    getModelConfig(): ModelContext;
+    startRun(configOrParentId: string | null | CreateStartRunConfig): void;
+    unstable_resumeRun(config: CreateResumeRunConfig): void;
+    cancelRun(): void;
+    stopSpeaking(): void;
+    export(): ExportedMessageRepository;
+    import(data: ExportedMessageRepository): void;
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    getMessageByIndex(idx: number): MessageRuntimeImpl;
+    getMessageById(messageId: string): MessageRuntimeImpl;
+    private _getMessageRuntime;
+    private _eventSubscriptionSubjects;
+    unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+}
+//# sourceMappingURL=ThreadRuntime.d.ts.map

package/dist/legacy-runtime/runtime/ThreadRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadRuntime.d.ts","sourceRoot":"","sources":["../../../src/legacy-runtime/runtime/ThreadRuntime.ts"],"names":[],"mappings":"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"}

package/dist/legacy-runtime/runtime/ThreadRuntime.js

@@ -0,0 +1,243 @@
+// src/legacy-runtime/runtime/ThreadRuntime.ts
+import {
+  MessageRuntimeImpl
+} from "./MessageRuntime.js";
+import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject.js";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject.js";
+import {
+  ThreadComposerRuntimeImpl
+} from "./ComposerRuntime.js";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE.js";
+import { EventSubscriptionSubject } from "./subscribable/EventSubscriptionSubject.js";
+import { symbolInnerMessage } from "../runtime-cores/external-store/getExternalStoreMessage.js";
+var toResumeRunConfig = (message) => {
+  return {
+    parentId: message.parentId ?? null,
+    sourceId: message.sourceId ?? null,
+    runConfig: message.runConfig ?? {},
+    stream: message.stream
+  };
+};
+var toStartRunConfig = (message) => {
+  return {
+    parentId: message.parentId ?? null,
+    sourceId: message.sourceId ?? null,
+    runConfig: message.runConfig ?? {}
+  };
+};
+var toAppendMessage = (messages, message) => {
+  if (typeof message === "string") {
+    return {
+      createdAt: /* @__PURE__ */ new Date(),
+      parentId: messages.at(-1)?.id ?? null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: message }],
+      attachments: [],
+      metadata: { custom: {} }
+    };
+  }
+  return {
+    createdAt: message.createdAt ?? /* @__PURE__ */ new Date(),
+    parentId: message.parentId ?? messages.at(-1)?.id ?? null,
+    sourceId: message.sourceId ?? null,
+    role: message.role ?? "user",
+    content: message.content,
+    attachments: message.attachments ?? [],
+    metadata: message.metadata ?? { custom: {} },
+    runConfig: message.runConfig ?? {},
+    startRun: message.startRun
+  };
+};
+var getThreadState = (runtime, threadListItemState) => {
+  const lastMessage = runtime.messages.at(-1);
+  return Object.freeze({
+    threadId: threadListItemState.id,
+    metadata: threadListItemState,
+    capabilities: runtime.capabilities,
+    isDisabled: runtime.isDisabled,
+    isLoading: runtime.isLoading,
+    isRunning: lastMessage?.role !== "assistant" ? false : lastMessage.status.type === "running",
+    messages: runtime.messages,
+    state: runtime.state,
+    suggestions: runtime.suggestions,
+    extras: runtime.extras,
+    speech: runtime.speech
+  });
+};
+var ThreadRuntimeImpl = class {
+  get path() {
+    return this._threadBinding.path;
+  }
+  get __internal_threadBinding() {
+    return this._threadBinding;
+  }
+  _threadBinding;
+  constructor(threadBinding, threadListItemBinding) {
+    const stateBinding = new ShallowMemoizeSubject({
+      path: threadBinding.path,
+      getState: () => getThreadState(
+        threadBinding.getState(),
+        threadListItemBinding.getState()
+      ),
+      subscribe: (callback) => {
+        const sub1 = threadBinding.subscribe(callback);
+        const sub2 = threadListItemBinding.subscribe(callback);
+        return () => {
+          sub1();
+          sub2();
+        };
+      }
+    });
+    this._threadBinding = {
+      path: threadBinding.path,
+      getState: () => threadBinding.getState(),
+      getStateState: () => stateBinding.getState(),
+      outerSubscribe: (callback) => threadBinding.outerSubscribe(callback),
+      subscribe: (callback) => threadBinding.subscribe(callback)
+    };
+    this.composer = new ThreadComposerRuntimeImpl(
+      new NestedSubscriptionSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.composer`,
+          composerSource: "thread"
+        },
+        getState: () => this._threadBinding.getState().composer,
+        subscribe: (callback) => this._threadBinding.subscribe(callback)
+      })
+    );
+    this.__internal_bindMethods();
+  }
+  __internal_bindMethods() {
+    this.append = this.append.bind(this);
+    this.unstable_resumeRun = this.unstable_resumeRun.bind(this);
+    this.startRun = this.startRun.bind(this);
+    this.cancelRun = this.cancelRun.bind(this);
+    this.stopSpeaking = this.stopSpeaking.bind(this);
+    this.export = this.export.bind(this);
+    this.import = this.import.bind(this);
+    this.reset = this.reset.bind(this);
+    this.getMessageByIndex = this.getMessageByIndex.bind(this);
+    this.getMessageById = this.getMessageById.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.unstable_on = this.unstable_on.bind(this);
+    this.getModelContext = this.getModelContext.bind(this);
+    this.getModelConfig = this.getModelConfig.bind(this);
+    this.getState = this.getState.bind(this);
+  }
+  composer;
+  getState() {
+    return this._threadBinding.getStateState();
+  }
+  append(message) {
+    this._threadBinding.getState().append(
+      toAppendMessage(this._threadBinding.getState().messages, message)
+    );
+  }
+  subscribe(callback) {
+    return this._threadBinding.subscribe(callback);
+  }
+  getModelContext() {
+    return this._threadBinding.getState().getModelContext();
+  }
+  getModelConfig() {
+    return this.getModelContext();
+  }
+  startRun(configOrParentId) {
+    const config = configOrParentId === null || typeof configOrParentId === "string" ? { parentId: configOrParentId } : configOrParentId;
+    return this._threadBinding.getState().startRun(toStartRunConfig(config));
+  }
+  unstable_resumeRun(config) {
+    return this._threadBinding.getState().resumeRun(toResumeRunConfig(config));
+  }
+  cancelRun() {
+    this._threadBinding.getState().cancelRun();
+  }
+  stopSpeaking() {
+    return this._threadBinding.getState().stopSpeaking();
+  }
+  export() {
+    return this._threadBinding.getState().export();
+  }
+  import(data) {
+    this._threadBinding.getState().import(data);
+  }
+  reset(initialMessages) {
+    this._threadBinding.getState().reset(initialMessages);
+  }
+  getMessageByIndex(idx) {
+    if (idx < 0) throw new Error("Message index must be >= 0");
+    return this._getMessageRuntime(
+      {
+        ...this.path,
+        ref: this.path.ref + `${this.path.ref}.messages[${idx}]`,
+        messageSelector: { type: "index", index: idx }
+      },
+      () => {
+        const messages = this._threadBinding.getState().messages;
+        const message = messages[idx];
+        if (!message) return void 0;
+        return {
+          message,
+          parentId: messages[idx - 1]?.id ?? null
+        };
+      }
+    );
+  }
+  getMessageById(messageId) {
+    return this._getMessageRuntime(
+      {
+        ...this.path,
+        ref: this.path.ref + `${this.path.ref}.messages[messageId=${JSON.stringify(messageId)}]`,
+        messageSelector: { type: "messageId", messageId }
+      },
+      () => this._threadBinding.getState().getMessageById(messageId)
+    );
+  }
+  _getMessageRuntime(path, callback) {
+    return new MessageRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path,
+        getState: () => {
+          const { message, parentId } = callback() ?? {};
+          const { messages, speech: speechState } = this._threadBinding.getState();
+          if (!message || parentId === void 0) return SKIP_UPDATE;
+          const thread = this._threadBinding.getState();
+          const branches = thread.getBranches(message.id);
+          const submittedFeedback = thread.getSubmittedFeedback(message.id);
+          return {
+            ...message,
+            ...{ [symbolInnerMessage]: message[symbolInnerMessage] },
+            isLast: messages.at(-1)?.id === message.id,
+            parentId,
+            branchNumber: branches.indexOf(message.id) + 1,
+            branchCount: branches.length,
+            speech: speechState?.messageId === message.id ? speechState : void 0,
+            submittedFeedback
+          };
+        },
+        subscribe: (callback2) => this._threadBinding.subscribe(callback2)
+      }),
+      this._threadBinding
+    );
+  }
+  _eventSubscriptionSubjects = /* @__PURE__ */ new Map();
+  unstable_on(event, callback) {
+    let subject = this._eventSubscriptionSubjects.get(event);
+    if (!subject) {
+      subject = new EventSubscriptionSubject({
+        event,
+        binding: this._threadBinding
+      });
+      this._eventSubscriptionSubjects.set(event, subject);
+    }
+    return subject.subscribe(callback);
+  }
+};
+export {
+  ThreadRuntimeImpl,
+  getThreadState
+};
+//# sourceMappingURL=ThreadRuntime.js.map