@kognitivedev/ui 0.2.11

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# @kognitivedev/ui
+
+## 0.2.11
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/shared@0.2.11
+
+## 0.2.10
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/shared@0.2.10

package/README.md

@@ -0,0 +1,264 @@
+# @kognitivedev/ui
+
+React components for building agentic chat UIs with Kognitive. Drop-in `<Thread />` for instant results, or use headless primitives for full control.
+
+## Installation
+
+```bash
+bun add @kognitivedev/ui
+```
+
+**Peer dependencies:** `react`, `ai`, `@ai-sdk/react`, `zod`
+
+## Quick Start
+
+```tsx
+import { KognitiveUI } from "@kognitivedev/ui";
+
+function App() {
+  return (
+    <KognitiveUI agentName="my-agent" baseUrl="http://localhost:3001">
+      <KognitiveUI.Thread />
+    </KognitiveUI>
+  );
+}
+```
+
+Or point at a custom API route:
+
+```tsx
+<KognitiveUI api="/api/chat" agentName="assistant" resourceId={{ userId: "user-1" }}>
+  <KognitiveUI.Thread allowAttachments />
+</KognitiveUI>
+```
+
+## Features
+
+### Tool UI Registration
+
+Register custom React components for tool calls — type-safe when using `@kognitivedev/tools`:
+
+```tsx
+import { makeToolUI } from "@kognitivedev/ui";
+import { weatherTool } from "./tools";
+
+const WeatherUI = makeToolUI({
+  tool: weatherTool,
+  render: ({ input, output, state }) => (
+    <div>{input.city}: {output?.temp}deg</div>
+  ),
+});
+
+<KognitiveUI toolUIs={[WeatherUI]} ...>
+```
+
+Batch register by name with `toolkit()`:
+
+```tsx
+import { toolkit } from "@kognitivedev/ui";
+
+const myToolkit = toolkit({
+  "weather-lookup": { render: ({ input, output }) => <WeatherCard {...output} /> },
+  "calculate":      { render: ({ input, output }) => <span>{output?.result}</span> },
+});
+
+<KognitiveUI toolkit={myToolkit} ...>
+```
+
+### Message Editing
+
+Users can edit sent messages and regenerate from that point. The Edit button appears on user messages, and submitting the edit trims the conversation and re-sends.
+
+### Feedback / Ratings
+
+Thumbs up/down on assistant messages:
+
+```tsx
+<KognitiveUI
+  onFeedback={(messageId, type) => {
+    // type is "positive" or "negative"
+    fetch("/api/feedback", { method: "POST", body: JSON.stringify({ messageId, type }) });
+  }}
+>
+```
+
+### Suggested Follow-ups
+
+Show clickable suggestion chips after the assistant responds:
+
+```tsx
+<KognitiveUI suggestions={["What's the weather?", "Tell me more"]}>
+```
+
+### Tool Approval (Human-in-the-Loop)
+
+When a tool enters `approval-requested` state, an Approve/Reject card renders automatically:
+
+```tsx
+<KognitiveUI
+  onToolApproval={(toolCallId, approved) => {
+    console.log(`Tool ${toolCallId}: ${approved ? "approved" : "rejected"}`);
+  }}
+>
+```
+
+### Error Display
+
+Stream errors are shown as dismissible banners via `ThreadPrimitive.Error` and the `ErrorBanner` component.
+
+### File Attachments
+
+Click-to-upload, drag-and-drop, and paste-to-upload are all supported:
+
+```tsx
+<KognitiveUI.Thread allowAttachments />
+```
+
+### Keyboard Shortcuts
+
+```tsx
+import { useKeyboardShortcuts } from "@kognitivedev/ui";
+
+useKeyboardShortcuts([
+  { key: "Escape", handler: () => stop() },
+  { key: "k", ctrl: true, handler: () => clearMessages() },
+]);
+```
+
+### Events System
+
+```tsx
+import { useKognitiveEvent, KognitiveEventEmitter } from "@kognitivedev/ui";
+
+const emitter = new KognitiveEventEmitter();
+useKognitiveEvent(emitter, "message:received", (data) => {
+  analytics.track("message_received", data);
+});
+```
+
+Events: `message:send`, `message:received`, `status:change`, `tool:invoked`, `tool:completed`, `error`
+
+### Thread Management
+
+```tsx
+<KognitiveUI baseUrl="http://localhost:3001" agentName="agent" threads>
+  <div className="grid grid-cols-[280px_1fr]">
+    <KognitiveUI.ThreadList />
+    <KognitiveUI.Thread />
+  </div>
+</KognitiveUI>
+```
+
+## API Reference
+
+### `<KognitiveUI>` Props
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `api` | `string` | Explicit API endpoint URL. Takes priority over baseUrl+agentName. |
+| `agentName` | `string` | **Required.** Agent name. |
+| `baseUrl` | `string` | Base URL of the Kognitive runtime. |
+| `headers` | `Record<string, string>` | Auth headers. |
+| `resourceId` | `{ userId?, sessionId?, organizationId? }` | User identity. |
+| `sessionId` | `string` | Controlled session/thread ID. |
+| `threads` | `boolean` | Enable thread management sidebar. |
+| `threadApiBase` | `string` | Override thread API base URL. |
+| `toolUIs` | `ToolUIRegistration[]` | Tool UI registrations from `makeToolUI()`. |
+| `toolkit` | `ToolUIRegistration[]` | Tool UI registrations from `toolkit()`. |
+| `body` | `Record<string, unknown>` | Extra request body fields. |
+| `suggestions` | `string[]` | Follow-up prompt suggestions. |
+| `onFeedback` | `(messageId, type) => void` | Feedback callback (positive/negative). |
+| `onToolApproval` | `(toolCallId, approved) => void` | Tool approval callback. |
+
+### Primitives
+
+Headless, unstyled components. Compose them for full control.
+
+- **ThreadPrimitive** — `Root`, `Messages`, `Empty`, `Loading`, `Error`, `Suggestions`, `ScrollToBottom`
+- **MessagePrimitive** — `Root`, `Content`, `Role`
+- **ComposerPrimitive** — `Root`, `Input`, `Send`, `Attachments`, `AttachmentTrigger`, `EditRoot`
+- **ActionBarPrimitive** — `Root`, `Copy`, `Retry`, `Stop`, `Feedback`, `Edit`
+- **ToolUIPrimitive** — `Root`, `Fallback`
+- **ThreadListPrimitive** — `Root`, `Items`, `Item`, `New`
+
+### Composed Components
+
+Pre-styled with Tailwind. Every `className` is overridable.
+
+- `Thread` — Full chat: messages + composer + status + error + suggestions
+- `Message` — Bubble with avatar, content, edit mode, feedback, copy
+- `Composer` — Input + send + attachment support (drag-drop, paste)
+- `ThreadList` — Sidebar with thread items + new button
+- `ToolInvocation` — Collapsible tool card with approval UI
+- `ToolApproval` — Approve/reject card for tool calls
+- `MarkdownContent` — Basic markdown renderer
+- `ErrorBanner` — Dismissible error display
+- `Suggestions` — Follow-up prompt chips
+- `AttachmentPreview` — File/image thumbnails
+- `StatusIndicator` — Streaming/ready/error dot
+
+### Hooks
+
+- `useKognitiveChat(config)` — Standalone chat hook (no provider needed)
+- `useKognitive()` — Access full context (messages, send, status, error, etc.)
+- `useThreadManager(config)` — Thread CRUD operations
+- `useKeyboardShortcuts(shortcuts)` — Register keyboard shortcuts
+- `useKognitiveEvent(emitter, event, handler)` — Subscribe to lifecycle events
+- `useAutoScroll(deps)` — Auto-scroll on dependency change
+- `useCopyToClipboard()` — Copy text with success state
+- `useStreamingStatus()` — Get current ChatStatus
+
+### Primitive Hooks
+
+- `useThread()` — Thread-level state (messages, status, send, stop)
+- `useMessage()` — Message-level state (message, isEditing, startEdit, submitEdit)
+- `useComposer()` — Composer state (input, files, submit, isDisabled)
+- `useThreadList()` — Thread list state (threads, activeSessionId, createThread)
+
+## Custom Layout with Primitives
+
+```tsx
+import {
+  KognitiveUI,
+  ThreadPrimitive,
+  MessagePrimitive,
+  ComposerPrimitive,
+  ActionBarPrimitive,
+} from "@kognitivedev/ui";
+
+<KognitiveUI api="/api/chat" agentName="agent">
+  <ThreadPrimitive.Root>
+    <ThreadPrimitive.Empty>No messages yet</ThreadPrimitive.Empty>
+    <ThreadPrimitive.Error>{(err) => <p>{err.message}</p>}</ThreadPrimitive.Error>
+
+    <ThreadPrimitive.Messages>
+      {(message) => (
+        <MessagePrimitive.Root key={message.id} message={message}>
+          <MessagePrimitive.Content
+            components={{
+              Text: ({ text }) => <MyMarkdown>{text}</MyMarkdown>,
+            }}
+          />
+          <ActionBarPrimitive.Root>
+            <ActionBarPrimitive.Copy />
+            <ActionBarPrimitive.Feedback />
+            <ActionBarPrimitive.Edit />
+          </ActionBarPrimitive.Root>
+        </MessagePrimitive.Root>
+      )}
+    </ThreadPrimitive.Messages>
+
+    <ThreadPrimitive.Suggestions />
+
+    <ComposerPrimitive.Root>
+      <ComposerPrimitive.Attachments />
+      <ComposerPrimitive.Input placeholder="Ask..." />
+      <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+    </ComposerPrimitive.Root>
+  </ThreadPrimitive.Root>
+</KognitiveUI>
+```
+
+## License
+
+MIT

