ikoncomponents 1.6.4 → 1.6.5

package/dist/vendor/assistant-ui-react/src/types/scopes/suggestion.d.ts

@@ -0,0 +1,19 @@
+export type SuggestionState = {
+    title: string;
+    label: string;
+    prompt: string;
+};
+export type SuggestionMethods = {
+    getState(): SuggestionState;
+};
+export type SuggestionMeta = {
+    source: "suggestions";
+    query: {
+        index: number;
+    };
+};
+export type SuggestionClientSchema = {
+    state: SuggestionState;
+    methods: SuggestionMethods;
+    meta: SuggestionMeta;
+};

package/dist/vendor/assistant-ui-react/src/types/scopes/suggestion.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/types/scopes/suggestions.d.ts

@@ -0,0 +1,19 @@
+import type { SuggestionMethods } from "./suggestion";
+export type Suggestion = {
+    title: string;
+    label: string;
+    prompt: string;
+};
+export type SuggestionsState = {
+    suggestions: Suggestion[];
+};
+export type SuggestionsMethods = {
+    getState(): SuggestionsState;
+    suggestion(query: {
+        index: number;
+    }): SuggestionMethods;
+};
+export type SuggestionsClientSchema = {
+    state: SuggestionsState;
+    methods: SuggestionsMethods;
+};

package/dist/vendor/assistant-ui-react/src/types/scopes/suggestions.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/types/scopes/thread.d.ts

@@ -0,0 +1,139 @@
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { RuntimeCapabilities, SpeechState } from "../../legacy-runtime/runtime-cores/core/ThreadRuntimeCore";
+import type { ThreadSuggestion, ExportedMessageRepository, ThreadMessageLike } from "../../legacy-runtime/runtime-cores";
+import type { CreateAppendMessage, CreateStartRunConfig, ThreadRuntime } from "../../legacy-runtime/runtime";
+import type { CreateResumeRunConfig } from "../../legacy-runtime/runtime/ThreadRuntime";
+import type { ModelContext } from "../../model-context";
+import type { MessageMethods, MessageState } from "./message";
+import type { ComposerMethods, ComposerState } from "./composer";
+export type ThreadState = {
+    /**
+     * Whether the thread is empty. A thread is considered empty when it has no messages and is not loading.
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Whether the thread is disabled. Disabled threads cannot receive new messages.
+     */
+    readonly isDisabled: boolean;
+    /**
+     * Whether the thread is loading its history.
+     */
+    readonly isLoading: boolean;
+    /**
+     * Whether the thread is running. A thread is considered running when there is an active stream connection to the backend.
+     */
+    readonly isRunning: boolean;
+    /**
+     * The capabilities of the thread, such as whether the thread supports editing, branch switching, etc.
+     */
+    readonly capabilities: RuntimeCapabilities;
+    /**
+     * The messages in the currently selected branch of the thread.
+     */
+    readonly messages: readonly MessageState[];
+    /**
+     * The thread state.
+     * @deprecated This feature is experimental
+     */
+    readonly state: ReadonlyJSONValue;
+    /**
+     * Follow up message suggestions to show the user.
+     */
+    readonly suggestions: readonly ThreadSuggestion[];
+    /**
+     * Custom extra information provided by the runtime.
+     */
+    readonly extras: unknown;
+    /** @deprecated This API is still under active development and might change without notice. */
+    readonly speech: SpeechState | undefined;
+    readonly composer: ComposerState;
+};
+export type ThreadMethods = {
+    /**
+     * Get the current state of the thread.
+     */
+    getState(): ThreadState;
+    /**
+     * The thread composer runtime.
+     */
+    composer: ComposerMethods;
+    /**
+     * Append a new message to the thread.
+     *
+     * @example ```ts
+     * // append a new user message with the text "Hello, world!"
+     * threadRuntime.append("Hello, world!");
+     * ```
+     *
+     * @example ```ts
+     * // append a new assistant message with the text "Hello, world!"
+     * threadRuntime.append({
+     *   role: "assistant",
+     *   content: [{ type: "text", text: "Hello, world!" }],
+     * });
+     * ```
+     */
+    append(message: CreateAppendMessage): void;
+    /**
+     * Start a new run with the given configuration.
+     * @param config The configuration for starting the run
+     */
+    startRun(config: CreateStartRunConfig): void;
+    /**
+     * Resume a run with the given configuration.
+     * @param config The configuration for resuming the run
+     */
+    unstable_resumeRun(config: CreateResumeRunConfig): void;
+    cancelRun(): void;
+    getModelContext(): ModelContext;
+    export(): ExportedMessageRepository;
+    import(repository: ExportedMessageRepository): void;
+    /**
+     * Reset the thread with optional initial messages.
+     * @param initialMessages - Optional array of initial messages to populate the thread
+     */
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    message(selector: {
+        id: string;
+    } | {
+        index: number;
+    }): MessageMethods;
+    /** @deprecated This API is still under active development and might change without notice. */
+    stopSpeaking(): void;
+    /**
+     * Start the voice session for the thread. Establishes any necessary media connections.
+     */
+    startVoice(): Promise<void>;
+    /**
+     * Stop the currently active voice session.
+     */
+    stopVoice(): Promise<void>;
+    /** @internal */
+    __internal_getRuntime?(): ThreadRuntime;
+};
+export type ThreadMeta = {
+    source: "threads";
+    query: {
+        type: "main";
+    };
+};
+export type ThreadEvents = {
+    "thread.runStart": {
+        threadId: string;
+    };
+    "thread.runEnd": {
+        threadId: string;
+    };
+    "thread.initialize": {
+        threadId: string;
+    };
+    "thread.modelContextUpdate": {
+        threadId: string;
+    };
+};
+export type ThreadClientSchema = {
+    state: ThreadState;
+    methods: ThreadMethods;
+    meta: ThreadMeta;
+    events: ThreadEvents;
+};

