@assistant-ui/core 0.3.16 → 0.3.17

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.d.ts

@@ -7,7 +7,7 @@ import { QueueItemState } from "../../runtime/queue/queue-item.js";
 import { QueuePlacement } from "../../runtime/queue/external-thread-queue-adapter.js";
 import { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "../../runtime/interfaces/composer-runtime-core.js";
 import { AddToolResultOptions, RespondToToolApprovalOptions, ResumeRunConfig, ResumeToolCallOptions, RuntimeCapabilities, SpeechState, StartRunConfig, SubmitFeedbackOptions, ThreadRuntimeEventCallback, ThreadRuntimeEventType, ThreadSuggestion, VoiceSessionState } from "../../runtime/interfaces/thread-runtime-core.js";
-import { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core.js";
+import { ThreadListRuntimeCore, ThreadListRuntimeEvent } from "../../runtime/interfaces/thread-list-runtime-core.js";
 import { BaseSubscribable } from "../../subscribable/subscribable.js";
 import { RuntimeAdapters } from "../../runtimes/remote-thread-list/types.js";
 import "../../store/index.js";
@@ -44,7 +44,7 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
-    respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
+    respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
     speak: (messageId: string) => void;
     stopSpeaking: () => void;
     connectVoice: () => void;
@@ -98,7 +98,7 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
-    respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
+    respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
     speak: (messageId: string) => void;
     stopSpeaking: () => void;
     connectVoice: () => void;
@@ -152,7 +152,7 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
-    respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
+    respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
     speak: (messageId: string) => void;
     stopSpeaking: () => void;
     connectVoice: () => void;
@@ -193,6 +193,8 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   __internal_isThreadRunning(threadId: string): boolean;
   private runningSubscribers;
   __internal_subscribeRunningChanged(callback: () => void): Unsubscribe;
+  private threadEventSubscribers;
+  __internal_subscribeThreadEvents(callback: (event: ThreadListRuntimeEvent) => void): Unsubscribe;
   private _publish;
   private _publishThreadRuntime;
   private replacedSubscribers;

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListHookInstanceManager.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;cA2Da,4CAA4C;UAC/C;mBACS;mBAIA;mBAIA;UAIT;UACA;UACA;EAGN,YAAA,aAAa,sBACb,QAAQ;UAOF;EAsBD,mBAAmB,mBAAgB,QAAA;;;eA7BhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CH,gCAAgC,mBAAgB,QAAA;;;eAbb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBnC,qBAAqB,mBAAgB;;;eAZW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBhD,2BAA2B;UAI1B;EAED,mCAAmC,uBAAuB;UAKzD;UAQA;UAsBA;EAED,oCACL,uBACC;UAKK;UAgBA;EASD,kBAAkB;EAUlB,eAAe,gBAAgB;EAS/B,8BAA8B,UAAU;EAMxC,6BACL,kBACA,UAAU;EASL;UAMC;EAYD,mBAAmB,cAAc,kBAAA;EAyBjC,iCAAiC;IACtC,UAAU,cAAc;;EAenB,iBAAiB;IAAK,cAAc;;UAOnC;UAmCA"}
+{"version":3,"file":"RemoteThreadListHookInstanceManager.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;cA4Ea,4CAA4C;UAC/C;mBACS;mBAIA;mBAIA;UAIT;UACA;UACA;EAGN,YAAA,aAAa,sBACb,QAAQ;UAOF;EAsBD,mBAAmB,mBAAgB,QAAA;;;eA7BhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CH,gCAAgC,mBAAgB,QAAA;;;eAbb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBnC,qBAAqB,mBAAgB;;;eAZW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBhD,2BAA2B;UAI1B;EAED,mCAAmC,uBAAuB;UAKzD;EAID,iCACL,WAAW,OAAO,kCACjB;UAKK;UAQA;UAsBA;EAED,oCACL,uBACC;UAKK;UAiCA;EASD,kBAAkB;EAUlB,eAAe,gBAAgB;EAO/B,8BAA8B,UAAU;EAMxC,6BACL,kBACA,UAAU;EASL;UAMC;EAUD,mBAAmB,cAAc,kBAAA;EAyBjC,iCAAiC;IACtC,UAAU,cAAc;;EAenB,iBAAiB;IAAK,cAAc;;UAOnC;UAmCA"}

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.js

@@ -1,7 +1,9 @@
-import { BaseSubscribable } from "../../subscribable/subscribable.js";
+import { notifyEventListeners } from "../../utils/notify-event-listeners.js";
+import { BaseSubscribable, WritableSubscribable } from "../../subscribable/subscribable.js";
 import { getThreadRuntimeCoreIsRunning } from "../../runtime/api/thread-runtime.js";
 import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime.js";
 import { invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle.js";
+import { useSubscribable } from "../../store/runtime-clients/useSubscribable.js";
 import { useRuntimeAdapters } from "./useRuntimeAdapters.js";
 import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider.js";
 import { RemoteThreadResource } from "./RemoteThreadResource.js";
@@ -9,8 +11,13 @@ import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { Fragment, memo, useEffect, useLayoutEffect, useMemo, useRef } from "@assistant-ui/tap/react-shim";
 import { useResources, withKey } from "@assistant-ui/tap";
 import { jsx } from "react/jsx-runtime";
-import { create } from "zustand";
 //#region src/react/runtimes/RemoteThreadListHookInstanceManager.tsx
+const THREAD_EVENTS = [
+	"runStart",
+	"runEnd",
+	"initialize",
+	"modelContextUpdate"
+];
 const ProviderRenderDetector = (t0) => {
 	const $ = c(3);
 	const { detectorRef } = t0;
@@ -33,14 +40,14 @@ const ProviderRenderDetector = (t0) => {
 };
 var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 	runtimeHook;
-	adapterStore = create(() => ({
+	adapterStore = new WritableSubscribable({
 		defaultAdapters: null,
 		threadAdapters: /* @__PURE__ */ new Map()
-	}));
-	hostStore = create(() => ({
+	});
+	hostStore = new WritableSubscribable({
 		threads: [],
 		hookEpoch: 0
-	}));
+	});
 	pendingThreadAdapters = /* @__PURE__ */ new Map();
 	instances = /* @__PURE__ */ new Map();
 	nextGeneration = 0;
@@ -100,6 +107,11 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		this.runningSubscribers.add(callback);
 		return () => this.runningSubscribers.delete(callback);
 	}
+	threadEventSubscribers = /* @__PURE__ */ new Set();
+	__internal_subscribeThreadEvents(callback) {
+		this.threadEventSubscribers.add(callback);
+		return () => this.threadEventSubscribers.delete(callback);
+	}
 	_publish = (threadId, runtime, generation) => {
 		this._publishThreadRuntime(threadId, runtime, generation);
 	};
@@ -110,7 +122,7 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		const previousRuntime = instance.runtime;
 		instance.runtime = runtime;
 		instance.publishedGeneration = generation;
-		if (previousRuntime !== runtime) this._trackRunning(instance);
+		if (previousRuntime !== runtime) this._trackRunning(threadId, instance);
 		this._notifySubscribers();
 		if (previousRuntime !== void 0 && previousRuntime !== runtime) for (const callback of this.replacedSubscribers) callback();
 	}
@@ -119,7 +131,7 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		this.replacedSubscribers.add(callback);
 		return () => this.replacedSubscribers.delete(callback);
 	}
-	_trackRunning(instance) {
+	_trackRunning(threadId, instance) {
 		instance.unsubscribeRunning?.();
 		const runtime = instance.runtime;
 		if (!runtime) {
@@ -128,9 +140,17 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 			return;
 		}
 		this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));
-		instance.unsubscribeRunning = runtime.subscribe(() => {
+		const unsubscribers = [runtime.subscribe(() => {
 			this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));
-		});
+		}), ...THREAD_EVENTS.map((type) => runtime.unstable_on(type, () => {
+			notifyEventListeners(this.threadEventSubscribers, {
+				threadId,
+				type
+			}, `Thread event "${type}"`);
+		}))];
+		instance.unsubscribeRunning = () => {
+			for (const unsubscribe of unsubscribers) unsubscribe();
+		};
 	}
 	_setRunning(instance, isRunning) {
 		if (instance.isRunning === isRunning) return;
@@ -149,10 +169,11 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 	setRuntimeHook(newRuntimeHook) {
 		if (this.runtimeHook === newRuntimeHook) return;
 		this.runtimeHook = newRuntimeHook;
-		this.hostStore.setState((state) => ({
-			...state,
-			hookEpoch: state.hookEpoch + 1
-		}), true);
+		const host = this.hostStore.getState();
+		this.hostStore.setState({
+			...host,
+			hookEpoch: host.hookEpoch + 1
+		});
 	}
 	__internal_setDefaultAdapters(adapters) {
 		const current = this.adapterStore.getState();
@@ -160,7 +181,7 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		this.adapterStore.setState({
 			...current,
 			defaultAdapters: adapters
-		}, true);
+		});
 	}
 	__internal_setThreadAdapters(threadId, adapters) {
 		const current = this.adapterStore.getState();
@@ -170,23 +191,24 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		this.adapterStore.setState({
 			...current,
 			threadAdapters: next
-		}, true);
+		});
 	}
 	__internal_dispose() {
 		for (const threadId of [...this.instances.keys()]) this.stopThreadRuntime(threadId);
 	}
 	_syncHostThreads() {
-		this.hostStore.setState((state) => ({
-			...state,
+		const host = this.hostStore.getState();
+		this.hostStore.setState({
+			...host,
 			threads: Array.from(this.instances.entries()).map(([id, { generation }]) => ({
 				id,
 				generation
 			}))
-		}), true);
+		});
 	}
 	__internal_useHost(parentClient) {
-		const { threads, hookEpoch } = this.hostStore();
-		const adapters = this.adapterStore();
+		const { threads, hookEpoch } = useSubscribable(this.hostStore);
+		const adapters = useSubscribable(this.adapterStore);
 		const runtimeHook = this.runtimeHook;
 		return useResources(threads.map(({ id, generation }) => {
 			const threadAdapters = this.pendingThreadAdapters.has(id) ? this.pendingThreadAdapters.get(id) : adapters.threadAdapters.get(id) ?? adapters.defaultAdapters;
@@ -202,7 +224,7 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		}));
 	}
 	__internal_RenderThreadRuntimes = ({ provider }) => {
-		this.hostStore();
+		useSubscribable(this.hostStore);
 		return Array.from(this.instances.entries()).map(([threadId, { generation }]) => /* @__PURE__ */ jsx(this._OuterActiveThreadProvider, {
 			threadId,
 			provider

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListHookInstanceManager.js","names":["FC","RefObject","useEffect","useLayoutEffect","useMemo","useRef","memo","PropsWithChildren","ComponentType","Fragment","create","useResources","withKey","AssistantClient","ThreadListItemRuntimeProvider","ThreadRuntimeCore","ThreadListRuntimeCore","Unsubscribe","BaseSubscribable","getThreadRuntimeCoreIsRunning","ThreadListRuntimeImpl","invalidateThreadRuntime","useRuntimeAdapters","RuntimeAdapters","RemoteThreadResource","RemoteThreadListHook","RemoteThreadListHookInstance","runtime","publishedGeneration","generation","isRunning","unsubscribeRunning","AdapterSnapshot","defaultAdapters","threadAdapters","ReadonlyMap","HostSnapshot","threads","id","hookEpoch","ProviderRenderDetector","detectorRef","t0","$","_c","t1","t2","current","RemoteThreadListHookInstanceManager","runtimeHook","adapterStore","Map","hostStore","pendingThreadAdapters","instances","nextGeneration","parent","constructor","_whenRuntimeAttached","threadId","Promise","resolve","reject","callback","instance","get","dispose","Error","subscribe","startThreadRuntime","has","set","_syncHostThreads","__internal_restartThreadRuntime","_notifySubscribers","getThreadRuntimeCore","undefined","__internal_isThreadRunning","runningSubscribers","Set","__internal_subscribeRunningChanged","add","delete","_publish","_publishThreadRuntime","previousRuntime","_trackRunning","replacedSubscribers","__internal_subscribeRuntimeReplaced","_setRunning","stopThreadRuntime","setRuntimeHook","newRuntimeHook","setState","state","__internal_setDefaultAdapters","adapters","getState","__internal_setThreadAdapters","next","__internal_dispose","keys","Array","from","entries","map","__internal_useHost","parentClient","parentList","publish","__internal_RenderThreadRuntimes","provider","__internal_Host","_OuterActiveThreadProvider","Provider","getItemById","process","env","NODE_ENV","setTimeout","console","warn","clearTimeout","_AdapterSink"],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"sourcesContent":["import {\n  type FC,\n  type RefObject,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  memo,\n  type PropsWithChildren,\n  type ComponentType,\n  Fragment,\n} from \"react\";\nimport { create } from \"zustand\";\nimport { useResources, withKey } from \"@assistant-ui/tap\";\nimport type { AssistantClient } from \"@assistant-ui/store\";\nimport { ThreadListItemRuntimeProvider } from \"../providers/ThreadListItemRuntimeProvider\";\nimport type { ThreadRuntimeCore } from \"../../runtime/interfaces/thread-runtime-core\";\nimport type { ThreadListRuntimeCore } from \"../../runtime/interfaces/thread-list-runtime-core\";\nimport type { Unsubscribe } from \"../../types/unsubscribe\";\nimport { BaseSubscribable } from \"../../subscribable/subscribable\";\nimport { getThreadRuntimeCoreIsRunning } from \"../../runtime/api/thread-runtime\";\nimport { ThreadListRuntimeImpl } from \"../../runtime/api/thread-list-runtime\";\nimport { invalidateThreadRuntime } from \"../../runtime/utils/thread-runtime-lifecycle\";\nimport {\n  useRuntimeAdapters,\n  type RuntimeAdapters,\n} from \"./RuntimeAdapterProvider\";\nimport {\n  RemoteThreadResource,\n  type RemoteThreadListHook,\n} from \"./RemoteThreadResource\";\n\ntype RemoteThreadListHookInstance = {\n  runtime?: ThreadRuntimeCore | undefined;\n  publishedGeneration?: number | undefined;\n  generation: number;\n  isRunning: boolean;\n  unsubscribeRunning?: Unsubscribe | undefined;\n};\n\ntype AdapterSnapshot = {\n  defaultAdapters: RuntimeAdapters | null;\n  threadAdapters: ReadonlyMap<string, RuntimeAdapters | null>;\n};\n\ntype HostSnapshot = {\n  threads: readonly { id: string; generation: number }[];\n  hookEpoch: number;\n};\n\nconst ProviderRenderDetector: FC<{\n  detectorRef: RefObject<boolean>;\n}> = ({ detectorRef }) => {\n  useLayoutEffect(() => {\n    detectorRef.current = true;\n  }, [detectorRef]);\n  return null;\n};\n\nexport class RemoteThreadListHookInstanceManager extends BaseSubscribable {\n  private runtimeHook: RemoteThreadListHook;\n  private readonly adapterStore = create<AdapterSnapshot>(() => ({\n    defaultAdapters: null,\n    threadAdapters: new Map(),\n  }));\n  private readonly hostStore = create<HostSnapshot>(() => ({\n    threads: [],\n    hookEpoch: 0,\n  }));\n  private readonly pendingThreadAdapters = new Map<\n    string,\n    RuntimeAdapters | null\n  >();\n  private instances = new Map<string, RemoteThreadListHookInstance>();\n  private nextGeneration = 0;\n  private parent: ThreadListRuntimeCore;\n\n  constructor(\n    runtimeHook: RemoteThreadListHook,\n    parent: ThreadListRuntimeCore,\n  ) {\n    super();\n    this.parent = parent;\n    this.runtimeHook = runtimeHook;\n  }\n\n  private _whenRuntimeAttached(threadId: string) {\n    return new Promise<ThreadRuntimeCore>((resolve, reject) => {\n      const callback = () => {\n        const instance = this.instances.get(threadId);\n        if (!instance) {\n          dispose();\n          reject(new Error(\"Thread was deleted before runtime was started\"));\n        } else if (\n          !instance.runtime ||\n          instance.publishedGeneration !== instance.generation\n        ) {\n          return;\n        } else {\n          dispose();\n          resolve(instance.runtime);\n        }\n      };\n      const dispose = this.subscribe(callback);\n      callback();\n    });\n  }\n\n  public startThreadRuntime(threadId: string) {\n    if (!this.instances.has(threadId)) {\n      const generation = this.nextGeneration++;\n      this.instances.set(threadId, {\n        generation,\n        isRunning: false,\n      });\n      this._syncHostThreads();\n    }\n\n    return this._whenRuntimeAttached(threadId);\n  }\n\n  public __internal_restartThreadRuntime(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return this.startThreadRuntime(threadId);\n\n    if (instance.runtime) invalidateThreadRuntime(instance.runtime);\n    instance.generation = this.nextGeneration++;\n    this._syncHostThreads();\n    this._notifySubscribers();\n\n    return this._whenRuntimeAttached(threadId);\n  }\n\n  public getThreadRuntimeCore(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return undefined;\n    return instance.runtime;\n  }\n\n  public __internal_isThreadRunning(threadId: string) {\n    return this.instances.get(threadId)?.isRunning ?? false;\n  }\n\n  private runningSubscribers = new Set<() => void>();\n\n  public __internal_subscribeRunningChanged(callback: () => void): Unsubscribe {\n    this.runningSubscribers.add(callback);\n    return () => this.runningSubscribers.delete(callback);\n  }\n\n  private _publish = (\n    threadId: string,\n    runtime: ThreadRuntimeCore,\n    generation: number,\n  ) => {\n    this._publishThreadRuntime(threadId, runtime, generation);\n  };\n\n  private _publishThreadRuntime(\n    threadId: string,\n    runtime: ThreadRuntimeCore,\n    generation: number,\n  ) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return;\n\n    if (instance.generation !== generation) return;\n\n    const previousRuntime = instance.runtime;\n    instance.runtime = runtime;\n    instance.publishedGeneration = generation;\n    if (previousRuntime !== runtime) {\n      this._trackRunning(instance);\n    }\n    this._notifySubscribers();\n    if (previousRuntime !== undefined && previousRuntime !== runtime) {\n      for (const callback of this.replacedSubscribers) callback();\n    }\n  }\n\n  private replacedSubscribers = new Set<() => void>();\n\n  public __internal_subscribeRuntimeReplaced(\n    callback: () => void,\n  ): Unsubscribe {\n    this.replacedSubscribers.add(callback);\n    return () => this.replacedSubscribers.delete(callback);\n  }\n\n  private _trackRunning(instance: RemoteThreadListHookInstance) {\n    instance.unsubscribeRunning?.();\n\n    const runtime = instance.runtime;\n    if (!runtime) {\n      instance.unsubscribeRunning = undefined;\n      this._setRunning(instance, false);\n      return;\n    }\n\n    this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));\n    instance.unsubscribeRunning = runtime.subscribe(() => {\n      this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));\n    });\n  }\n\n  private _setRunning(\n    instance: RemoteThreadListHookInstance,\n    isRunning: boolean,\n  ) {\n    if (instance.isRunning === isRunning) return;\n    instance.isRunning = isRunning;\n    for (const callback of this.runningSubscribers) callback();\n  }\n\n  public stopThreadRuntime(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (instance?.runtime) invalidateThreadRuntime(instance.runtime);\n    instance?.unsubscribeRunning?.();\n    this.instances.delete(threadId);\n    this.pendingThreadAdapters.delete(threadId);\n    this._syncHostThreads();\n    this._notifySubscribers();\n  }\n\n  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {\n    if (this.runtimeHook === newRuntimeHook) return;\n    this.runtimeHook = newRuntimeHook;\n    this.hostStore.setState(\n      (state) => ({ ...state, hookEpoch: state.hookEpoch + 1 }),\n      true,\n    );\n  }\n\n  public __internal_setDefaultAdapters(adapters: RuntimeAdapters | null) {\n    const current = this.adapterStore.getState();\n    if (current.defaultAdapters === adapters) return;\n    this.adapterStore.setState({ ...current, defaultAdapters: adapters }, true);\n  }\n\n  public __internal_setThreadAdapters(\n    threadId: string,\n    adapters: RuntimeAdapters | null,\n  ) {\n    const current = this.adapterStore.getState();\n    const next = new Map(current.threadAdapters);\n    if (adapters === null) next.delete(threadId);\n    else next.set(threadId, adapters);\n    this.adapterStore.setState({ ...current, threadAdapters: next }, true);\n  }\n\n  public __internal_dispose() {\n    for (const threadId of [...this.instances.keys()]) {\n      this.stopThreadRuntime(threadId);\n    }\n  }\n\n  private _syncHostThreads() {\n    this.hostStore.setState(\n      (state) => ({\n        ...state,\n        threads: Array.from(this.instances.entries()).map(\n          ([id, { generation }]) => ({ id, generation }),\n        ),\n      }),\n      true,\n    );\n  }\n\n  public __internal_useHost(parentClient: AssistantClient) {\n    const { threads, hookEpoch } = this.hostStore();\n    const adapters = this.adapterStore();\n    const runtimeHook = this.runtimeHook;\n    return useResources(\n      threads.map(({ id, generation }) => {\n        const threadAdapters = this.pendingThreadAdapters.has(id)\n          ? this.pendingThreadAdapters.get(id)!\n          : (adapters.threadAdapters.get(id) ?? adapters.defaultAdapters);\n        return withKey(\n          `${id}:${generation}:${hookEpoch}`,\n          RemoteThreadResource({\n            threadId: id,\n            generation,\n            parentList: this.parent,\n            runtimeHook,\n            parentClient,\n            adapters: threadAdapters,\n            publish: this._publish,\n          }),\n        );\n      }),\n    );\n  }\n\n  public __internal_RenderThreadRuntimes: FC<{\n    provider: ComponentType<PropsWithChildren>;\n  }> = ({ provider }) => {\n    this.hostStore();\n\n    return Array.from(this.instances.entries()).map(\n      ([threadId, { generation }]) => (\n        <this._OuterActiveThreadProvider\n          key={`${threadId}:${generation}`}\n          threadId={threadId}\n          provider={provider}\n        />\n      ),\n    );\n  };\n\n  public __internal_Host: FC<{ parentClient: AssistantClient }> = ({\n    parentClient,\n  }) => {\n    this.__internal_useHost(parentClient);\n    return null;\n  };\n\n  private _OuterActiveThreadProvider: FC<{\n    threadId: string;\n    provider: ComponentType<PropsWithChildren>;\n  }> = memo(({ threadId, provider: Provider }) => {\n    const runtime = useMemo(\n      () => new ThreadListRuntimeImpl(this.parent).getItemById(threadId),\n      [threadId],\n    );\n\n    const detectorRef = useRef(false);\n    useEffect(() => {\n      if (process.env.NODE_ENV !== \"production\" && Provider !== Fragment) {\n        const id = setTimeout(() => {\n          if (!detectorRef.current) {\n            console.warn(\n              \"RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. \" +\n                \"Render `children` on first commit; deferring them behind a loading state, Suspense boundary, \" +\n                \"or `useEffect` gate strands the runtime host and leaves the thread without context.\",\n            );\n          }\n        }, 100);\n        return () => clearTimeout(id);\n      }\n      return undefined;\n    }, [Provider]);\n\n    return (\n      <ThreadListItemRuntimeProvider runtime={runtime}>\n        <Provider>\n          <this._AdapterSink threadId={threadId} detectorRef={detectorRef} />\n        </Provider>\n      </ThreadListItemRuntimeProvider>\n    );\n  });\n\n  private _AdapterSink: FC<{\n    threadId: string;\n    detectorRef: RefObject<boolean>;\n  }> = ({ threadId, detectorRef }) => {\n    const adapters = useRuntimeAdapters();\n    this.pendingThreadAdapters.set(threadId, adapters);\n    useLayoutEffect(() => {\n      this.__internal_setThreadAdapters(threadId, adapters);\n      return () => {\n        if (this.pendingThreadAdapters.get(threadId) === adapters) {\n          this.pendingThreadAdapters.delete(threadId);\n        }\n        this.__internal_setThreadAdapters(threadId, null);\n      };\n    }, [threadId, adapters]);\n    return <ProviderRenderDetector detectorRef={detectorRef} />;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"RemoteThreadListHookInstanceManager.js","names":["FC","RefObject","useEffect","useLayoutEffect","useMemo","useRef","memo","PropsWithChildren","ComponentType","Fragment","useResources","withKey","AssistantClient","ThreadListItemRuntimeProvider","ThreadRuntimeCore","ThreadRuntimeEventType","ThreadListRuntimeCore","ThreadListRuntimeEvent","Unsubscribe","BaseSubscribable","WritableSubscribable","useSubscribable","getThreadRuntimeCoreIsRunning","ThreadListRuntimeImpl","invalidateThreadRuntime","notifyEventListeners","useRuntimeAdapters","RuntimeAdapters","RemoteThreadResource","RemoteThreadListHook","THREAD_EVENTS","const","RemoteThreadListHookInstance","runtime","publishedGeneration","generation","isRunning","unsubscribeRunning","AdapterSnapshot","defaultAdapters","threadAdapters","ReadonlyMap","HostSnapshot","threads","id","hookEpoch","ProviderRenderDetector","detectorRef","t0","$","_c","t1","t2","current","RemoteThreadListHookInstanceManager","runtimeHook","adapterStore","Map","hostStore","pendingThreadAdapters","instances","nextGeneration","parent","constructor","_whenRuntimeAttached","threadId","Promise","resolve","reject","callback","instance","get","dispose","Error","subscribe","startThreadRuntime","has","set","_syncHostThreads","__internal_restartThreadRuntime","_notifySubscribers","getThreadRuntimeCore","undefined","__internal_isThreadRunning","runningSubscribers","Set","__internal_subscribeRunningChanged","add","delete","threadEventSubscribers","event","__internal_subscribeThreadEvents","_publish","_publishThreadRuntime","previousRuntime","_trackRunning","replacedSubscribers","__internal_subscribeRuntimeReplaced","_setRunning","unsubscribers","map","type","unstable_on","unsubscribe","stopThreadRuntime","setRuntimeHook","newRuntimeHook","host","getState","setState","__internal_setDefaultAdapters","adapters","__internal_setThreadAdapters","next","__internal_dispose","keys","Array","from","entries","__internal_useHost","parentClient","parentList","publish","__internal_RenderThreadRuntimes","provider","__internal_Host","_OuterActiveThreadProvider","Provider","getItemById","process","env","NODE_ENV","setTimeout","console","warn","clearTimeout","_AdapterSink"],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"sourcesContent":["import {\n  type FC,\n  type RefObject,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  memo,\n  type PropsWithChildren,\n  type ComponentType,\n  Fragment,\n} from \"react\";\nimport { useResources, withKey } from \"@assistant-ui/tap\";\nimport type { AssistantClient } from \"@assistant-ui/store\";\nimport { ThreadListItemRuntimeProvider } from \"../providers/ThreadListItemRuntimeProvider\";\nimport type {\n  ThreadRuntimeCore,\n  ThreadRuntimeEventType,\n} from \"../../runtime/interfaces/thread-runtime-core\";\nimport type {\n  ThreadListRuntimeCore,\n  ThreadListRuntimeEvent,\n} from \"../../runtime/interfaces/thread-list-runtime-core\";\nimport type { Unsubscribe } from \"../../types/unsubscribe\";\nimport {\n  BaseSubscribable,\n  WritableSubscribable,\n} from \"../../subscribable/subscribable\";\nimport { useSubscribable } from \"../../store/runtime-clients/useSubscribable\";\nimport { getThreadRuntimeCoreIsRunning } from \"../../runtime/api/thread-runtime\";\nimport { ThreadListRuntimeImpl } from \"../../runtime/api/thread-list-runtime\";\nimport { invalidateThreadRuntime } from \"../../runtime/utils/thread-runtime-lifecycle\";\nimport { notifyEventListeners } from \"../../utils/notify-event-listeners\";\nimport {\n  useRuntimeAdapters,\n  type RuntimeAdapters,\n} from \"./RuntimeAdapterProvider\";\nimport {\n  RemoteThreadResource,\n  type RemoteThreadListHook,\n} from \"./RemoteThreadResource\";\n\nconst THREAD_EVENTS = [\n  \"runStart\",\n  \"runEnd\",\n  \"initialize\",\n  \"modelContextUpdate\",\n] as const satisfies readonly ThreadRuntimeEventType[];\n\ntype RemoteThreadListHookInstance = {\n  runtime?: ThreadRuntimeCore | undefined;\n  publishedGeneration?: number | undefined;\n  generation: number;\n  isRunning: boolean;\n  unsubscribeRunning?: Unsubscribe | undefined;\n};\n\ntype AdapterSnapshot = {\n  defaultAdapters: RuntimeAdapters | null;\n  threadAdapters: ReadonlyMap<string, RuntimeAdapters | null>;\n};\n\ntype HostSnapshot = {\n  threads: readonly { id: string; generation: number }[];\n  hookEpoch: number;\n};\n\nconst ProviderRenderDetector: FC<{\n  detectorRef: RefObject<boolean>;\n}> = ({ detectorRef }) => {\n  useLayoutEffect(() => {\n    detectorRef.current = true;\n  }, [detectorRef]);\n  return null;\n};\n\nexport class RemoteThreadListHookInstanceManager extends BaseSubscribable {\n  private runtimeHook: RemoteThreadListHook;\n  private readonly adapterStore = new WritableSubscribable<AdapterSnapshot>({\n    defaultAdapters: null,\n    threadAdapters: new Map(),\n  });\n  private readonly hostStore = new WritableSubscribable<HostSnapshot>({\n    threads: [],\n    hookEpoch: 0,\n  });\n  private readonly pendingThreadAdapters = new Map<\n    string,\n    RuntimeAdapters | null\n  >();\n  private instances = new Map<string, RemoteThreadListHookInstance>();\n  private nextGeneration = 0;\n  private parent: ThreadListRuntimeCore;\n\n  constructor(\n    runtimeHook: RemoteThreadListHook,\n    parent: ThreadListRuntimeCore,\n  ) {\n    super();\n    this.parent = parent;\n    this.runtimeHook = runtimeHook;\n  }\n\n  private _whenRuntimeAttached(threadId: string) {\n    return new Promise<ThreadRuntimeCore>((resolve, reject) => {\n      const callback = () => {\n        const instance = this.instances.get(threadId);\n        if (!instance) {\n          dispose();\n          reject(new Error(\"Thread was deleted before runtime was started\"));\n        } else if (\n          !instance.runtime ||\n          instance.publishedGeneration !== instance.generation\n        ) {\n          return;\n        } else {\n          dispose();\n          resolve(instance.runtime);\n        }\n      };\n      const dispose = this.subscribe(callback);\n      callback();\n    });\n  }\n\n  public startThreadRuntime(threadId: string) {\n    if (!this.instances.has(threadId)) {\n      const generation = this.nextGeneration++;\n      this.instances.set(threadId, {\n        generation,\n        isRunning: false,\n      });\n      this._syncHostThreads();\n    }\n\n    return this._whenRuntimeAttached(threadId);\n  }\n\n  public __internal_restartThreadRuntime(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return this.startThreadRuntime(threadId);\n\n    if (instance.runtime) invalidateThreadRuntime(instance.runtime);\n    instance.generation = this.nextGeneration++;\n    this._syncHostThreads();\n    this._notifySubscribers();\n\n    return this._whenRuntimeAttached(threadId);\n  }\n\n  public getThreadRuntimeCore(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return undefined;\n    return instance.runtime;\n  }\n\n  public __internal_isThreadRunning(threadId: string) {\n    return this.instances.get(threadId)?.isRunning ?? false;\n  }\n\n  private runningSubscribers = new Set<() => void>();\n\n  public __internal_subscribeRunningChanged(callback: () => void): Unsubscribe {\n    this.runningSubscribers.add(callback);\n    return () => this.runningSubscribers.delete(callback);\n  }\n\n  private threadEventSubscribers = new Set<\n    (event: ThreadListRuntimeEvent) => void\n  >();\n\n  public __internal_subscribeThreadEvents(\n    callback: (event: ThreadListRuntimeEvent) => void,\n  ): Unsubscribe {\n    this.threadEventSubscribers.add(callback);\n    return () => this.threadEventSubscribers.delete(callback);\n  }\n\n  private _publish = (\n    threadId: string,\n    runtime: ThreadRuntimeCore,\n    generation: number,\n  ) => {\n    this._publishThreadRuntime(threadId, runtime, generation);\n  };\n\n  private _publishThreadRuntime(\n    threadId: string,\n    runtime: ThreadRuntimeCore,\n    generation: number,\n  ) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return;\n\n    if (instance.generation !== generation) return;\n\n    const previousRuntime = instance.runtime;\n    instance.runtime = runtime;\n    instance.publishedGeneration = generation;\n    if (previousRuntime !== runtime) {\n      this._trackRunning(threadId, instance);\n    }\n    this._notifySubscribers();\n    if (previousRuntime !== undefined && previousRuntime !== runtime) {\n      for (const callback of this.replacedSubscribers) callback();\n    }\n  }\n\n  private replacedSubscribers = new Set<() => void>();\n\n  public __internal_subscribeRuntimeReplaced(\n    callback: () => void,\n  ): Unsubscribe {\n    this.replacedSubscribers.add(callback);\n    return () => this.replacedSubscribers.delete(callback);\n  }\n\n  private _trackRunning(\n    threadId: string,\n    instance: RemoteThreadListHookInstance,\n  ) {\n    instance.unsubscribeRunning?.();\n\n    const runtime = instance.runtime;\n    if (!runtime) {\n      instance.unsubscribeRunning = undefined;\n      this._setRunning(instance, false);\n      return;\n    }\n\n    this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));\n    const unsubscribers = [\n      runtime.subscribe(() => {\n        this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));\n      }),\n      ...THREAD_EVENTS.map((type) =>\n        runtime.unstable_on(type, () => {\n          notifyEventListeners(\n            this.threadEventSubscribers,\n            { threadId, type },\n            `Thread event \"${type}\"`,\n          );\n        }),\n      ),\n    ];\n    instance.unsubscribeRunning = () => {\n      for (const unsubscribe of unsubscribers) unsubscribe();\n    };\n  }\n\n  private _setRunning(\n    instance: RemoteThreadListHookInstance,\n    isRunning: boolean,\n  ) {\n    if (instance.isRunning === isRunning) return;\n    instance.isRunning = isRunning;\n    for (const callback of this.runningSubscribers) callback();\n  }\n\n  public stopThreadRuntime(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (instance?.runtime) invalidateThreadRuntime(instance.runtime);\n    instance?.unsubscribeRunning?.();\n    this.instances.delete(threadId);\n    this.pendingThreadAdapters.delete(threadId);\n    this._syncHostThreads();\n    this._notifySubscribers();\n  }\n\n  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {\n    if (this.runtimeHook === newRuntimeHook) return;\n    this.runtimeHook = newRuntimeHook;\n    const host = this.hostStore.getState();\n    this.hostStore.setState({ ...host, hookEpoch: host.hookEpoch + 1 });\n  }\n\n  public __internal_setDefaultAdapters(adapters: RuntimeAdapters | null) {\n    const current = this.adapterStore.getState();\n    if (current.defaultAdapters === adapters) return;\n    this.adapterStore.setState({ ...current, defaultAdapters: adapters });\n  }\n\n  public __internal_setThreadAdapters(\n    threadId: string,\n    adapters: RuntimeAdapters | null,\n  ) {\n    const current = this.adapterStore.getState();\n    const next = new Map(current.threadAdapters);\n    if (adapters === null) next.delete(threadId);\n    else next.set(threadId, adapters);\n    this.adapterStore.setState({ ...current, threadAdapters: next });\n  }\n\n  public __internal_dispose() {\n    for (const threadId of [...this.instances.keys()]) {\n      this.stopThreadRuntime(threadId);\n    }\n  }\n\n  private _syncHostThreads() {\n    const host = this.hostStore.getState();\n    this.hostStore.setState({\n      ...host,\n      threads: Array.from(this.instances.entries()).map(\n        ([id, { generation }]) => ({ id, generation }),\n      ),\n    });\n  }\n\n  public __internal_useHost(parentClient: AssistantClient) {\n    const { threads, hookEpoch } = useSubscribable(this.hostStore);\n    const adapters = useSubscribable(this.adapterStore);\n    const runtimeHook = this.runtimeHook;\n    return useResources(\n      threads.map(({ id, generation }) => {\n        const threadAdapters = this.pendingThreadAdapters.has(id)\n          ? this.pendingThreadAdapters.get(id)!\n          : (adapters.threadAdapters.get(id) ?? adapters.defaultAdapters);\n        return withKey(\n          `${id}:${generation}:${hookEpoch}`,\n          RemoteThreadResource({\n            threadId: id,\n            generation,\n            parentList: this.parent,\n            runtimeHook,\n            parentClient,\n            adapters: threadAdapters,\n            publish: this._publish,\n          }),\n        );\n      }),\n    );\n  }\n\n  public __internal_RenderThreadRuntimes: FC<{\n    provider: ComponentType<PropsWithChildren>;\n  }> = ({ provider }) => {\n    useSubscribable(this.hostStore);\n\n    return Array.from(this.instances.entries()).map(\n      ([threadId, { generation }]) => (\n        <this._OuterActiveThreadProvider\n          key={`${threadId}:${generation}`}\n          threadId={threadId}\n          provider={provider}\n        />\n      ),\n    );\n  };\n\n  public __internal_Host: FC<{ parentClient: AssistantClient }> = ({\n    parentClient,\n  }) => {\n    this.__internal_useHost(parentClient);\n    return null;\n  };\n\n  private _OuterActiveThreadProvider: FC<{\n    threadId: string;\n    provider: ComponentType<PropsWithChildren>;\n  }> = memo(({ threadId, provider: Provider }) => {\n    const runtime = useMemo(\n      () => new ThreadListRuntimeImpl(this.parent).getItemById(threadId),\n      [threadId],\n    );\n\n    const detectorRef = useRef(false);\n    useEffect(() => {\n      if (process.env.NODE_ENV !== \"production\" && Provider !== Fragment) {\n        const id = setTimeout(() => {\n          if (!detectorRef.current) {\n            console.warn(\n              \"RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. \" +\n                \"Render `children` on first commit; deferring them behind a loading state, Suspense boundary, \" +\n                \"or `useEffect` gate strands the runtime host and leaves the thread without context.\",\n            );\n          }\n        }, 100);\n        return () => clearTimeout(id);\n      }\n      return undefined;\n    }, [Provider]);\n\n    return (\n      <ThreadListItemRuntimeProvider runtime={runtime}>\n        <Provider>\n          <this._AdapterSink threadId={threadId} detectorRef={detectorRef} />\n        </Provider>\n      </ThreadListItemRuntimeProvider>\n    );\n  });\n\n  private _AdapterSink: FC<{\n    threadId: string;\n    detectorRef: RefObject<boolean>;\n  }> = ({ threadId, detectorRef }) => {\n    const adapters = useRuntimeAdapters();\n    this.pendingThreadAdapters.set(threadId, adapters);\n    useLayoutEffect(() => {\n      this.__internal_setThreadAdapters(threadId, adapters);\n      return () => {\n        if (this.pendingThreadAdapters.get(threadId) === adapters) {\n          this.pendingThreadAdapters.delete(threadId);\n        }\n        this.__internal_setThreadAdapters(threadId, null);\n      };\n    }, [threadId, adapters]);\n    return <ProviderRenderDetector detectorRef={detectorRef} />;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AA0CA,MAAM8B,gBAAgB;CACpB;CACA;CACA;CACA;AAAoB;AAqBtB,MAAMgB,0BAEDE,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAH,gBAAAC;CAAe,IAAAG;CAAA,IAAAC;CAAA,IAAAH,EAAA,OAAAF,aAAA;EACHI,WAAA;GACdJ,YAAWM,UAAW;EAAH;EAClBD,KAAA,CAACL,WAAW;EAACE,EAAA,KAAAF;EAAAE,EAAA,KAAAE;EAAAF,EAAA,KAAAG;CAAA,OAAA;EAAAD,KAAAF,EAAA;EAAAG,KAAAH,EAAA;CAAA;CAFhB9C,gBAAgBgD,IAEbC,EAAa;CAAC,OACV;AAAI;AAGb,IAAaE,sCAAb,cAAyDnC,iBAAiB;CACxE;CACA,eAAgC,IAAIC,qBAAsC;EACxEmB,iBAAiB;EACjBC,gCAAgB,IAAIiB,IAAI;CAC1B,CAAC;CACD,YAA6B,IAAIrC,qBAAmC;EAClEuB,SAAS,CAAA;EACTE,WAAW;CACb,CAAC;CACD,wCAAyC,IAAIY,IAG3C;CACF,4BAAoB,IAAIA,IAA0C;CAClE,iBAAyB;CACzB;CAEAM,YACER,aACAO,QACA;EACA,MAAM;EACN,KAAKA,SAASA;EACd,KAAKP,cAAcA;CACrB;CAEA,qBAA6BU,UAAkB;EAC7C,OAAO,IAAIC,SAA4BC,SAASC,WAAW;GACzD,MAAMC,iBAAiB;IACrB,MAAMC,WAAW,KAAKV,UAAUW,IAAIN,QAAQ;IAC5C,IAAI,CAACK,UAAU;KACbE,QAAQ;KACRJ,uBAAO,IAAIK,MAAM,+CAA+C,CAAC;IACnE,OAAO,IACL,CAACH,SAASrC,WACVqC,SAASpC,wBAAwBoC,SAASnC,YAE1C;SACK;KACLqC,QAAQ;KACRL,QAAQG,SAASrC,OAAO;IAC1B;GACF;GACA,MAAMuC,UAAU,KAAKE,UAAUL,QAAQ;GACvCA,SAAS;EACX,CAAC;CACH;CAEA,mBAA0BJ,UAAkB;EAC1C,IAAI,CAAC,KAAKL,UAAUgB,IAAIX,QAAQ,GAAG;GACjC,MAAM9B,aAAa,KAAK0B;GACxB,KAAKD,UAAUiB,IAAIZ,UAAU;IAC3B9B;IACAC,WAAW;GACb,CAAC;GACD,KAAK0C,iBAAiB;EACxB;EAEA,OAAO,KAAKd,qBAAqBC,QAAQ;CAC3C;CAEA,gCAAuCA,UAAkB;EACvD,MAAMK,WAAW,KAAKV,UAAUW,IAAIN,QAAQ;EAC5C,IAAI,CAACK,UAAU,OAAO,KAAKK,mBAAmBV,QAAQ;EAEtD,IAAIK,SAASrC,SAAST,wBAAwB8C,SAASrC,OAAO;EAC9DqC,SAASnC,aAAa,KAAK0B;EAC3B,KAAKiB,iBAAiB;EACtB,KAAKE,mBAAmB;EAExB,OAAO,KAAKhB,qBAAqBC,QAAQ;CAC3C;CAEA,qBAA4BA,UAAkB;EAC5C,MAAMK,WAAW,KAAKV,UAAUW,IAAIN,QAAQ;EAC5C,IAAI,CAACK,UAAU,OAAOY,KAAAA;EACtB,OAAOZ,SAASrC;CAClB;CAEA,2BAAkCgC,UAAkB;EAClD,OAAO,KAAKL,UAAUW,IAAIN,QAAQ,CAAC,EAAE7B,aAAa;CACpD;CAEA,qCAA6B,IAAIiD,IAAgB;CAEjD,mCAA0ChB,UAAmC;EAC3E,KAAKe,mBAAmBG,IAAIlB,QAAQ;EACpC,aAAa,KAAKe,mBAAmBI,OAAOnB,QAAQ;CACtD;CAEA,yCAAiC,IAAIgB,IAEnC;CAEF,iCACEhB,UACa;EACb,KAAKoB,uBAAuBF,IAAIlB,QAAQ;EACxC,aAAa,KAAKoB,uBAAuBD,OAAOnB,QAAQ;CAC1D;CAEA,YACEJ,UACAhC,SACAE,eACG;EACH,KAAK0D,sBAAsB5B,UAAUhC,SAASE,UAAU;CAC1D;CAEA,sBACE8B,UACAhC,SACAE,YACA;EACA,MAAMmC,WAAW,KAAKV,UAAUW,IAAIN,QAAQ;EAC5C,IAAI,CAACK,UAAU;EAEf,IAAIA,SAASnC,eAAeA,YAAY;EAExC,MAAM2D,kBAAkBxB,SAASrC;EACjCqC,SAASrC,UAAUA;EACnBqC,SAASpC,sBAAsBC;EAC/B,IAAI2D,oBAAoB7D,SACtB,KAAK8D,cAAc9B,UAAUK,QAAQ;EAEvC,KAAKU,mBAAmB;EACxB,IAAIc,oBAAoBZ,KAAAA,KAAaY,oBAAoB7D,SACvD,KAAK,MAAMoC,YAAY,KAAK2B,qBAAqB3B,SAAS;CAE9D;CAEA,sCAA8B,IAAIgB,IAAgB;CAElD,oCACEhB,UACa;EACb,KAAK2B,oBAAoBT,IAAIlB,QAAQ;EACrC,aAAa,KAAK2B,oBAAoBR,OAAOnB,QAAQ;CACvD;CAEA,cACEJ,UACAK,UACA;EACAA,SAASjC,qBAAqB;EAE9B,MAAMJ,UAAUqC,SAASrC;EACzB,IAAI,CAACA,SAAS;GACZqC,SAASjC,qBAAqB6C,KAAAA;GAC9B,KAAKgB,YAAY5B,UAAU,KAAK;GAChC;EACF;EAEA,KAAK4B,YAAY5B,UAAUhD,8BAA8BW,OAAO,CAAC;EACjE,MAAMkE,gBAAgB,CACpBlE,QAAQyC,gBAAgB;GACtB,KAAKwB,YAAY5B,UAAUhD,8BAA8BW,OAAO,CAAC;EACnE,CAAC,GACD,GAAGH,cAAcsE,KAAKC,SACpBpE,QAAQqE,YAAYD,YAAY;GAC9B5E,qBACE,KAAKgE,wBACL;IAAExB;IAAUoC;GAAK,GACjB,iBAAiBA,KAAI,EACvB;EACF,CAAC,CACH,CAAC;EAEH/B,SAASjC,2BAA2B;GAClC,KAAK,MAAMkE,eAAeJ,eAAeI,YAAY;EACvD;CACF;CAEA,YACEjC,UACAlC,WACA;EACA,IAAIkC,SAASlC,cAAcA,WAAW;EACtCkC,SAASlC,YAAYA;EACrB,KAAK,MAAMiC,YAAY,KAAKe,oBAAoBf,SAAS;CAC3D;CAEA,kBAAyBJ,UAAkB;EACzC,MAAMK,WAAW,KAAKV,UAAUW,IAAIN,QAAQ;EAC5C,IAAIK,UAAUrC,SAAST,wBAAwB8C,SAASrC,OAAO;EAC/DqC,UAAUjC,qBAAqB;EAC/B,KAAKuB,UAAU4B,OAAOvB,QAAQ;EAC9B,KAAKN,sBAAsB6B,OAAOvB,QAAQ;EAC1C,KAAKa,iBAAiB;EACtB,KAAKE,mBAAmB;CAC1B;CAEA,eAAsB0B,gBAAsC;EAC1D,IAAI,KAAKnD,gBAAgBmD,gBAAgB;EACzC,KAAKnD,cAAcmD;EACnB,MAAMC,OAAO,KAAKjD,UAAUkD,SAAS;EACrC,KAAKlD,UAAUmD,SAAS;GAAE,GAAGF;GAAM9D,WAAW8D,KAAK9D,YAAY;EAAE,CAAC;CACpE;CAEA,8BAAqCkE,UAAkC;EACrE,MAAM1D,UAAU,KAAKG,aAAaoD,SAAS;EAC3C,IAAIvD,QAAQd,oBAAoBwE,UAAU;EAC1C,KAAKvD,aAAaqD,SAAS;GAAE,GAAGxD;GAASd,iBAAiBwE;EAAS,CAAC;CACtE;CAEA,6BACE9C,UACA8C,UACA;EACA,MAAM1D,UAAU,KAAKG,aAAaoD,SAAS;EAC3C,MAAMK,OAAO,IAAIxD,IAAIJ,QAAQb,cAAc;EAC3C,IAAIuE,aAAa,MAAME,KAAKzB,OAAOvB,QAAQ;OACtCgD,KAAKpC,IAAIZ,UAAU8C,QAAQ;EAChC,KAAKvD,aAAaqD,SAAS;GAAE,GAAGxD;GAASb,gBAAgByE;EAAK,CAAC;CACjE;CAEA,qBAA4B;EAC1B,KAAK,MAAMhD,YAAY,CAAC,GAAG,KAAKL,UAAUuD,KAAK,CAAC,GAC9C,KAAKX,kBAAkBvC,QAAQ;CAEnC;CAEA,mBAA2B;EACzB,MAAM0C,OAAO,KAAKjD,UAAUkD,SAAS;EACrC,KAAKlD,UAAUmD,SAAS;GACtB,GAAGF;GACHhE,SAASyE,MAAMC,KAAK,KAAKzD,UAAU0D,QAAQ,CAAC,CAAC,CAAClB,KAC3C,CAACxD,IAAI,EAAET,mBAAmB;IAAES;IAAIT;GAAW,EAC9C;EACF,CAAC;CACH;CAEA,mBAA0BqF,cAA+B;EACvD,MAAM,EAAE7E,SAASE,cAAcxB,gBAAgB,KAAKqC,SAAS;EAC7D,MAAMqD,WAAW1F,gBAAgB,KAAKmC,YAAY;EAClD,MAAMD,cAAc,KAAKA;EACzB,OAAO7C,aACLiC,QAAQyD,KAAK,EAAExD,IAAIT,iBAAiB;GAClC,MAAMK,iBAAiB,KAAKmB,sBAAsBiB,IAAIhC,EAAE,IACpD,KAAKe,sBAAsBY,IAAI3B,EAAE,IAChCmE,SAASvE,eAAe+B,IAAI3B,EAAE,KAAKmE,SAASxE;GACjD,OAAO5B,QACL,GAAGiC,GAAE,GAAIT,WAAU,GAAIU,aACvBjB,qBAAqB;IACnBqC,UAAUrB;IACVT;IACAsF,YAAY,KAAK3D;IACjBP;IACAiE;IACAT,UAAUvE;IACVkF,SAAS,KAAK9B;GAChB,CAAC,CACH;EACF,CAAC,CACH;CACF;CAEA,mCAEM,EAAEgC,eAAe;EACrBvG,gBAAgB,KAAKqC,SAAS;EAE9B,OAAO0D,MAAMC,KAAK,KAAKzD,UAAU0D,QAAQ,CAAC,CAAC,CAAClB,KACzC,CAACnC,UAAU,EAAE9B,kBACZ,oBAAC,KAAK,4BAAN;GAEY8B;GACA2D;EAAS,GAFd,GAAG3D,SAAQ,GAAI9B,YAED,CAGzB;CACF;CAEA,mBAAiE,EAC/DqF,mBACI;EACJ,KAAKD,mBAAmBC,YAAY;EACpC,OAAO;CACT;CAEA,6BAGKlH,MAAM,EAAE2D,UAAU2D,UAAUG,eAAe;EAC9C,MAAM9F,UAAU7B,cACR,IAAImB,sBAAsB,KAAKuC,MAAM,CAAC,CAACkE,YAAY/D,QAAQ,GACjE,CAACA,QAAQ,CACX;EAEA,MAAMlB,cAAc1C,OAAO,KAAK;EAChCH,gBAAgB;GACd,IAAI+H,QAAQC,IAAIC,aAAa,gBAAgBJ,aAAatH,UAAU;IAClE,MAAMmC,KAAKwF,iBAAiB;KAC1B,IAAI,CAACrF,YAAYM,SACfgF,QAAQC,KACN,yQAGF;IAEJ,GAAG,GAAG;IACN,aAAaC,aAAa3F,EAAE;GAC9B;EAEF,GAAG,CAACmF,QAAQ,CAAC;EAEb,OACE,oBAAC,+BAAD;GAAwC9F;GACtC,UAAA,oBAAC,UAAD,EAAA,UACE,oBAAC,KAAK,cAAN;IAA6BgC;IAAuBlB;GAAY,CAAA,EACxD,CAAA;EACmB,CAAA;CAEnC,CAAC;CAED,gBAGM,EAAEkB,UAAUlB,kBAAkB;EAClC,MAAMgE,WAAWrF,mBAAmB;EACpC,KAAKiC,sBAAsBkB,IAAIZ,UAAU8C,QAAQ;EACjD5G,sBAAsB;GACpB,KAAK6G,6BAA6B/C,UAAU8C,QAAQ;GACpD,aAAa;IACX,IAAI,KAAKpD,sBAAsBY,IAAIN,QAAQ,MAAM8C,UAC/C,KAAKpD,sBAAsB6B,OAAOvB,QAAQ;IAE5C,KAAK+C,6BAA6B/C,UAAU,IAAI;GAClD;EACF,GAAG,CAACA,UAAU8C,QAAQ,CAAC;EACvB,OAAO,oBAAC,wBAAD,EAAqChE,YAAY,CAAA;CAC1D;AACF"}

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.d.ts

@@ -7,7 +7,7 @@ import { QueueItemState } from "../../runtime/queue/queue-item.js";
 import { QueuePlacement } from "../../runtime/queue/external-thread-queue-adapter.js";
 import { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "../../runtime/interfaces/composer-runtime-core.js";
 import { AddToolResultOptions, RespondToToolApprovalOptions, ResumeRunConfig, ResumeToolCallOptions, RuntimeCapabilities, SpeechState, StartRunConfig, SubmitFeedbackOptions, ThreadRuntimeEventCallback, ThreadRuntimeEventType, ThreadSuggestion, VoiceSessionState } from "../../runtime/interfaces/thread-runtime-core.js";
-import { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core.js";
+import { ThreadListRuntimeCore, ThreadListRuntimeEvent } from "../../runtime/interfaces/thread-list-runtime-core.js";
 import { BaseSubscribable } from "../../subscribable/subscribable.js";
 import { RemoteThreadListOptions } from "../../runtimes/remote-thread-list/types.js";
 import "../../store/index.js";
@@ -38,7 +38,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
   loadMore(): Promise<void>;
   constructor(options: RemoteThreadListOptions, contextProvider: ModelContextProvider);
   private _initialThreadLoaded;
-  private useProvider;
+  private providerStore;
   __internal_setOptions(options: RemoteThreadListOptions): void;
   private _requireAdapterGeneration;
   private _requireAdapterSettled;
@@ -72,7 +72,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
     unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
-    respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
+    respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
     speak: (messageId: string) => void;
     stopSpeaking: () => void;
     connectVoice: () => void;
@@ -126,7 +126,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
     unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
-    respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
+    respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
     speak: (messageId: string) => void;
     stopSpeaking: () => void;
     connectVoice: () => void;
@@ -165,6 +165,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
     unstable_on<E extends ThreadRuntimeEventType>(event: E, callback: ThreadRuntimeEventCallback<E>): Unsubscribe;
   }>;
   unstable_isThreadRunning(threadIdOrRemoteId: string): boolean;
+  unstable_subscribeThreadEvents(callback: (event: ThreadListRuntimeEvent) => void): Unsubscribe;
   getItemById(threadIdOrRemoteId: string): RemoteThreadData | undefined;
   switchToThread(threadIdOrRemoteId: string, options?: {
     unarchive?: boolean;
@@ -188,7 +189,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
   delete(threadIdOrRemoteId: string): Promise<void>;
   __internal_dispose(): void;
   detach(threadIdOrRemoteId: string): Promise<void>;
-  private useBoundIds;
+  private boundIdsStore;
   __internal_RenderComponent: FC;
 }
 //#endregion

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"mappings":";;;;;;;;;;;;;;;;;;cAwDa,8CACH,4BACG;UAEH;mBACS;mBACA;UAET;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UAEA;mBACS;mBAIA;mBAYA;UAcT;MAUG,eAAW,SAAA,OA1DX,mBA0DW;EAIf,yBAAqB;EA2ErB,YAAY;EAqDjB,YAAA,SAAS,yBACT,iBAAiB;UA6BX;UACA;EAED,sBAAsB,SAAS;UA2C9B;UAMA;UAMA;EAiGD;EAgBM,oBAAoB;EA4B1B,UAAM;MAWF;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;cAMC;UAKJ;UAEA;EASD,4BAAwB;;;eAzDlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DN,qBAAqB,6BAA0B;;;eANvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBxB,yBAAyB;EAMzB,YAAY,6BAA0B;EAItC,eACL,4BACA;IAAY;MACX;UAIK;UAgBM;EAgHP,qBAAqB;UAIpB;UAMA;UAOM;EAwBP,aAAoB,qBAAgB;;;;EA+DpC,gBAAuB,qBAAgB;EA6CjC,OACX,4BACA,mBACC;EAiCU,aACX,4BACA,QAAQ,sCACP;UAoDW;EAsBD,QAAQ,6BAA0B;EAwBlC,UAAU,6BAA6B;EA4BvC,OAAO,6BAA0B;EAyBvC;EAIM,OAAO,6BAA6B;UAYzC;EAED,4BAA4B"}
+{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"mappings":";;;;;;;;;;;;;;;;;;cA+Da,8CACH,4BACG;UAEH;mBACS;mBACA;UAET;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UAEA;mBACS;mBAIA;mBAYA;UAcT;MAUG,eAAW,SAAA,OA1DX,mBA0DW;EAIf,yBAAqB;EA4ErB,YAAY;EAwDjB,YAAA,SAAS,yBACT,iBAAiB;UA6BX;UACA;EAED,sBAAsB,SAAS;UAwC9B;UAMA;UAMA;EAsGD;EAgBM,oBAAoB;EA4B1B,UAAM;MAWF;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;cAMC;UAKJ;UAEA;EASD,4BAAwB;;;eAzDlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DN,qBAAqB,6BAA0B;;;eANvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBxB,yBAAyB;EAMzB,+BACL,WAAW,OAAO,kCAAA;EAKb,YAAY,6BAA0B;EAItC,eACL,4BACA;IAAY;MACX;UAIK;UAgBM;EA0HP,qBAAqB;UAIpB;UAMA;UAOM;EAwBP,aAAoB,qBAAgB;;;;EA8EpC,gBAAuB,qBAAgB;EA6CjC,OACX,4BACA,mBACC;EAiCU,aACX,4BACA,QAAQ,sCACP;UAoDW;EAsBD,QAAQ,6BAA0B;EAwBlC,UAAU,6BAA6B;EA4BvC,OAAO,6BAA0B;EAyBvC;EAIM,OAAO,6BAA6B;UAYzC;EAED,4BAA4B"}

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -1,17 +1,17 @@
-import { BaseSubscribable } from "../../subscribable/subscribable.js";
+import { BaseSubscribable, WritableSubscribable } from "../../subscribable/subscribable.js";
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state.js";
 import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core.js";
 import { classifyThreads, createEmptyRemoteThreadState, createThreadMappingId, getThreadData, normalizeCursor, preserveMidLoadTransitions, seedNewThread, statusSnapshot, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
+import { useSubscribable } from "../../store/runtime-clients/useSubscribable.js";
 import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed.js";
 import { useStableRuntimeAdapters } from "./useRuntimeAdapters.js";
+import { isTitleSourceMessage } from "../../runtimes/remote-thread-list/title.js";
 import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider.js";
-import { isTitleSourceMessage } from "./RemoteThreadResource.js";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager.js";
 import { AssistantMessageStream } from "assistant-stream";
 import { Fragment, useEffect, useId } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { create } from "zustand";
 //#region src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx
 const threadNotFoundError = (threadIdOrRemoteId, action) => /* @__PURE__ */ new Error(`Thread "${threadIdOrRemoteId}" not found while ${action}.`);
 const threadStatusError = (threadIdOrRemoteId, status, action) => /* @__PURE__ */ new Error(`Thread "${threadIdOrRemoteId}" has status "${status}", so it cannot ${action}.`);
@@ -62,6 +62,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			this._loadThreadsPromise = this._state.optimisticUpdate({
 				execute: () => this._options.adapter.list(),
 				loading: (state) => {
+					if (generation !== this._loadGeneration) return state;
 					return {
 						...state,
 						isLoading: true
@@ -77,8 +78,8 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 					const fresh = classifyThreads(l.threads, {
 						threadIds: [],
 						archivedThreadIds: [],
-						threadIdMap: {},
-						threadData: {}
+						threadIdMap: { ...state.threadIdMap },
+						threadData: { ...state.threadData }
 					});
 					const merged = {
 						...state,
@@ -86,14 +87,8 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 						cursor: normalizeCursor(l.nextCursor),
 						threadIds: fresh.threadIds,
 						archivedThreadIds: fresh.archivedThreadIds,
-						threadIdMap: {
-							...state.threadIdMap,
-							...fresh.threadIdMap
-						},
-						threadData: {
-							...state.threadData,
-							...fresh.threadData
-						}
+						threadIdMap: fresh.threadIdMap,
+						threadData: fresh.threadData
 					};
 					return preserveMidLoadTransitions(merged, state, statusAtRequest);
 				}
@@ -130,10 +125,13 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		const cursor = initialState.cursor;
 		const dedup = this._state.optimisticUpdate({
 			execute: () => adapter.list({ after: cursor }),
-			loading: (state) => ({
-				...state,
-				isLoadingMore: true
-			}),
+			loading: (state) => {
+				if (generation !== this._loadGeneration) return state;
+				return {
+					...state,
+					isLoadingMore: true
+				};
+			},
 			then: (state, l) => {
 				if (generation !== this._loadGeneration) return state;
 				if (adapter !== this._options.adapter) return state;
@@ -175,19 +173,18 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._hookManager.__internal_subscribeRuntimeReplaced(() => {
 			queueMicrotask(() => this._notifySubscribers());
 		});
-		this.useProvider = create(() => ({ Provider: this.resolveProvider(options.adapter) }));
+		this.providerStore = new WritableSubscribable(this.resolveProvider(options.adapter));
 		this.__internal_setOptions(options);
 		this.switchToNewThread();
 	}
 	_initialThreadLoaded = false;
-	useProvider;
+	providerStore;
 	__internal_setOptions(options) {
 		if (this._options === options) return;
 		const adapterChanged = this._options !== void 0 && this._options.adapter !== options.adapter;
 		const controlledThreadIdChanged = this._initialThreadLoaded && this._options !== void 0 && this._options.threadId !== options.threadId;
 		this._options = options;
-		const Provider = this.resolveProvider(options.adapter);
-		if (Provider !== this.useProvider.getState().Provider) this.useProvider.setState({ Provider }, true);
+		this.providerStore.setState(this.resolveProvider(options.adapter));
 		this._hookManager.setRuntimeHook(options.runtimeHook);
 		if (adapterChanged) {
 			this._loadGeneration++;
@@ -212,38 +209,40 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		if (this._replaceListOnNextLoad) throw new ThreadListAdapterChangedError();
 	}
 	_replaceWithThreads(state, threads, cursor) {
-		const fresh = classifyThreads(threads, {
-			threadIds: [],
-			archivedThreadIds: [],
-			threadIdMap: {},
-			threadData: {}
-		});
-		const threadIdMap = { ...fresh.threadIdMap };
-		const threadData = { ...fresh.threadData };
-		const threadIds = [...fresh.threadIds];
-		const archivedThreadIds = [...fresh.archivedThreadIds];
+		const carried = [];
 		if (state.newThreadId) {
 			const mappingId = state.threadIdMap[state.newThreadId];
 			const draft = mappingId ? state.threadData[mappingId] : void 0;
-			if (draft?.status === "new") {
-				threadIdMap[state.newThreadId] = mappingId;
-				threadData[mappingId] = draft;
-			}
+			if (draft?.status === "new") carried.push(draft);
 		}
 		const stale = this._staleThreadIdsOnReplace;
 		if (stale) for (const item of Object.values(state.threadData)) {
 			if (stale.has(item.id)) continue;
 			if (item.status !== "new" && item.remoteId === void 0) continue;
+			carried.push(item);
+		}
+		this._staleThreadIdsOnReplace = void 0;
+		const seed = {
+			threadIds: [],
+			archivedThreadIds: [],
+			threadIdMap: {},
+			threadData: {}
+		};
+		for (const item of carried) {
 			const mappingId = createThreadMappingId(item.id);
-			if (threadData[mappingId]) continue;
-			threadIdMap[item.id] = mappingId;
-			if (item.remoteId !== void 0) threadIdMap[item.remoteId] = mappingId;
-			threadData[mappingId] = item;
+			if (seed.threadData[mappingId]) continue;
+			seed.threadIdMap[item.id] = mappingId;
+			if (item.remoteId !== void 0) seed.threadIdMap[item.remoteId] = mappingId;
+			seed.threadData[mappingId] = item;
+		}
+		const { threadIds, archivedThreadIds, threadIdMap, threadData } = classifyThreads(threads, seed);
+		for (const item of carried) {
 			if (item.remoteId === void 0) continue;
-			if (item.status === "regular" && !threadIds.includes(item.remoteId)) threadIds.push(item.remoteId);
-			else if (item.status === "archived" && !archivedThreadIds.includes(item.remoteId)) archivedThreadIds.push(item.remoteId);
+			const current = threadData[createThreadMappingId(item.id)];
+			if (current === void 0) continue;
+			if (current.status === "regular" && !threadIds.includes(current.id)) threadIds.push(current.id);
+			else if (current.status === "archived" && !archivedThreadIds.includes(current.id)) archivedThreadIds.push(current.id);
 		}
-		this._staleThreadIdsOnReplace = void 0;
 		let nextState = {
 			...state,
 			isLoading: false,
@@ -351,6 +350,9 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		if (!data) return false;
 		return this._hookManager.__internal_isThreadRunning(data.id);
 	}
+	unstable_subscribeThreadEvents(callback) {
+		return this._hookManager.__internal_subscribeThreadEvents(callback);
+	}
 	getItemById(threadIdOrRemoteId) {
 		return getThreadData(this._state.value, threadIdOrRemoteId);
 	}
@@ -412,11 +414,21 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		if (this.mainThreadId !== void 0) await task;
 		else task.then(() => this._notifySubscribers(), () => void 0);
 		if (generation !== this._switchGeneration) return;
-		if (data.status === "archived" && options?.unarchive !== false) {
-			await this.unarchive(data.id);
+		let current = this.getItemById(data.id);
+		if (current?.id !== data.id) return;
+		if (current.status === "archived" && options?.unarchive !== false) {
+			await current.initializeTask;
 			if (generation !== this._switchGeneration) return;
+			current = this.getItemById(data.id);
+			if (current?.id !== data.id) return;
+			if (current.status === "archived") {
+				await this.unarchive(current.id);
+				if (generation !== this._switchGeneration) return;
+				current = this.getItemById(data.id);
+				if (current?.id !== data.id) return;
+			}
 		}
-		this._mainThreadId = data.id;
+		this._mainThreadId = current.id;
 		this._notifySubscribers();
 		this._notifyThreadIdChange(emitThreadIdChange);
 	}
@@ -487,24 +499,29 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				const data = getThreadData(state, threadId);
 				if (!data) return state;
 				const mappingId = createThreadMappingId(threadId);
+				const listedMappingId = state.threadIdMap[remoteId];
+				const orphan = listedMappingId !== void 0 && listedMappingId !== mappingId ? state.threadData[listedMappingId] : void 0;
+				const threadData = { ...state.threadData };
+				if (orphan !== void 0) delete threadData[listedMappingId];
+				threadData[mappingId] = {
+					...data,
+					initializeTask: Promise.resolve({
+						remoteId,
+						externalId
+					}),
+					remoteId,
+					externalId
+				};
+				const rewire = (ids) => orphan === void 0 ? ids : ids.filter((id) => id !== orphan.id);
 				return {
 					...state,
+					threadIds: rewire(state.threadIds),
+					archivedThreadIds: rewire(state.archivedThreadIds),
 					threadIdMap: {
 						...state.threadIdMap,
 						[remoteId]: mappingId
 					},
-					threadData: {
-						...state.threadData,
-						[mappingId]: {
-							...data,
-							initializeTask: Promise.resolve({
-								remoteId,
-								externalId
-							}),
-							remoteId,
-							externalId
-						}
-					}
+					threadData
 				};
 			}
 		});
@@ -702,17 +719,17 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._requireAdapterGeneration(adapterGeneration);
 		this._hookManager.stopThreadRuntime(data.id);
 	}
-	useBoundIds = create(() => []);
+	boundIdsStore = new WritableSubscribable([]);
 	__internal_RenderComponent = () => {
 		const id = useId();
 		useEffect(() => {
-			this.useBoundIds.setState((s) => [...s, id], true);
+			this.boundIdsStore.setState([...this.boundIdsStore.getState(), id]);
 			return () => {
-				this.useBoundIds.setState((s) => s.filter((i) => i !== id), true);
+				this.boundIdsStore.setState(this.boundIdsStore.getState().filter((i) => i !== id));
 			};
 		}, [id]);
-		const boundIds = this.useBoundIds();
-		const { Provider } = this.useProvider();
+		const boundIds = useSubscribable(this.boundIdsStore);
+		const Provider = useSubscribable(this.providerStore);
 		const aui = useAui();
 		return (boundIds.length === 0 || boundIds[0] === id) && /* @__PURE__ */ jsxs(RuntimeAdapterProvider, {
 			adapters: this._runtimeAdapters,