package/dist/__tests__/context-provider.test.d.ts

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

package/dist/__tests__/context-provider.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const registry_1 = require("../tool-ui/registry");
+(0, vitest_1.describe)("Context isolation", () => {
+    (0, vitest_1.it)("ToolUIRegistry can be constructed standalone", () => {
+        const registry = new registry_1.ToolUIRegistry();
+        (0, vitest_1.expect)(registry.names()).toHaveLength(0);
+    });
+    (0, vitest_1.it)("ToolUIRegistry supports full CRUD lifecycle", () => {
+        const registry = new registry_1.ToolUIRegistry();
+        // Initially empty
+        (0, vitest_1.expect)(registry.has("tool-a")).toBe(false);
+        (0, vitest_1.expect)(registry.get("tool-a")).toBeUndefined();
+        // Register
+        const component = () => null;
+        registry.register({ toolName: "tool-a", component });
+        (0, vitest_1.expect)(registry.has("tool-a")).toBe(true);
+        (0, vitest_1.expect)(registry.get("tool-a")).toBe(component);
+        (0, vitest_1.expect)(registry.names()).toContain("tool-a");
+        // Overwrite
+        const component2 = () => null;
+        registry.register({ toolName: "tool-a", component: component2 });
+        (0, vitest_1.expect)(registry.get("tool-a")).toBe(component2);
+        // Multiple
+        registry.register({ toolName: "tool-b", component });
+        (0, vitest_1.expect)(registry.names()).toHaveLength(2);
+    });
+    (0, vitest_1.it)("ToolUIRegistry.registerAll registers multiple at once", () => {
+        const registry = new registry_1.ToolUIRegistry();
+        registry.registerAll([
+            { toolName: "a", component: () => null },
+            { toolName: "b", component: () => null },
+            { toolName: "c", component: () => null },
+        ]);
+        (0, vitest_1.expect)(registry.names()).toHaveLength(3);
+    });
+});

