@kognitivedev/ui 0.2.11

package/dist/context/kognitive-context.js

@@ -0,0 +1,6 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveContext = exports.useKognitiveContext = exports.KognitiveContextProvider = void 0;
+const create_context_1 = require("../utils/create-context");
+_a = (0, create_context_1.createContext)("Kognitive"), exports.KognitiveContextProvider = _a[0], exports.useKognitiveContext = _a[1], exports.KognitiveContext = _a[2];

package/dist/context/types.d.ts

@@ -0,0 +1,44 @@
+import type { UIMessage, ChatStatus, FileUIPart } from "ai";
+import type { ThreadManager } from "../runtime/thread-manager";
+import type { ToolUIRegistry } from "../tool-ui/registry";
+import type { ThreadSummary } from "../runtime/types";
+export interface KognitiveContextValue {
+    /** Current messages in the thread */
+    messages: UIMessage[];
+    /** Send a message to the agent */
+    send: (text: string, options?: {
+        files?: FileUIPart[];
+    }) => void;
+    /** Current runtime status */
+    status: ChatStatus;
+    /** Whether the agent is currently streaming */
+    isStreaming: boolean;
+    /** Stop the current stream */
+    stop: () => void;
+    /** Replace the message list */
+    setMessages: (messages: UIMessage[]) => void;
+    /** Thread manager (null if threads not enabled) */
+    threadManager: ThreadManager | null;
+    /** Tool UI registry */
+    toolUIRegistry: ToolUIRegistry;
+    /** Active session ID */
+    activeSessionId: string | null;
+    /** Switch to a different thread */
+    setActiveSessionId: (sessionId: string | null) => void;
+    /** List of threads (empty if threads not enabled) */
+    threads: ThreadSummary[];
+    /** Reload threads list */
+    refreshThreads: () => Promise<void>;
+    /** Create a new thread and switch to it */
+    createThread: () => Promise<void>;
+    /** Agent name */
+    agentName: string;
+    /** Current error (from stream or network failure) */
+    error: Error | undefined;
+    /** Feedback callback — called when user rates a message */
+    onFeedback?: (messageId: string, type: "positive" | "negative") => void;
+    /** Tool approval callback — called when user approves/rejects a tool call */
+    onToolApproval?: (toolCallId: string, approved: boolean) => void;
+    /** Suggested follow-up prompts shown after assistant responds */
+    suggestions: string[];
+}

package/dist/context/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/context/use-kognitive.d.ts

@@ -0,0 +1 @@
+export declare function useKognitive(): import("./types").KognitiveContextValue;

package/dist/context/use-kognitive.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKognitive = useKognitive;
+const kognitive_context_1 = require("./kognitive-context");
+function useKognitive() {
+    return (0, kognitive_context_1.useKognitiveContext)();
+}

package/dist/hooks/use-auto-scroll.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from "react";
+export declare function useAutoScroll(deps: unknown[], containerRef?: RefObject<HTMLElement | null>): RefObject<HTMLDivElement | null>;

