@assistant-ui/core 0.3.13 → 0.3.14

package/dist/react/primitives/thread/ThreadMessages.js.map

@@ -1 +1 @@
-{"version":3,"file":"ThreadMessages.js","names":["ComponentType","FC","ReactNode","memo","useMemo","RenderChildrenWithAccessor","useAuiState","MessageByIndexProvider","MessageByIdProvider","MessageState","MessagesComponentConfig","Message","EditComposer","UserEditComposer","AssistantEditComposer","SystemEditComposer","UserMessage","AssistantMessage","SystemMessage","ThreadPrimitiveMessages","Props","components","children","value","message","isComponentsSame","prev","next","DEFAULT_SYSTEM_MESSAGE","messageIdSetCache","WeakMap","ReadonlySet","hasMessageId","messages","messageId","ids","get","Set","map","m","id","set","has","getComponent","role","isEditing","_exhaustiveCheck","Error","ThreadMessageComponentProps","ThreadMessageComponent","t0","$","_c","_temp","_temp2","t1","Component","t2","ThreadPrimitiveMessageByIndex","index","displayName","ThreadPrimitiveUnstable_MessageById","s","thread","exists","t3","ThreadPrimitiveMessagesInner","messagesLength","length","Array","from","_","aui","getState","getItem","ThreadPrimitiveMessagesImpl","s_0","composer"],"sources":["../../../../src/react/primitives/thread/ThreadMessages.tsx"],"sourcesContent":["import {\n  type ComponentType,\n  type FC,\n  type ReactNode,\n  memo,\n  useMemo,\n} from \"react\";\nimport { RenderChildrenWithAccessor, useAuiState } from \"@assistant-ui/store\";\nimport { MessageByIndexProvider } from \"../../providers/MessageByIndexProvider\";\nimport { MessageByIdProvider } from \"../../providers/MessageByIdProvider\";\nimport type { MessageState } from \"../../../store\";\n\ntype MessagesComponentConfig =\n  | {\n      /** Component used to render all message types */\n      Message: ComponentType;\n      /** Component used when editing any message type */\n      EditComposer?: ComponentType | undefined;\n      /** Component used when editing user messages specifically */\n      UserEditComposer?: ComponentType | undefined;\n      /** Component used when editing assistant messages specifically */\n      AssistantEditComposer?: ComponentType | undefined;\n      /** Component used when editing system messages specifically */\n      SystemEditComposer?: ComponentType | undefined;\n      /** Component used to render user messages specifically */\n      UserMessage?: ComponentType | undefined;\n      /** Component used to render assistant messages specifically */\n      AssistantMessage?: ComponentType | undefined;\n      /** Component used to render system messages specifically */\n      SystemMessage?: ComponentType | undefined;\n    }\n  | {\n      /** Component used to render all message types (fallback) */\n      Message?: ComponentType | undefined;\n      /** Component used when editing any message type */\n      EditComposer?: ComponentType | undefined;\n      /** Component used when editing user messages specifically */\n      UserEditComposer?: ComponentType | undefined;\n      /** Component used when editing assistant messages specifically */\n      AssistantEditComposer?: ComponentType | undefined;\n      /** Component used when editing system messages specifically */\n      SystemEditComposer?: ComponentType | undefined;\n      /** Component used to render user messages */\n      UserMessage: ComponentType;\n      /** Component used to render assistant messages */\n      AssistantMessage: ComponentType;\n      /** Component used to render system messages */\n      SystemMessage?: ComponentType | undefined;\n    };\n\nexport namespace ThreadPrimitiveMessages {\n  export type Props =\n    | {\n        /** @deprecated Use the children render function instead. */\n        components: MessagesComponentConfig;\n        children?: never;\n      }\n    | {\n        /** Render function called for each message. Receives the message. */\n        children: (value: { message: MessageState }) => ReactNode;\n        components?: never;\n      };\n}\n\nconst isComponentsSame = (\n  prev: MessagesComponentConfig,\n  next: MessagesComponentConfig,\n) => {\n  return (\n    prev.Message === next.Message &&\n    prev.EditComposer === next.EditComposer &&\n    prev.UserEditComposer === next.UserEditComposer &&\n    prev.AssistantEditComposer === next.AssistantEditComposer &&\n    prev.SystemEditComposer === next.SystemEditComposer &&\n    prev.UserMessage === next.UserMessage &&\n    prev.AssistantMessage === next.AssistantMessage &&\n    prev.SystemMessage === next.SystemMessage\n  );\n};\n\nconst DEFAULT_SYSTEM_MESSAGE = () => null;\n\nconst messageIdSetCache = new WeakMap<\n  readonly MessageState[],\n  ReadonlySet<string>\n>();\n\nconst hasMessageId = (messages: readonly MessageState[], messageId: string) => {\n  let ids = messageIdSetCache.get(messages);\n  if (!ids) {\n    ids = new Set(messages.map((m) => m.id));\n    messageIdSetCache.set(messages, ids);\n  }\n  return ids.has(messageId);\n};\n\nconst getComponent = (\n  components: MessagesComponentConfig,\n  role: MessageState[\"role\"],\n  isEditing: boolean,\n) => {\n  switch (role) {\n    case \"user\":\n      if (isEditing) {\n        return (\n          components.UserEditComposer ??\n          components.EditComposer ??\n          components.UserMessage ??\n          (components.Message as ComponentType)\n        );\n      } else {\n        return components.UserMessage ?? (components.Message as ComponentType);\n      }\n    case \"assistant\":\n      if (isEditing) {\n        return (\n          components.AssistantEditComposer ??\n          components.EditComposer ??\n          components.AssistantMessage ??\n          (components.Message as ComponentType)\n        );\n      } else {\n        return (\n          components.AssistantMessage ?? (components.Message as ComponentType)\n        );\n      }\n    case \"system\":\n      if (isEditing) {\n        return (\n          components.SystemEditComposer ??\n          components.EditComposer ??\n          components.SystemMessage ??\n          (components.Message as ComponentType)\n        );\n      } else {\n        return (\n          components.SystemMessage ??\n          (components.Message as ComponentType) ??\n          DEFAULT_SYSTEM_MESSAGE\n        );\n      }\n    default: {\n      const _exhaustiveCheck: never = role;\n      throw new Error(`Unknown message role: ${_exhaustiveCheck}`);\n    }\n  }\n};\n\ntype ThreadMessageComponentProps = {\n  components: MessagesComponentConfig;\n};\n\nconst ThreadMessageComponent: FC<ThreadMessageComponentProps> = ({\n  components,\n}) => {\n  const role = useAuiState((s) => s.message.role);\n  const isEditing = useAuiState((s) => s.message.composer.isEditing);\n  const Component = getComponent(components, role, isEditing);\n\n  return <Component />;\n};\nexport namespace ThreadPrimitiveMessageByIndex {\n  export type Props = {\n    index: number;\n    components: MessagesComponentConfig;\n  };\n}\n\n/**\n * Renders a single message at the specified index in the current thread.\n */\nexport const ThreadPrimitiveMessageByIndex: FC<ThreadPrimitiveMessageByIndex.Props> =\n  memo(\n    ({ index, components }) => {\n      return (\n        <MessageByIndexProvider index={index}>\n          <ThreadMessageComponent components={components} />\n        </MessageByIndexProvider>\n      );\n    },\n    (prev, next) =>\n      prev.index === next.index &&\n      isComponentsSame(prev.components, next.components),\n  );\n\nThreadPrimitiveMessageByIndex.displayName = \"ThreadPrimitive.MessageByIndex\";\n\nexport namespace ThreadPrimitiveUnstable_MessageById {\n  export type Props = {\n    messageId: string;\n    components: MessagesComponentConfig;\n  };\n}\n\n/**\n * Renders the message with the given id in the current thread.\n *\n * Unlike {@link ThreadPrimitiveMessageByIndex}, this keys off the message id,\n * so it stays attached to the same message across reordering and windowing -\n * the shape needed to drive a virtualized or custom message list together with\n * `unstable_useThreadMessageIds`. A missing or removed id renders `null` rather\n * than throwing.\n *\n * @deprecated Unstable / Experimental - may change in any release.\n *\n * @example\n * ```tsx\n * const messageIds = unstable_useThreadMessageIds();\n * return messageIds.map((messageId) => (\n *   <ThreadPrimitive.Unstable_MessageById\n *     key={messageId}\n *     messageId={messageId}\n *     components={MESSAGE_COMPONENTS}\n *   />\n * ));\n * ```\n */\nexport const ThreadPrimitiveUnstable_MessageById: FC<ThreadPrimitiveUnstable_MessageById.Props> =\n  memo(\n    ({ messageId, components }) => {\n      const exists = useAuiState((s) =>\n        hasMessageId(s.thread.messages, messageId),\n      );\n      if (!exists) return null;\n\n      return (\n        <MessageByIdProvider id={messageId}>\n          <ThreadMessageComponent components={components} />\n        </MessageByIdProvider>\n      );\n    },\n    (prev, next) =>\n      prev.messageId === next.messageId &&\n      isComponentsSame(prev.components, next.components),\n  );\n\nThreadPrimitiveUnstable_MessageById.displayName =\n  \"ThreadPrimitive.Unstable_MessageById\";\n\nconst ThreadPrimitiveMessagesInner: FC<{\n  children: (value: { message: MessageState }) => ReactNode;\n}> = ({ children }) => {\n  const messagesLength = useAuiState((s) => s.thread.messages.length);\n\n  return useMemo(() => {\n    if (messagesLength === 0) return null;\n    return Array.from({ length: messagesLength }, (_, index) => (\n      <MessageByIndexProvider key={index} index={index}>\n        <RenderChildrenWithAccessor\n          getItemState={(aui) => aui.thread.message({ index }).getState()}\n        >\n          {(getItem) =>\n            children({\n              get message() {\n                return getItem();\n              },\n            })\n          }\n        </RenderChildrenWithAccessor>\n      </MessageByIndexProvider>\n    ));\n  }, [messagesLength, children]);\n};\n\n/**\n * Renders all messages in the current thread.\n *\n * @example\n * ```tsx\n * <ThreadPrimitive.Messages>\n *   {({ message }) => {\n *     if (message.role === \"user\") return <MyUserMessage />;\n *     return <MyAssistantMessage />;\n *   }}\n * </ThreadPrimitive.Messages>\n * ```\n */\nexport const ThreadPrimitiveMessagesImpl: FC<ThreadPrimitiveMessages.Props> = ({\n  components,\n  children,\n}) => {\n  if (components) {\n    return (\n      <ThreadPrimitiveMessagesInner>\n        {() => <ThreadMessageComponent components={components} />}\n      </ThreadPrimitiveMessagesInner>\n    );\n  }\n  return (\n    <ThreadPrimitiveMessagesInner>{children}</ThreadPrimitiveMessagesInner>\n  );\n};\n\nThreadPrimitiveMessagesImpl.displayName = \"ThreadPrimitive.Messages\";\n\nexport const ThreadPrimitiveMessages = memo(\n  ThreadPrimitiveMessagesImpl,\n  (prev, next) => {\n    if (prev.children || next.children) {\n      return prev.children === next.children;\n    }\n    return isComponentsSame(prev.components!, next.components!);\n  },\n);\n"],"mappings":"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"}
+{"version":3,"file":"ThreadMessages.js","names":["ComponentType","FC","ReactNode","memo","useMemo","RenderChildrenWithAccessor","useAuiState","MessageByIndexProvider","MessageByIdProvider","MessageState","MessagesComponentConfig","Message","EditComposer","UserEditComposer","AssistantEditComposer","SystemEditComposer","UserMessage","AssistantMessage","SystemMessage","ThreadPrimitiveMessages","Props","components","children","value","message","isComponentsSame","prev","next","DEFAULT_SYSTEM_MESSAGE","messageIdSetCache","WeakMap","ReadonlySet","hasMessageId","messages","messageId","ids","get","Set","map","m","id","set","has","getComponent","role","isEditing","_exhaustiveCheck","Error","ThreadMessageComponentProps","ThreadMessageComponent","t0","$","_c","_temp","_temp2","t1","Component","t2","ThreadPrimitiveMessageByIndex","index","displayName","ThreadPrimitiveUnstable_MessageById","s","thread","exists","t3","ThreadPrimitiveMessagesInner","messagesLength","length","Array","from","_","aui","getState","getItem","ThreadPrimitiveMessagesImpl","s_0","composer"],"sources":["../../../../src/react/primitives/thread/ThreadMessages.tsx"],"sourcesContent":["import {\n  type ComponentType,\n  type FC,\n  type ReactNode,\n  memo,\n  useMemo,\n} from \"react\";\nimport { RenderChildrenWithAccessor, useAuiState } from \"@assistant-ui/store\";\nimport { MessageByIndexProvider } from \"../../providers/MessageByIndexProvider\";\nimport { MessageByIdProvider } from \"../../providers/MessageByIdProvider\";\nimport type { MessageState } from \"../../../store\";\n\ntype MessagesComponentConfig =\n  | {\n      /** Component used to render all message types */\n      Message: ComponentType;\n      /** Component used when editing any message type */\n      EditComposer?: ComponentType | undefined;\n      /** Component used when editing user messages specifically */\n      UserEditComposer?: ComponentType | undefined;\n      /** Component used when editing assistant messages specifically */\n      AssistantEditComposer?: ComponentType | undefined;\n      /** Component used when editing system messages specifically */\n      SystemEditComposer?: ComponentType | undefined;\n      /** Component used to render user messages specifically */\n      UserMessage?: ComponentType | undefined;\n      /** Component used to render assistant messages specifically */\n      AssistantMessage?: ComponentType | undefined;\n      /** Component used to render system messages specifically */\n      SystemMessage?: ComponentType | undefined;\n    }\n  | {\n      /** Component used to render all message types (fallback) */\n      Message?: ComponentType | undefined;\n      /** Component used when editing any message type */\n      EditComposer?: ComponentType | undefined;\n      /** Component used when editing user messages specifically */\n      UserEditComposer?: ComponentType | undefined;\n      /** Component used when editing assistant messages specifically */\n      AssistantEditComposer?: ComponentType | undefined;\n      /** Component used when editing system messages specifically */\n      SystemEditComposer?: ComponentType | undefined;\n      /** Component used to render user messages */\n      UserMessage: ComponentType;\n      /** Component used to render assistant messages */\n      AssistantMessage: ComponentType;\n      /** Component used to render system messages */\n      SystemMessage?: ComponentType | undefined;\n    };\n\nexport namespace ThreadPrimitiveMessages {\n  export type Props =\n    | {\n        /** @deprecated Use the children render function instead. */\n        components: MessagesComponentConfig;\n        children?: never;\n      }\n    | {\n        /** Render function called for each message. Receives the message. */\n        children: (value: { message: MessageState }) => ReactNode;\n        components?: never;\n      };\n}\n\nconst isComponentsSame = (\n  prev: MessagesComponentConfig,\n  next: MessagesComponentConfig,\n) => {\n  return (\n    prev.Message === next.Message &&\n    prev.EditComposer === next.EditComposer &&\n    prev.UserEditComposer === next.UserEditComposer &&\n    prev.AssistantEditComposer === next.AssistantEditComposer &&\n    prev.SystemEditComposer === next.SystemEditComposer &&\n    prev.UserMessage === next.UserMessage &&\n    prev.AssistantMessage === next.AssistantMessage &&\n    prev.SystemMessage === next.SystemMessage\n  );\n};\n\nconst DEFAULT_SYSTEM_MESSAGE = () => null;\n\nconst messageIdSetCache = new WeakMap<\n  readonly MessageState[],\n  ReadonlySet<string>\n>();\n\nconst hasMessageId = (messages: readonly MessageState[], messageId: string) => {\n  let ids = messageIdSetCache.get(messages);\n  if (!ids) {\n    ids = new Set(messages.map((m) => m.id));\n    messageIdSetCache.set(messages, ids);\n  }\n  return ids.has(messageId);\n};\n\nconst getComponent = (\n  components: MessagesComponentConfig,\n  role: MessageState[\"role\"],\n  isEditing: boolean,\n) => {\n  switch (role) {\n    case \"user\":\n      if (isEditing) {\n        return (\n          components.UserEditComposer ??\n          components.EditComposer ??\n          components.UserMessage ??\n          (components.Message as ComponentType)\n        );\n      } else {\n        return components.UserMessage ?? (components.Message as ComponentType);\n      }\n    case \"assistant\":\n      if (isEditing) {\n        return (\n          components.AssistantEditComposer ??\n          components.EditComposer ??\n          components.AssistantMessage ??\n          (components.Message as ComponentType)\n        );\n      } else {\n        return (\n          components.AssistantMessage ?? (components.Message as ComponentType)\n        );\n      }\n    case \"system\":\n      if (isEditing) {\n        return (\n          components.SystemEditComposer ??\n          components.EditComposer ??\n          components.SystemMessage ??\n          (components.Message as ComponentType) ??\n          DEFAULT_SYSTEM_MESSAGE\n        );\n      } else {\n        return (\n          components.SystemMessage ??\n          (components.Message as ComponentType) ??\n          DEFAULT_SYSTEM_MESSAGE\n        );\n      }\n    default: {\n      const _exhaustiveCheck: never = role;\n      throw new Error(`Unknown message role: ${_exhaustiveCheck}`);\n    }\n  }\n};\n\ntype ThreadMessageComponentProps = {\n  components: MessagesComponentConfig;\n};\n\nconst ThreadMessageComponent: FC<ThreadMessageComponentProps> = ({\n  components,\n}) => {\n  const role = useAuiState((s) => s.message.role);\n  const isEditing = useAuiState((s) => s.message.composer.isEditing);\n  const Component = getComponent(components, role, isEditing);\n\n  return <Component />;\n};\nexport namespace ThreadPrimitiveMessageByIndex {\n  export type Props = {\n    index: number;\n    components: MessagesComponentConfig;\n  };\n}\n\n/**\n * Renders a single message at the specified index in the current thread.\n */\nexport const ThreadPrimitiveMessageByIndex: FC<ThreadPrimitiveMessageByIndex.Props> =\n  memo(\n    ({ index, components }) => {\n      return (\n        <MessageByIndexProvider index={index}>\n          <ThreadMessageComponent components={components} />\n        </MessageByIndexProvider>\n      );\n    },\n    (prev, next) =>\n      prev.index === next.index &&\n      isComponentsSame(prev.components, next.components),\n  );\n\nThreadPrimitiveMessageByIndex.displayName = \"ThreadPrimitive.MessageByIndex\";\n\nexport namespace ThreadPrimitiveUnstable_MessageById {\n  export type Props = {\n    messageId: string;\n    components: MessagesComponentConfig;\n  };\n}\n\n/**\n * Renders the message with the given id in the current thread.\n *\n * Unlike {@link ThreadPrimitiveMessageByIndex}, this keys off the message id,\n * so it stays attached to the same message across reordering and windowing -\n * the shape needed to drive a virtualized or custom message list together with\n * `unstable_useThreadMessageIds`. A missing or removed id renders `null` rather\n * than throwing.\n *\n * @deprecated Unstable / Experimental - may change in any release.\n *\n * @example\n * ```tsx\n * const messageIds = unstable_useThreadMessageIds();\n * return messageIds.map((messageId) => (\n *   <ThreadPrimitive.Unstable_MessageById\n *     key={messageId}\n *     messageId={messageId}\n *     components={MESSAGE_COMPONENTS}\n *   />\n * ));\n * ```\n */\nexport const ThreadPrimitiveUnstable_MessageById: FC<ThreadPrimitiveUnstable_MessageById.Props> =\n  memo(\n    ({ messageId, components }) => {\n      const exists = useAuiState((s) =>\n        hasMessageId(s.thread.messages, messageId),\n      );\n      if (!exists) return null;\n\n      return (\n        <MessageByIdProvider id={messageId}>\n          <ThreadMessageComponent components={components} />\n        </MessageByIdProvider>\n      );\n    },\n    (prev, next) =>\n      prev.messageId === next.messageId &&\n      isComponentsSame(prev.components, next.components),\n  );\n\nThreadPrimitiveUnstable_MessageById.displayName =\n  \"ThreadPrimitive.Unstable_MessageById\";\n\nconst ThreadPrimitiveMessagesInner: FC<{\n  children: (value: { message: MessageState }) => ReactNode;\n}> = ({ children }) => {\n  const messagesLength = useAuiState((s) => s.thread.messages.length);\n\n  return useMemo(() => {\n    if (messagesLength === 0) return null;\n    return Array.from({ length: messagesLength }, (_, index) => (\n      <MessageByIndexProvider key={index} index={index}>\n        <RenderChildrenWithAccessor\n          getItemState={(aui) => aui.thread.message({ index }).getState()}\n        >\n          {(getItem) =>\n            children({\n              get message() {\n                return getItem();\n              },\n            })\n          }\n        </RenderChildrenWithAccessor>\n      </MessageByIndexProvider>\n    ));\n  }, [messagesLength, children]);\n};\n\n/**\n * Renders all messages in the current thread.\n *\n * @example\n * ```tsx\n * <ThreadPrimitive.Messages>\n *   {({ message }) => {\n *     if (message.role === \"user\") return <MyUserMessage />;\n *     return <MyAssistantMessage />;\n *   }}\n * </ThreadPrimitive.Messages>\n * ```\n */\nexport const ThreadPrimitiveMessagesImpl: FC<ThreadPrimitiveMessages.Props> = ({\n  components,\n  children,\n}) => {\n  if (components) {\n    return (\n      <ThreadPrimitiveMessagesInner>\n        {() => <ThreadMessageComponent components={components} />}\n      </ThreadPrimitiveMessagesInner>\n    );\n  }\n  return (\n    <ThreadPrimitiveMessagesInner>{children}</ThreadPrimitiveMessagesInner>\n  );\n};\n\nThreadPrimitiveMessagesImpl.displayName = \"ThreadPrimitive.Messages\";\n\nexport const ThreadPrimitiveMessages = memo(\n  ThreadPrimitiveMessagesImpl,\n  (prev, next) => {\n    if (prev.children || next.children) {\n      return prev.children === next.children;\n    }\n    return isComponentsSame(prev.components!, next.components!);\n  },\n);\n"],"mappings":"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"}

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

