@kognitivedev/ui 0.2.11

package/dist/primitives/tool-ui/tool-ui-root.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolUIRoot = ToolUIRoot;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const tool_ui_context_1 = require("../../tool-ui/tool-ui-context");
+const tool_ui_fallback_1 = require("./tool-ui-fallback");
+function ToolUIRoot(props) {
+    let registry;
+    try {
+        registry = (0, tool_ui_context_1.useToolUIRegistry)();
+    }
+    catch (_a) {
+        // Registry not available
+    }
+    const RegisteredUI = registry === null || registry === void 0 ? void 0 : registry.get(props.toolName);
+    if (RegisteredUI) {
+        return (0, jsx_runtime_1.jsx)(RegisteredUI, Object.assign({}, props));
+    }
+    return (0, jsx_runtime_1.jsx)(tool_ui_fallback_1.ToolUIFallback, Object.assign({}, props));
+}

package/dist/primitives/tool-ui/use-tool-ui.d.ts

@@ -0,0 +1,2 @@
+import type { ToolUIComponent } from "../../tool-ui/types";
+export declare function useToolUI(toolName: string): ToolUIComponent | undefined;

package/dist/primitives/tool-ui/use-tool-ui.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToolUI = useToolUI;
+const tool_ui_context_1 = require("../../tool-ui/tool-ui-context");
+function useToolUI(toolName) {
+    const registry = (0, tool_ui_context_1.useToolUIRegistry)();
+    return registry.get(toolName);
+}

package/dist/runtime/kognitive-runtime.d.ts

@@ -0,0 +1,30 @@
+import type { DefaultChatTransport, UIMessage } from "ai";
+import { ThreadManager } from "./thread-manager";
+import type { ToolUIRegistry } from "../tool-ui/registry";
+export interface KognitiveRuntimeConfig {
+    /** Base URL of the Kognitive runtime */
+    baseUrl: string;
+    /** Agent name to connect to */
+    agentName: string;
+    /** Additional headers (e.g., auth) */
+    headers?: Record<string, string>;
+    /** User identity */
+    resourceId?: {
+        userId?: string;
+    };
+    /** Initial session/thread ID */
+    sessionId?: string;
+    /** Enable thread management. When true, uses threadApiBase for CRUD. */
+    threads?: boolean;
+    /** Thread API base URL. Defaults to {baseUrl}/api/agents/{agentName}/threads */
+    threadApiBase?: string;
+    /** Tool UI registry */
+    toolUIRegistry?: ToolUIRegistry;
+}
+export declare class KognitiveRuntime {
+    readonly config: KognitiveRuntimeConfig;
+    readonly threadManager: ThreadManager | null;
+    readonly toolUIRegistry: ToolUIRegistry | null;
+    constructor(config: KognitiveRuntimeConfig);
+    createTransport(sessionId?: string): DefaultChatTransport<UIMessage>;
+}

package/dist/runtime/kognitive-runtime.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveRuntime = void 0;
+const kognitive_transport_1 = require("./kognitive-transport");
+const thread_manager_1 = require("./thread-manager");
+class KognitiveRuntime {
+    constructor(config) {
+        var _a, _b;
+        this.config = config;
+        this.toolUIRegistry = (_a = config.toolUIRegistry) !== null && _a !== void 0 ? _a : null;
+        if (config.threads) {
+            const threadApiBase = (_b = config.threadApiBase) !== null && _b !== void 0 ? _b : `${config.baseUrl.replace(/\/$/, "")}/api/agents/${encodeURIComponent(config.agentName)}/threads`;
+            this.threadManager = new thread_manager_1.ThreadManager({
+                baseUrl: threadApiBase,
+                headers: config.headers,
+            });
+        }
+        else {
+            this.threadManager = null;
+        }
+    }
+    createTransport(sessionId) {
+        return (0, kognitive_transport_1.createKognitiveTransport)({
+            baseUrl: this.config.baseUrl,
+            agentName: this.config.agentName,
+            sessionId: sessionId !== null && sessionId !== void 0 ? sessionId : this.config.sessionId,
+            resourceId: this.config.resourceId,
+            headers: this.config.headers,
+        });
+    }
+}
+exports.KognitiveRuntime = KognitiveRuntime;

