ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/client/ThreadMessageClient.js

@@ -0,0 +1,110 @@
+"use client";
+import { resource, tapMemo, tapState, tapInlineResource, withKey, } from "@assistant-ui/tap";
+import { tapClientLookup } from "@assistant-ui/store";
+import { NoOpComposerClient } from "./NoOpComposerClient";
+const ThreadMessagePartClient = resource(({ part, }) => {
+    const state = tapMemo(() => {
+        return Object.assign(Object.assign({}, part), { status: { type: "complete" } });
+    }, [part]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            addToolResult: () => {
+                throw new Error("Not supported");
+            },
+            resumeToolCall: () => {
+                throw new Error("Not supported");
+            },
+        },
+    };
+});
+const ThreadMessageAttachmentClient = resource(({ attachment }) => {
+    return {
+        state: attachment,
+        methods: {
+            getState: () => attachment,
+            remove: () => {
+                throw new Error("Not supported");
+            },
+        },
+    };
+});
+export const ThreadMessageClient = resource(({ message, index, isLast = true, branchNumber = 1, branchCount = 1, }) => {
+    const [isCopiedState, setIsCopied] = tapState(false);
+    const [isHoveringState, setIsHovering] = tapState(false);
+    const parts = tapClientLookup(() => message.content.map((part, idx) => withKey("toolCallId" in part && part.toolCallId != null
+        ? `toolCallId-${part.toolCallId}`
+        : `index-${idx}`, ThreadMessagePartClient({ part }))), [message.content]);
+    const attachments = tapClientLookup(() => {
+        var _a;
+        return ((_a = message.attachments) !== null && _a !== void 0 ? _a : []).map((attachment) => withKey(attachment.id, ThreadMessageAttachmentClient({ attachment })));
+    }, [message.attachments]);
+    const composer = tapInlineResource(NoOpComposerClient({ type: "edit" }));
+    const state = tapMemo(() => {
+        return Object.assign(Object.assign({}, message), { parts: parts.state, composer: composer.state, parentId: null, index,
+            isLast,
+            branchNumber,
+            branchCount, speech: undefined, submittedFeedback: message.metadata.submittedFeedback, isCopied: isCopiedState, isHovering: isHoveringState });
+    }, [
+        message,
+        index,
+        isCopiedState,
+        isHoveringState,
+        isLast,
+        parts.state,
+        composer.state,
+        branchNumber,
+        branchCount,
+    ]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            composer: composer.methods,
+            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);
+                }
+            },
+            reload: () => {
+                throw new Error("Not supported in ThreadMessageProvider");
+            },
+            speak: () => {
+                throw new Error("Not supported in ThreadMessageProvider");
+            },
+            stopSpeaking: () => {
+                throw new Error("Not supported in ThreadMessageProvider");
+            },
+            submitFeedback: () => {
+                throw new Error("Not supported in ThreadMessageProvider");
+            },
+            switchToBranch: () => {
+                throw new Error("Not supported in ThreadMessageProvider");
+            },
+            getCopyText: () => {
+                return message.content
+                    .map((part) => {
+                    if ("text" in part && typeof part.text === "string") {
+                        return part.text;
+                    }
+                    return "";
+                })
+                    .join("\n");
+            },
+            setIsCopied,
+            setIsHovering,
+        },
+    };
+});

package/dist/vendor/assistant-ui-react/src/client/Tools.d.ts

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

package/dist/vendor/assistant-ui-react/src/client/Tools.js