@@ -9,17 +9,22 @@ import { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "../../runtim
 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 { BaseSubscribable } from "../../subscribable/subscribable.js";
+import { RuntimeAdapters } from "../../runtimes/remote-thread-list/types.js";
 import "../../store/index.js";
 import { AssistantRuntime } from "../../runtime/api/assistant-runtime.js";
 import "../../index.js";
+import "./RuntimeAdapterProvider.js";
+import { RemoteThreadListHook } from "./RemoteThreadResource.js";
 import { ComponentType, FC, PropsWithChildren } from "react";
+import { AssistantClient } from "@assistant-ui/store";
 //#region src/react/runtimes/RemoteThreadListHookInstanceManager.d.ts
-type RemoteThreadListHook = () => AssistantRuntime;
 declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
-  private useRuntimeHook;
+  private runtimeHook;
+  private readonly adapterStore;
+  private readonly hostStore;
+  private readonly pendingThreadAdapters;
   private instances;
   private nextGeneration;
-  private useAliveThreadsKeysChanged;
   private parent;
   constructor(runtimeHook: RemoteThreadListHook, parent: ThreadListRuntimeCore);
   private _whenRuntimeAttached;
@@ -36,6 +41,7 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     startRun: (config: StartRunConfig) => void;
     resumeRun: (config: ResumeRunConfig) => void;
     cancelRun: () => void;
+    unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
     respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
@@ -89,6 +95,7 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     startRun: (config: StartRunConfig) => void;
     resumeRun: (config: ResumeRunConfig) => void;
     cancelRun: () => void;
+    unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
     respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
@@ -142,6 +149,7 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     startRun: (config: StartRunConfig) => void;
     resumeRun: (config: ResumeRunConfig) => void;
     cancelRun: () => void;
+    unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
     respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
@@ -184,22 +192,26 @@ declare class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   }> | undefined;
   __internal_isThreadRunning(threadId: string): boolean;
   private runningSubscribers;