package/dist/runtime/kognitive-transport.d.ts

@@ -0,0 +1,26 @@
+import { DefaultChatTransport, type UIMessage } from "ai";
+export interface KognitiveTransportConfig {
+    /**
+     * Explicit API endpoint URL for streaming.
+     * When set, takes priority over baseUrl + agentName URL construction.
+     * Use this for custom proxy routes (e.g., "/api/chat").
+     */
+    api?: string;
+    /** Base URL of the Kognitive runtime. Combined with agentName to construct the stream URL. */
+    baseUrl?: string;
+    /** Agent name. Used with baseUrl to build the URL. Also sent in body when using `api` mode. */
+    agentName?: string;
+    /** Current session/thread ID — sent in every request body */
+    sessionId?: string;
+    /** User identity — sent in every request body as resourceId */
+    resourceId?: {
+        userId?: string;
+        sessionId?: string;
+        organizationId?: string;
+    };
+    /** Additional headers (e.g., auth) */
+    headers?: Record<string, string>;
+    /** Extra fields merged into every request body (e.g., { agentName: "assistant" }) */
+    body?: Record<string, unknown>;
+}
+export declare function createKognitiveTransport(config: KognitiveTransportConfig): DefaultChatTransport<UIMessage>;

package/dist/runtime/kognitive-transport.js

@@ -0,0 +1,42 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKognitiveTransport = createKognitiveTransport;
+const ai_1 = require("ai");
+function createKognitiveTransport(config) {
+    var _a;
+    let apiUrl;
+    if (config.api) {
+        apiUrl = config.api;
+    }
+    else if (config.baseUrl && config.agentName) {
+        apiUrl = `${config.baseUrl.replace(/\/$/, "")}/api/agents/${encodeURIComponent(config.agentName)}/stream`;
+    }
+    else {
+        throw new Error("createKognitiveTransport requires either `api` or both `baseUrl` and `agentName`.");
+    }
+    return new ai_1.DefaultChatTransport({
+        api: apiUrl,
+        headers: (_a = config.headers) !== null && _a !== void 0 ? _a : {},
+        body: () => {
+            var _a;
+            return (Object.assign(Object.assign(Object.assign(Object.assign({}, ((_a = config.body) !== null && _a !== void 0 ? _a : {})), (config.agentName && config.api ? { agentName: config.agentName } : {})), (config.sessionId ? { sessionId: config.sessionId } : {})), (config.resourceId ? { resourceId: config.resourceId } : {})));
+        },
+        prepareSendMessagesRequest: async ({ messages, body }) => ({
+            body: Object.assign(Object.assign({}, (body !== null && body !== void 0 ? body : {})), { messages: await (0, ai_1.convertToModelMessages)(messages.map((_a) => {
+                    var { id: _id } = _a, message = __rest(_a, ["id"]);
+                    return message;
+                })) }),
+        }),
+    });
+}

package/dist/runtime/thread-manager.d.ts

@@ -0,0 +1,17 @@
+import type { ThreadSummary, ThreadDetail } from "./types";
+export interface ThreadManagerConfig {
+    /** Base URL for thread API endpoints */
+    baseUrl: string;
+    /** Additional headers (e.g., auth) */
+    headers?: Record<string, string>;
+}
+export declare class ThreadManager {
+    private baseUrl;
+    private headers;
+    constructor(config: ThreadManagerConfig);
+    list(): Promise<ThreadSummary[]>;
+    get(sessionId: string): Promise<ThreadDetail>;
+    create(): Promise<ThreadSummary>;
+    fork(sessionId: string): Promise<ThreadSummary>;
+    interrupt(sessionId: string): Promise<void>;
+}