package/dist/__tests__/event-emitter.test.d.ts

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

package/dist/__tests__/event-emitter.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const use_kognitive_event_1 = require("../hooks/use-kognitive-event");
+(0, vitest_1.describe)("KognitiveEventEmitter", () => {
+    (0, vitest_1.it)("emits events to registered listeners", () => {
+        const emitter = new use_kognitive_event_1.KognitiveEventEmitter();
+        const handler = vitest_1.vi.fn();
+        emitter.on("message:send", handler);
+        emitter.emit("message:send", { text: "hello" });
+        (0, vitest_1.expect)(handler).toHaveBeenCalledWith({ text: "hello" });
+    });
+    (0, vitest_1.it)("supports multiple listeners for the same event", () => {
+        const emitter = new use_kognitive_event_1.KognitiveEventEmitter();
+        const h1 = vitest_1.vi.fn();
+        const h2 = vitest_1.vi.fn();
+        emitter.on("message:received", h1);
+        emitter.on("message:received", h2);
+        emitter.emit("message:received", "data");
+        (0, vitest_1.expect)(h1).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(h2).toHaveBeenCalledOnce();
+    });
+    (0, vitest_1.it)("returns an unsubscribe function", () => {
+        const emitter = new use_kognitive_event_1.KognitiveEventEmitter();
+        const handler = vitest_1.vi.fn();
+        const unsub = emitter.on("status:change", handler);
+        emitter.emit("status:change", "streaming");
+        (0, vitest_1.expect)(handler).toHaveBeenCalledOnce();
+        unsub();
+        emitter.emit("status:change", "ready");
+        (0, vitest_1.expect)(handler).toHaveBeenCalledOnce(); // not called again
+    });
+    (0, vitest_1.it)("does not throw when emitting with no listeners", () => {
+        const emitter = new use_kognitive_event_1.KognitiveEventEmitter();
+        (0, vitest_1.expect)(() => emitter.emit("error", new Error("test"))).not.toThrow();
+    });
+    (0, vitest_1.it)("swallows listener errors", () => {
+        const emitter = new use_kognitive_event_1.KognitiveEventEmitter();
+        emitter.on("tool:invoked", () => { throw new Error("boom"); });
+        const good = vitest_1.vi.fn();
+        emitter.on("tool:invoked", good);
+        (0, vitest_1.expect)(() => emitter.emit("tool:invoked", {})).not.toThrow();
+        (0, vitest_1.expect)(good).toHaveBeenCalledOnce();
+    });
+    (0, vitest_1.it)("supports all event types", () => {
+        const emitter = new use_kognitive_event_1.KognitiveEventEmitter();
+        const events = [
+            "message:send",
+            "message:received",
+            "status:change",
+            "tool:invoked",
+            "tool:completed",
+            "error",
+        ];
+        for (const event of events) {
+            const handler = vitest_1.vi.fn();
+            emitter.on(event, handler);
+            emitter.emit(event, "test");
+            (0, vitest_1.expect)(handler).toHaveBeenCalledWith("test");
+        }
+    });
+});

