ikoncomponents 1.6.3 → 1.6.5

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

@@ -0,0 +1,311 @@
+import { resource, tapState, tapMemo, tapEffect, tapEffectEvent, } from "@assistant-ui/tap";
+import { tapClientLookup, attachDefaultPeers, tapClientResource, Derived, } from "@assistant-ui/store";
+import { withKey } from "@assistant-ui/tap";
+import { ModelContext } from "./ModelContextClient";
+import { Tools } from "./Tools";
+import { Suggestions } from "./Suggestions";
+// Message Client - minimal implementation
+const MessageClient = resource(({ message, index, onEdit, onReload, }) => {
+    const [isCopied, setIsCopied] = tapState(false);
+    const [isHovering, setIsHovering] = tapState(false);
+    const [isEditing, setIsEditing] = tapState(false);
+    const partClients = tapClientLookup(() => message.content.map((part, idx) => withKey(idx, PartResource({ part }))), [message.content]);
+    const attachmentClients = tapClientLookup(() => {
+        var _a;
+        return ((_a = message.attachments) !== null && _a !== void 0 ? _a : []).map((attachment) => withKey(attachment.id, AttachmentResource({
+            attachment,
+            onRemove: () => { },
+        })));
+    }, [message.attachments]);
+    const handleBeginEdit = () => {
+        setIsEditing(true);
+    };
+    const handleCancelEdit = () => {
+        setIsEditing(false);
+    };
+    const handleSendEdit = (msg) => {
+        onEdit === null || onEdit === void 0 ? void 0 : onEdit(Object.assign(Object.assign({}, msg), { parentId: message.id, sourceId: message.id }));
+        setIsEditing(false);
+    };
+    const composerClient = tapClientResource(ComposerClientResource({
+        type: "edit",
+        isEditing,
+        canCancel: true,
+        onCancel: handleCancelEdit,
+        onBeginEdit: handleBeginEdit,
+        onSend: handleSendEdit,
+        message,
+    }));
+    const state = tapMemo(() => {
+        var _a;
+        return Object.assign(Object.assign({}, message), { attachments: (_a = message.attachments) !== null && _a !== void 0 ? _a : [], parentId: null, isLast: false, branchNumber: 1, branchCount: 1, speech: undefined, submittedFeedback: undefined, parts: partClients.state, isCopied,
+            isHovering,
+            index, composer: composerClient.state });
+    }, [
+        message,
+        isCopied,
+        isHovering,
+        index,
+        composerClient.state,
+        partClients.state,
+    ]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            composer: composerClient.methods,
+            reload: () => {
+                onReload === null || onReload === void 0 ? void 0 : onReload();
+            },
+            speak: () => { },
+            stopSpeaking: () => { },
+            submitFeedback: () => { },
+            switchToBranch: () => { },
+            getCopyText: () => message.content.map((c) => ("text" in c ? c.text : "")).join(""),
+            part: (selector) => {
+                if ("index" in selector) {
+                    return partClients.get(selector);
+                }
+                const partIndex = state.parts.findIndex((p) => p.type === "tool-call" && p.toolCallId === selector.toolCallId);
+                return partClients.get({ index: partIndex });
+            },
+            attachment: (selector) => {
+                if ("id" in selector) {
+                    return attachmentClients.get({ key: selector.id });
+                }
+                return attachmentClients.get(selector);
+            },
+            setIsCopied,
+            setIsHovering,
+        },
+    };
+});
+// Part Client - minimal implementation
+const PartResource = resource(({ part }) => {
+    const state = tapMemo(() => (Object.assign(Object.assign({}, part), { status: { type: "complete" } })), [part]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            addToolResult: () => { },
+            resumeToolCall: () => { },
+        },
+    };
+});
+// Attachment Client - minimal implementation
+const AttachmentResource = resource(({ attachment, onRemove, }) => {
+    return {
+        state: attachment,
+        methods: {
+            getState: () => attachment,
+            remove: async () => {
+                onRemove === null || onRemove === void 0 ? void 0 : onRemove();
+            },
+        },
+    };
+});
+// Composer Client - minimal implementation
+const ComposerClientResource = resource(({ type, isEditing, canCancel, onCancel, onBeginEdit, onSend, message, }) => {
+    const [text, setText] = tapState("");
+    const [role, setRole] = tapState("user");
+    const [runConfig, setRunConfig] = tapState({});
+    const [attachments, setAttachments] = tapState([]);
+    // Update composer values when editing begins
+    const updateFromMessage = tapEffectEvent(() => {
+        var _a;
+        if (message) {
+            // Extract text from message content (text parts only)
+            const textParts = message.content.filter((part) => part.type === "text");
+            const messageText = textParts
+                .map((part) => ("text" in part ? part.text : ""))
+                .join("\n\n");
+            setText(messageText);
+            setRole(message.role);
+            setAttachments((_a = message.attachments) !== null && _a !== void 0 ? _a : []);
+        }
+    });
+    tapEffect(() => {
+        if (isEditing) {
+            updateFromMessage();
+        }
+    }, [isEditing]);
+    const attachmentClients = tapClientLookup(() => attachments.map((attachment, idx) => withKey(attachment.id, AttachmentResource({
+        attachment,
+        onRemove: () => {
+            setAttachments(attachments.filter((_, i) => i !== idx));
+        },
+    }))), [attachments]);
+    const state = tapMemo(() => ({
+        text,
+        role,
+        attachments: attachmentClients.state,
+        runConfig,
+        isEditing,
+        canCancel,
+        attachmentAccept: "*",
+        isEmpty: !text.trim() && !attachments.length,
+        type,
+        dictation: undefined,
+    }), [
+        text,
+        role,
+        attachmentClients.state,
+        runConfig,
+        isEditing,
+        canCancel,
+        type,
+        attachments.length,
+    ]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            setText,
+            setRole,
+            setRunConfig,
+            addAttachment: async (file) => {
+                const newAttachment = {
+                    id: Math.random().toString(36).substring(7),
+                    type: "file",
+                    name: file.name,
+                    contentType: file.type,
+                    file,
+                    status: { type: "complete" },
+                    content: [],
+                };
+                setAttachments([...attachments, newAttachment]);
+            },
+            clearAttachments: async () => {
+                setAttachments([]);
+            },
+            attachment: (selector) => {
+                if ("id" in selector) {
+                    return attachmentClients.get({ key: selector.id });
+                }
+                return attachmentClients.get(selector);
+            },
+            reset: async () => {
+                setText("");
+                setRole("user");
+                setRunConfig({});
+                setAttachments([]);
+            },
+            send: () => {
+                const message = {
+                    role,
+                    content: text ? [{ type: "text", text }] : [],
+                    attachments: attachments,
+                    createdAt: new Date(),
+                    runConfig,
+                };
+                onSend === null || onSend === void 0 ? void 0 : onSend(message);
+                setText("");
+                setAttachments([]);
+            },
+            cancel: onCancel,
+            beginEdit: () => {
+                onBeginEdit === null || onBeginEdit === void 0 ? void 0 : onBeginEdit();
+            },
+            startDictation: () => { },
+            stopDictation: () => { },
+        },
+    };
+});
+// External Thread Client
+export const ExternalThread = resource(({ messages, isRunning = false, onNew, onEdit, onReload, onStartRun, onCancel, }) => {
+    const handleReload = (messageId) => {
+        const messageIndex = messages.findIndex((m) => m.id === messageId);
+        if (messageIndex === -1)
+            return;
+        const parentId = messageIndex > 0 ? messages[messageIndex - 1].id : null;
+        onReload === null || onReload === void 0 ? void 0 : onReload(parentId);
+    };
+    const messageClients = tapClientLookup(() => messages.map((msg, index) => {
+        const props = {
+            message: msg,
+            index,
+            onReload: () => handleReload(msg.id),
+        };
+        if (onEdit)
+            props.onEdit = onEdit;
+        return withKey(msg.id, MessageClient(props));
+    }), [messages, onEdit]);
+    const handleCancelRun = () => {
+        onCancel === null || onCancel === void 0 ? void 0 : onCancel();
+    };
+    const handleSendNew = (message) => {
+        onNew === null || onNew === void 0 ? void 0 : onNew(message);
+    };
+    const composerClient = tapClientResource(ComposerClientResource({
+        type: "thread",
+        isEditing: true,
+        canCancel: isRunning,
+        onCancel: handleCancelRun,
+        onSend: handleSendNew,
+    }));
+    const state = tapMemo(() => {
+        const messageStates = messageClients.state.map((s, idx, arr) => (Object.assign(Object.assign({}, s), { isLast: idx === arr.length - 1 })));
+        return {
+            isEmpty: messages.length === 0,
+            isDisabled: false,
+            isLoading: false,
+            isRunning,
+            capabilities: {
+                edit: false,
+                reload: false,
+                cancel: isRunning,
+                speech: false,
+                attachments: false,
+                feedback: false,
+                switchToBranch: false,
+                switchBranchDuringRun: false,
+                unstable_copy: false,
+                dictation: false,
+            },
+            messages: messageStates,
+            state: {},
+            suggestions: [],
+            extras: undefined,
+            speech: undefined,
+            composer: composerClient.state,
+        };
+    }, [messages, isRunning, messageClients.state, composerClient.state]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            composer: composerClient.methods,
+            append: (message) => {
+                onNew === null || onNew === void 0 ? void 0 : onNew(message);
+            },
+            startRun: () => {
+                onStartRun === null || onStartRun === void 0 ? void 0 : onStartRun();
+            },
+            unstable_resumeRun: () => { },
+            cancelRun: handleCancelRun,
+            getModelContext: () => ({ tools: {}, config: {} }),
+            export: () => ({ messages: [] }),
+            import: () => { },
+            reset: () => { },
+            message: (selector) => {
+                if ("id" in selector) {
+                    return messageClients.get({ key: selector.id });
+                }
+                return messageClients.get(selector);
+            },
+            stopSpeaking: () => { },
+            startVoice: async () => { },
+            stopVoice: async () => { },
+        },
+    };
+});
+attachDefaultPeers(ExternalThread, {
+    modelContext: ModelContext(),
+    tools: Tools({}),
+    suggestions: Suggestions(),
+    composer: Derived({
+        source: "thread",
+        query: {},
+        get: (aui) => aui.thread().composer,
+    }),
+});

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