package/dist/vendor/assistant-ui-react/src/types/scopes/thread.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/types/scopes/threadListItem.d.ts

@@ -0,0 +1,52 @@
+import type { ThreadListItemRuntime } from "../../legacy-runtime/runtime";
+import type { ThreadListItemStatus } from "../../legacy-runtime/runtime/ThreadListItemRuntime";
+export type ThreadListItemState = {
+    readonly id: string;
+    readonly remoteId: string | undefined;
+    readonly externalId: string | undefined;
+    readonly title?: string | undefined;
+    readonly status: ThreadListItemStatus;
+};
+export type ThreadListItemMethods = {
+    getState(): ThreadListItemState;
+    switchTo(): void;
+    rename(newTitle: string): void;
+    archive(): void;
+    unarchive(): void;
+    delete(): void;
+    generateTitle(): void;
+    initialize(): Promise<{
+        remoteId: string;
+        externalId: string | undefined;
+    }>;
+    detach(): void;
+    /** @internal */
+    __internal_getRuntime?(): ThreadListItemRuntime;
+};
+export type ThreadListItemMeta = {
+    source: "threads";
+    query: {
+        type: "main";
+    } | {
+        type: "id";
+        id: string;
+    } | {
+        type: "index";
+        index: number;
+        archived?: boolean;
+    };
+};
+export type ThreadListItemEvents = {
+    "threadListItem.switchedTo": {
+        threadId: string;
+    };
+    "threadListItem.switchedAway": {
+        threadId: string;
+    };
+};
+export type ThreadListItemClientSchema = {
+    state: ThreadListItemState;
+    methods: ThreadListItemMethods;
+    meta: ThreadListItemMeta;
+    events: ThreadListItemEvents;
+};

package/dist/vendor/assistant-ui-react/src/types/scopes/threadListItem.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/types/scopes/threads.d.ts

@@ -0,0 +1,30 @@
+import type { AssistantRuntime } from "../../legacy-runtime/runtime/AssistantRuntime";
+import type { ThreadListItemMethods, ThreadListItemState } from "./threadListItem";
+import type { ThreadMethods, ThreadState } from "./thread";
+export type ThreadsState = {
+    readonly mainThreadId: string;
+    readonly newThreadId: string | null;
+    readonly isLoading: boolean;
+    readonly threadIds: readonly string[];
+    readonly archivedThreadIds: readonly string[];
+    readonly threadItems: readonly ThreadListItemState[];
+    readonly main: ThreadState;
+};
+export type ThreadsMethods = {
+    getState(): ThreadsState;
+    switchToThread(threadId: string): void;
+    switchToNewThread(): void;
+    item(threadIdOrOptions: "main" | {
+        id: string;
+    } | {
+        index: number;
+        archived?: boolean;
+    }): ThreadListItemMethods;
+    thread(selector: "main"): ThreadMethods;
+    /** @internal */
+    __internal_getAssistantRuntime?(): AssistantRuntime;
+};
+export type ThreadsClientSchema = {
+    state: ThreadsState;
+    methods: ThreadsMethods;
+};