package/dist/__tests__/keyboard-shortcuts.test.d.ts

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

package/dist/__tests__/keyboard-shortcuts.test.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Test the shortcut matching logic directly (not the hook, since it needs React)
+(0, vitest_1.describe)("Keyboard shortcut matching", () => {
+    function matchShortcut(shortcut, event) {
+        const ctrlOrMeta = shortcut.ctrl || shortcut.meta;
+        const matchesMod = ctrlOrMeta ? !!(event.ctrlKey || event.metaKey) : true;
+        const matchesShift = shortcut.shift ? !!event.shiftKey : !event.shiftKey;
+        return event.key.toLowerCase() === shortcut.key.toLowerCase() && matchesMod && matchesShift;
+    }
+    (0, vitest_1.it)("matches simple key", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "Escape" }, { key: "Escape" })).toBe(true);
+    });
+    (0, vitest_1.it)("does not match different key", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "Escape" }, { key: "Enter" })).toBe(false);
+    });
+    (0, vitest_1.it)("matches Ctrl+key", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "c", ctrl: true }, { key: "c", ctrlKey: true })).toBe(true);
+    });
+    (0, vitest_1.it)("matches Meta+key (Mac Cmd)", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "c", meta: true }, { key: "c", metaKey: true })).toBe(true);
+    });
+    (0, vitest_1.it)("matches Ctrl+Shift+key", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "c", ctrl: true, shift: true }, { key: "c", ctrlKey: true, shiftKey: true })).toBe(true);
+    });
+    (0, vitest_1.it)("does not match when shift is required but not pressed", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "c", ctrl: true, shift: true }, { key: "c", ctrlKey: true, shiftKey: false })).toBe(false);
+    });
+    (0, vitest_1.it)("does not match when shift is pressed but not required", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "c", ctrl: true }, { key: "c", ctrlKey: true, shiftKey: true })).toBe(false);
+    });
+    (0, vitest_1.it)("is case insensitive", () => {
+        (0, vitest_1.expect)(matchShortcut({ key: "escape" }, { key: "Escape" })).toBe(true);
+    });
+});

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

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

