@assistant-ui/core 0.1.3 → 0.1.7

package/src/react/primitives/thread/ThreadSuggestions.tsx

@@ -1,21 +1,35 @@
-import { type ComponentType, type FC, memo, useMemo } from "react";
-import { useAuiState } from "@assistant-ui/store";
+import {
+  type ComponentType,
+  type FC,
+  type ReactNode,
+  memo,
+  useMemo,
+} from "react";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
+import type { SuggestionState } from "../../../store/scopes/suggestion";
 import { SuggestionByIndexProvider } from "../../providers/SuggestionByIndexProvider";
 
+type SuggestionsComponentConfig = {
+  /** Component used to render each suggestion */
+  Suggestion: ComponentType;
+};
+
 export namespace ThreadPrimitiveSuggestions {
-  export type Props = {
-    /**
-     * Component to render for each suggestion.
-     */
-    components: {
-      /** Component used to render each suggestion */
-      Suggestion: ComponentType;
-    };
-  };
+  export type Props =
+    | {
+        /** @deprecated Use the children render function instead. */
+        components: SuggestionsComponentConfig;
+        children?: never;
+      }
+    | {
+        /** Render function called for each suggestion. Receives the suggestion. */
+        children: (value: { suggestion: SuggestionState }) => ReactNode;
+        components?: never;
+      };
 }
 
 type SuggestionComponentProps = {
-  components: ThreadPrimitiveSuggestions.Props["components"];
+  components: SuggestionsComponentConfig;
 };
 
 const SuggestionComponent: FC<SuggestionComponentProps> = ({ components }) => {
@@ -26,7 +40,7 @@ const SuggestionComponent: FC<SuggestionComponentProps> = ({ components }) => {
 export namespace ThreadPrimitiveSuggestionByIndex {
   export type Props = {
     index: number;
-    components: ThreadPrimitiveSuggestions.Props["components"];
+    components: SuggestionsComponentConfig;
   };
 }
 
@@ -50,33 +64,63 @@ export const ThreadPrimitiveSuggestionByIndex: FC<ThreadPrimitiveSuggestionByInd
 ThreadPrimitiveSuggestionByIndex.displayName =
   "ThreadPrimitive.SuggestionByIndex";
 
-/**
- * Renders all suggestions using the provided component configuration.
- */
-export const ThreadPrimitiveSuggestionsImpl: FC<
-  ThreadPrimitiveSuggestions.Props
-> = ({ components }) => {
+const ThreadPrimitiveSuggestionsInner: FC<{
+  children: (value: { suggestion: SuggestionState }) => ReactNode;
+}> = ({ children }) => {
   const suggestionsLength = useAuiState(
     (s) => s.suggestions.suggestions.length,
   );
 
-  const suggestionElements = useMemo(() => {
+  return useMemo(() => {
     if (suggestionsLength === 0) return null;
     return Array.from({ length: suggestionsLength }, (_, index) => (
-      <ThreadPrimitiveSuggestionByIndex
-        key={index}
-        index={index}
-        components={components}
-      />
+      <SuggestionByIndexProvider key={index} index={index}>
+        <RenderChildrenWithAccessor
+          getItemState={(aui) =>
+            aui.suggestions().suggestion({ index }).getState()
+          }
+        >
+          {(getItem) =>
+            children({
+              get suggestion() {
+                return getItem();
+              },
+            })
+          }
+        </RenderChildrenWithAccessor>
+      </SuggestionByIndexProvider>
     ));
-  }, [suggestionsLength, components]);
+  }, [suggestionsLength, children]);
+};
 
-  return suggestionElements;
+/**
+ * Renders all suggestions.
+ */
+export const ThreadPrimitiveSuggestionsImpl: FC<
+  ThreadPrimitiveSuggestions.Props
+> = ({ components, children }) => {
+  if (components) {
+    return (
+      <ThreadPrimitiveSuggestionsInner>
+        {() => <SuggestionComponent components={components} />}
+      </ThreadPrimitiveSuggestionsInner>
+    );
+  }
+  return (
+    <ThreadPrimitiveSuggestionsInner>
+      {children}
+    </ThreadPrimitiveSuggestionsInner>
+  );
 };
 
 ThreadPrimitiveSuggestionsImpl.displayName = "ThreadPrimitive.Suggestions";
 
 export const ThreadPrimitiveSuggestions = memo(
   ThreadPrimitiveSuggestionsImpl,
-  (prev, next) => prev.components.Suggestion === next.components.Suggestion,
+  (prev, next) => {
+    if (prev.children || next.children) {
+      return prev.children === next.children;
+    }
+    return prev.components!.Suggestion === next.components!.Suggestion;
+  },
 );

package/src/react/primitives/threadList/ThreadListItems.tsx

@@ -1,21 +1,34 @@
-import { ComponentType, FC, memo, useMemo } from "react";
-import { useAuiState } from "@assistant-ui/store";
-import { ThreadListItemByIndexProvider } from "../../providers";
+import { ComponentType, FC, ReactNode, memo, useMemo } from "react";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
+import type { ThreadListItemState } from "../../../store/scopes/thread-list-item";
+import { ThreadListItemByIndexProvider } from "../../providers/ThreadListItemByIndexProvider";
+
+type ThreadListItemsComponentConfig = {
+  ThreadListItem: ComponentType;
+};
 
 export namespace ThreadListPrimitiveItems {
   export type Props = {
     archived?: boolean | undefined;
-    components: {
-      ThreadListItem: ComponentType;
-    };
-  };
+  } & (
+    | {
+        /** @deprecated Use the children render function instead. */
+        components: ThreadListItemsComponentConfig;
+        children?: never;
+      }
+    | {
+        /** Render function called for each thread list item. Receives the item. */
+        children: (value: { threadListItem: ThreadListItemState }) => ReactNode;
+        components?: never;
+      }
+  );
 }
 
 export namespace ThreadListPrimitiveItemByIndex {
   export type Props = {
     index: number;
     archived?: boolean | undefined;
-    components: ThreadListPrimitiveItems.Props["components"];
+    components: ThreadListItemsComponentConfig;
   };
 }
 
@@ -41,26 +54,59 @@ export const ThreadListPrimitiveItemByIndex: FC<ThreadListPrimitiveItemByIndex.P
 
 ThreadListPrimitiveItemByIndex.displayName = "ThreadListPrimitive.ItemByIndex";
 
-export const ThreadListPrimitiveItems: FC<ThreadListPrimitiveItems.Props> = ({
-  archived = false,
-  components,
-}) => {
+const ThreadListPrimitiveItemsInner: FC<{
+  archived: boolean;
+  children: (value: { threadListItem: ThreadListItemState }) => ReactNode;
+}> = ({ archived, children }) => {
   const contentLength = useAuiState((s) =>
     archived ? s.threads.archivedThreadIds.length : s.threads.threadIds.length,
   );
 
-  const listElements = useMemo(() => {
-    return Array.from({ length: contentLength }, (_, index) => (
-      <ThreadListPrimitiveItemByIndex
-        key={index}
-        index={index}
-        archived={archived}
-        components={components}
-      />
-    ));
-  }, [contentLength, archived, components]);
+  return useMemo(
+    () =>
+      Array.from({ length: contentLength }, (_, index) => (
+        <ThreadListItemByIndexProvider
+          key={index}
+          index={index}
+          archived={archived}
+        >
+          <RenderChildrenWithAccessor
+            getItemState={(aui) =>
+              aui.threads().item({ index, archived }).getState()
+            }
+          >
+            {(getItem) =>
+              children({
+                get threadListItem() {
+                  return getItem();
+                },
+              })
+            }
+          </RenderChildrenWithAccessor>
+        </ThreadListItemByIndexProvider>
+      )),
+    [contentLength, archived, children],
+  );
+};
 
-  return listElements;
+export const ThreadListPrimitiveItems: FC<ThreadListPrimitiveItems.Props> = ({
+  archived = false,
+  components,
+  children,
+}) => {
+  if (components) {
+    const ThreadListItemComponent = components.ThreadListItem;
+    return (
+      <ThreadListPrimitiveItemsInner archived={archived}>
+        {() => <ThreadListItemComponent />}
+      </ThreadListPrimitiveItemsInner>
+    );
+  }
+  return (
+    <ThreadListPrimitiveItemsInner archived={archived}>
+      {children}
+    </ThreadListPrimitiveItemsInner>
+  );
 };
 
 ThreadListPrimitiveItems.displayName = "ThreadListPrimitive.Items";

package/src/react/providers/ReadonlyThreadProvider.tsx

@@ -0,0 +1,84 @@
+import {
+  type FC,
+  type PropsWithChildren,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
+import type { ThreadMessage } from "../../types/message";
+import { ReadonlyThreadRuntimeCore } from "../../runtimes/readonly/ReadonlyThreadRuntimeCore";
+import {
+  ThreadRuntimeImpl,
+  type ThreadRuntimeCoreBinding,
+  type ThreadListItemRuntimeBinding,
+} from "../../runtime/internal";
+import { ThreadClient } from "../../store/runtime-clients/thread-runtime-client";
+import type { ThreadListItemState } from "../../runtime/api/bindings";
+
+const READONLY_THREAD_PATH = Object.freeze({
+  ref: "readonly-thread",
+  threadSelector: { type: "main" as const },
+});
+
+const READONLY_THREAD_LIST_ITEM: ThreadListItemState = Object.freeze({
+  id: "readonly",
+  remoteId: undefined,
+  externalId: undefined,
+  isMain: true,
+  status: "regular" as const,
+  title: undefined,
+});
+
+const READONLY_THREAD_LIST_ITEM_BINDING: ThreadListItemRuntimeBinding =
+  Object.freeze({
+    path: READONLY_THREAD_PATH,
+    getState: () => READONLY_THREAD_LIST_ITEM,
+    subscribe: () => () => {},
+  });
+
+export namespace ReadonlyThreadProvider {
+  export type Props = PropsWithChildren<{
+    messages: readonly ThreadMessage[];
+  }>;
+}
+
+export const ReadonlyThreadProvider: FC<ReadonlyThreadProvider.Props> = ({
+  messages,
+  children,
+}) => {
+  const [core] = useState(() => {
+    const c = new ReadonlyThreadRuntimeCore();
+    c.setMessages(messages);
+    return c;
+  });
+
+  useEffect(() => {
+    core.setMessages(messages);
+  }, [core, messages]);
+
+  const threadRuntime = useMemo(() => {
+    const threadBinding: ThreadRuntimeCoreBinding = {
+      path: READONLY_THREAD_PATH,
+      getState: () => core,
+      subscribe: (callback) => core.subscribe(callback),
+      outerSubscribe: (callback) => core.subscribe(callback),
+    };
+
+    return new ThreadRuntimeImpl(
+      threadBinding,
+      READONLY_THREAD_LIST_ITEM_BINDING,
+    );
+  }, [core]);
+
+  const aui = useAui({
+    thread: ThreadClient({ runtime: threadRuntime }),
+    composer: Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread().composer(),
+    }),
+  });
+
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+};

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -14,7 +14,7 @@ import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntim
 import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
 import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
-import { BaseSubscribable } from "../../subscribable";
+import { BaseSubscribable } from "../../subscribable/subscribable";
 import { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime";
 import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime";
 

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -1,6 +1,6 @@
 import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
 import { generateId } from "../../utils/id";
-import { BaseSubscribable } from "../../subscribable";
+import { BaseSubscribable } from "../../subscribable/subscribable";
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state";
 import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core";
 import type {

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts

@@ -5,7 +5,7 @@ import type {
   MessageFormatAdapter,
   MessageFormatItem,
   MessageFormatRepository,
-} from "../../../adapters";
+} from "../../../adapters/thread-history";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 import {
   AssistantCloud,

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.ts

@@ -3,8 +3,8 @@ import type {
   Attachment,
   PendingAttachment,
   CompleteAttachment,
-  ThreadUserMessagePart,
-} from "../../../types";
+} from "../../../types/attachment";
+import type { ThreadUserMessagePart } from "../../../types/message";
 import type { AttachmentAdapter } from "../../../adapters/attachment";
 
 const guessAttachmentType = (

package/src/react/runtimes/cloud/auiV0.ts

@@ -1,4 +1,4 @@
-import type { MessageStatus, ThreadMessage } from "../../../types";
+import type { MessageStatus, ThreadMessage } from "../../../types/message";
 import { fromThreadMessageLike } from "../../../runtime/utils/thread-message-like";
 import { CloudMessage } from "assistant-cloud";
 import { isJSONValue } from "../../../utils/json/is-json";

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -26,7 +26,9 @@ type CloudThreadListAdapterOptions = {
   delete?: ((threadId: string) => Promise<void>) | undefined;
 };
 
-const baseUrl = process?.env?.["NEXT_PUBLIC_ASSISTANT_BASE_URL"];
+const baseUrl =
+  typeof process !== "undefined" &&
+  process?.env?.["NEXT_PUBLIC_ASSISTANT_BASE_URL"];
 const autoCloud = baseUrl
   ? new AssistantCloud({ baseUrl, anonymous: true })
   : undefined;

package/src/react/runtimes/createMessageConverter.ts

@@ -1,5 +1,5 @@
 "use client";
-import type { ThreadMessage } from "../../types";
+import type { ThreadMessage } from "../../types/message";
 import type { ThreadState } from "../../runtime/api/thread-runtime";
 import { useAui, useAuiState } from "@assistant-ui/store";
 import {

package/src/react/runtimes/external-message-converter.ts

@@ -16,11 +16,11 @@ import type { ToolExecutionStatus } from "./useToolInvocations";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import { generateErrorMessageId } from "../../utils/id";
 import type {
-  MessageTiming,
   ThreadAssistantMessage,
   ThreadMessage,
   ToolCallMessagePart,
-} from "../../types";
+} from "../../types/message";
+import type { MessageTiming } from "../../types/message";
 
 export namespace useExternalMessageConverter {
   export type Message =

package/src/react/runtimes/useLocalRuntime.ts

@@ -0,0 +1,101 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import type {
+  AssistantRuntime,
+  ChatModelAdapter,
+  ThreadMessageLike,
+} from "../../index";
+import type { LocalRuntimeOptionsBase } from "../../runtimes/local/local-runtime-options";
+import { AssistantRuntimeImpl, LocalRuntimeCore } from "../../internal";
+import { useAuiState } from "@assistant-ui/store";
+import { useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
+import { useCloudThreadListAdapter } from "./cloud/useCloudThreadListAdapter";
+import { useRuntimeAdapters } from "./RuntimeAdapterProvider";
+import type { AssistantCloud } from "assistant-cloud";
+
+export type LocalRuntimeOptions = Omit<LocalRuntimeOptionsBase, "adapters"> & {
+  cloud?: AssistantCloud | undefined;
+  initialMessages?: readonly ThreadMessageLike[] | undefined;
+  adapters?: Omit<LocalRuntimeOptionsBase["adapters"], "chatModel"> | undefined;
+};
+
+const useLocalThreadRuntime = (
+  chatModel: ChatModelAdapter,
+  { initialMessages, ...options }: LocalRuntimeOptions,
+): AssistantRuntime => {
+  const { modelContext, ...threadListAdapters } = useRuntimeAdapters() ?? {};
+  const opt = {
+    ...options,
+    adapters: {
+      ...threadListAdapters,
+      ...options.adapters,
+      chatModel,
+    },
+  };
+
+  const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
+
+  const threadIdRef = useRef<string | undefined>(undefined);
+  threadIdRef.current = useAuiState((s) => s.threadListItem.remoteId);
+
+  useEffect(() => {
+    runtime.threads
+      .getMainThreadRuntimeCore()
+      .__internal_setGetThreadId(() => threadIdRef.current);
+  }, [runtime]);
+
+  useEffect(() => {
+    return () => {
+      runtime.threads.getMainThreadRuntimeCore().detach();
+    };
+  }, [runtime]);
+
+  useEffect(() => {
+    runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
+    runtime.threads.getMainThreadRuntimeCore().__internal_load();
+  });
+
+  useEffect(() => {
+    if (!modelContext) return undefined;
+    return runtime.registerModelContextProvider(modelContext);
+  }, [modelContext, runtime]);
+
+  return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
+};
+
+export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
+  options: T,
+) => {
+  const {
+    cloud,
+    initialMessages,
+    maxSteps,
+    adapters,
+    unstable_humanToolNames,
+    ...rest
+  } = options;
+
+  return {
+    localRuntimeOptions: {
+      cloud,
+      initialMessages,
+      maxSteps,
+      adapters,
+      unstable_humanToolNames,
+    },
+    otherOptions: rest,
+  };
+};
+
+export const useLocalRuntime = (
+  chatModel: ChatModelAdapter,
+  { cloud, ...options }: LocalRuntimeOptions = {},
+): AssistantRuntime => {
+  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  return useRemoteThreadListRuntime({
+    runtimeHook: function RuntimeHook() {
+      return useLocalThreadRuntime(chatModel, options);
+    },
+    adapter: cloudAdapter,
+    allowNesting: true,
+  });
+};

package/src/react/runtimes/useToolInvocations.ts

@@ -13,7 +13,7 @@ import {
   type ReadonlyJSONValue,
 } from "assistant-stream/utils";
 import { isJSONValueEqual } from "../../utils/json/is-json-equal";
-import type { ThreadMessage } from "../../types";
+import type { ThreadMessage } from "../../types/message";
 
 export type AssistantTransportState = {
   readonly messages: readonly ThreadMessage[];

package/src/react/types/MessagePartComponentTypes.ts

@@ -9,6 +9,7 @@ import type {
   TextMessagePart,
   ToolCallMessagePart,
   Unstable_AudioMessagePart,
+  QuoteInfo,
 } from "../..";
 import type { MessagePartState } from "../..";
 import { ToolResponse } from "assistant-stream";
@@ -64,3 +65,6 @@ export type ToolCallMessagePartComponent<
   TArgs = any,
   TResult = any,
 > = ComponentType<ToolCallMessagePartProps<TArgs, TResult>>;
+
+export type QuoteMessagePartProps = QuoteInfo;
+export type QuoteMessagePartComponent = ComponentType<QuoteMessagePartProps>;

package/src/react/utils/getMessageQuote.ts

@@ -0,0 +1,18 @@
+import type { QuoteInfo } from "../../types/quote";
+
+type MessageQuoteState = {
+  message: {
+    metadata?: unknown;
+  };
+};
+
+export const getMessageQuote = (
+  state: MessageQuoteState,
+): QuoteInfo | undefined => {
+  const metadata = state.message.metadata;
+  if (!metadata || typeof metadata !== "object") return undefined;
+
+  return (metadata as { custom?: Record<string, unknown> }).custom?.quote as
+    | QuoteInfo
+    | undefined;
+};

package/src/runtime/api/assistant-runtime.ts

@@ -1,5 +1,5 @@
-import type { Unsubscribe } from "../../types";
-import type { ModelContextProvider } from "../../model-context";
+import type { Unsubscribe } from "../../types/unsubscribe";
+import type { ModelContextProvider } from "../../model-context/types";
 import type { AssistantRuntimeCore } from "../interfaces/assistant-runtime-core";
 import type { ThreadRuntime } from "./thread-runtime";
 import {

package/src/runtime/api/attachment-runtime.ts

@@ -1,4 +1,5 @@
-import type { Attachment, CompleteAttachment, Unsubscribe } from "../../types";
+import type { Attachment, CompleteAttachment } from "../../types/attachment";
+import type { Unsubscribe } from "../../types/unsubscribe";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
 
 import type { ComposerRuntimeCoreBinding } from "./bindings";

package/src/runtime/api/bindings.ts

@@ -1,4 +1,4 @@
-import type { ThreadMessage } from "../../types";
+import type { ThreadMessage } from "../../types/message";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
 import type {
   ComposerRuntimeCore,

package/src/runtime/api/composer-runtime.ts

@@ -1,17 +1,16 @@
-import type {
-  Attachment,
-  CreateAttachment,
-  MessageRole,
-  RunConfig,
-  QuoteInfo,
-  Unsubscribe,
-} from "../../types";
+import type { Attachment, CreateAttachment } from "../../types/attachment";
+import type { MessageRole } from "../../types/message";
+import type { QuoteInfo } from "../../types/quote";
+import type { Unsubscribe } from "../../types/unsubscribe";
+import type { RunConfig } from "../../types/message";
 import {
   LazyMemoizeSubject,
+  EventSubscriptionSubject,
+} from "../../subscribable/subscribable";
+import {
   ShallowMemoizeSubject,
   SKIP_UPDATE,
-  EventSubscriptionSubject,
-} from "../../subscribable";
+} from "../../subscribable/subscribable";
 import type {
   ComposerRuntimeCore,
   ComposerRuntimeEventType,

package/src/runtime/api/message-part-runtime.ts

@@ -1,10 +1,10 @@
 import type {
   ThreadAssistantMessagePart,
   ThreadUserMessagePart,
-  MessagePartStatus,
   ToolCallMessagePartStatus,
-  Unsubscribe,
-} from "../../types";
+} from "../../types/message";
+import type { Unsubscribe } from "../../types/unsubscribe";
+import type { MessagePartStatus } from "../../types/message";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
 import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
 import type { MessageStateBinding } from "./bindings";

package/src/runtime/api/message-runtime.ts

@@ -4,20 +4,19 @@ import {
 } from "../interfaces/thread-runtime-core";
 import { symbolInnerMessage } from "../utils/external-store-message";
 import type {
-  MessagePartStatus,
-  RunConfig,
   ToolCallMessagePartStatus,
   ThreadMessage,
   ThreadAssistantMessagePart,
   ThreadUserMessagePart,
-  Unsubscribe,
-} from "../../types";
+} from "../../types/message";
+import type { Unsubscribe } from "../../types/unsubscribe";
+import type { MessagePartStatus, RunConfig } from "../../types/message";
 import { getThreadMessageText } from "../../utils/text";
+import { NestedSubscriptionSubject } from "../../subscribable/subscribable";
 import {
-  NestedSubscriptionSubject,
   SKIP_UPDATE,
   ShallowMemoizeSubject,
-} from "../../subscribable";
+} from "../../subscribable/subscribable";
 import {
   AttachmentRuntime,
   AttachmentState,

package/src/runtime/api/thread-list-item-runtime.ts

@@ -1,4 +1,4 @@
-import type { Unsubscribe } from "../../types";
+import type { Unsubscribe } from "../../types/unsubscribe";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
 import type { ThreadListItemRuntimePath } from "./paths";
 import type { ThreadListRuntimeCoreBinding } from "./thread-list-runtime";