@@ -0,0 +1,68 @@
+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 { resource, tapState, tapEffect, tapCallback } from "@assistant-ui/tap";
+import { tapAssistantClientRef, attachDefaultPeers, } from "@assistant-ui/store";
+import { ModelContext } from "./ModelContextClient";
+export const Tools = resource(({ toolkit }) => {
+    const [state, setState] = tapState(() => ({
+        tools: {},
+    }));
+    const clientRef = tapAssistantClientRef();
+    const setToolUI = tapCallback((toolName, render) => {
+        setState((prev) => {
+            var _a;
+            return Object.assign(Object.assign({}, prev), { tools: Object.assign(Object.assign({}, prev.tools), { [toolName]: [...((_a = prev.tools[toolName]) !== null && _a !== void 0 ? _a : []), render] }) });
+        });
+        return () => {
+            setState((prev) => {
+                var _a, _b;
+                return Object.assign(Object.assign({}, prev), { tools: Object.assign(Object.assign({}, prev.tools), { [toolName]: (_b = (_a = prev.tools[toolName]) === null || _a === void 0 ? void 0 : _a.filter((r) => r !== render)) !== null && _b !== void 0 ? _b : [] }) });
+            });
+        };
+    }, []);
+    tapEffect(() => {
+        if (!toolkit)
+            return;
+        const unsubscribes = [];
+        // Register tool UIs (exclude symbols)
+        for (const [toolName, tool] of Object.entries(toolkit)) {
+            if (tool.render) {
+                unsubscribes.push(setToolUI(toolName, tool.render));
+            }
+        }
+        // Register tools with model context (exclude symbols)
+        const toolsWithoutRender = Object.entries(toolkit).reduce((acc, [name, tool]) => {
+            const { render } = tool, rest = __rest(tool, ["render"]);
+            acc[name] = rest;
+            return acc;
+        }, {});
+        const modelContextProvider = {
+            getModelContext: () => ({
+                tools: toolsWithoutRender,
+            }),
+        };
+        unsubscribes.push(clientRef.current.modelContext().register(modelContextProvider));
+        return () => {
+            unsubscribes.forEach((fn) => fn());
+        };
+    }, [toolkit, setToolUI, clientRef]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            setToolUI,
+        },
+    };
+});
+attachDefaultPeers(Tools, {
+    modelContext: ModelContext(),
+});

package/dist/vendor/assistant-ui-react/src/client/index.d.ts

@@ -0,0 +1,5 @@
+export { ModelContext as ModelContextClient } from "./ModelContextClient";
+export { Tools } from "./Tools";
+export { Suggestions, type SuggestionConfig } from "./Suggestions";
+export { ExternalThread, type ExternalThreadProps, type ExternalThreadMessage, } from "./ExternalThread";
+export { InMemoryThreadList, type InMemoryThreadListProps, } from "./InMemoryThreadList";

package/dist/vendor/assistant-ui-react/src/client/index.js

@@ -0,0 +1,5 @@
+export { ModelContext as ModelContextClient } from "./ModelContextClient";
+export { Tools } from "./Tools";
+export { Suggestions } from "./Suggestions";
+export { ExternalThread, } from "./ExternalThread";
+export { InMemoryThreadList, } from "./InMemoryThreadList";

package/dist/vendor/assistant-ui-react/src/context/ReadonlyStore.d.ts

@@ -0,0 +1,3 @@
+import type { StoreApi } from "zustand";
+export type ReadonlyStore<T> = Omit<StoreApi<T>, "setState" | "destroy">;
+export declare const writableStore: <T>(store: ReadonlyStore<T> | undefined) => StoreApi<T>;

package/dist/vendor/assistant-ui-react/src/context/ReadonlyStore.js

@@ -0,0 +1,3 @@
+export const writableStore = (store) => {
+    return store;
+};

package/dist/vendor/assistant-ui-react/src/context/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./providers";
+export * from "./stores";
+export * from "./react";

package/dist/vendor/assistant-ui-react/src/context/index.js

@@ -0,0 +1,3 @@
+export * from "./providers";
+export * from "./stores";
+export * from "./react";

package/dist/vendor/assistant-ui-react/src/context/providers/AttachmentByIndexProvider.d.ts

@@ -0,0 +1,7 @@
+import { type FC, type PropsWithChildren } from "react";
+export declare const MessageAttachmentByIndexProvider: FC<PropsWithChildren<{
+    index: number;
+}>>;
+export declare const ComposerAttachmentByIndexProvider: FC<PropsWithChildren<{
+    index: number;
+}>>;

package/dist/vendor/assistant-ui-react/src/context/providers/AttachmentByIndexProvider.js