package/dist/vendor/assistant-ui-react/src/types/scopes/threads.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/types/scopes/tools.d.ts

@@ -0,0 +1,13 @@
+import type { ToolCallMessagePartComponent } from "../MessagePartComponentTypes";
+import type { Unsubscribe } from "../Unsubscribe";
+export type ToolsState = {
+    tools: Record<string, ToolCallMessagePartComponent[]>;
+};
+export type ToolsMethods = {
+    getState(): ToolsState;
+    setToolUI(toolName: string, render: ToolCallMessagePartComponent): Unsubscribe;
+};
+export type ToolsClientSchema = {
+    state: ToolsState;
+    methods: ToolsMethods;
+};

package/dist/vendor/assistant-ui-react/src/types/scopes/tools.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/types/store-augmentation.d.ts

@@ -0,0 +1,27 @@
+import "@assistant-ui/store";
+import type { ThreadsClientSchema } from "./scopes/threads";
+import type { ThreadListItemClientSchema } from "./scopes/threadListItem";
+import type { ThreadClientSchema } from "./scopes/thread";
+import type { MessageClientSchema } from "./scopes/message";
+import type { PartClientSchema } from "./scopes/part";
+import type { ComposerClientSchema } from "./scopes/composer";
+import type { AttachmentClientSchema } from "./scopes/attachment";
+import type { ToolsClientSchema } from "./scopes/tools";
+import type { ModelContextClientSchema } from "./scopes/modelContext";
+import type { SuggestionsClientSchema } from "./scopes/suggestions";
+import type { SuggestionClientSchema } from "./scopes/suggestion";
+declare module "@assistant-ui/store" {
+    interface ClientRegistry {
+        threads: ThreadsClientSchema;
+        threadListItem: ThreadListItemClientSchema;
+        thread: ThreadClientSchema;
+        message: MessageClientSchema;
+        part: PartClientSchema;
+        composer: ComposerClientSchema;
+        attachment: AttachmentClientSchema;
+        tools: ToolsClientSchema;
+        modelContext: ModelContextClientSchema;
+        suggestions: SuggestionsClientSchema;
+        suggestion: SuggestionClientSchema;
+    }
+}

package/dist/vendor/assistant-ui-react/src/types/store-augmentation.js

@@ -0,0 +1 @@
+import "@assistant-ui/store";

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

@@ -0,0 +1,9 @@
+import { type ModelContextProvider } from "../model-context/ModelContextTypes";
+export declare class CompositeContextProvider implements ModelContextProvider {
+    private _providers;
+    getModelContext(): import("..").ModelContext;
+    registerModelContextProvider(provider: ModelContextProvider): () => void;
+    private _subscribers;
+    notifySubscribers(): void;
+    subscribe(callback: () => void): () => boolean;
+}

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

@@ -0,0 +1,31 @@
+import { mergeModelContexts, } from "../model-context/ModelContextTypes";
+export class CompositeContextProvider {
+    constructor() {
+        this._providers = new Set();
+        this._subscribers = new Set();
+    }
+    getModelContext() {
+        return mergeModelContexts(this._providers);
+    }
+    registerModelContextProvider(provider) {
+        var _a;
+        this._providers.add(provider);
+        const unsubscribe = (_a = provider.subscribe) === null || _a === void 0 ? void 0 : _a.call(provider, () => {
+            this.notifySubscribers();
+        });
+        this.notifySubscribers();
+        return () => {
+            this._providers.delete(provider);
+            unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+            this.notifySubscribers();
+        };
+    }
+    notifySubscribers() {
+        for (const callback of this._subscribers)
+            callback();
+    }
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+}

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