package/dist/hooks/use-auto-scroll.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAutoScroll = useAutoScroll;
+const react_1 = require("react");
+function useAutoScroll(deps, containerRef) {
+    const endRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (containerRef === null || containerRef === void 0 ? void 0 : containerRef.current) {
+            containerRef.current.scrollTop = containerRef.current.scrollHeight;
+        }
+        else {
+            (_a = endRef.current) === null || _a === void 0 ? void 0 : _a.scrollIntoView({ behavior: "smooth" });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+    return endRef;
+}

package/dist/hooks/use-copy-to-clipboard.d.ts

@@ -0,0 +1,4 @@
+export declare function useCopyToClipboard(resetDelay?: number): {
+    copied: boolean;
+    copy: (text: string) => Promise<void>;
+};

package/dist/hooks/use-copy-to-clipboard.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCopyToClipboard = useCopyToClipboard;
+const react_1 = require("react");
+function useCopyToClipboard(resetDelay = 2000) {
+    const [copied, setCopied] = (0, react_1.useState)(false);
+    const copy = (0, react_1.useCallback)(async (text) => {
+        await navigator.clipboard.writeText(text);
+        setCopied(true);
+        setTimeout(() => setCopied(false), resetDelay);
+    }, [resetDelay]);
+    return { copied, copy };
+}

package/dist/hooks/use-keyboard-shortcuts.d.ts

@@ -0,0 +1,8 @@
+export interface KeyboardShortcut {
+    key: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    handler: () => void;
+}
+export declare function useKeyboardShortcuts(shortcuts: KeyboardShortcut[]): void;

package/dist/hooks/use-keyboard-shortcuts.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeyboardShortcuts = useKeyboardShortcuts;
+const react_1 = require("react");
+function useKeyboardShortcuts(shortcuts) {
+    (0, react_1.useEffect)(() => {
+        function handleKeyDown(e) {
+            for (const shortcut of shortcuts) {
+                const ctrlOrMeta = shortcut.ctrl || shortcut.meta;
+                const matchesMod = ctrlOrMeta ? (e.ctrlKey || e.metaKey) : true;
+                const matchesShift = shortcut.shift ? e.shiftKey : !e.shiftKey;
+                if (e.key.toLowerCase() === shortcut.key.toLowerCase() &&
+                    matchesMod &&
+                    matchesShift) {
+                    e.preventDefault();
+                    shortcut.handler();
+                    return;
+                }
+            }
+        }
+        document.addEventListener("keydown", handleKeyDown);
+        return () => document.removeEventListener("keydown", handleKeyDown);
+    }, [shortcuts]);
+}

package/dist/hooks/use-kognitive-chat.d.ts

@@ -0,0 +1,38 @@
+import type { UIMessage, FileUIPart, ChatStatus } from "ai";
+export interface UseKognitiveChatConfig {
+    /** Explicit API endpoint URL (e.g., "/api/chat"). Takes priority over baseUrl+agentName. */
+    api?: string;
+    /** Agent name to connect to */
+    agentName?: string;
+    /** Base URL of the Kognitive runtime */
+    baseUrl?: string;
+    /** Current session/thread ID */
+    sessionId?: string;
+    /** User identity */
+    resourceId?: {
+        userId?: string;
+        sessionId?: string;
+        organizationId?: string;
+    };
+    /** Additional headers (e.g., auth) */
+    headers?: Record<string, string>;
+    /** Extra body fields merged into every request */
+    body?: Record<string, unknown>;
+}
+export interface UseKognitiveChatReturn {
+    /** Current messages */
+    messages: UIMessage[];
+    /** Send a text message, optionally with file attachments */
+    send: (text: string, options?: {
+        files?: FileUIPart[];
+    }) => void;
+    /** Current status */
+    status: ChatStatus;
+    /** Whether the agent is streaming */
+    isStreaming: boolean;
+    /** Stop the current stream */
+    stop: () => void;
+    /** Replace the message list */
+    setMessages: (messages: UIMessage[]) => void;
+}
+export declare function useKognitiveChat(config: UseKognitiveChatConfig): UseKognitiveChatReturn;

package/dist/hooks/use-kognitive-chat.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKognitiveChat = useKognitiveChat;
+const react_1 = require("react");
+const react_2 = require("@ai-sdk/react");
+const kognitive_transport_1 = require("../runtime/kognitive-transport");
+function useKognitiveChat(config) {
+    const transport = (0, react_1.useMemo)(() => (0, kognitive_transport_1.createKognitiveTransport)({
+        api: config.api,
+        baseUrl: config.baseUrl,
+        agentName: config.agentName,
+        sessionId: config.sessionId,
+        resourceId: config.resourceId,
+        headers: config.headers,
+        body: config.body,
+    }), [config.api, config.baseUrl, config.agentName, config.sessionId, config.resourceId, config.headers, config.body]);
+    const { messages, sendMessage, status, stop, setMessages } = (0, react_2.useChat)({
+        transport,
+    });
+    const send = (text, options) => {
+        const parts = [{ type: "text", text }];
+        if (options === null || options === void 0 ? void 0 : options.files) {
+            parts.push(...options.files);
+        }
+        sendMessage({ role: "user", parts });
+    };
+    return {
+        messages,
+        send,
+        status,
+        isStreaming: status === "streaming",
+        stop,
+        setMessages,
+    };
+}

package/dist/hooks/use-kognitive-event.d.ts

@@ -0,0 +1,12 @@
+export type KognitiveEventType = "message:send" | "message:received" | "status:change" | "tool:invoked" | "tool:completed" | "error";
+export type KognitiveEventHandler = (data: unknown) => void;
+export declare class KognitiveEventEmitter {
+    private listeners;
+    on(event: KognitiveEventType, handler: KognitiveEventHandler): () => void;
+    emit(event: KognitiveEventType, data?: unknown): void;
+}
+/**
+ * Subscribe to Kognitive lifecycle events.
+ * The handler is automatically cleaned up on unmount.
+ */
+export declare function useKognitiveEvent(emitter: KognitiveEventEmitter | undefined, event: KognitiveEventType, handler: KognitiveEventHandler): void;

package/dist/hooks/use-kognitive-event.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveEventEmitter = void 0;
+exports.useKognitiveEvent = useKognitiveEvent;
+const react_1 = require("react");
+class KognitiveEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, handler) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(handler);
+        return () => {
+            var _a;
+            (_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+        };
+    }
+    emit(event, data) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            for (const handler of handlers) {
+                try {
+                    handler(data);
+                }
+                catch (_a) {
+                    // Swallow listener errors
+                }
+            }
+        }
+    }
+}
+exports.KognitiveEventEmitter = KognitiveEventEmitter;
+/**
+ * Subscribe to Kognitive lifecycle events.
+ * The handler is automatically cleaned up on unmount.
+ */
+function useKognitiveEvent(emitter, event, handler) {
+    const handlerRef = (0, react_1.useRef)(handler);
+    handlerRef.current = handler;
+    (0, react_1.useEffect)(() => {
+        if (!emitter)
+            return;
+        return emitter.on(event, (data) => handlerRef.current(data));
+    }, [emitter, event]);
+}