-  /**
-   * Fires when any thread crosses the running boundary. Separate from the
-   * general subscription so a run does not push the thread list through the
-   * channel that resolves pending runtime attachments.
-   */
   __internal_subscribeRunningChanged(callback: () => void): Unsubscribe;
+  private _publish;
   private _publishThreadRuntime;
   private _trackRunning;
   private _setRunning;
   stopThreadRuntime(threadId: string): void;
   setRuntimeHook(newRuntimeHook: RemoteThreadListHook): void;
-  private _RuntimeBinder;
-  private _OuterActiveThreadProvider;
+  __internal_setDefaultAdapters(adapters: RuntimeAdapters | null): void;
+  __internal_setThreadAdapters(threadId: string, adapters: RuntimeAdapters | null): void;
+  __internal_dispose(): void;
+  private _syncHostThreads;
+  __internal_useHost(parentClient: AssistantClient): AssistantRuntime[];
   __internal_RenderThreadRuntimes: FC<{
     provider: ComponentType<PropsWithChildren>;
   }>;
+  __internal_Host: FC<{
+    parentClient: AssistantClient;
+  }>;
+  private _OuterActiveThreadProvider;
+  private _AdapterSink;
 }
 //#endregion
 export { RemoteThreadListHookInstanceManager };

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

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListHookInstanceManager.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"mappings":";;;;;;;;;;;;;;;;KA4BK,6BAA6B;cAqBrB,4CAA4C;UAC/C;UAGA;UAGA;UACA;UACA;EAGN,YAAA,aAAa,sBACb,QAAQ;UAOF;EAsBD,mBAAmB,mBAAgB,QAAA;;;eA7BhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCH,gCAAgC,mBAAgB,QAAA;;;eAZb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBnC,qBAAqB,mBAAgB;;;eAXW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBhD,2BAA2B;UAI1B;;;;;;EAOD,mCAAmC,uBAAuB;UAKzD;UA0BA;UAgBA;EASD,kBAAkB;EAOlB,eAAe,gBAAgB;UAS9B;UAgEA;EAsCD,iCAAiC;IACtC,UAAU,cAAc"}
+{"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;UAmBA;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"}

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.js