@@ -0,0 +1,3 @@
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import { ComponentRef, ComponentPropsWithoutRef, MouseEventHandler } from "react";
+import { Primitive } from "@radix-ui/react-primitive";
+type ActionButtonCallback<TProps> = (props: TProps) => MouseEventHandler<HTMLButtonElement> | null;
+type PrimitiveButtonProps = ComponentPropsWithoutRef<typeof Primitive.button>;
+export type ActionButtonProps<THook> = PrimitiveButtonProps & (THook extends (props: infer TProps) => unknown ? TProps : never);
+export type ActionButtonElement = ComponentRef<typeof Primitive.button>;
+export declare const createActionButton: <TProps>(displayName: string, useActionButton: ActionButtonCallback<TProps>, forwardProps?: (keyof NonNullable<TProps>)[]) => import("react").ForwardRefExoticComponent<import("react").PropsWithoutRef<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & TProps> & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

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

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, } from "react";
+import { Primitive } from "@radix-ui/react-primitive";
+import { composeEventHandlers } from "@radix-ui/primitive";
+export const createActionButton = (displayName, useActionButton, forwardProps = []) => {
+    const ActionButton = forwardRef((props, forwardedRef) => {
+        var _a;
+        const forwardedProps = {};
+        const primitiveProps = {};
+        Object.keys(props).forEach((key) => {
+            if (forwardProps.includes(key)) {
+                forwardedProps[key] = props[key];
+            }
+            else {
+                primitiveProps[key] = props[key];
+            }
+        });
+        const callback = (_a = useActionButton(forwardedProps)) !== null && _a !== void 0 ? _a : undefined;
+        return (_jsx(Primitive.button, Object.assign({ type: "button" }, primitiveProps, { ref: forwardedRef, disabled: primitiveProps.disabled || !callback, onClick: composeEventHandlers(primitiveProps.onClick, callback) })));
+    });
+    ActionButton.displayName = displayName;
+    return ActionButton;
+};

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

@@ -0,0 +1,2 @@
+import type { AppendMessage, ThreadMessage } from "../types/AssistantTypes";
+export declare const getThreadMessageText: (message: ThreadMessage | AppendMessage) => string;

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

@@ -0,0 +1,4 @@
+export const getThreadMessageText = (message) => {
+    const textParts = message.content.filter((part) => part.type === "text");
+    return textParts.map((part) => part.text).join("\n\n");
+};

package/dist/vendor/assistant-ui-react/src/utils/hooks/useManagedRef.d.ts

@@ -0,0 +1 @@
+export declare const useManagedRef: <TNode>(callback: (node: TNode) => (() => void) | void) => (el: TNode | null) => void;

package/dist/vendor/assistant-ui-react/src/utils/hooks/useManagedRef.js

@@ -0,0 +1,15 @@
+import { useCallback, useRef } from "react";
+export const useManagedRef = (callback) => {
+    const cleanupRef = useRef(undefined);
+    const ref = useCallback((el) => {
+        // Call the previous cleanup function
+        if (cleanupRef.current) {
+            cleanupRef.current();
+        }
+        // Call the new callback and store its cleanup function
+        if (el) {
+            cleanupRef.current = callback(el);
+        }
+    }, [callback]);
+    return ref;
+};

package/dist/vendor/assistant-ui-react/src/utils/hooks/useOnResizeContent.d.ts

@@ -0,0 +1 @@
+export declare const useOnResizeContent: (callback: () => void) => (el: HTMLElement | null) => void;

package/dist/vendor/assistant-ui-react/src/utils/hooks/useOnResizeContent.js

@@ -0,0 +1,32 @@
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useCallback } from "react";
+import { useManagedRef } from "./useManagedRef";
+export const useOnResizeContent = (callback) => {
+    const callbackRef = useCallbackRef(callback);
+    const refCallback = useCallback((el) => {
+        const resizeObserver = new ResizeObserver(() => {
+            callbackRef();
+        });
+        const mutationObserver = new MutationObserver((mutations) => {
+            // Filter out style-only attribute mutations to prevent feedback loops
+            // with components like ThreadViewportSlack that write styles in response
+            // to viewport changes
+            const hasRelevantMutation = mutations.some((m) => m.type !== "attributes" || m.attributeName !== "style");
+            if (hasRelevantMutation) {
+                callbackRef();
+            }
+        });
+        resizeObserver.observe(el);
+        mutationObserver.observe(el, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            characterData: true,
+        });
+        return () => {
+            resizeObserver.disconnect();
+            mutationObserver.disconnect();
+        };
+    }, [callbackRef]);
+    return useManagedRef(refCallback);
+};

package/dist/vendor/assistant-ui-react/src/utils/hooks/useOnScrollToBottom.d.ts

@@ -0,0 +1,3 @@
+export declare const useOnScrollToBottom: (callback: (config: {
+    behavior: ScrollBehavior;
+}) => void) => void;

package/dist/vendor/assistant-ui-react/src/utils/hooks/useOnScrollToBottom.js