package/dist/hooks/use-streaming-status.d.ts

@@ -0,0 +1,2 @@
+import type { ChatStatus } from "ai";
+export declare function useStreamingStatus(): ChatStatus;

package/dist/hooks/use-streaming-status.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStreamingStatus = useStreamingStatus;
+const kognitive_context_1 = require("../context/kognitive-context");
+function useStreamingStatus() {
+    const { status } = (0, kognitive_context_1.useKognitiveContext)();
+    return status;
+}

package/dist/hooks/use-thread-manager.d.ts

@@ -0,0 +1,20 @@
+import { type ThreadManagerConfig } from "../runtime/thread-manager";
+import type { ThreadSummary, ThreadDetail } from "../runtime/types";
+export interface UseThreadManagerConfig extends ThreadManagerConfig {
+    /** Auto-create a thread if none exist */
+    autoCreate?: boolean;
+}
+export interface UseThreadManagerReturn {
+    threads: ThreadSummary[];
+    activeSessionId: string | null;
+    threadDetail: ThreadDetail | null;
+    loadingThreads: boolean;
+    loadingThread: boolean;
+    setActiveSessionId: (sessionId: string | null) => void;
+    createThread: () => Promise<ThreadSummary>;
+    forkThread: (sessionId: string) => Promise<ThreadSummary>;
+    interruptThread: (sessionId: string) => Promise<void>;
+    refreshThreads: () => Promise<void>;
+    refreshThreadDetail: () => Promise<void>;
+}
+export declare function useThreadManager(config: UseThreadManagerConfig): UseThreadManagerReturn;