@@ -1,11 +1,14 @@
 import { BaseSubscribable } 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 { useRuntimeAdapters } from "./useRuntimeAdapters.js";
 import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider.js";
+import { RemoteThreadResource } from "./RemoteThreadResource.js";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-import { Fragment, memo, useCallback, useEffect, useEffectEvent, useLayoutEffect, useMemo, useRef } from "@assistant-ui/tap/react-shim";
-import { useAui } from "@assistant-ui/store";
-import { Fragment as Fragment$1, jsx } from "react/jsx-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 ProviderRenderDetector = (t0) => {
@@ -29,15 +32,23 @@ const ProviderRenderDetector = (t0) => {
 	return null;
 };
 var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
-	useRuntimeHook;
+	runtimeHook;
+	adapterStore = create(() => ({
+		defaultAdapters: null,
+		threadAdapters: /* @__PURE__ */ new Map()
+	}));
+	hostStore = create(() => ({
+		threads: [],
+		hookEpoch: 0
+	}));
+	pendingThreadAdapters = /* @__PURE__ */ new Map();
 	instances = /* @__PURE__ */ new Map();
 	nextGeneration = 0;
-	useAliveThreadsKeysChanged = create(() => ({}));
 	parent;
 	constructor(runtimeHook, parent) {
 		super();
 		this.parent = parent;
-		this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));
+		this.runtimeHook = runtimeHook;
 	}
 	_whenRuntimeAttached(threadId) {
 		return new Promise((resolve, reject) => {
@@ -58,19 +69,21 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 	}
 	startThreadRuntime(threadId) {
 		if (!this.instances.has(threadId)) {
+			const generation = this.nextGeneration++;
 			this.instances.set(threadId, {
-				generation: this.nextGeneration++,
+				generation,
 				isRunning: false
 			});
-			this.useAliveThreadsKeysChanged.setState({}, true);
+			this._syncHostThreads();
 		}
 		return this._whenRuntimeAttached(threadId);
 	}
 	__internal_restartThreadRuntime(threadId) {
 		const instance = this.instances.get(threadId);
 		if (!instance) return this.startThreadRuntime(threadId);
+		if (instance.runtime) invalidateThreadRuntime(instance.runtime);
 		instance.generation = this.nextGeneration++;
-		this.useAliveThreadsKeysChanged.setState({}, true);
+		this._syncHostThreads();
 		this._notifySubscribers();
 		return this._whenRuntimeAttached(threadId);
 	}
@@ -83,18 +96,16 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		return this.instances.get(threadId)?.isRunning ?? false;
 	}
 	runningSubscribers = /* @__PURE__ */ new Set();
-	/**
-	* Fires when any thread crosses the running boundary. Separate from the
-	* general subscription so a run does not push the thread list through the
-	* channel that resolves pending runtime attachments.
-	*/
 	__internal_subscribeRunningChanged(callback) {
 		this.runningSubscribers.add(callback);
 		return () => this.runningSubscribers.delete(callback);
 	}
+	_publish = (threadId, runtime, generation) => {
+		this._publishThreadRuntime(threadId, runtime, generation);
+	};
 	_publishThreadRuntime(threadId, runtime, generation) {
 		const instance = this.instances.get(threadId);
-		if (!instance) throw new Error(`Thread "${threadId}" runtime binding not found. This is a bug in assistant-ui.`);
+		if (!instance) return;
 		if (instance.generation !== generation) return;
 		const previousRuntime = instance.runtime;
 		instance.runtime = runtime;
@@ -121,83 +132,110 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 		for (const callback of this.runningSubscribers) callback();
 	}
 	stopThreadRuntime(threadId) {
-		this.instances.get(threadId)?.unsubscribeRunning?.();
+		const instance = this.instances.get(threadId);
+		if (instance?.runtime) invalidateThreadRuntime(instance.runtime);
+		instance?.unsubscribeRunning?.();
 		this.instances.delete(threadId);
-		this.useAliveThreadsKeysChanged.setState({}, true);
+		this.pendingThreadAdapters.delete(threadId);
+		this._syncHostThreads();
 		this._notifySubscribers();
 	}
 	setRuntimeHook(newRuntimeHook) {
-		if (this.useRuntimeHook.getState().useRuntime !== newRuntimeHook) this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);
-	}
-	_RuntimeBinder = ({ threadId, generation, children }) => {
-		const { useRuntime } = this.useRuntimeHook();
-		const runtime = useRuntime();
-		const threadBinding = runtime.thread.__internal_threadBinding;
-		const updateRuntime = useCallback(() => {
-			this._publishThreadRuntime(threadId, threadBinding.getState(), generation);
-		}, [
+		if (this.runtimeHook === newRuntimeHook) return;
+		this.runtimeHook = newRuntimeHook;
+		this.hostStore.setState((state) => ({
+			...state,
+			hookEpoch: state.hookEpoch + 1
+		}), true);
+	}
+	__internal_setDefaultAdapters(adapters) {
+		const current = this.adapterStore.getState();
+		if (current.defaultAdapters === adapters) return;
+		this.adapterStore.setState({
+			...current,
+			defaultAdapters: adapters
+		}, true);
+	}
+	__internal_setThreadAdapters(threadId, adapters) {
+		const current = this.adapterStore.getState();
+		const next = new Map(current.threadAdapters);
+		if (adapters === null) next.delete(threadId);
+		else next.set(threadId, adapters);
+		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,
+			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 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;
+			return withKey(`${id}:${generation}:${hookEpoch}`, RemoteThreadResource({
+				threadId: id,
+				generation,
+				parentList: this.parent,
+				runtimeHook,
+				parentClient,
+				adapters: threadAdapters,
+				publish: this._publish
+			}));
+		}));
+	}
+	__internal_RenderThreadRuntimes = ({ provider }) => {
+		this.hostStore();
+		return Array.from(this.instances.entries()).map(([threadId, { generation }]) => /* @__PURE__ */ jsx(this._OuterActiveThreadProvider, {
 			threadId,
-			generation,
-			threadBinding
-		]);
-		const isMounted = useRef(false);
-		if (!isMounted.current) updateRuntime();
-		useEffect(() => {
-			isMounted.current = true;
-			updateRuntime();
-			return threadBinding.outerSubscribe(updateRuntime);
-		}, [threadBinding, updateRuntime]);
-		const aui = useAui();
-		const initPromiseRef = useRef(void 0);
-		const hasInitializedRef = useRef(false);
-		useEffect(() => {
-			const runtimeCore = threadBinding.getState();
-			const setGetInitializePromise = runtimeCore.__internal_setGetInitializePromise;
-			if (typeof setGetInitializePromise === "function") setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);
-		}, [threadBinding]);
-		const handleInitialize = useEffectEvent(() => {
-			if (hasInitializedRef.current) return;
-			if (aui.threadListItem.getState().status !== "new") return;
-			hasInitializedRef.current = true;
-			initPromiseRef.current = aui.threadListItem.initialize();
-			const dispose = runtime.thread.unstable_on("runEnd", () => {
-				dispose();
-				aui.threadListItem.generateTitle();
-			});
-		});
-		useEffect(() => {
-			hasInitializedRef.current = false;
-			return runtime.threads.main.unstable_on("initialize", handleInitialize);
-		}, [runtime]);
-		return /* @__PURE__ */ jsx(Fragment$1, { children });
+			provider
+		}, `${threadId}:${generation}`));
+	};
+	__internal_Host = ({ parentClient }) => {
+		this.__internal_useHost(parentClient);
+		return null;
 	};