package/dist/runtime/thread-manager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadManager = void 0;
+class ThreadManager {
+    constructor(config) {
+        var _a;
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.headers = Object.assign({ "Content-Type": "application/json" }, ((_a = config.headers) !== null && _a !== void 0 ? _a : {}));
+    }
+    async list() {
+        var _a;
+        const res = await fetch(this.baseUrl, { headers: this.headers });
+        if (!res.ok) {
+            throw new Error((await res.json().catch(() => ({ error: "Failed to list threads" }))).error);
+        }
+        const data = await res.json();
+        return ((_a = data.threads) !== null && _a !== void 0 ? _a : []);
+    }
+    async get(sessionId) {
+        const res = await fetch(`${this.baseUrl}/${encodeURIComponent(sessionId)}`, {
+            headers: this.headers,
+        });
+        if (!res.ok) {
+            throw new Error((await res.json().catch(() => ({ error: "Failed to get thread" }))).error);
+        }
+        return (await res.json());
+    }
+    async create() {
+        const res = await fetch(this.baseUrl, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({}),
+        });
+        if (!res.ok) {
+            throw new Error((await res.json().catch(() => ({ error: "Failed to create thread" }))).error);
+        }
+        const data = await res.json();
+        return data.thread;
+    }
+    async fork(sessionId) {
+        const res = await fetch(`${this.baseUrl}/${encodeURIComponent(sessionId)}/fork`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({}),
+        });
+        if (!res.ok) {
+            throw new Error((await res.json().catch(() => ({ error: "Failed to fork thread" }))).error);
+        }
+        const data = await res.json();
+        return data.thread;
+    }
+    async interrupt(sessionId) {
+        const res = await fetch(`${this.baseUrl}/${encodeURIComponent(sessionId)}/interrupt`, {
+            method: "POST",
+            headers: this.headers,
+        });
+        if (!res.ok) {
+            throw new Error((await res.json().catch(() => ({ error: "Failed to interrupt thread" }))).error);
+        }
+    }
+}
+exports.ThreadManager = ThreadManager;

package/dist/runtime/types.d.ts

@@ -0,0 +1,58 @@
+export type ThreadSummary = {
+    sessionDbId: string;
+    sessionId: string;
+    title: string;
+    status: string;
+    updatedAt: string;
+    messageCount: number;
+    lastUserPreview: string;
+    lastAssistantPreview: string;
+    lastError?: string | null;
+    lastTraceDbId?: string | null;
+};
+export type ThreadEvent = {
+    id: string;
+    sequence: number;
+    eventType: "user_message" | "assistant_message" | "tool_call" | "tool_result" | "status";
+    payload: Record<string, unknown>;
+    createdAt: string;
+};
+export type ThreadTrace = {
+    id: string;
+    traceId: string;
+    state: string;
+    durationMs: number | null;
+    totalCostCents: number;
+    inputTokens: number;
+    outputTokens: number;
+    modelId: string | null;
+    createdAt: string;
+};
+export type ThreadRun = {
+    id: string;
+    runId: string;
+    agentName: string;
+    status: string;
+    triggerType: string;
+    inputPreview: string | null;
+    outputPreview: string | null;
+    inputTokens: number;
+    outputTokens: number;
+    totalCostCents: number;
+    durationMs: number | null;
+    startedAt: string;
+    completedAt: string | null;
+    parentRunId: string | null;
+};
+export type ThreadDetail = {
+    session: {
+        id: string;
+        sessionId: string;
+        messageCount: number;
+        metadata?: Record<string, unknown> | null;
+    };
+    events: ThreadEvent[];
+    traces: ThreadTrace[];
+    runs: ThreadRun[];
+};
+export type RuntimeStatus = "ready" | "submitted" | "streaming" | "error";

package/dist/runtime/types.js

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

package/dist/tool-ui/make-tool-ui.d.ts