@@ -0,0 +1,8 @@
+import { type ClientOutput } from "@assistant-ui/store";
+import type { ResourceElement } from "@assistant-ui/tap";
+export type InMemoryThreadListProps = {
+    thread: (threadId: string) => ResourceElement<ClientOutput<"thread">>;
+    onSwitchToThread?: (threadId: string) => void;
+    onSwitchToNewThread?: () => void;
+};
+export declare const InMemoryThreadList: any;

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

@@ -0,0 +1,129 @@
+import { resource, tapState, tapMemo } from "@assistant-ui/tap";
+import { tapClientLookup, Derived, attachDefaultPeers, tapClientResource, } from "@assistant-ui/store";
+import { withKey } from "@assistant-ui/tap";
+import { Suggestions } from "./Suggestions";
+import { ModelContext } from "./ModelContextClient";
+import { Tools } from "./Tools";
+// ThreadListItem Client
+const ThreadListItemClient = resource((props) => {
+    const { data, onSwitchTo, onArchive, onUnarchive, onDelete } = props;
+    const state = tapMemo(() => ({
+        id: data.id,
+        remoteId: undefined,
+        externalId: undefined,
+        title: data.title,
+        status: data.status,
+    }), [data.id, data.title, data.status]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            switchTo: onSwitchTo,
+            rename: () => { },
+            archive: onArchive,
+            unarchive: onUnarchive,
+            delete: onDelete,
+            generateTitle: () => { },
+            initialize: async () => ({ remoteId: data.id, externalId: undefined }),
+            detach: () => { },
+        },
+    };
+});
+// InMemoryThreadList Client
+export const InMemoryThreadList = resource((props) => {
+    const { thread: threadFactory, onSwitchToThread, onSwitchToNewThread, } = props;
+    const [mainThreadId, setMainThreadId] = tapState("main");
+    const [threads, setThreads] = tapState(() => [
+        { id: "main", title: "Main Thread", status: "regular" },
+    ]);
+    const handleSwitchToThread = (threadId) => {
+        setMainThreadId(threadId);
+        onSwitchToThread === null || onSwitchToThread === void 0 ? void 0 : onSwitchToThread(threadId);
+    };
+    const handleArchive = (threadId) => {
+        setThreads((prev) => prev.map((t) => t.id === threadId ? Object.assign(Object.assign({}, t), { status: "archived" }) : t));
+    };
+    const handleUnarchive = (threadId) => {
+        setThreads((prev) => prev.map((t) => t.id === threadId ? Object.assign(Object.assign({}, t), { status: "regular" }) : t));
+    };
+    const handleDelete = (threadId) => {
+        var _a;
+        setThreads((prev) => prev.filter((t) => t.id !== threadId));
+        if (mainThreadId === threadId) {
+            const remaining = threads.filter((t) => t.id !== threadId);
+            setMainThreadId(((_a = remaining[0]) === null || _a === void 0 ? void 0 : _a.id) || "main");
+        }
+    };
+    const handleSwitchToNewThread = () => {
+        const newId = `thread-${Date.now()}`;
+        setThreads((prev) => [
+            ...prev,
+            { id: newId, title: "New Thread", status: "regular" },
+        ]);
+        setMainThreadId(newId);
+        onSwitchToNewThread === null || onSwitchToNewThread === void 0 ? void 0 : onSwitchToNewThread();
+    };
+    const threadListItems = tapClientLookup(() => threads.map((t) => withKey(t.id, ThreadListItemClient({
+        data: t,
+        onSwitchTo: () => handleSwitchToThread(t.id),
+        onArchive: () => handleArchive(t.id),
+        onUnarchive: () => handleUnarchive(t.id),
+        onDelete: () => handleDelete(t.id),
+    }))), [threads]);
+    // Create the main thread
+    const mainThreadClient = tapClientResource(threadFactory(mainThreadId));
+    const state = tapMemo(() => {
+        const regularThreads = threads.filter((t) => t.status === "regular");
+        const archivedThreads = threads.filter((t) => t.status === "archived");
+        const mainThreadState = mainThreadClient.state;
+        return {
+            mainThreadId,
+            newThreadId: null,
+            isLoading: false,
+            threadIds: regularThreads.map((t) => t.id),
+            archivedThreadIds: archivedThreads.map((t) => t.id),
+            threadItems: threadListItems.state,
+            main: mainThreadState,
+        };
+    }, [mainThreadId, threads, threadListItems.state, mainThreadClient.state]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            switchToThread: handleSwitchToThread,
+            switchToNewThread: handleSwitchToNewThread,
+            item: (selector) => {
+                if (selector === "main") {
+                    const index = threads.findIndex((t) => t.id === mainThreadId);
+                    return threadListItems.get({ index: index === -1 ? 0 : index });
+                }
+                if ("id" in selector) {
+                    const index = threads.findIndex((t) => t.id === selector.id);
+                    return threadListItems.get({ index });
+                }
+                return threadListItems.get(selector);
+            },
+            thread: () => mainThreadClient.methods,
+        },
+    };
+});
+attachDefaultPeers(InMemoryThreadList, {
+    thread: Derived({
+        source: "threads",
+        query: { type: "main" },
+        get: (aui) => aui.threads().thread("main"),
+    }),
+    threadListItem: Derived({
+        source: "threads",
+        query: { type: "main" },
+        get: (aui) => aui.threads().item("main"),
+    }),
+    composer: Derived({
+        source: "thread",
+        query: {},
+        get: (aui) => aui.threads().thread("main").composer,
+    }),
+    modelContext: ModelContext(),
+    tools: Tools({}),
+    suggestions: Suggestions(),
+});

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

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

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