package/dist/__tests__/kognitive-runtime.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const kognitive_runtime_1 = require("../runtime/kognitive-runtime");
+(0, vitest_1.describe)("KognitiveRuntime", () => {
+    (0, vitest_1.it)("creates a transport from config", () => {
+        const runtime = new kognitive_runtime_1.KognitiveRuntime({
+            baseUrl: "http://localhost:3001",
+            agentName: "test-agent",
+        });
+        const transport = runtime.createTransport();
+        (0, vitest_1.expect)(transport).toBeDefined();
+    });
+    (0, vitest_1.it)("creates a transport with custom sessionId", () => {
+        const runtime = new kognitive_runtime_1.KognitiveRuntime({
+            baseUrl: "http://localhost:3001",
+            agentName: "test-agent",
+        });
+        const transport = runtime.createTransport("session-123");
+        (0, vitest_1.expect)(transport).toBeDefined();
+    });
+    (0, vitest_1.it)("creates ThreadManager when threads=true", () => {
+        const runtime = new kognitive_runtime_1.KognitiveRuntime({
+            baseUrl: "http://localhost:3001",
+            agentName: "test-agent",
+            threads: true,
+        });
+        (0, vitest_1.expect)(runtime.threadManager).not.toBeNull();
+    });
+    (0, vitest_1.it)("does not create ThreadManager when threads=false", () => {
+        const runtime = new kognitive_runtime_1.KognitiveRuntime({
+            baseUrl: "http://localhost:3001",
+            agentName: "test-agent",
+        });
+        (0, vitest_1.expect)(runtime.threadManager).toBeNull();
+    });
+    (0, vitest_1.it)("uses custom threadApiBase", () => {
+        const runtime = new kognitive_runtime_1.KognitiveRuntime({
+            baseUrl: "http://localhost:3001",
+            agentName: "test-agent",
+            threads: true,
+            threadApiBase: "http://custom:4000/threads",
+        });
+        (0, vitest_1.expect)(runtime.threadManager).not.toBeNull();
+    });
+    (0, vitest_1.it)("stores config for later access", () => {
+        const config = {
+            baseUrl: "http://localhost:3001",
+            agentName: "test-agent",
+            headers: { Authorization: "Bearer token" },
+            resourceId: { userId: "user-1" },
+        };
+        const runtime = new kognitive_runtime_1.KognitiveRuntime(config);
+        (0, vitest_1.expect)(runtime.config.baseUrl).toBe(config.baseUrl);
+        (0, vitest_1.expect)(runtime.config.agentName).toBe(config.agentName);
+        (0, vitest_1.expect)(runtime.config.headers).toEqual(config.headers);
+    });
+});

package/dist/__tests__/kognitive-transport.test.d.ts

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