@@ -0,0 +1,23 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
+export const MessageAttachmentByIndexProvider = ({ index, children }) => {
+    const aui = useAui({
+        attachment: Derived({
+            source: "message",
+            query: { type: "index", index },
+            get: (aui) => aui.message().attachment({ index }),
+        }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};
+export const ComposerAttachmentByIndexProvider = ({ index, children }) => {
+    const aui = useAui({
+        attachment: Derived({
+            source: "composer",
+            query: { type: "index", index },
+            get: (aui) => aui.composer().attachment({ index }),
+        }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/MessageByIndexProvider.d.ts

@@ -0,0 +1,4 @@
+import { type FC, type PropsWithChildren } from "react";
+export declare const MessageByIndexProvider: FC<PropsWithChildren<{
+    index: number;
+}>>;

package/dist/vendor/assistant-ui-react/src/context/providers/MessageByIndexProvider.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
+export const MessageByIndexProvider = ({ index, children }) => {
+    const aui = useAui({
+        message: Derived({
+            source: "thread",
+            query: { type: "index", index },
+            get: (aui) => aui.thread().message({ index }),
+        }),
+        composer: Derived({
+            source: "message",
+            query: {},
+            get: (aui) => aui.thread().message({ index }).composer,
+        }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/MessageProvider.d.ts

@@ -0,0 +1,3 @@
+import { type FC, type PropsWithChildren } from "react";
+import { ThreadMessageClientProps } from "../../client/ThreadMessageClient";
+export declare const MessageProvider: FC<PropsWithChildren<ThreadMessageClientProps>>;

package/dist/vendor/assistant-ui-react/src/context/providers/MessageProvider.js

@@ -0,0 +1,22 @@
+"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 { jsx as _jsx } from "react/jsx-runtime";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import { ThreadMessageClient, } from "../../client/ThreadMessageClient";
+export const MessageProvider = (_a) => {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    const aui = useAui({
+        message: ThreadMessageClient(props),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/PartByIndexProvider.d.ts

@@ -0,0 +1,4 @@
+import { type FC, type PropsWithChildren } from "react";
+export declare const PartByIndexProvider: FC<PropsWithChildren<{
+    index: number;
+}>>;

package/dist/vendor/assistant-ui-react/src/context/providers/PartByIndexProvider.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
+export const PartByIndexProvider = ({ index, children }) => {
+    const aui = useAui({
+        part: Derived({
+            source: "message",
+            query: { type: "index", index },
+            get: (aui) => aui.message().part({ index }),
+        }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/SuggestionByIndexProvider.d.ts

@@ -0,0 +1,5 @@
+import { type FC, type PropsWithChildren } from "react";
+export type SuggestionByIndexProviderProps = PropsWithChildren<{
+    index: number;
+}>;
+export declare const SuggestionByIndexProvider: FC<SuggestionByIndexProviderProps>;

package/dist/vendor/assistant-ui-react/src/context/providers/SuggestionByIndexProvider.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
+export const SuggestionByIndexProvider = ({ index, children, }) => {
+    const aui = useAui({
+        suggestion: Derived({
+            source: "suggestions",
+            query: { index },
+            get: (aui) => aui.suggestions().suggestion({ index }),
+        }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/TextMessagePartProvider.d.ts

@@ -0,0 +1,5 @@
+import { type FC, type PropsWithChildren } from "react";
+export declare const TextMessagePartProvider: FC<PropsWithChildren<{
+    text: string;
+    isRunning?: boolean;
+}>>;

package/dist/vendor/assistant-ui-react/src/context/providers/TextMessagePartProvider.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import { resource, tapMemo } from "@assistant-ui/tap";
+const TextMessagePartClient = resource(({ text, isRunning, }) => {
+    const state = tapMemo(() => ({
+        type: "text",
+        text,
+        status: isRunning ? { type: "running" } : { type: "complete" },
+    }), [text, isRunning]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            addToolResult: () => {
+                throw new Error("Not supported");
+            },
+            resumeToolCall: () => {
+                throw new Error("Not supported");
+            },
+        },
+    };
+});
+export const TextMessagePartProvider = ({ text, isRunning = false, children }) => {
+    const aui = useAui({
+        part: TextMessagePartClient({ text, isRunning }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/ThreadListItemProvider.d.ts

@@ -0,0 +1,9 @@
+import { type FC, type PropsWithChildren } from "react";
+import type { ThreadListItemRuntime } from "../../legacy-runtime/runtime/ThreadListItemRuntime";
+export declare const ThreadListItemByIndexProvider: FC<PropsWithChildren<{
+    index: number;
+    archived: boolean;
+}>>;
+export declare const ThreadListItemRuntimeProvider: FC<PropsWithChildren<{
+    runtime: ThreadListItemRuntime;
+}>>;

package/dist/vendor/assistant-ui-react/src/context/providers/ThreadListItemProvider.js

@@ -0,0 +1,20 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
+import { ThreadListItemClient } from "../../legacy-runtime/client/ThreadListItemRuntimeClient";
+export const ThreadListItemByIndexProvider = ({ index, archived, children }) => {
+    const aui = useAui({
+        threadListItem: Derived({
+            source: "threads",
+            query: { type: "index", index, archived },
+            get: (aui) => aui.threads().item({ index, archived }),
+        }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};
+export const ThreadListItemRuntimeProvider = ({ runtime, children }) => {
+    const aui = useAui({
+        threadListItem: ThreadListItemClient({ runtime }),
+    });
+    return _jsx(AuiProvider, { value: aui, children: children });
+};

package/dist/vendor/assistant-ui-react/src/context/providers/ThreadViewportProvider.d.ts

@@ -0,0 +1,6 @@
+import type { FC, PropsWithChildren } from "react";
+import { type ThreadViewportStoreOptions } from "../stores/ThreadViewport";
+export type ThreadViewportProviderProps = PropsWithChildren<{
+    options?: ThreadViewportStoreOptions;
+}>;
+export declare const ThreadPrimitiveViewportProvider: FC<ThreadViewportProviderProps>;

package/dist/vendor/assistant-ui-react/src/context/providers/ThreadViewportProvider.js

@@ -0,0 +1,46 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { makeThreadViewportStore, } from "../stores/ThreadViewport";
+import { ThreadViewportContext, useThreadViewportStore, } from "../react/ThreadViewportContext";
+import { writableStore } from "../ReadonlyStore";
+const useThreadViewportStoreValue = (options) => {
+    const outerViewport = useThreadViewportStore({ optional: true });
+    const [store] = useState(() => makeThreadViewportStore(options));
+    // Forward scrollToBottom from outer viewport to inner viewport
+    useEffect(() => {
+        return outerViewport === null || outerViewport === void 0 ? void 0 : outerViewport.getState().onScrollToBottom(() => {
+            store.getState().scrollToBottom();
+        });
+    }, [outerViewport, store]);
+    useEffect(() => {
+        if (!outerViewport)
+            return;
+        return store.subscribe((state) => {
+            if (outerViewport.getState().isAtBottom !== state.isAtBottom) {
+                writableStore(outerViewport).setState({ isAtBottom: state.isAtBottom });
+            }
+        });
+    }, [store, outerViewport]);
+    // Sync options to store when they change
+    useEffect(() => {
+        var _a;
+        const nextState = {
+            turnAnchor: (_a = options.turnAnchor) !== null && _a !== void 0 ? _a : "bottom",
+        };
+        const currentState = store.getState();
+        if (currentState.turnAnchor !== nextState.turnAnchor) {
+            writableStore(store).setState(nextState);
+        }
+    }, [store, options.turnAnchor]);
+    return store;
+};
+export const ThreadPrimitiveViewportProvider = ({ children, options = {} }) => {
+    const useThreadViewport = useThreadViewportStoreValue(options);
+    const [context] = useState(() => {
+        return {
+            useThreadViewport,
+        };
+    });
+    return (_jsx(ThreadViewportContext.Provider, { value: context, children: children }));
+};

package/dist/vendor/assistant-ui-react/src/context/providers/index.d.ts

@@ -0,0 +1,8 @@
+export { AssistantRuntimeProvider } from "../../legacy-runtime/AssistantRuntimeProvider";
+export { ThreadListItemByIndexProvider, ThreadListItemRuntimeProvider, } from "./ThreadListItemProvider";
+export { MessageByIndexProvider } from "./MessageByIndexProvider";
+export { SuggestionByIndexProvider } from "./SuggestionByIndexProvider";
+export { PartByIndexProvider } from "./PartByIndexProvider";
+export { MessageAttachmentByIndexProvider, ComposerAttachmentByIndexProvider, } from "./AttachmentByIndexProvider";
+export { TextMessagePartProvider } from "./TextMessagePartProvider";
+export { MessageProvider } from "./MessageProvider";

package/dist/vendor/assistant-ui-react/src/context/providers/index.js

@@ -0,0 +1,8 @@
+export { AssistantRuntimeProvider } from "../../legacy-runtime/AssistantRuntimeProvider";
+export { ThreadListItemByIndexProvider, ThreadListItemRuntimeProvider, } from "./ThreadListItemProvider";
+export { MessageByIndexProvider } from "./MessageByIndexProvider";
+export { SuggestionByIndexProvider } from "./SuggestionByIndexProvider";
+export { PartByIndexProvider } from "./PartByIndexProvider";
+export { MessageAttachmentByIndexProvider, ComposerAttachmentByIndexProvider, } from "./AttachmentByIndexProvider";
+export { TextMessagePartProvider } from "./TextMessagePartProvider";
+export { MessageProvider } from "./MessageProvider";

package/dist/vendor/assistant-ui-react/src/context/react/ThreadViewportContext.d.ts

@@ -0,0 +1,23 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ThreadViewportState } from "../stores";
+export type ThreadViewportContextValue = {
+    useThreadViewport: UseBoundStore<ReadonlyStore<ThreadViewportState>>;
+};
+export declare const ThreadViewportContext: import("react").Context<ThreadViewportContextValue | null>;
+export declare const useThreadViewport: {
+    (): ThreadViewportState;
+    <TSelected>(selector: (state: ThreadViewportState) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): ThreadViewportState | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: ((state: ThreadViewportState) => TSelected) | undefined;
+    }): TSelected | null;
+}, useThreadViewportStore: {
+    (): ReadonlyStore<ThreadViewportState>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<ThreadViewportState> | null;
+};

package/dist/vendor/assistant-ui-react/src/context/react/ThreadViewportContext.js

@@ -0,0 +1,7 @@
+"use client";
+import { createContext } from "react";
+import { createContextHook } from "./utils/createContextHook";
+import { createContextStoreHook } from "./utils/createContextStoreHook";
+export const ThreadViewportContext = createContext(null);
+const useThreadViewportContext = createContextHook(ThreadViewportContext, "ThreadPrimitive.Viewport");
+export const { useThreadViewport, useThreadViewportStore } = createContextStoreHook(useThreadViewportContext, "useThreadViewport");

package/dist/vendor/assistant-ui-react/src/context/react/index.d.ts

@@ -0,0 +1,8 @@
+export { useThreadViewport, useThreadViewportStore, } from "./ThreadViewportContext";
+export { useAssistantRuntime, useThreadList, } from "../../legacy-runtime/hooks/AssistantContext";
+export { useAttachmentRuntime, useAttachment, useThreadComposerAttachmentRuntime, useThreadComposerAttachment, useEditComposerAttachmentRuntime, useEditComposerAttachment, useMessageAttachment, useMessageAttachmentRuntime, } from "../../legacy-runtime/hooks/AttachmentContext";
+export { useComposerRuntime, useComposer, } from "../../legacy-runtime/hooks/ComposerContext";
+export { useMessageRuntime, useEditComposer, useMessage, } from "../../legacy-runtime/hooks/MessageContext";
+export { useMessagePartRuntime, useMessagePart, } from "../../legacy-runtime/hooks/MessagePartContext";
+export { useThreadRuntime, useThread, useThreadComposer, useThreadModelContext, } from "../../legacy-runtime/hooks/ThreadContext";
+export { useThreadListItemRuntime, useThreadListItem, } from "../../legacy-runtime/hooks/ThreadListItemContext";

package/dist/vendor/assistant-ui-react/src/context/react/index.js

@@ -0,0 +1,9 @@
+"use client";
+export { useThreadViewport, useThreadViewportStore, } from "./ThreadViewportContext";
+export { useAssistantRuntime, useThreadList, } from "../../legacy-runtime/hooks/AssistantContext";
+export { useAttachmentRuntime, useAttachment, useThreadComposerAttachmentRuntime, useThreadComposerAttachment, useEditComposerAttachmentRuntime, useEditComposerAttachment, useMessageAttachment, useMessageAttachmentRuntime, } from "../../legacy-runtime/hooks/AttachmentContext";
+export { useComposerRuntime, useComposer, } from "../../legacy-runtime/hooks/ComposerContext";
+export { useMessageRuntime, useEditComposer, useMessage, } from "../../legacy-runtime/hooks/MessageContext";
+export { useMessagePartRuntime, useMessagePart, } from "../../legacy-runtime/hooks/MessagePartContext";
+export { useThreadRuntime, useThread, useThreadComposer, useThreadModelContext, } from "../../legacy-runtime/hooks/ThreadContext";
+export { useThreadListItemRuntime, useThreadListItem, } from "../../legacy-runtime/hooks/ThreadListItemContext";

package/dist/vendor/assistant-ui-react/src/context/react/utils/createContextHook.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "react";
+/**
+ * Creates a context hook with optional support.
+ * @param context - The React context to consume.
+ * @param providerName - The name of the provider for error messages.
+ * @returns A hook function that provides the context value.
+ */
+export declare function createContextHook<T>(context: Context<T | null>, providerName: string): (options?: {
+    optional?: boolean | undefined;
+}) => T | null;

package/dist/vendor/assistant-ui-react/src/context/react/utils/createContextHook.js

@@ -0,0 +1,18 @@
+"use client";
+import { useContext } from "react";
+/**
+ * Creates a context hook with optional support.
+ * @param context - The React context to consume.
+ * @param providerName - The name of the provider for error messages.
+ * @returns A hook function that provides the context value.
+ */
+export function createContextHook(context, providerName) {
+    function useContextHook(options) {
+        const contextValue = useContext(context);
+        if (!(options === null || options === void 0 ? void 0 : options.optional) && !contextValue) {
+            throw new Error(`This component must be used within ${providerName}.`);
+        }
+        return contextValue;
+    }
+    return useContextHook;
+}

package/dist/vendor/assistant-ui-react/src/context/react/utils/createContextStoreHook.d.ts

@@ -0,0 +1,25 @@
+import { ReadonlyStore } from "../../ReadonlyStore";
+/**
+ * Creates hooks for accessing a store within a context.
+ * @param contextHook - The hook to access the context.
+ * @param contextKey - The key of the store in the context.
+ * @returns An object containing the hooks: `use...` and `use...Store`.
+ */
+export declare function createContextStoreHook<T, K extends keyof T & string>(contextHook: (options?: {
+    optional?: boolean;
+}) => T | null, contextKey: K): { [P in K]: {
+    (): T[K] extends ReadonlyStore<infer S> ? S : never;
+    <TSelected>(selector: (state: T[K] extends ReadonlyStore<infer S> ? S : never) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): (T[K] extends ReadonlyStore<infer S> ? S : never) | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: T[K] extends ReadonlyStore<infer S> ? S : never) => TSelected;
+    }): TSelected | null;
+}; } & { [P in `${K}Store`]: {
+    (): ReadonlyStore<T[K] extends ReadonlyStore<infer S> ? S : never>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<T[K] extends ReadonlyStore<infer S> ? S : never> | null;
+}; };

package/dist/vendor/assistant-ui-react/src/context/react/utils/createContextStoreHook.js

@@ -0,0 +1,36 @@
+/**
+ * Creates hooks for accessing a store within a context.
+ * @param contextHook - The hook to access the context.
+ * @param contextKey - The key of the store in the context.
+ * @returns An object containing the hooks: `use...` and `use...Store`.
+ */
+export function createContextStoreHook(contextHook, contextKey) {
+    function useStoreStoreHook(options) {
+        const context = contextHook(options);
+        if (!context)
+            return null;
+        return context[contextKey];
+    }
+    function useStoreHook(param) {
+        let optional = false;
+        let selector;
+        if (typeof param === "function") {
+            selector = param;
+        }
+        else if (param && typeof param === "object") {
+            optional = !!param.optional;
+            selector = param.selector;
+        }
+        const store = useStoreStoreHook({
+            optional,
+        });
+        if (!store)
+            return null;
+        return selector ? store(selector) : store();
+    }
+    // Return an object with keys based on contextKey
+    return {
+        [contextKey]: useStoreHook,
+        [`${contextKey}Store`]: useStoreStoreHook,
+    };
+}