ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/MessagePartRuntimeClient.js

@@ -0,0 +1,14 @@
+import { resource } from "@assistant-ui/tap";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+export const MessagePartClient = resource(({ runtime }) => {
+    const state = tapSubscribable(runtime);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            addToolResult: (result) => runtime.addToolResult(result),
+            resumeToolCall: (payload) => runtime.resumeToolCall(payload),
+            __internal_getRuntime: () => runtime,
+        },
+    };
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/MessageRuntimeClient.d.ts

@@ -0,0 +1 @@
+export declare const MessageClient: any;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/MessageRuntimeClient.js

@@ -0,0 +1,77 @@
+import { withKey, resource, tapInlineResource, tapMemo, tapState, } from "@assistant-ui/tap";
+import { tapClientLookup, tapClientResource, } from "@assistant-ui/store";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+import { ComposerClient } from "./ComposerRuntimeClient";
+import { MessagePartClient } from "./MessagePartRuntimeClient";
+import { AttachmentRuntimeClient } from "./AttachmentRuntimeClient";
+const MessageAttachmentClientByIndex = resource(({ runtime, index }) => {
+    const attachmentRuntime = tapMemo(() => runtime.getAttachmentByIndex(index), [runtime, index]);
+    return tapInlineResource(AttachmentRuntimeClient({ runtime: attachmentRuntime }));
+});
+const MessagePartByIndex = resource(({ runtime, index }) => {
+    const partRuntime = tapMemo(() => runtime.getMessagePartByIndex(index), [runtime, index]);
+    return tapInlineResource(MessagePartClient({ runtime: partRuntime }));
+});
+export const MessageClient = resource(({ runtime, threadIdRef, }) => {
+    const runtimeState = tapSubscribable(runtime);
+    const [isCopiedState, setIsCopied] = tapState(false);
+    const [isHoveringState, setIsHovering] = tapState(false);
+    const messageIdRef = tapMemo(() => ({
+        get current() {
+            return runtime.getState().id;
+        },
+    }), [runtime]);
+    const composer = tapClientResource(ComposerClient({
+        runtime: runtime.composer,
+        threadIdRef,
+        messageIdRef,
+    }));
+    const parts = tapClientLookup(() => runtimeState.content.map((part, idx) => withKey("toolCallId" in part && part.toolCallId != null
+        ? `toolCallId-${part.toolCallId}`
+        : `index-${idx}`, MessagePartByIndex({ runtime, index: idx }))), [runtimeState.content, runtime]);
+    const attachments = tapClientLookup(() => {
+        var _a;
+        return ((_a = runtimeState.attachments) !== null && _a !== void 0 ? _a : []).map((attachment, idx) => withKey(attachment.id, MessageAttachmentClientByIndex({ runtime, index: idx })));
+    }, [runtimeState.attachments, runtime]);
+    const state = tapMemo(() => {
+        return Object.assign(Object.assign({}, runtimeState), { parts: parts.state, composer: composer.state, isCopied: isCopiedState, isHovering: isHoveringState });
+    }, [
+        runtimeState,
+        parts.state,
+        composer.state,
+        isCopiedState,
+        isHoveringState,
+    ]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            composer: composer.methods,
+            reload: (config) => runtime.reload(config),
+            speak: () => runtime.speak(),
+            stopSpeaking: () => runtime.stopSpeaking(),
+            submitFeedback: (feedback) => runtime.submitFeedback(feedback),
+            switchToBranch: (options) => runtime.switchToBranch(options),
+            getCopyText: () => runtime.unstable_getCopyText(),
+            part: (selector) => {
+                if ("index" in selector) {
+                    return parts.get({ index: selector.index });
+                }
+                else {
+                    return parts.get({ key: `toolCallId-${selector.toolCallId}` });
+                }
+            },
+            attachment: (selector) => {
+                if ("id" in selector) {
+                    return attachments.get({ key: selector.id });
+                }
+                else {
+                    return attachments.get(selector);
+                }
+            },
+            setIsCopied,
+            setIsHovering,
+            __internal_getRuntime: () => runtime,
+        },
+    };
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/ThreadListItemRuntimeClient.d.ts

@@ -0,0 +1 @@
+export declare const ThreadListItemClient: any;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/ThreadListItemRuntimeClient.js

@@ -0,0 +1,43 @@
+import { resource, tapEffect } from "@assistant-ui/tap";
+import { tapAssistantEmit } from "@assistant-ui/store";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+export const ThreadListItemClient = resource(({ runtime, }) => {
+    const state = tapSubscribable(runtime);
+    const emit = tapAssistantEmit();
+    // Bind thread list item events to event manager
+    tapEffect(() => {
+        const unsubscribers = [];
+        // Subscribe to thread list item events
+        const threadListItemEvents = [
+            "switchedTo",
+            "switchedAway",
+        ];
+        for (const event of threadListItemEvents) {
+            const unsubscribe = runtime.unstable_on(event, () => {
+                emit(`threadListItem.${event}`, {
+                    threadId: runtime.getState().id,
+                });
+            });
+            unsubscribers.push(unsubscribe);
+        }
+        return () => {
+            for (const unsub of unsubscribers)
+                unsub();
+        };
+    }, [runtime, emit]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            switchTo: runtime.switchTo,
+            rename: runtime.rename,
+            archive: runtime.archive,
+            unarchive: runtime.unarchive,
+            delete: runtime.delete,
+            generateTitle: runtime.generateTitle,
+            initialize: runtime.initialize,
+            detach: runtime.detach,
+            __internal_getRuntime: () => runtime,
+        },
+    };
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/ThreadListRuntimeClient.d.ts

@@ -0,0 +1 @@
+export declare const ThreadListClient: any;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/ThreadListRuntimeClient.js

@@ -0,0 +1,57 @@
+import { withKey, resource, tapInlineResource, tapMemo, } from "@assistant-ui/tap";
+import { tapClientLookup, tapClientResource, } from "@assistant-ui/store";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+import { ThreadListItemClient } from "./ThreadListItemRuntimeClient";
+import { ThreadClient } from "./ThreadRuntimeClient";
+const ThreadListItemClientById = resource(({ runtime, id }) => {
+    const threadListItemRuntime = tapMemo(() => runtime.getItemById(id), [runtime, id]);
+    return tapInlineResource(ThreadListItemClient({
+        runtime: threadListItemRuntime,
+    }));
+});
+export const ThreadListClient = resource(({ runtime, __internal_assistantRuntime, }) => {
+    const runtimeState = tapSubscribable(runtime);
+    const main = tapClientResource(ThreadClient({
+        runtime: runtime.main,
+    }));
+    const threadItems = tapClientLookup(() => Object.keys(runtimeState.threadItems).map((id) => withKey(id, ThreadListItemClientById({ runtime, id }))), [runtimeState.threadItems, runtime]);
+    const state = tapMemo(() => {
+        var _a;
+        return {
+            mainThreadId: runtimeState.mainThreadId,
+            newThreadId: (_a = runtimeState.newThreadId) !== null && _a !== void 0 ? _a : null,
+            isLoading: runtimeState.isLoading,
+            threadIds: runtimeState.threadIds,
+            archivedThreadIds: runtimeState.archivedThreadIds,
+            threadItems: threadItems.state,
+            main: main.state,
+        };
+    }, [runtimeState, threadItems.state, main.state]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            thread: () => main.methods,
+            item: (threadIdOrOptions) => {
+                if (threadIdOrOptions === "main") {
+                    return threadItems.get({ key: state.mainThreadId });
+                }
+                if ("id" in threadIdOrOptions) {
+                    return threadItems.get({ key: threadIdOrOptions.id });
+                }
+                const { index, archived = false } = threadIdOrOptions;
+                const id = archived
+                    ? state.archivedThreadIds[index]
+                    : state.threadIds[index];
+                return threadItems.get({ key: id });
+            },
+            switchToThread: async (threadId) => {
+                await runtime.switchToThread(threadId);
+            },
+            switchToNewThread: async () => {
+                await runtime.switchToNewThread();
+            },
+            __internal_getAssistantRuntime: () => __internal_assistantRuntime,
+        },
+    };
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/ThreadRuntimeClient.d.ts

@@ -0,0 +1 @@
+export declare const ThreadClient: any;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/client/ThreadRuntimeClient.js

@@ -0,0 +1,94 @@
+import { resource, tapInlineResource, tapMemo, tapEffect, withKey, } from "@assistant-ui/tap";
+import { tapAssistantEmit, tapClientLookup, tapClientResource, } from "@assistant-ui/store";
+import { ComposerClient } from "./ComposerRuntimeClient";
+import { MessageClient } from "./MessageRuntimeClient";
+import { tapSubscribable } from "../util-hooks/tapSubscribable";
+const MessageClientById = resource(({ runtime, id, threadIdRef, }) => {
+    const messageRuntime = tapMemo(() => runtime.getMessageById(id), [runtime, id]);
+    return tapInlineResource(MessageClient({ runtime: messageRuntime, threadIdRef }));
+});
+export const ThreadClient = resource(({ runtime }) => {
+    const runtimeState = tapSubscribable(runtime);
+    const emit = tapAssistantEmit();
+    // Bind thread events to event manager
+    tapEffect(() => {
+        const unsubscribers = [];
+        // Subscribe to thread events
+        const threadEvents = [
+            "runStart",
+            "runEnd",
+            "initialize",
+            "modelContextUpdate",
+        ];
+        for (const event of threadEvents) {
+            const unsubscribe = runtime.unstable_on(event, () => {
+                var _a;
+                const threadId = ((_a = runtime.getState()) === null || _a === void 0 ? void 0 : _a.threadId) || "unknown";
+                emit(`thread.${event}`, {
+                    threadId,
+                });
+            });
+            unsubscribers.push(unsubscribe);
+        }
+        return () => {
+            for (const unsub of unsubscribers)
+                unsub();
+        };
+    }, [runtime, emit]);
+    const threadIdRef = tapMemo(() => ({
+        get current() {
+            return runtime.getState().threadId;
+        },
+    }), [runtime]);
+    const composer = tapClientResource(ComposerClient({
+        runtime: runtime.composer,
+        threadIdRef,
+    }));
+    const messages = tapClientLookup(() => runtimeState.messages.map((m) => withKey(m.id, MessageClientById({ runtime, id: m.id, threadIdRef }))), [runtimeState.messages, runtime, threadIdRef]);
+    const state = tapMemo(() => {
+        return {
+            isEmpty: messages.state.length === 0 && !runtimeState.isLoading,
+            isDisabled: runtimeState.isDisabled,
+            isLoading: runtimeState.isLoading,
+            isRunning: runtimeState.isRunning,
+            capabilities: runtimeState.capabilities,
+            state: runtimeState.state,
+            suggestions: runtimeState.suggestions,
+            extras: runtimeState.extras,
+            speech: runtimeState.speech,
+            composer: composer.state,
+            messages: messages.state,
+        };
+    }, [runtimeState, messages, composer.state]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            composer: composer.methods,
+            append: runtime.append,
+            startRun: runtime.startRun,
+            unstable_resumeRun: runtime.unstable_resumeRun,
+            cancelRun: runtime.cancelRun,
+            getModelContext: runtime.getModelContext,
+            export: runtime.export,
+            import: runtime.import,
+            reset: runtime.reset,
+            stopSpeaking: runtime.stopSpeaking,
+            startVoice: async () => {
+                throw new Error("startVoice is not supported in this runtime");
+            },
+            stopVoice: async () => {
+                throw new Error("stopVoice is not supported in this runtime");
+            },
+            message: (selector) => {
+                if ("id" in selector) {
+                    return messages.get({ key: selector.id });
+                }
+                else {
+                    return messages.get(selector);
+                }
+            },
+            __internal_getRuntime: () => runtime,
+        },
+    };
+});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/AssistantCloudThreadHistoryAdapter.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from "react";
+import { ThreadHistoryAdapter } from "../runtime-cores/adapters/thread-history/ThreadHistoryAdapter";
+import { AssistantCloud } from "assistant-cloud";
+export declare const useAssistantCloudThreadHistoryAdapter: (cloudRef: RefObject<AssistantCloud>) => ThreadHistoryAdapter;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/AssistantCloudThreadHistoryAdapter.js

@@ -0,0 +1,113 @@
+import { useState } from "react";
+import { auiV0Decode, auiV0Encode } from "./auiV0";
+import { useAui } from "@assistant-ui/store";
+// Global WeakMap to store message ID mappings across adapter instances
+const globalMessageIdMapping = new WeakMap();
+class FormattedThreadHistoryAdapter {
+    constructor(parent, formatAdapter) {
+        this.parent = parent;
+        this.formatAdapter = formatAdapter;
+    }
+    async append(item) {
+        // Encode the message using the format adapter
+        const encoded = this.formatAdapter.encode(item);
+        const messageId = this.formatAdapter.getId(item.message);
+        // Delegate to parent's internal append method with the encoded format
+        return this.parent._appendWithFormat(item.parentId, messageId, this.formatAdapter.format, encoded);
+    }
+    async load() {
+        // Delegate to parent's internal load method with format filter
+        return this.parent._loadWithFormat(this.formatAdapter.format, (message) => this.formatAdapter.decode(message));
+    }
+}
+class AssistantCloudThreadHistoryAdapter {
+    constructor(cloudRef, aui) {
+        this.cloudRef = cloudRef;
+        this.aui = aui;
+    }
+    get _getIdForLocalId() {
+        if (!globalMessageIdMapping.has(this.aui.threadListItem())) {
+            globalMessageIdMapping.set(this.aui.threadListItem(), {});
+        }
+        return globalMessageIdMapping.get(this.aui.threadListItem());
+    }
+    withFormat(formatAdapter) {
+        return new FormattedThreadHistoryAdapter(this, formatAdapter);
+    }
+    async append({ parentId, message }) {
+        var _a;
+        const { remoteId } = await this.aui.threadListItem().initialize();
+        const task = this.cloudRef.current.threads.messages
+            .create(remoteId, {
+            parent_id: parentId
+                ? ((_a = (await this._getIdForLocalId[parentId])) !== null && _a !== void 0 ? _a : parentId)
+                : null,
+            format: "aui/v0",
+            content: auiV0Encode(message),
+        })
+            .then(({ message_id }) => {
+            this._getIdForLocalId[message.id] = message_id;
+            return message_id;
+        });
+        this._getIdForLocalId[message.id] = task;
+        return task.then(() => { });
+    }
+    async load() {
+        const remoteId = this.aui.threadListItem().getState().remoteId;
+        if (!remoteId)
+            return { messages: [] };
+        const { messages } = await this.cloudRef.current.threads.messages.list(remoteId, {
+            format: "aui/v0",
+        });
+        const payload = {
+            messages: messages
+                .filter((m) => m.format === "aui/v0")
+                .map(auiV0Decode)
+                .reverse(),
+        };
+        return payload;
+    }
+    // Internal methods for FormattedThreadHistoryAdapter
+    async _appendWithFormat(parentId, messageId, format, content) {
+        var _a;
+        const { remoteId } = await this.aui.threadListItem().initialize();
+        const task = this.cloudRef.current.threads.messages
+            .create(remoteId, {
+            parent_id: parentId
+                ? ((_a = (await this._getIdForLocalId[parentId])) !== null && _a !== void 0 ? _a : parentId)
+                : null,
+            format,
+            content: content,
+        })
+            .then(({ message_id }) => {
+            this._getIdForLocalId[messageId] = message_id;
+            return message_id;
+        });
+        this._getIdForLocalId[messageId] = task;
+        return task.then(() => { });
+    }
+    async _loadWithFormat(format, decoder) {
+        const remoteId = this.aui.threadListItem().getState().remoteId;
+        if (!remoteId)
+            return { messages: [] };
+        const { messages } = await this.cloudRef.current.threads.messages.list(remoteId, {
+            format,
+        });
+        return {
+            messages: messages
+                .filter((m) => m.format === format)
+                .map((m) => decoder({
+                id: m.id,
+                parent_id: m.parent_id,
+                format: m.format,
+                content: m.content,
+            }))
+                .reverse(),
+        };
+    }
+}
+export const useAssistantCloudThreadHistoryAdapter = (cloudRef) => {
+    const aui = useAui();
+    const [adapter] = useState(() => new AssistantCloudThreadHistoryAdapter(cloudRef, aui));
+    return adapter;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/auiV0.d.ts

@@ -0,0 +1,62 @@
+import { ThreadMessage } from "../../types";
+import { MessageStatus } from "../../types/AssistantTypes";
+import { CloudMessage } from "assistant-cloud";
+import { ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
+import { ExportedMessageRepositoryItem } from "../runtime-cores/utils/MessageRepository";
+type AuiV0MessageMessagePart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "reasoning";
+    readonly text: string;
+} | {
+    readonly type: "source";
+    readonly sourceType: "url";
+    readonly id: string;
+    readonly url: string;
+    readonly title?: string;
+} | {
+    readonly type: "tool-call";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly args: ReadonlyJSONObject;
+    readonly result?: ReadonlyJSONValue;
+    readonly isError?: true;
+} | {
+    readonly type: "tool-call";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly argsText: string;
+    readonly result?: ReadonlyJSONValue;
+    readonly isError?: true;
+} | {
+    readonly type: "image";
+    readonly image: string;
+} | {
+    readonly type: "file";
+    readonly data: string;
+    readonly mimeType: string;
+    readonly filename?: string;
+};
+type AuiV0Message = {
+    readonly role: "assistant" | "user" | "system";
+    readonly status?: MessageStatus;
+    readonly content: readonly AuiV0MessageMessagePart[];
+    readonly metadata: {
+        readonly unstable_state?: ReadonlyJSONValue;
+        readonly unstable_annotations: readonly ReadonlyJSONValue[];
+        readonly unstable_data: readonly ReadonlyJSONValue[];
+        readonly steps: readonly {
+            readonly usage?: {
+                readonly promptTokens: number;
+                readonly completionTokens: number;
+            };
+        }[];
+        readonly custom: ReadonlyJSONObject;
+    };
+};
+export declare const auiV0Encode: (message: ThreadMessage) => AuiV0Message;
+export declare const auiV0Decode: (cloudMessage: CloudMessage & {
+    format: "aui/v0";
+}) => ExportedMessageRepositoryItem;
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/auiV0.js

@@ -0,0 +1,72 @@
+import { fromThreadMessageLike } from "../runtime-cores/external-store/ThreadMessageLike";
+import { isJSONValue } from "../../utils/json/is-json";
+export const auiV0Encode = (message) => {
+    var _a;
+    // TODO attachments are currently intentionally ignored
+    // info: ID and createdAt are ignored (we use the server value instead)
+    return Object.assign({ role: message.role, content: message.content.map((part) => {
+            const type = part.type;
+            switch (type) {
+                case "text": {
+                    return {
+                        type: "text",
+                        text: part.text,
+                    };
+                }
+                case "reasoning": {
+                    return {
+                        type: "reasoning",
+                        text: part.text,
+                    };
+                }
+                case "source": {
+                    return Object.assign({ type: "source", sourceType: part.sourceType, id: part.id, url: part.url }, (part.title ? { title: part.title } : undefined));
+                }
+                case "tool-call": {
+                    if (!isJSONValue(part.result)) {
+                        console.warn(`tool-call result is not JSON! ${JSON.stringify(part)}`);
+                    }
+                    return Object.assign(Object.assign(Object.assign({ type: "tool-call", toolCallId: part.toolCallId, toolName: part.toolName }, (JSON.stringify(part.args) === part.argsText
+                        ? {
+                            args: part.args,
+                        }
+                        : { argsText: part.argsText })), (part.result
+                        ? { result: part.result }
+                        : {})), (part.isError ? { isError: true } : {}));
+                }
+                case "image": {
+                    return {
+                        type: "image",
+                        image: part.image,
+                    };
+                }
+                case "file": {
+                    return Object.assign({ type: "file", data: part.data, mimeType: part.mimeType }, (part.filename ? { filename: part.filename } : undefined));
+                }
+                default: {
+                    const unhandledType = type;
+                    throw new Error(`Message part type not supported by aui/v0: ${unhandledType}`);
+                }
+            }
+        }), metadata: message.metadata }, (message.status
+        ? {
+            status: ((_a = message.status) === null || _a === void 0 ? void 0 : _a.type) === "running"
+                ? {
+                    type: "incomplete",
+                    reason: "cancelled",
+                }
+                : message.status,
+        }
+        : undefined));
+};
+export const auiV0Decode = (cloudMessage) => {
+    const payload = cloudMessage.content;
+    const message = fromThreadMessageLike(Object.assign({ id: cloudMessage.id, createdAt: cloudMessage.created_at }, payload), cloudMessage.id, {
+        type: "complete",
+        reason: "unknown",
+    });
+    return {
+        parentId: cloudMessage.parent_id,
+        message,
+    };
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/index.d.ts

@@ -0,0 +1,2 @@
+export { useCloudThreadListRuntime } from "./useCloudThreadListRuntime";
+export { AssistantCloud } from "assistant-cloud";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/index.js

@@ -0,0 +1,2 @@
+export { useCloudThreadListRuntime } from "./useCloudThreadListRuntime";
+export { AssistantCloud } from "assistant-cloud";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/useCloudThreadListRuntime.d.ts

@@ -0,0 +1,13 @@
+import { AssistantCloud } from "assistant-cloud";
+import { AssistantRuntime } from "../runtime";
+type ThreadData = {
+    externalId: string;
+};
+type CloudThreadListAdapter = {
+    cloud: AssistantCloud;
+    runtimeHook: () => AssistantRuntime;
+    create?(): Promise<ThreadData>;
+    delete?(threadId: string): Promise<void>;
+};
+export declare const useCloudThreadListRuntime: ({ runtimeHook, ...adapterOptions }: CloudThreadListAdapter) => AssistantRuntime;
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/cloud/useCloudThreadListRuntime.js

@@ -0,0 +1,24 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useRemoteThreadListRuntime } from "../runtime-cores/remote-thread-list/useRemoteThreadListRuntime";
+import { useCloudThreadListAdapter } from "../runtime-cores/remote-thread-list/adapter/cloud";
+export const useCloudThreadListRuntime = (_a) => {
+    var { runtimeHook } = _a, adapterOptions = __rest(_a, ["runtimeHook"]);
+    const adapter = useCloudThreadListAdapter(adapterOptions);
+    const runtime = useRemoteThreadListRuntime({
+        runtimeHook: runtimeHook,
+        adapter,
+        allowNesting: true,
+    });
+    return runtime;
+};