package/dist/__tests__/kognitive-transport.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const kognitive_transport_1 = require("../runtime/kognitive-transport");
+(0, vitest_1.describe)("createKognitiveTransport", () => {
+    (0, vitest_1.describe)("URL resolution", () => {
+        (0, vitest_1.it)("uses baseUrl + agentName to construct URL", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                baseUrl: "http://localhost:3001",
+                agentName: "my-agent",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("uses explicit api URL when provided", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/chat",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("api takes priority over baseUrl + agentName", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/custom",
+                baseUrl: "http://localhost:3001",
+                agentName: "agent",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("throws when neither api nor baseUrl+agentName provided", () => {
+            (0, vitest_1.expect)(() => (0, kognitive_transport_1.createKognitiveTransport)({})).toThrow("requires either `api` or both `baseUrl` and `agentName`");
+        });
+        (0, vitest_1.it)("throws when only baseUrl provided (no agentName)", () => {
+            (0, vitest_1.expect)(() => (0, kognitive_transport_1.createKognitiveTransport)({ baseUrl: "http://localhost:3001" })).toThrow();
+        });
+        (0, vitest_1.it)("throws when only agentName provided (no baseUrl)", () => {
+            (0, vitest_1.expect)(() => (0, kognitive_transport_1.createKognitiveTransport)({ agentName: "my-agent" })).toThrow();
+        });
+    });
+    (0, vitest_1.describe)("URL construction", () => {
+        (0, vitest_1.it)("URL-encodes the agent name", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                baseUrl: "http://localhost:3001",
+                agentName: "agent with spaces",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("strips trailing slash from baseUrl", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                baseUrl: "http://localhost:3001/",
+                agentName: "test",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+    });
+    (0, vitest_1.describe)("config passthrough", () => {
+        (0, vitest_1.it)("accepts sessionId", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/chat",
+                sessionId: "sess-123",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("accepts full resourceId with userId, sessionId, organizationId", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/chat",
+                resourceId: {
+                    userId: "user-1",
+                    sessionId: "sess-1",
+                    organizationId: "org-1",
+                },
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("accepts custom headers", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/chat",
+                headers: { Authorization: "Bearer token123" },
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("accepts extra body fields", () => {
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/chat",
+                body: { agentName: "assistant", customField: true },
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.it)("sends agentName in body when using api mode", () => {
+            // When api is set and agentName is provided, agentName should be in body
+            const transport = (0, kognitive_transport_1.createKognitiveTransport)({
+                api: "/api/chat",
+                agentName: "assistant",
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const make_tool_ui_1 = require("../tool-ui/make-tool-ui");
+const registry_1 = require("../tool-ui/registry");
+(0, vitest_1.describe)("makeToolUI", () => {
+    (0, vitest_1.it)("creates a registration from a tool object with id", () => {
+        const render = () => null;
+        const reg = (0, make_tool_ui_1.makeToolUI)({
+            tool: { id: "weather" },
+            render,
+        });
+        (0, vitest_1.expect)(reg.toolName).toBe("weather");
+        (0, vitest_1.expect)(reg.component).toBe(render);
+    });
+    (0, vitest_1.it)("creates a registration from toolName string", () => {
+        const render = () => null;
+        const reg = (0, make_tool_ui_1.makeToolUI)({
+            toolName: "database_query",
+            render,
+        });
+        (0, vitest_1.expect)(reg.toolName).toBe("database_query");
+        (0, vitest_1.expect)(reg.component).toBe(render);
+    });
+    (0, vitest_1.it)("integrates with ToolUIRegistry", () => {
+        const reg = (0, make_tool_ui_1.makeToolUI)({
+            tool: { id: "my-tool" },
+            render: () => null,
+        });
+        const registry = new registry_1.ToolUIRegistry();
+        registry.register(reg);
+        (0, vitest_1.expect)(registry.has("my-tool")).toBe(true);
+        (0, vitest_1.expect)(registry.get("my-tool")).toBe(reg.component);
+    });
+    (0, vitest_1.it)("tool.id takes priority over toolName in tool-based registration", () => {
+        const reg = (0, make_tool_ui_1.makeToolUI)({
+            tool: { id: "from-tool-id" },
+            render: () => null,
+        });
+        (0, vitest_1.expect)(reg.toolName).toBe("from-tool-id");
+    });
+    (0, vitest_1.it)("multiple registrations can coexist in registry", () => {
+        const reg1 = (0, make_tool_ui_1.makeToolUI)({ tool: { id: "tool-a" }, render: () => "a" });
+        const reg2 = (0, make_tool_ui_1.makeToolUI)({ toolName: "tool-b", render: () => "b" });
+        const registry = new registry_1.ToolUIRegistry();
+        registry.register(reg1);
+        registry.register(reg2);
+        (0, vitest_1.expect)(registry.names()).toEqual(vitest_1.expect.arrayContaining(["tool-a", "tool-b"]));
+    });
+});

package/dist/__tests__/message-helpers.test.d.ts

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