package/dist/hooks/use-thread-manager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useThreadManager = useThreadManager;
+const react_1 = require("react");
+const thread_manager_1 = require("../runtime/thread-manager");
+function useThreadManager(config) {
+    const [manager] = (0, react_1.useState)(() => new thread_manager_1.ThreadManager(config));
+    const [threads, setThreads] = (0, react_1.useState)([]);
+    const [activeSessionId, setActiveSessionId] = (0, react_1.useState)(null);
+    const [threadDetail, setThreadDetail] = (0, react_1.useState)(null);
+    const [loadingThreads, setLoadingThreads] = (0, react_1.useState)(true);
+    const [loadingThread, setLoadingThread] = (0, react_1.useState)(false);
+    const refreshThreads = (0, react_1.useCallback)(async (preferredSessionId) => {
+        setLoadingThreads(true);
+        try {
+            const nextThreads = await manager.list();
+            setThreads(nextThreads);
+            if (preferredSessionId) {
+                setActiveSessionId(preferredSessionId);
+            }
+            else if (!activeSessionId && nextThreads.length > 0) {
+                setActiveSessionId(nextThreads[0].sessionId);
+            }
+            else if (nextThreads.length === 0 && config.autoCreate) {
+                const thread = await manager.create();
+                setThreads([thread]);
+                setActiveSessionId(thread.sessionId);
+            }
+        }
+        finally {
+            setLoadingThreads(false);
+        }
+    }, [manager, activeSessionId, config.autoCreate]);
+    const refreshThreadDetail = (0, react_1.useCallback)(async () => {
+        if (!activeSessionId)
+            return;
+        setLoadingThread(true);
+        try {
+            const detail = await manager.get(activeSessionId);
+            setThreadDetail(detail);
+        }
+        finally {
+            setLoadingThread(false);
+        }
+    }, [manager, activeSessionId]);
+    const createThread = (0, react_1.useCallback)(async () => {
+        const thread = await manager.create();
+        await refreshThreads(thread.sessionId);
+        return thread;
+    }, [manager, refreshThreads]);
+    const forkThread = (0, react_1.useCallback)(async (sessionId) => {
+        const thread = await manager.fork(sessionId);
+        await refreshThreads(thread.sessionId);
+        return thread;
+    }, [manager, refreshThreads]);
+    const interruptThread = (0, react_1.useCallback)(async (sessionId) => {
+        await manager.interrupt(sessionId);
+        await refreshThreads(sessionId);
+        await refreshThreadDetail();
+    }, [manager, refreshThreads, refreshThreadDetail]);
+    (0, react_1.useEffect)(() => {
+        void refreshThreads();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (activeSessionId) {
+            void refreshThreadDetail();
+        }
+    }, [activeSessionId, refreshThreadDetail]);
+    return {
+        threads,
+        activeSessionId,
+        threadDetail,
+        loadingThreads,
+        loadingThread,
+        setActiveSessionId,
+        createThread,
+        forkThread,
+        interruptThread,
+        refreshThreads: () => refreshThreads(),
+        refreshThreadDetail,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+export { KognitiveUI, type KognitiveUIProps } from "./kognitive-ui";
+export { makeToolUI, type MakeToolUIOptions, type MakeToolUIByNameOptions } from "./tool-ui/make-tool-ui";
+export { toolkit, type ToolkitEntry } from "./tool-ui/toolkit";
+export { ToolUIRegistry } from "./tool-ui/registry";
+export type { ToolUIRegistration, ToolUIRenderProps, ToolUIComponent } from "./tool-ui/types";
+export { ThreadPrimitive } from "./primitives/thread";
+export { MessagePrimitive } from "./primitives/message";
+export { ComposerPrimitive } from "./primitives/composer";
+export { ActionBarPrimitive } from "./primitives/action-bar";
+export { ToolUIPrimitive } from "./primitives/tool-ui";
+export { ThreadListPrimitive } from "./primitives/thread-list";
+export { Thread } from "./components/thread";
+export { Message } from "./components/message";
+export { Composer } from "./components/composer";
+export { ThreadList } from "./components/thread-list";
+export { ToolInvocation } from "./components/tool-invocation";
+export { ToolApproval } from "./components/tool-approval";
+export { MarkdownContent } from "./components/markdown-content";
+export { AttachmentPreview } from "./components/attachment-preview";
+export { StatusIndicator } from "./components/status-indicator";
+export { ErrorBanner } from "./components/error-banner";
+export { Suggestions } from "./components/suggestions";
+export { useKognitiveChat, type UseKognitiveChatConfig, type UseKognitiveChatReturn } from "./hooks/use-kognitive-chat";
+export { useKognitive } from "./context/use-kognitive";
+export { useThreadManager, type UseThreadManagerConfig, type UseThreadManagerReturn } from "./hooks/use-thread-manager";
+export { useAutoScroll } from "./hooks/use-auto-scroll";
+export { useCopyToClipboard } from "./hooks/use-copy-to-clipboard";
+export { useStreamingStatus } from "./hooks/use-streaming-status";
+export { useKeyboardShortcuts, type KeyboardShortcut } from "./hooks/use-keyboard-shortcuts";
+export { useKognitiveEvent, KognitiveEventEmitter, type KognitiveEventType, type KognitiveEventHandler } from "./hooks/use-kognitive-event";
+export { useThread } from "./primitives/thread";
+export { useMessage } from "./primitives/message";
+export { useComposer } from "./primitives/composer";
+export { useThreadList } from "./primitives/thread-list";
+export { createKognitiveTransport, type KognitiveTransportConfig } from "./runtime/kognitive-transport";
+export { KognitiveRuntime, type KognitiveRuntimeConfig } from "./runtime/kognitive-runtime";
+export { ThreadManager, type ThreadManagerConfig } from "./runtime/thread-manager";
+export type { ThreadSummary, ThreadDetail, ThreadEvent, ThreadTrace, ThreadRun } from "./runtime/types";
+export type { ToolInvocationState } from "./tool-ui/types";
+export { cn } from "./utils/cn";
+export { getMessageText, getMessagePreview, getToolInvocations, hasToolInvocations, extractTextContent } from "./utils/message-helpers";

package/dist/index.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextContent = exports.hasToolInvocations = exports.getToolInvocations = exports.getMessagePreview = exports.getMessageText = exports.cn = exports.ThreadManager = exports.KognitiveRuntime = exports.createKognitiveTransport = exports.useThreadList = exports.useComposer = exports.useMessage = exports.useThread = exports.KognitiveEventEmitter = exports.useKognitiveEvent = exports.useKeyboardShortcuts = exports.useStreamingStatus = exports.useCopyToClipboard = exports.useAutoScroll = exports.useThreadManager = exports.useKognitive = exports.useKognitiveChat = exports.Suggestions = exports.ErrorBanner = exports.StatusIndicator = exports.AttachmentPreview = exports.MarkdownContent = exports.ToolApproval = exports.ToolInvocation = exports.ThreadList = exports.Composer = exports.Message = exports.Thread = exports.ThreadListPrimitive = exports.ToolUIPrimitive = exports.ActionBarPrimitive = exports.ComposerPrimitive = exports.MessagePrimitive = exports.ThreadPrimitive = exports.ToolUIRegistry = exports.toolkit = exports.makeToolUI = exports.KognitiveUI = void 0;
+// ── Root Provider ──
+var kognitive_ui_1 = require("./kognitive-ui");
+Object.defineProperty(exports, "KognitiveUI", { enumerable: true, get: function () { return kognitive_ui_1.KognitiveUI; } });
+// ── Tool UI System ──
+var make_tool_ui_1 = require("./tool-ui/make-tool-ui");
+Object.defineProperty(exports, "makeToolUI", { enumerable: true, get: function () { return make_tool_ui_1.makeToolUI; } });
+var toolkit_1 = require("./tool-ui/toolkit");
+Object.defineProperty(exports, "toolkit", { enumerable: true, get: function () { return toolkit_1.toolkit; } });
+var registry_1 = require("./tool-ui/registry");
+Object.defineProperty(exports, "ToolUIRegistry", { enumerable: true, get: function () { return registry_1.ToolUIRegistry; } });
+// ── Primitives ──
+var thread_1 = require("./primitives/thread");
+Object.defineProperty(exports, "ThreadPrimitive", { enumerable: true, get: function () { return thread_1.ThreadPrimitive; } });
+var message_1 = require("./primitives/message");
+Object.defineProperty(exports, "MessagePrimitive", { enumerable: true, get: function () { return message_1.MessagePrimitive; } });
+var composer_1 = require("./primitives/composer");
+Object.defineProperty(exports, "ComposerPrimitive", { enumerable: true, get: function () { return composer_1.ComposerPrimitive; } });
+var action_bar_1 = require("./primitives/action-bar");
+Object.defineProperty(exports, "ActionBarPrimitive", { enumerable: true, get: function () { return action_bar_1.ActionBarPrimitive; } });
+var tool_ui_1 = require("./primitives/tool-ui");
+Object.defineProperty(exports, "ToolUIPrimitive", { enumerable: true, get: function () { return tool_ui_1.ToolUIPrimitive; } });
+var thread_list_1 = require("./primitives/thread-list");
+Object.defineProperty(exports, "ThreadListPrimitive", { enumerable: true, get: function () { return thread_list_1.ThreadListPrimitive; } });
+// ── Composed Components ──
+var thread_2 = require("./components/thread");
+Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_2.Thread; } });
+var message_2 = require("./components/message");
+Object.defineProperty(exports, "Message", { enumerable: true, get: function () { return message_2.Message; } });
+var composer_2 = require("./components/composer");
+Object.defineProperty(exports, "Composer", { enumerable: true, get: function () { return composer_2.Composer; } });
+var thread_list_2 = require("./components/thread-list");
+Object.defineProperty(exports, "ThreadList", { enumerable: true, get: function () { return thread_list_2.ThreadList; } });
+var tool_invocation_1 = require("./components/tool-invocation");
+Object.defineProperty(exports, "ToolInvocation", { enumerable: true, get: function () { return tool_invocation_1.ToolInvocation; } });
+var tool_approval_1 = require("./components/tool-approval");
+Object.defineProperty(exports, "ToolApproval", { enumerable: true, get: function () { return tool_approval_1.ToolApproval; } });
+var markdown_content_1 = require("./components/markdown-content");
+Object.defineProperty(exports, "MarkdownContent", { enumerable: true, get: function () { return markdown_content_1.MarkdownContent; } });
+var attachment_preview_1 = require("./components/attachment-preview");
+Object.defineProperty(exports, "AttachmentPreview", { enumerable: true, get: function () { return attachment_preview_1.AttachmentPreview; } });
+var status_indicator_1 = require("./components/status-indicator");
+Object.defineProperty(exports, "StatusIndicator", { enumerable: true, get: function () { return status_indicator_1.StatusIndicator; } });
+var error_banner_1 = require("./components/error-banner");
+Object.defineProperty(exports, "ErrorBanner", { enumerable: true, get: function () { return error_banner_1.ErrorBanner; } });
+var suggestions_1 = require("./components/suggestions");
+Object.defineProperty(exports, "Suggestions", { enumerable: true, get: function () { return suggestions_1.Suggestions; } });
+// ── Hooks ──
+var use_kognitive_chat_1 = require("./hooks/use-kognitive-chat");
+Object.defineProperty(exports, "useKognitiveChat", { enumerable: true, get: function () { return use_kognitive_chat_1.useKognitiveChat; } });
+var use_kognitive_1 = require("./context/use-kognitive");
+Object.defineProperty(exports, "useKognitive", { enumerable: true, get: function () { return use_kognitive_1.useKognitive; } });
+var use_thread_manager_1 = require("./hooks/use-thread-manager");
+Object.defineProperty(exports, "useThreadManager", { enumerable: true, get: function () { return use_thread_manager_1.useThreadManager; } });
+var use_auto_scroll_1 = require("./hooks/use-auto-scroll");
+Object.defineProperty(exports, "useAutoScroll", { enumerable: true, get: function () { return use_auto_scroll_1.useAutoScroll; } });
+var use_copy_to_clipboard_1 = require("./hooks/use-copy-to-clipboard");
+Object.defineProperty(exports, "useCopyToClipboard", { enumerable: true, get: function () { return use_copy_to_clipboard_1.useCopyToClipboard; } });
+var use_streaming_status_1 = require("./hooks/use-streaming-status");
+Object.defineProperty(exports, "useStreamingStatus", { enumerable: true, get: function () { return use_streaming_status_1.useStreamingStatus; } });
+var use_keyboard_shortcuts_1 = require("./hooks/use-keyboard-shortcuts");
+Object.defineProperty(exports, "useKeyboardShortcuts", { enumerable: true, get: function () { return use_keyboard_shortcuts_1.useKeyboardShortcuts; } });
+var use_kognitive_event_1 = require("./hooks/use-kognitive-event");
+Object.defineProperty(exports, "useKognitiveEvent", { enumerable: true, get: function () { return use_kognitive_event_1.useKognitiveEvent; } });
+Object.defineProperty(exports, "KognitiveEventEmitter", { enumerable: true, get: function () { return use_kognitive_event_1.KognitiveEventEmitter; } });
+// ── Primitive Hooks ──
+var thread_3 = require("./primitives/thread");
+Object.defineProperty(exports, "useThread", { enumerable: true, get: function () { return thread_3.useThread; } });
+var message_3 = require("./primitives/message");
+Object.defineProperty(exports, "useMessage", { enumerable: true, get: function () { return message_3.useMessage; } });
+var composer_3 = require("./primitives/composer");
+Object.defineProperty(exports, "useComposer", { enumerable: true, get: function () { return composer_3.useComposer; } });
+var thread_list_3 = require("./primitives/thread-list");
+Object.defineProperty(exports, "useThreadList", { enumerable: true, get: function () { return thread_list_3.useThreadList; } });
+// ── Runtime (advanced) ──
+var kognitive_transport_1 = require("./runtime/kognitive-transport");
+Object.defineProperty(exports, "createKognitiveTransport", { enumerable: true, get: function () { return kognitive_transport_1.createKognitiveTransport; } });
+var kognitive_runtime_1 = require("./runtime/kognitive-runtime");
+Object.defineProperty(exports, "KognitiveRuntime", { enumerable: true, get: function () { return kognitive_runtime_1.KognitiveRuntime; } });
+var thread_manager_1 = require("./runtime/thread-manager");
+Object.defineProperty(exports, "ThreadManager", { enumerable: true, get: function () { return thread_manager_1.ThreadManager; } });
+// ── Utilities ──
+var cn_1 = require("./utils/cn");
+Object.defineProperty(exports, "cn", { enumerable: true, get: function () { return cn_1.cn; } });
+var message_helpers_1 = require("./utils/message-helpers");
+Object.defineProperty(exports, "getMessageText", { enumerable: true, get: function () { return message_helpers_1.getMessageText; } });
+Object.defineProperty(exports, "getMessagePreview", { enumerable: true, get: function () { return message_helpers_1.getMessagePreview; } });
+Object.defineProperty(exports, "getToolInvocations", { enumerable: true, get: function () { return message_helpers_1.getToolInvocations; } });
+Object.defineProperty(exports, "hasToolInvocations", { enumerable: true, get: function () { return message_helpers_1.hasToolInvocations; } });
+Object.defineProperty(exports, "extractTextContent", { enumerable: true, get: function () { return message_helpers_1.extractTextContent; } });