@@ -0,0 +1,59 @@
+import type { ReactNode } from "react";
+import type { ToolUIRenderProps, ToolUIRegistration } from "./types";
+/**
+ * Options for makeToolUI when using a @kognitivedev/tools Tool definition.
+ * The tool's inputSchema and outputSchema provide type inference.
+ */
+export interface MakeToolUIOptions<TInput = any, TOutput = any> {
+    /** The tool definition from createTool(). Provides name and type info. */
+    tool: {
+        id: string;
+        inputSchema?: unknown;
+        outputSchema?: unknown;
+    };
+    /** Render function with fully typed props from the tool definition. */
+    render: (props: ToolUIRenderProps<TInput, TOutput>) => ReactNode;
+}
+/**
+ * Options for makeToolUI when registering by tool name string.
+ */
+export interface MakeToolUIByNameOptions {
+    /** The tool name (must match the tool ID used on the server) */
+    toolName: string;
+    /** Render function for the tool UI */
+    render: (props: ToolUIRenderProps) => ReactNode;
+}
+/**
+ * Create a type-safe tool UI registration from a @kognitivedev/tools Tool definition.
+ *
+ * @example
+ * ```tsx
+ * const weatherTool = createTool({
+ *   id: "get_weather",
+ *   inputSchema: z.object({ city: z.string() }),
+ *   execute: async ({ city }) => ({ temp: 22 }),
+ * });
+ *
+ * const WeatherUI = makeToolUI({
+ *   tool: weatherTool,
+ *   render: ({ input, output, state }) => (
+ *     <div>{input.city}: {output?.temp}°</div>
+ *   ),
+ * });
+ * ```
+ */
+export declare function makeToolUI<TInput, TOutput>(options: MakeToolUIOptions<TInput, TOutput>): ToolUIRegistration;
+/**
+ * Create a tool UI registration by tool name string.
+ *
+ * @example
+ * ```tsx
+ * const SearchUI = makeToolUI({
+ *   toolName: "search",
+ *   render: ({ input, output, state }) => (
+ *     <div>Searching for {input.query}...</div>
+ *   ),
+ * });
+ * ```
+ */
+export declare function makeToolUI(options: MakeToolUIByNameOptions): ToolUIRegistration;

package/dist/tool-ui/make-tool-ui.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToolUI = makeToolUI;
+function makeToolUI(options) {
+    const toolName = "tool" in options ? options.tool.id : options.toolName;
+    return {
+        toolName,
+        component: options.render,
+    };
+}

package/dist/tool-ui/registry.d.ts

@@ -0,0 +1,9 @@
+import type { ToolUIComponent, ToolUIRegistration } from "./types";
+export declare class ToolUIRegistry {
+    private map;
+    register(registration: ToolUIRegistration): void;
+    registerAll(registrations: ToolUIRegistration[]): void;
+    get(toolName: string): ToolUIComponent | undefined;
+    has(toolName: string): boolean;
+    names(): string[];
+}

package/dist/tool-ui/registry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolUIRegistry = void 0;
+class ToolUIRegistry {
+    constructor() {
+        this.map = new Map();
+    }
+    register(registration) {
+        this.map.set(registration.toolName, registration.component);
+    }
+    registerAll(registrations) {
+        for (const reg of registrations) {
+            this.register(reg);
+        }
+    }
+    get(toolName) {
+        return this.map.get(toolName);
+    }
+    has(toolName) {
+        return this.map.has(toolName);
+    }
+    names() {
+        return Array.from(this.map.keys());
+    }
+}
+exports.ToolUIRegistry = ToolUIRegistry;

package/dist/tool-ui/tool-ui-context.d.ts

@@ -0,0 +1,2 @@
+import type { ToolUIRegistry } from "./registry";
+export declare const ToolUIRegistryProvider: import("react").Provider<ToolUIRegistry | null>, useToolUIRegistry: () => ToolUIRegistry, ToolUIRegistryContext: import("react").Context<ToolUIRegistry | null>;

package/dist/tool-ui/tool-ui-context.js

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

package/dist/tool-ui/toolkit.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from "react";
+import type { ToolUIRenderProps, ToolUIRegistration } from "./types";
+export interface ToolkitEntry {
+    /** Render function for this tool's UI */
+    render: (props: ToolUIRenderProps) => ReactNode;
+}
+/**
+ * Register multiple tool UIs at once by tool name.
+ *
+ * Useful when you don't have the Tool objects on the client
+ * (e.g., backend-only tools) but still want custom renderers.
+ *
+ * @example
+ * ```tsx
+ * const myToolkit = toolkit({
+ *   get_weather: {
+ *     render: ({ input, output, state }) => (
+ *       <WeatherCard city={input.city} data={output} />
+ *     ),
+ *   },
+ *   search_database: {
+ *     render: ({ input, output }) => (
+ *       <QueryResults query={input.query} results={output?.rows} />
+ *     ),
+ *   },
+ * });
+ *
+ * <KognitiveUI toolkit={myToolkit} ... />
+ * ```
+ */
+export declare function toolkit(map: Record<string, ToolkitEntry>): ToolUIRegistration[];