-	_OuterActiveThreadProvider = memo(({ threadId, generation, provider: Provider }) => {
+	_OuterActiveThreadProvider = memo(({ threadId, provider: Provider }) => {
 		const runtime = useMemo(() => new ThreadListRuntimeImpl(this.parent).getItemById(threadId), [threadId]);
 		const detectorRef = useRef(false);
 		useEffect(() => {
 			if (process.env.NODE_ENV !== "production" && Provider !== Fragment) {
 				const id = setTimeout(() => {
-					if (!detectorRef.current) console.warn("RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. Render `children` on first commit; deferring them behind a loading state, Suspense boundary, or `useEffect` gate strands the runtime binder and leaves the thread without context.");
+					if (!detectorRef.current) console.warn("RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. Render `children` on first commit; deferring them behind a loading state, Suspense boundary, or `useEffect` gate strands the runtime host and leaves the thread without context.");
 				}, 100);
 				return () => clearTimeout(id);
 			}
 		}, [Provider]);
 		return /* @__PURE__ */ jsx(ThreadListItemRuntimeProvider, {
 			runtime,
-			children: /* @__PURE__ */ jsx(Provider, { children: /* @__PURE__ */ jsx(this._RuntimeBinder, {
+			children: /* @__PURE__ */ jsx(Provider, { children: /* @__PURE__ */ jsx(this._AdapterSink, {
 				threadId,
-				generation,
-				children: /* @__PURE__ */ jsx(ProviderRenderDetector, { detectorRef })
+				detectorRef
 			}) })
 		});
 	});
-	__internal_RenderThreadRuntimes = ({ provider }) => {
-		this.useAliveThreadsKeysChanged();
-		return Array.from(this.instances.entries()).map(([threadId, { generation }]) => /* @__PURE__ */ jsx(this._OuterActiveThreadProvider, {
-			threadId,
-			generation,
-			provider
-		}, `${threadId}:${generation}`));
+	_AdapterSink = ({ threadId, detectorRef }) => {
+		const adapters = useRuntimeAdapters();
+		this.pendingThreadAdapters.set(threadId, adapters);
+		useLayoutEffect(() => {
+			this.__internal_setThreadAdapters(threadId, adapters);
+			return () => {
+				if (this.pendingThreadAdapters.get(threadId) === adapters) this.pendingThreadAdapters.delete(threadId);
+				this.__internal_setThreadAdapters(threadId, null);
+			};
+		}, [threadId, adapters]);
+		return /* @__PURE__ */ jsx(ProviderRenderDetector, { detectorRef });
 	};
 };
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListHookInstanceManager.js","names":["FC","RefObject","useCallback","useRef","useEffect","useEffectEvent","useLayoutEffect","memo","PropsWithChildren","ComponentType","useMemo","Fragment","UseBoundStore","StoreApi","create","useAui","ThreadListItemRuntimeProvider","ThreadRuntimeCore","ThreadListRuntimeCore","AssistantRuntime","Unsubscribe","BaseSubscribable","getThreadRuntimeCoreIsRunning","ThreadRuntimeImpl","ThreadListRuntimeImpl","RemoteThreadListHook","RemoteThreadListHookInstance","runtime","publishedGeneration","generation","isRunning","unsubscribeRunning","ProviderRenderDetector","detectorRef","t0","$","_c","t1","t2","current","RemoteThreadListHookInstanceManager","useRuntimeHook","useRuntime","instances","Map","nextGeneration","useAliveThreadsKeysChanged","parent","constructor","runtimeHook","_whenRuntimeAttached","threadId","Promise","resolve","reject","callback","instance","get","dispose","Error","subscribe","startThreadRuntime","has","set","setState","__internal_restartThreadRuntime","_notifySubscribers","getThreadRuntimeCore","undefined","__internal_isThreadRunning","runningSubscribers","Set","__internal_subscribeRunningChanged","add","delete","_publishThreadRuntime","previousRuntime","_trackRunning","_setRunning","stopThreadRuntime","setRuntimeHook","newRuntimeHook","prevRuntimeHook","getState","_RuntimeBinder","children","threadBinding","thread","__internal_threadBinding","updateRuntime","isMounted","outerSubscribe","aui","initPromiseRef","hasInitializedRef","runtimeCore","setGetInitializePromise","Record","__internal_setGetInitializePromise","call","handleInitialize","state","threadListItem","status","initialize","unstable_on","generateTitle","threads","main","_OuterActiveThreadProvider","provider","Provider","getItemById","process","env","NODE_ENV","id","setTimeout","console","warn","clearTimeout","__internal_RenderThreadRuntimes","Array","from","entries","map"],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"sourcesContent":["import {\n  type FC,\n  type RefObject,\n  useCallback,\n  useRef,\n  useEffect,\n  useEffectEvent,\n  useLayoutEffect,\n  memo,\n  type PropsWithChildren,\n  type ComponentType,\n  useMemo,\n  Fragment,\n} from \"react\";\nimport { type UseBoundStore, type StoreApi, create } from \"zustand\";\nimport { useAui } 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 { AssistantRuntime } from \"../../runtime/api/assistant-runtime\";\nimport type { Unsubscribe } from \"../../types/unsubscribe\";\nimport { BaseSubscribable } from \"../../subscribable/subscribable\";\nimport {\n  getThreadRuntimeCoreIsRunning,\n  type ThreadRuntimeImpl,\n} from \"../../runtime/api/thread-runtime\";\nimport { ThreadListRuntimeImpl } from \"../../runtime/api/thread-list-runtime\";\n\ntype RemoteThreadListHook = () => AssistantRuntime;\n\ntype RemoteThreadListHookInstance = {\n  runtime?: ThreadRuntimeCore | undefined;\n  // A runtime riding across a restart stays readable, but only counts as\n  // attached once a binder of the current generation re-publishes it.\n  publishedGeneration?: number | undefined;\n  // Part of the binder's React key, so only a bump remounts the hook.\n  generation: number;\n  isRunning: boolean;\n  unsubscribeRunning?: Unsubscribe | undefined;\n};\n\nconst ProviderRenderDetector: FC<{\n  detectorRef: RefObject<boolean>;\n}> = ({ detectorRef }) => {\n  useLayoutEffect(() => {\n    detectorRef.current = true;\n  }, [detectorRef]);\n  return null;\n};\nexport class RemoteThreadListHookInstanceManager extends BaseSubscribable {\n  private useRuntimeHook: UseBoundStore<\n    StoreApi<{ useRuntime: RemoteThreadListHook }>\n  >;\n  private instances = new Map<string, RemoteThreadListHookInstance>();\n  // Manager-wide so it survives instance deletion: a stop and start within one\n  // React commit must not reuse a binder key.\n  private nextGeneration = 0;\n  private useAliveThreadsKeysChanged = create(() => ({}));\n  private parent: ThreadListRuntimeCore;\n\n  constructor(\n    runtimeHook: RemoteThreadListHook,\n    parent: ThreadListRuntimeCore,\n  ) {\n    super();\n    this.parent = parent;\n    this.useRuntimeHook = create(() => ({ useRuntime: 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; // not yet published by the current generation's binder\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      this.instances.set(threadId, {\n        generation: this.nextGeneration++,\n        isRunning: false,\n      });\n      this.useAliveThreadsKeysChanged.setState({}, true);\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    instance.generation = this.nextGeneration++;\n    this.useAliveThreadsKeysChanged.setState({}, true);\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  /**\n   * Fires when any thread crosses the running boundary. Separate from the\n   * general subscription so a run does not push the thread list through the\n   * channel that resolves pending runtime attachments.\n   */\n  public __internal_subscribeRunningChanged(callback: () => void): Unsubscribe {\n    this.runningSubscribers.add(callback);\n    return () => this.runningSubscribers.delete(callback);\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)\n      throw new Error(\n        `Thread \"${threadId}\" runtime binding not found. This is a bug in assistant-ui.`,\n      );\n\n    // An outgoing binder outlives its generation until React commits the key\n    // change, and must not publish over the incoming one.\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  }\n\n  // Run state changes far more often than the thread list does, so the list is\n  // only notified when a thread crosses the running boundary.\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    this.instances.get(threadId)?.unsubscribeRunning?.();\n    this.instances.delete(threadId);\n    this.useAliveThreadsKeysChanged.setState({}, true);\n    this._notifySubscribers();\n  }\n\n  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {\n    const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;\n    if (prevRuntimeHook !== newRuntimeHook) {\n      this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);\n    }\n  }\n\n  // Rendered as a child of the user's Provider so the runtime hook can\n  // read context the Provider injects (e.g. RuntimeAdapterProvider).\n  private _RuntimeBinder: FC<\n    PropsWithChildren<{ threadId: string; generation: number }>\n  > = ({ threadId, generation, children }) => {\n    const { useRuntime } = this.useRuntimeHook();\n    const runtime = useRuntime();\n\n    const threadBinding = (runtime.thread as ThreadRuntimeImpl)\n      .__internal_threadBinding;\n\n    const updateRuntime = useCallback(() => {\n      this._publishThreadRuntime(\n        threadId,\n        threadBinding.getState(),\n        generation,\n      );\n    }, [threadId, generation, threadBinding]);\n\n    const isMounted = useRef(false);\n    if (!isMounted.current) {\n      updateRuntime();\n    }\n\n    useEffect(() => {\n      isMounted.current = true;\n      updateRuntime();\n      return threadBinding.outerSubscribe(updateRuntime);\n    }, [threadBinding, updateRuntime]);\n\n    const aui = useAui();\n    const initPromiseRef = useRef<Promise<unknown> | undefined>(undefined);\n    const hasInitializedRef = useRef(false);\n\n    useEffect(() => {\n      const runtimeCore = threadBinding.getState();\n      const setGetInitializePromise = (runtimeCore as Record<string, unknown>)\n        .__internal_setGetInitializePromise;\n      if (typeof setGetInitializePromise === \"function\") {\n        setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);\n      }\n    }, [threadBinding]);\n\n    const handleInitialize = useEffectEvent(() => {\n      if (hasInitializedRef.current) return;\n\n      const state = aui.threadListItem.getState();\n      if (state.status !== \"new\") return;\n      hasInitializedRef.current = true;\n\n      initPromiseRef.current = aui.threadListItem.initialize();\n\n      const dispose = runtime.thread.unstable_on(\"runEnd\", () => {\n        dispose();\n        aui.threadListItem.generateTitle();\n      });\n    });\n\n    useEffect(() => {\n      hasInitializedRef.current = false;\n      return runtime.threads.main.unstable_on(\"initialize\", handleInitialize);\n    }, [runtime]);\n\n    return <>{children}</>;\n  };\n\n  private _OuterActiveThreadProvider: FC<{\n    threadId: string;\n    generation: number;\n    provider: ComponentType<PropsWithChildren>;\n  }> = memo(({ threadId, generation, 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 binder 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._RuntimeBinder threadId={threadId} generation={generation}>\n            <ProviderRenderDetector detectorRef={detectorRef} />\n          </this._RuntimeBinder>\n        </Provider>\n      </ThreadListItemRuntimeProvider>\n    );\n  });\n\n  public __internal_RenderThreadRuntimes: FC<{\n    provider: ComponentType<PropsWithChildren>;\n  }> = ({ provider }) => {\n    this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change\n\n    return Array.from(this.instances.entries()).map(\n      ([threadId, { generation }]) => (\n        <this._OuterActiveThreadProvider\n          key={`${threadId}:${generation}`}\n          threadId={threadId}\n          generation={generation}\n          provider={provider}\n        />\n      ),\n    );\n  };\n}\n"],"mappings":"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"}
+{"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","_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  }\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":";;;;;;;;;;;;;AAkDA,MAAMwC,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;CAFhBxC,gBAAgB0C,IAEbC,EAAa;CAAC,OACV;AAAI;AAGb,IAAaE,sCAAb,cAAyD9B,iBAAiB;CACxE;CACA,eAAgCR,cAA+B;EAC7DuB,iBAAiB;EACjBC,gCAAgB,IAAIiB,IAAI;CAC1B,EAAE;CACF,YAA6BzC,cAA4B;EACvD2B,SAAS,CAAA;EACTE,WAAW;CACb,EAAE;CACF,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,SAASN,wBAAwB2C,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,YACEJ,UACAhC,SACAE,eACG;EACH,KAAKuD,sBAAsBzB,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,MAAMwD,kBAAkBrB,SAASrC;EACjCqC,SAASrC,UAAUA;EACnBqC,SAASpC,sBAAsBC;EAC/B,IAAIwD,oBAAoB1D,SACtB,KAAK2D,cAActB,QAAQ;EAE7B,KAAKU,mBAAmB;CAC1B;CAEA,cAAsBV,UAAwC;EAC5DA,SAASjC,qBAAqB;EAE9B,MAAMJ,UAAUqC,SAASrC;EACzB,IAAI,CAACA,SAAS;GACZqC,SAASjC,qBAAqB6C,KAAAA;GAC9B,KAAKW,YAAYvB,UAAU,KAAK;GAChC;EACF;EAEA,KAAKuB,YAAYvB,UAAU7C,8BAA8BQ,OAAO,CAAC;EACjEqC,SAASjC,qBAAqBJ,QAAQyC,gBAAgB;GACpD,KAAKmB,YAAYvB,UAAU7C,8BAA8BQ,OAAO,CAAC;EACnE,CAAC;CACH;CAEA,YACEqC,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,SAASN,wBAAwB2C,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,eAAsBgB,gBAAsC;EAC1D,IAAI,KAAKzC,gBAAgByC,gBAAgB;EACzC,KAAKzC,cAAcyC;EACnB,KAAKtC,UAAUuC,UACZC,WAAW;GAAE,GAAGA;GAAOrD,WAAWqD,MAAMrD,YAAY;EAAE,IACvD,IACF;CACF;CAEA,8BAAqCuD,UAAkC;EACrE,MAAM/C,UAAU,KAAKG,aAAa6C,SAAS;EAC3C,IAAIhD,QAAQd,oBAAoB6D,UAAU;EAC1C,KAAK5C,aAAayC,SAAS;GAAE,GAAG5C;GAASd,iBAAiB6D;EAAS,GAAG,IAAI;CAC5E;CAEA,6BACEnC,UACAmC,UACA;EACA,MAAM/C,UAAU,KAAKG,aAAa6C,SAAS;EAC3C,MAAME,OAAO,IAAI9C,IAAIJ,QAAQb,cAAc;EAC3C,IAAI4D,aAAa,MAAMG,KAAKf,OAAOvB,QAAQ;OACtCsC,KAAK1B,IAAIZ,UAAUmC,QAAQ;EAChC,KAAK5C,aAAayC,SAAS;GAAE,GAAG5C;GAASb,gBAAgB+D;EAAK,GAAG,IAAI;CACvE;CAEA,qBAA4B;EAC1B,KAAK,MAAMtC,YAAY,CAAC,GAAG,KAAKL,UAAU6C,KAAK,CAAC,GAC9C,KAAKX,kBAAkB7B,QAAQ;CAEnC;CAEA,mBAA2B;EACzB,KAAKP,UAAUuC,UACZC,WAAW;GACV,GAAGA;GACHvD,SAAS+D,MAAMC,KAAK,KAAK/C,UAAUgD,QAAQ,CAAC,CAAC,CAACC,KAC3C,CAACjE,IAAI,EAAET,mBAAmB;IAAES;IAAIT;GAAW,EAC9C;EACF,IACA,IACF;CACF;CAEA,mBAA0B4E,cAA+B;EACvD,MAAM,EAAEpE,SAASE,cAAc,KAAKa,UAAU;EAC9C,MAAM0C,WAAW,KAAK5C,aAAa;EACnC,MAAMD,cAAc,KAAKA;EACzB,OAAOtC,aACL0B,QAAQkE,KAAK,EAAEjE,IAAIT,iBAAiB;GAClC,MAAMK,iBAAiB,KAAKmB,sBAAsBiB,IAAIhC,EAAE,IACpD,KAAKe,sBAAsBY,IAAI3B,EAAE,IAChCwD,SAAS5D,eAAe+B,IAAI3B,EAAE,KAAKwD,SAAS7D;GACjD,OAAOrB,QACL,GAAG0B,GAAE,GAAIT,WAAU,GAAIU,aACvBf,qBAAqB;IACnBmC,UAAUrB;IACVT;IACA6E,YAAY,KAAKlD;IACjBP;IACAwD;IACAX,UAAU5D;IACVyE,SAAS,KAAKxB;GAChB,CAAC,CACH;EACF,CAAC,CACH;CACF;CAEA,mCAEM,EAAE0B,eAAe;EACrB,KAAKzD,UAAU;EAEf,OAAOgD,MAAMC,KAAK,KAAK/C,UAAUgD,QAAQ,CAAC,CAAC,CAACC,KACzC,CAAC5C,UAAU,EAAE9B,kBACZ,oBAAC,KAAK,4BAAN;GAEY8B;GACAkD;EAAS,GAFd,GAAGlD,SAAQ,GAAI9B,YAED,CAGzB;CACF;CAEA,mBAAiE,EAC/D4E,mBACI;EACJ,KAAKD,mBAAmBC,YAAY;EACpC,OAAO;CACT;CAEA,6BAGKnG,MAAM,EAAEqD,UAAUkD,UAAUG,eAAe;EAC9C,MAAMrF,UAAUvB,cACR,IAAIgB,sBAAsB,KAAKoC,MAAM,CAAC,CAACyD,YAAYtD,QAAQ,GACjE,CAACA,QAAQ,CACX;EAEA,MAAMlB,cAAcpC,OAAO,KAAK;EAChCH,gBAAgB;GACd,IAAIgH,QAAQC,IAAIC,aAAa,gBAAgBJ,aAAavG,UAAU;IAClE,MAAM6B,KAAK+E,iBAAiB;KAC1B,IAAI,CAAC5E,YAAYM,SACfuE,QAAQC,KACN,yQAGF;IAEJ,GAAG,GAAG;IACN,aAAaC,aAAalF,EAAE;GAC9B;EAEF,GAAG,CAAC0E,QAAQ,CAAC;EAEb,OACE,oBAAC,+BAAD;GAAwCrF;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,MAAMqD,WAAWxE,mBAAmB;EACpC,KAAK+B,sBAAsBkB,IAAIZ,UAAUmC,QAAQ;EACjD3F,sBAAsB;GACpB,KAAK6F,6BAA6BrC,UAAUmC,QAAQ;GACpD,aAAa;IACX,IAAI,KAAKzC,sBAAsBY,IAAIN,QAAQ,MAAMmC,UAC/C,KAAKzC,sBAAsB6B,OAAOvB,QAAQ;IAE5C,KAAKqC,6BAA6BrC,UAAU,IAAI;GAClD;EACF,GAAG,CAACA,UAAUmC,QAAQ,CAAC;EACvB,OAAO,oBAAC,wBAAD,EAAqCrD,YAAY,CAAA;CAC1D;AACF"}

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

@@ -9,8 +9,8 @@ import { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "../../runtim
 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 { BaseSubscribable } from "../../subscribable/subscribable.js";
-import "../../store/index.js";
 import { RemoteThreadListOptions } from "../../runtimes/remote-thread-list/types.js";
+import "../../store/index.js";
 import { RemoteThreadData, THREAD_MAPPING_ID } from "../../runtimes/remote-thread-list/remote-thread-state.js";
 import "../../internal.js";
 import "../../index.js";
@@ -19,6 +19,7 @@ import { FC } from "react";
 declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable implements ThreadListRuntimeCore {
   private _options;
   private readonly _hookManager;
+  private readonly _runtimeAdapters;
   private _loadThreadsPromise;
   private _loadMorePromise;
   private _loadGeneration;
@@ -26,10 +27,12 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
   private _switchTask;
   private _mainThreadId;
   private readonly _state;
+  private readonly _useAdaptersProvider;
+  private readonly _SynthesizedAdapters;
+  private resolveProvider;
   get threadItems(): Readonly<Record<THREAD_MAPPING_ID, RemoteThreadData>>;
   getLoadThreadsPromise(): Promise<void>;
   loadMore(): Promise<void>;
-  private readonly contextProvider;
   constructor(options: RemoteThreadListOptions, contextProvider: ModelContextProvider);
   private _initialThreadLoaded;
   private useProvider;
@@ -60,6 +63,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
     startRun: (config: StartRunConfig) => void;
     resumeRun: (config: ResumeRunConfig) => void;
     cancelRun: () => void;
+    unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
     respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
@@ -113,6 +117,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
     startRun: (config: StartRunConfig) => void;
     resumeRun: (config: ResumeRunConfig) => void;
     cancelRun: () => void;
+    unstable_notifySessionReset: () => void;
     addToolResult: (options: AddToolResultOptions) => void;
     resumeToolCall: (options: ResumeToolCallOptions) => void;
     respondToToolApproval: (options: RespondToToolApprovalOptions) => void;
@@ -175,6 +180,7 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
   archive(threadIdOrRemoteId: string): Promise<void>;
   unarchive(threadIdOrRemoteId: string): Promise<void>;
   delete(threadIdOrRemoteId: string): Promise<void>;
+  __internal_dispose(): void;
   detach(threadIdOrRemoteId: string): Promise<void>;
   private useBoundIds;
   __internal_RenderComponent: FC;

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

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"mappings":";;;;;;;;;;;;;;;;;;cAmDa,8CACH,4BACG;UAEH;mBACS;UAET;UACA;UACA;UACA;UACA;UAEA;mBACS;MAWN,eAAW,SAAA,OAzBX,mBAyBW;EAIf,yBAAqB;EAsDrB,YAAY;mBAmDF;EAGf,YAAA,SAAS,yBACT,iBAAiB;UAuBX;UACA;EAED,sBAAsB,SAAS;EAkC/B;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;EA0GP,qBAAqB;UAIpB;UAMA;UAOM;EA6CP,aAAoB,qBAAgB;;;;EAwDpC,gBAAuB,qBAAgB;EAmCvC,OAAO,4BAA4B,mBAAmB;EA6BtD,aACL,4BACA,QAAQ,sCACP;UAiDW;EAsBD,QAAQ,6BAA0B;EAmBxC,UAAU,6BAA6B;EAsBjC,OAAO,6BAA0B;EAoBjC,OAAO,6BAA6B;UAUzC;EAED,4BAA4B"}
+{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"mappings":";;;;;;;;;;;;;;;;;;cAiDa,8CACH,4BACG;UAEH;mBACS;mBACA;UAET;UACA;UACA;UACA;UACA;UAEA;mBACS;mBAWA;mBAYA;UAcT;MAUG,eAAW,SAAA,OA9DX,mBA8DW;EAIf,yBAAqB;EAsDrB,YAAY;EAoDjB,YAAA,SAAS,yBACT,iBAAiB;UAwBX;UACA;EAED,sBAAsB,SAAS;EAkC/B;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;EA0GP,qBAAqB;UAIpB;UAMA;UAOM;EA6CP,aAAoB,qBAAgB;;;;EAwDpC,gBAAuB,qBAAgB;EAsCvC,OAAO,4BAA4B,mBAAmB;EA6BtD,aACL,4BACA,QAAQ,sCACP;UAiDW;EAsBD,QAAQ,6BAA0B;EAmBxC,UAAU,6BAA6B;EAsBjC,OAAO,6BAA0B;EAoBvC;EAIM,OAAO,6BAA6B;UAUzC;EAED,4BAA4B"}