@@ -0,0 +1,16 @@
+import { resource, tapMemo, tapState } from "@assistant-ui/tap";
+import { CompositeContextProvider } from "../utils/CompositeContextProvider";
+const version = 1;
+export const ModelContext = resource(() => {
+    const [state] = tapState(() => ({ version: version + 1 }));
+    const composite = tapMemo(() => new CompositeContextProvider(), []);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            getModelContext: () => composite.getModelContext(),
+            subscribe: (callback) => composite.subscribe(callback),
+            register: (provider) => composite.registerModelContextProvider(provider),
+        },
+    };
+});

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

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

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

@@ -0,0 +1,60 @@
+"use client";
+import { resource, tapMemo } from "@assistant-ui/tap";
+export const NoOpComposerClient = resource(({ type }) => {
+    const state = tapMemo(() => {
+        return {
+            isEditing: false,
+            isEmpty: true,
+            text: "",
+            attachmentAccept: "*",
+            attachments: [],
+            role: "user",
+            runConfig: {},
+            canCancel: false,
+            type: type,
+            dictation: undefined,
+        };
+    }, [type]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            setText: () => {
+                throw new Error("Not supported");
+            },
+            setRole: () => {
+                throw new Error("Not supported");
+            },
+            setRunConfig: () => {
+                throw new Error("Not supported");
+            },
+            addAttachment: () => {
+                throw new Error("Not supported");
+            },
+            clearAttachments: () => {
+                throw new Error("Not supported");
+            },
+            attachment: () => {
+                throw new Error("Not supported");
+            },
+            reset: () => {
+                throw new Error("Not supported");
+            },
+            send: () => {
+                throw new Error("Not supported");
+            },
+            cancel: () => {
+                throw new Error("Not supported");
+            },
+            startDictation: () => {
+                throw new Error("Not supported");
+            },
+            stopDictation: () => {
+                throw new Error("Not supported");
+            },
+            beginEdit: () => {
+                throw new Error("Not supported");
+            },
+        },
+    };
+});

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