package/dist/tool-ui/toolkit.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolkit = toolkit;
+/**
+ * Register multiple tool UIs at once by tool name.
+ *
+ * Useful when you don't have the Tool objects on the client
+ * (e.g., backend-only tools) but still want custom renderers.
+ *
+ * @example
+ * ```tsx
+ * const myToolkit = toolkit({
+ *   get_weather: {
+ *     render: ({ input, output, state }) => (
+ *       <WeatherCard city={input.city} data={output} />
+ *     ),
+ *   },
+ *   search_database: {
+ *     render: ({ input, output }) => (
+ *       <QueryResults query={input.query} results={output?.rows} />
+ *     ),
+ *   },
+ * });
+ *
+ * <KognitiveUI toolkit={myToolkit} ... />
+ * ```
+ */
+function toolkit(map) {
+    return Object.entries(map).map(([toolName, entry]) => ({
+        toolName,
+        component: entry.render,
+    }));
+}

package/dist/tool-ui/types.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentType } from "react";
+export type ToolInvocationState = "input-streaming" | "input-available" | "approval-requested" | "approval-responded" | "output-available" | "error";
+export interface ToolUIRenderProps<TInput = any, TOutput = any> {
+    /** The tool's input arguments */
+    input: TInput;
+    /** The tool's output (undefined while executing) */
+    output: TOutput | undefined;
+    /** Current state of the tool invocation */
+    state: ToolInvocationState;
+    /** The tool call ID */
+    toolCallId: string;
+    /** The tool name */
+    toolName: string;
+}
+export type ToolUIComponent = ComponentType<ToolUIRenderProps<any, any>>;
+export interface ToolUIRegistration {
+    toolName: string;
+    component: ToolUIComponent;
+}

package/dist/tool-ui/types.js

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

package/dist/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/utils/cn.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cn = cn;
+const clsx_1 = require("clsx");
+const tailwind_merge_1 = require("tailwind-merge");
+function cn(...inputs) {
+    return (0, tailwind_merge_1.twMerge)((0, clsx_1.clsx)(inputs));
+}

package/dist/utils/create-context.d.ts

@@ -0,0 +1 @@
+export declare function createContext<T>(name: string): readonly [import("react").Provider<T | null>, () => T, import("react").Context<T | null>];

package/dist/utils/create-context.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+const react_1 = require("react");
+function createContext(name) {
+    const Context = (0, react_1.createContext)(null);
+    Context.displayName = name;
+    function useContextValue() {
+        const value = (0, react_1.useContext)(Context);
+        if (value === null) {
+            throw new Error(`use${name} must be used within a <${name}Provider>`);
+        }
+        return value;
+    }
+    return [Context.Provider, useContextValue, Context];
+}

package/dist/utils/message-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { UIMessage } from "ai";
+export declare function extractTextContent(content: unknown): string;
+export declare function getMessageText(message: UIMessage): string;
+export declare function getMessagePreview(message: UIMessage, maxLength?: number): string;
+export declare function getToolInvocations(message: UIMessage): import("ai").UIMessagePart<import("ai").UIDataTypes, import("ai").UITools>[];
+export declare function hasToolInvocations(message: UIMessage): boolean;

package/dist/utils/message-helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextContent = extractTextContent;
+exports.getMessageText = getMessageText;
+exports.getMessagePreview = getMessagePreview;
+exports.getToolInvocations = getToolInvocations;
+exports.hasToolInvocations = hasToolInvocations;
+function extractTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object")
+            return "";
+        if ("text" in part && typeof part.text === "string")
+            return part.text;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+}
+function getMessageText(message) {
+    return message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+}
+function getMessagePreview(message, maxLength = 80) {
+    const text = getMessageText(message);
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength).trimEnd() + "...";
+}
+function isToolPart(part) {
+    return part.type.startsWith("tool-") || part.type === "dynamic-tool";
+}
+function getToolInvocations(message) {
+    return message.parts.filter((part) => isToolPart(part));
+}
+function hasToolInvocations(message) {
+    return message.parts.some((part) => isToolPart(part));
+}