package/dist/kognitive-ui.d.ts

@@ -0,0 +1,48 @@
+import React from "react";
+import type { ToolUIRegistration } from "./tool-ui/types";
+export interface KognitiveUIProps {
+    /**
+     * Explicit API endpoint URL (e.g., "/api/chat").
+     * When set, takes priority over baseUrl + agentName for URL construction.
+     * agentName is sent in the request body instead.
+     */
+    api?: string;
+    /** Agent name to connect to */
+    agentName: string;
+    /** Base URL of the Kognitive runtime (or proxy). Used with agentName to build stream URL. */
+    baseUrl?: string;
+    /** Auth headers */
+    headers?: Record<string, string>;
+    /** User identity */
+    resourceId?: {
+        userId?: string;
+        sessionId?: string;
+        organizationId?: string;
+    };
+    /** Session/thread ID (controlled mode — disables thread management) */
+    sessionId?: string;
+    /** Enable thread management */
+    threads?: boolean;
+    /** Thread API base URL. Defaults to {baseUrl}/api/agents/{agentName}/threads */
+    threadApiBase?: string;
+    /** Tool UI registrations from makeToolUI() */
+    toolUIs?: ToolUIRegistration[];
+    /** Tool UI registrations from toolkit() */
+    toolkit?: ToolUIRegistration[];
+    /** Extra body fields merged into every request */
+    body?: Record<string, unknown>;
+    /** Callback when user rates an assistant message (thumbs up/down) */
+    onFeedback?: (messageId: string, type: "positive" | "negative") => void;
+    /** Callback when user approves or rejects a tool call */
+    onToolApproval?: (toolCallId: string, approved: boolean) => void;
+    /** Suggested follow-up prompts shown after assistant response */
+    suggestions?: string[];
+    /** Children */
+    children: React.ReactNode;
+}
+export declare function KognitiveUI(props: KognitiveUIProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace KognitiveUI {
+    var Thread: typeof import("./components/thread").Thread;
+    var ThreadList: typeof import("./components/thread-list").ThreadList;
+    var Composer: typeof import("./components/composer").Composer;
+}