@@ -0,0 +1,10 @@
+import { type ClientOutput } from "@assistant-ui/store";
+export type SuggestionConfig = string | {
+    title: string;
+    label: string;
+    prompt: string;
+};
+export declare const Suggestions: {
+    (): import("@assistant-ui/tap").ResourceElement<ClientOutput<"suggestions">, undefined>;
+    (suggestions: SuggestionConfig[]): import("@assistant-ui/tap").ResourceElement<ClientOutput<"suggestions">, SuggestionConfig[]>;
+};

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

@@ -0,0 +1,42 @@
+import { resource, tapState, withKey } from "@assistant-ui/tap";
+import { tapClientLookup } from "@assistant-ui/store";
+const SuggestionClient = resource((state) => {
+    return {
+        state,
+        methods: {
+            getState: () => state,
+        },
+    };
+});
+const SuggestionsResource = resource((suggestions) => {
+    const [state] = tapState(() => {
+        const normalizedSuggestions = (suggestions !== null && suggestions !== void 0 ? suggestions : []).map((s) => {
+            if (typeof s === "string") {
+                return {
+                    title: s,
+                    label: "",
+                    prompt: s,
+                };
+            }
+            return {
+                title: s.title,
+                label: s.label,
+                prompt: s.prompt,
+            };
+        });
+        return {
+            suggestions: normalizedSuggestions,
+        };
+    });
+    const suggestionClients = tapClientLookup(() => state.suggestions.map((suggestion, index) => withKey(index, SuggestionClient(suggestion))), [state.suggestions]);
+    return {
+        state,
+        methods: {
+            getState: () => state,
+            suggestion: ({ index }) => {
+                return suggestionClients.get({ index });
+            },
+        },
+    };
+});
+export const Suggestions = SuggestionsResource;

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

@@ -0,0 +1,9 @@
+import { ThreadMessage } from "../types";
+export type ThreadMessageClientProps = {
+    message: ThreadMessage;
+    index: number;
+    isLast?: boolean;
+    branchNumber?: number;
+    branchCount?: number;
+};
+export declare const ThreadMessageClient: any;