@@ -0,0 +1,11 @@
+"use client";
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useEffect } from "react";
+import { useThreadViewport } from "../../context/react/ThreadViewportContext";
+export const useOnScrollToBottom = (callback) => {
+    const callbackRef = useCallbackRef(callback);
+    const onScrollToBottom = useThreadViewport((vp) => vp.onScrollToBottom);
+    useEffect(() => {
+        return onScrollToBottom(callbackRef);
+    }, [onScrollToBottom, callbackRef]);
+};

package/dist/vendor/assistant-ui-react/src/utils/hooks/useSizeHandle.d.ts

@@ -0,0 +1,10 @@
+import type { SizeHandle } from "../../context/stores/ThreadViewport";
+/**
+ * Hook that creates a ref for tracking element size via a SizeHandle.
+ * Automatically sets up ResizeObserver and reports height changes.
+ *
+ * @param register - Function that returns a SizeHandle (e.g., registerContentInset)
+ * @param getHeight - Optional function to compute height (defaults to el.offsetHeight)
+ * @returns A ref callback to attach to the element
+ */
+export declare const useSizeHandle: (register: (() => SizeHandle) | null | undefined, getHeight?: (el: HTMLElement) => number) => (el: HTMLElement | null) => void;

package/dist/vendor/assistant-ui-react/src/utils/hooks/useSizeHandle.js

@@ -0,0 +1,30 @@
+"use client";
+import { useCallback } from "react";
+import { useManagedRef } from "./useManagedRef";
+/**
+ * Hook that creates a ref for tracking element size via a SizeHandle.
+ * Automatically sets up ResizeObserver and reports height changes.
+ *
+ * @param register - Function that returns a SizeHandle (e.g., registerContentInset)
+ * @param getHeight - Optional function to compute height (defaults to el.offsetHeight)
+ * @returns A ref callback to attach to the element
+ */
+export const useSizeHandle = (register, getHeight) => {
+    const callbackRef = useCallback((el) => {
+        if (!register)
+            return;
+        const sizeHandle = register();
+        const updateHeight = () => {
+            const height = getHeight ? getHeight(el) : el.offsetHeight;
+            sizeHandle.setHeight(height);
+        };
+        const ro = new ResizeObserver(updateHeight);
+        ro.observe(el);
+        updateHeight();
+        return () => {
+            ro.disconnect();
+            sizeHandle.unregister();
+        };
+    }, [register, getHeight]);
+    return useManagedRef(callbackRef);
+};

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

@@ -0,0 +1,5 @@
+export declare const generateId: any;
+export declare const generateOptimisticId: () => string;
+export declare const isOptimisticId: (id: string) => boolean;
+export declare const generateErrorMessageId: () => string;
+export declare const isErrorMessageId: (id: string) => boolean;

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

@@ -0,0 +1,8 @@
+import { customAlphabet } from "nanoid/non-secure";
+export const generateId = customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7);
+const optimisticPrefix = "__optimistic__";
+export const generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
+export const isOptimisticId = (id) => id.startsWith(optimisticPrefix);
+const errorPrefix = "__error__";
+export const generateErrorMessageId = () => `${errorPrefix}${generateId()}`;
+export const isErrorMessageId = (id) => id.startsWith(errorPrefix);

package/dist/vendor/assistant-ui-react/src/utils/json/is-json.d.ts

@@ -0,0 +1,4 @@
+import { ReadonlyJSONArray, ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
+export declare function isJSONValue(value: unknown, currentDepth?: number): value is ReadonlyJSONValue;
+export declare function isJSONArray(value: unknown): value is ReadonlyJSONArray;
+export declare function isJSONObject(value: unknown): value is ReadonlyJSONObject;

package/dist/vendor/assistant-ui-react/src/utils/json/is-json.js

@@ -0,0 +1,30 @@
+export function isJSONValue(value, currentDepth = 0) {
+    // Protect against too deep recursion
+    if (currentDepth > 100) {
+        return false;
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    // Handle special number cases
+    if (typeof value === "number") {
+        return !Number.isNaN(value) && Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJSONValue(item, currentDepth + 1));
+    }
+    if (typeof value === "object") {
+        return Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val, currentDepth + 1));
+    }
+    return false;
+}
+export function isJSONArray(value) {
+    return Array.isArray(value) && value.every(isJSONValue);
+}
+export function isJSONObject(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val)));
+}