neeter 0.6.0

package/dist/react/ThinkingBlock.d.ts

@@ -0,0 +1,5 @@
+export declare function ThinkingBlock({ thinking, streaming, className, }: {
+    thinking: string;
+    streaming?: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/ThinkingBlock.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import Markdown from "react-markdown";
+import { cn } from "./cn.js";
+import { ChevronIcon } from "./icons.js";
+import { markdownComponents } from "./markdown-overrides.js";
+import { PulsingDot } from "./StatusDot.js";
+const STORAGE_KEY = "neeter-thinking-open";
+function readPref() {
+    try {
+        return localStorage.getItem(STORAGE_KEY) === "true";
+    }
+    catch {
+        return false;
+    }
+}
+function writePref(open) {
+    try {
+        localStorage.setItem(STORAGE_KEY, String(open));
+    }
+    catch {
+        /* SSR / restricted env */
+    }
+}
+export function ThinkingBlock({ thinking, streaming = false, className, }) {
+    const [open, setOpen] = useState(readPref);
+    const toggle = useCallback(() => {
+        setOpen((prev) => {
+            const next = !prev;
+            writePref(next);
+            return next;
+        });
+    }, []);
+    return (_jsx("div", { className: cn("flex justify-start", className), children: _jsxs("div", { className: "rounded-md border border-border/40 bg-accent/20 overflow-hidden", children: [_jsxs("button", { type: "button", onClick: toggle, className: "flex w-full items-center gap-2 px-2.5 py-1.5 text-xs text-muted-foreground/60 hover:bg-accent/30 transition-colors", children: [_jsx(ChevronIcon, { open: open }), streaming && !open && _jsx(PulsingDot, {}), _jsx("span", { className: "truncate min-w-0", children: "Thinking" })] }), open && (_jsx("div", { className: "px-2.5 pt-1 pb-2", children: _jsx(ThinkingContent, { children: thinking }) }))] }) }));
+}
+function ThinkingContent({ children }) {
+    return (_jsx("div", { className: "text-xs text-muted-foreground/70 italic [&>*:first-child]:mt-0 [&>*:last-child]:mb-0", children: _jsx(Markdown, { components: markdownComponents, children: children }) }));
+}

package/dist/react/ThinkingIndicator.d.ts

@@ -0,0 +1,3 @@
+export declare function ThinkingIndicator({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/ThinkingIndicator.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "./cn.js";
+export function ThinkingIndicator({ className }) {
+    return (_jsx("div", { className: cn("flex justify-start", className), children: _jsxs("div", { className: "flex items-center gap-1 rounded-lg bg-muted px-3 py-2", children: [_jsx("span", { className: "h-1.5 w-1.5 rounded-full bg-muted-foreground animate-bounce [animation-delay:0ms]" }), _jsx("span", { className: "h-1.5 w-1.5 rounded-full bg-muted-foreground animate-bounce [animation-delay:150ms]" }), _jsx("span", { className: "h-1.5 w-1.5 rounded-full bg-muted-foreground animate-bounce [animation-delay:300ms]" })] }) }));
+}

package/dist/react/ToolApprovalCard.d.ts

@@ -0,0 +1,7 @@
+import type { ToolApprovalRequest } from "../types.js";
+export declare function ToolApprovalCard({ request, onApprove, onDeny, className, }: {
+    request: ToolApprovalRequest;
+    onApprove: () => void;
+    onDeny: (message?: string) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/ToolApprovalCard.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ApprovalButtons } from "./ApprovalButtons.js";
+import { cn } from "./cn.js";
+import { getWidget, stripMcpPrefix } from "./registry.js";
+import { PulsingDot } from "./StatusDot.js";
+export function ToolApprovalCard({ request, onApprove, onDeny, className, }) {
+    const reg = getWidget(stripMcpPrefix(request.toolName));
+    const label = reg?.label ?? request.toolName;
+    const InputRenderer = reg?.inputRenderer;
+    return (_jsxs("div", { className: cn("rounded-md border border-amber-500/40 bg-amber-500/5 px-3 py-2.5 text-xs", className), children: [_jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [_jsx(PulsingDot, {}), _jsx("span", { className: "font-medium", children: label }), request.description && (_jsxs("span", { className: "ml-1 opacity-70", children: ["\u2014 ", request.description] }))] }), InputRenderer ? (_jsx(InputRenderer, { input: request.input })) : (Object.keys(request.input).length > 0 && (_jsx("pre", { className: "mt-1.5 max-h-32 overflow-auto rounded bg-background/60 px-2 py-1 font-mono text-[10px] text-muted-foreground", children: JSON.stringify(request.input, null, 2) }))), _jsx(ApprovalButtons, { onApprove: onApprove, onDeny: () => onDeny() })] }));
+}

package/dist/react/ToolCallCard.d.ts

@@ -0,0 +1,5 @@
+import type { ToolCallInfo } from "../types.js";
+export declare function ToolCallCard({ toolCall, className, }: {
+    toolCall: ToolCallInfo;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/ToolCallCard.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useAgentContext, useChatStore } from "./AgentProvider.js";
+import { ApprovalButtons } from "./ApprovalButtons.js";
+import { findMatchingApproval } from "./approval-matching.js";
+import { CollapsibleCard } from "./CollapsibleCard.js";
+import { cn } from "./cn.js";
+import { getWidget, stripMcpPrefix } from "./registry.js";
+import { PulsingDot, StatusDot } from "./StatusDot.js";
+export function ToolCallCard({ toolCall, className, }) {
+    const short = stripMcpPrefix(toolCall.name);
+    const reg = getWidget(short);
+    const label = reg?.label ?? short;
+    const pendingPermissions = useChatStore((s) => s.pendingPermissions);
+    const { respondToPermission, store } = useAgentContext();
+    const matchingApproval = findMatchingApproval(pendingPermissions, toolCall);
+    if (toolCall.status === "complete" && toolCall.result && reg) {
+        let parsed;
+        try {
+            parsed = JSON.parse(toolCall.result);
+        }
+        catch {
+            parsed = toolCall.result;
+        }
+        const displayLabel = reg.richLabel
+            ? (reg.richLabel(parsed, toolCall.input) ?? label)
+            : label;
+        const widgetProps = {
+            phase: toolCall.status,
+            toolUseId: toolCall.id,
+            input: toolCall.input,
+            partialInput: toolCall.partialInput,
+            result: parsed,
+            error: toolCall.error,
+        };
+        return (_jsx(CollapsibleCard, { label: displayLabel, status: toolCall.status, className: className, children: _jsx(reg.component, { ...widgetProps }) }));
+    }
+    if (toolCall.status === "error") {
+        return (_jsxs("div", { className: cn("flex items-center gap-2 rounded-md border border-destructive/50 bg-destructive/10 px-2.5 py-1.5 text-xs text-muted-foreground", className), children: [_jsx(StatusDot, { status: toolCall.status }), _jsx("span", { children: label }), toolCall.error && _jsx("span", { className: "ml-auto text-destructive", children: toolCall.error })] }));
+    }
+    if (matchingApproval) {
+        const InputRenderer = reg?.inputRenderer;
+        return (_jsxs("div", { className: cn("rounded-md border border-amber-500/40 bg-amber-500/5 px-3 py-2.5 text-xs", className), children: [_jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [_jsx(PulsingDot, {}), _jsx("span", { className: "font-medium", children: label }), matchingApproval.description && (_jsxs("span", { className: "ml-1 opacity-70", children: ["\u2014 ", matchingApproval.description] }))] }), InputRenderer ? (_jsx(InputRenderer, { input: matchingApproval.input })) : (Object.keys(matchingApproval.input).length > 0 && (_jsx("pre", { className: "mt-1.5 max-h-32 overflow-auto rounded bg-background/60 px-2 py-1 font-mono text-[10px] text-muted-foreground", children: JSON.stringify(matchingApproval.input, null, 2) }))), _jsx(ApprovalButtons, { onApprove: () => respondToPermission({
+                        kind: "tool_approval",
+                        requestId: matchingApproval.requestId,
+                        behavior: "allow",
+                    }), onDeny: () => {
+                        store.getState().errorToolCall(toolCall.id, "Not approved");
+                        respondToPermission({
+                            kind: "tool_approval",
+                            requestId: matchingApproval.requestId,
+                            behavior: "deny",
+                            message: "Denied by user",
+                        });
+                    } })] }));
+    }
+    const FallbackInputRenderer = reg?.inputRenderer;
+    const hasInput = Object.keys(toolCall.input).length > 0;
+    return (_jsxs("div", { className: cn("rounded-md border border-border bg-accent/50 px-2.5 py-1.5 text-xs text-muted-foreground", className), children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(StatusDot, { status: toolCall.status }), _jsx("span", { children: label }), toolCall.status === "streaming_input" && toolCall.partialInput && (_jsx("span", { className: "ml-auto truncate max-w-[200px] opacity-50 font-mono text-[10px]", children: toolCall.partialInput.slice(0, 80) }))] }), hasInput && FallbackInputRenderer && _jsx(FallbackInputRenderer, { input: toolCall.input })] }));
+}

package/dist/react/UserQuestionCard.d.ts

@@ -0,0 +1,6 @@
+import type { UserQuestionRequest } from "../types.js";
+export declare function UserQuestionCard({ request, onSubmit, className, }: {
+    request: UserQuestionRequest;
+    onSubmit: (answers: Record<string, string>) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/UserQuestionCard.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { cn } from "./cn.js";
+const OTHER_LABEL = "__other__";
+export function UserQuestionCard({ request, onSubmit, className, }) {
+    const wrapperRef = useRef(null);
+    const [answers, setAnswers] = useState({});
+    const [otherText, setOtherText] = useState({});
+    const otherInputRefs = useRef({});
+    // Auto-focus wrapper so number-key shortcuts work immediately
+    useEffect(() => {
+        wrapperRef.current?.focus();
+    }, []);
+    const allAnswered = request.questions.every((q) => {
+        const vals = answers[q.question];
+        if (!vals || vals.length === 0)
+            return false;
+        if (vals.includes(OTHER_LABEL))
+            return !!otherText[q.question]?.trim();
+        return true;
+    });
+    function resolvedAnswers() {
+        const resolved = {};
+        for (const q of request.questions) {
+            const vals = answers[q.question] ?? [];
+            const mapped = vals.map((v) => (v === OTHER_LABEL ? (otherText[q.question] ?? "") : v));
+            resolved[q.question] = mapped.join(", ");
+        }
+        return resolved;
+    }
+    function selectOption(question, label, multiSelect) {
+        setAnswers((prev) => {
+            if (!multiSelect)
+                return { ...prev, [question]: [label] };
+            const current = prev[question] ?? [];
+            return {
+                ...prev,
+                [question]: current.includes(label)
+                    ? current.filter((l) => l !== label)
+                    : [...current, label],
+            };
+        });
+        if (label === OTHER_LABEL) {
+            setTimeout(() => otherInputRefs.current[question]?.focus(), 0);
+        }
+    }
+    // Keyboard shortcuts: number keys select options, Enter submits
+    useEffect(() => {
+        function handleKeyDown(e) {
+            const tag = e.target?.tagName;
+            if (tag === "INPUT" || tag === "TEXTAREA" || e.target?.isContentEditable) {
+                return;
+            }
+            if (request.questions.length !== 1)
+                return;
+            const q = request.questions[0];
+            if (!q.options?.length)
+                return;
+            if (e.key === "Enter" && allAnswered) {
+                e.preventDefault();
+                onSubmit(resolvedAnswers());
+                return;
+            }
+            const totalOptions = q.options.length + 1; // +1 for "Other"
+            const num = parseInt(e.key, 10);
+            if (num >= 1 && num <= totalOptions) {
+                e.preventDefault();
+                if (num <= q.options.length) {
+                    if (!q.multiSelect) {
+                        // Single-select: submit immediately (matches ApprovalButtons)
+                        onSubmit({ [q.question]: q.options[num - 1].label });
+                    }
+                    else {
+                        selectOption(q.question, q.options[num - 1].label, true);
+                    }
+                }
+                else {
+                    selectOption(q.question, OTHER_LABEL, q.multiSelect);
+                }
+            }
+        }
+        document.addEventListener("keydown", handleKeyDown);
+        return () => document.removeEventListener("keydown", handleKeyDown);
+    });
+    return (_jsxs("div", { ref: wrapperRef, tabIndex: -1, className: cn("rounded-md border border-blue-500/40 bg-blue-500/5 px-3 py-2.5 text-xs focus:outline-none", className), children: [request.questions.map((q) => {
+                const hasOptions = q.options && q.options.length > 0;
+                const isSingleQuestion = request.questions.length === 1;
+                return (_jsxs("div", { className: "mb-3 last:mb-0", children: [q.header && (_jsx("span", { className: "text-[10px] uppercase tracking-wider text-muted-foreground/70", children: q.header })), _jsx("p", { className: "mt-0.5 text-foreground", children: q.question }), hasOptions && (_jsxs("div", { className: "mt-1.5 flex flex-col gap-1", children: [q.options?.map((opt, idx) => {
+                                    const selected = (answers[q.question] ?? []).includes(opt.label);
+                                    return (_jsxs("button", { type: "button", onClick: () => {
+                                            if (!q.multiSelect && isSingleQuestion) {
+                                                onSubmit({ [q.question]: opt.label });
+                                            }
+                                            else {
+                                                selectOption(q.question, opt.label, q.multiSelect);
+                                            }
+                                        }, className: cn("flex items-start gap-2 rounded border px-2 py-1.5 text-left transition-colors", selected
+                                            ? "border-blue-500 bg-blue-500/15 text-foreground ring-1 ring-blue-500/30"
+                                            : "border-border text-muted-foreground hover:bg-accent"), children: [_jsx("span", { className: "mt-px shrink-0", children: q.multiSelect ? (selected ? "☑" : "☐") : selected ? "●" : "○" }), _jsxs("span", { className: "flex-1", children: [_jsx("span", { className: "font-medium", children: opt.label }), opt.description && (_jsxs("span", { className: "ml-1 opacity-70", children: ["\u2014 ", opt.description] }))] }), isSingleQuestion && (_jsx("kbd", { className: "ml-auto shrink-0 text-[9px] opacity-40", children: idx + 1 }))] }, opt.label));
+                                }), (() => {
+                                    const isOther = (answers[q.question] ?? []).includes(OTHER_LABEL);
+                                    const otherIdx = (q.options?.length ?? 0) + 1;
+                                    return (_jsxs("div", { children: [_jsxs("button", { type: "button", onClick: () => selectOption(q.question, OTHER_LABEL, q.multiSelect), className: cn("flex w-full items-start gap-2 rounded border px-2 py-1.5 text-left transition-colors", isOther
+                                                    ? "border-blue-500 bg-blue-500/15 text-foreground ring-1 ring-blue-500/30"
+                                                    : "border-border text-muted-foreground hover:bg-accent"), children: [_jsx("span", { className: "mt-px shrink-0", children: q.multiSelect ? (isOther ? "☑" : "☐") : isOther ? "●" : "○" }), _jsx("span", { className: "font-medium", children: "Other" }), isSingleQuestion && (_jsx("kbd", { className: "ml-auto shrink-0 text-[9px] opacity-40", children: otherIdx }))] }), isOther && (_jsx("input", { ref: (el) => {
+                                                    otherInputRefs.current[q.question] = el;
+                                                }, type: "text", className: "mt-1 w-full rounded border border-border bg-background px-2 py-1 text-foreground focus:outline-none focus:ring-1 focus:ring-blue-500/50", placeholder: "Type your answer\u2026", value: otherText[q.question] ?? "", onChange: (e) => setOtherText((prev) => ({ ...prev, [q.question]: e.target.value })), onKeyDown: (e) => {
+                                                    if (e.key === "Enter" && otherText[q.question]?.trim()) {
+                                                        e.preventDefault();
+                                                        onSubmit(resolvedAnswers());
+                                                    }
+                                                } }))] }));
+                                })()] })), !hasOptions && (_jsx("input", { type: "text", className: "mt-1.5 w-full rounded border border-border bg-background px-2 py-1 text-foreground focus:outline-none focus:ring-1 focus:ring-blue-500/50", placeholder: "Type your answer\u2026", value: (answers[q.question] ?? [])[0] ?? "", onChange: (e) => setAnswers((prev) => ({ ...prev, [q.question]: [e.target.value] })), onKeyDown: (e) => {
+                                if (e.key === "Enter" && (answers[q.question]?.[0] ?? "").trim()) {
+                                    e.preventDefault();
+                                    onSubmit(resolvedAnswers());
+                                }
+                            } }))] }, q.question));
+            }), _jsx("button", { type: "button", disabled: !allAnswered, onClick: () => onSubmit(resolvedAnswers()), className: cn("mt-2 rounded bg-primary px-3 py-1 text-primary-foreground transition-colors focus:outline-none focus:ring-2 focus:ring-primary/50", allAnswered ? "hover:bg-primary/90" : "opacity-50 cursor-not-allowed"), children: "Submit" })] }));
+}

package/dist/react/approval-matching.d.ts

@@ -0,0 +1,13 @@
+import type { ChatMessage, PermissionRequest, ToolApprovalRequest, ToolCallInfo } from "../types.js";
+/**
+ * Find the pending approval that matches a specific tool call.
+ * Matches by toolUseId when available, falls back to toolName.
+ * Only considers non-terminal tool calls (not complete/error).
+ */
+export declare function findMatchingApproval(pendingPermissions: PermissionRequest[], toolCall: ToolCallInfo): ToolApprovalRequest | undefined;
+/**
+ * Check if an approval request is "claimed" by any non-terminal tool call
+ * in the message list. Claimed approvals are rendered inline by ToolCallCard
+ * and should be skipped by PendingPermissions to avoid duplicate UI.
+ */
+export declare function isApprovalClaimedByToolCall(request: ToolApprovalRequest, messages: ChatMessage[]): boolean;

package/dist/react/approval-matching.js

@@ -0,0 +1,30 @@
+/**
+ * Find the pending approval that matches a specific tool call.
+ * Matches by toolUseId when available, falls back to toolName.
+ * Only considers non-terminal tool calls (not complete/error).
+ */
+export function findMatchingApproval(pendingPermissions, toolCall) {
+    if (toolCall.status === "complete" || toolCall.status === "error")
+        return undefined;
+    return pendingPermissions.find((p) => p.kind === "tool_approval" &&
+        (p.toolUseId ? p.toolUseId === toolCall.id : p.toolName === toolCall.name));
+}
+/**
+ * Check if an approval request is "claimed" by any non-terminal tool call
+ * in the message list. Claimed approvals are rendered inline by ToolCallCard
+ * and should be skipped by PendingPermissions to avoid duplicate UI.
+ */
+export function isApprovalClaimedByToolCall(request, messages) {
+    for (const msg of messages) {
+        if (msg.toolCalls) {
+            for (const tc of msg.toolCalls) {
+                if (tc.status === "complete" || tc.status === "error")
+                    continue;
+                if (request.toolUseId ? tc.id === request.toolUseId : tc.name === request.toolName) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}

package/dist/react/cn.d.ts

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

package/dist/react/cn.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/react/icons.d.ts

@@ -0,0 +1,7 @@
+export declare function ChevronIcon({ open, className }: {
+    open: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SendIcon({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/icons.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "./cn.js";
+export function ChevronIcon({ open, className }) {
+    return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", className: cn("h-3 w-3 transition-transform", open && "rotate-90", className), "aria-hidden": "true", children: _jsx("path", { d: "m9 18 6-6-6-6" }) }));
+}
+export function SendIcon({ className }) {
+    return (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", className: cn("h-4 w-4", className), "aria-hidden": "true", children: [_jsx("path", { d: "M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z" }), _jsx("path", { d: "m21.854 2.147-10.94 10.939" })] }));
+}

package/dist/react/index.d.ts

@@ -0,0 +1,28 @@
+import "./widgets/AskUserQuestionWidget.js";
+import "./widgets/BashWidget.js";
+import "./widgets/EditWidget.js";
+import "./widgets/GlobWidget.js";
+import "./widgets/GrepWidget.js";
+import "./widgets/NotebookEditWidget.js";
+import "./widgets/ReadWidget.js";
+import "./widgets/TodoWriteWidget.js";
+import "./widgets/WebFetchWidget.js";
+import "./widgets/WebSearchWidget.js";
+import "./widgets/WriteWidget.js";
+export type { ChatMessage, CustomEvent, PermissionRequest, PermissionResponse, SSEEvent, ToolApprovalRequest, ToolApprovalResponse, ToolCallInfo, ToolCallPhase, UserQuestion, UserQuestionOption, UserQuestionRequest, UserQuestionResponse, WidgetProps, WidgetRegistration, } from "../types.js";
+export { AgentProvider, useAgentContext, useChatStore } from "./AgentProvider.js";
+export { ChatInput } from "./ChatInput.js";
+export { CollapsibleCard } from "./CollapsibleCard.js";
+export { cn } from "./cn.js";
+export { MessageList } from "./MessageList.js";
+export { PendingPermissions } from "./PendingPermissions.js";
+export { getWidget, registerWidget, stripMcpPrefix } from "./registry.js";
+export { StatusDot } from "./StatusDot.js";
+export { type ChatStore, type ChatStoreShape, createChatStore } from "./store.js";
+export { TextMessage } from "./TextMessage.js";
+export { ThinkingBlock } from "./ThinkingBlock.js";
+export { ThinkingIndicator } from "./ThinkingIndicator.js";
+export { ToolApprovalCard } from "./ToolApprovalCard.js";
+export { ToolCallCard } from "./ToolCallCard.js";
+export { UserQuestionCard } from "./UserQuestionCard.js";
+export { type UseAgentConfig, type UseAgentReturn, useAgent } from "./use-agent.js";

package/dist/react/index.js

@@ -0,0 +1,28 @@
+// Built-in widgets (side-effect: auto-registers)
+import "./widgets/AskUserQuestionWidget.js";
+import "./widgets/BashWidget.js";
+import "./widgets/EditWidget.js";
+import "./widgets/GlobWidget.js";
+import "./widgets/GrepWidget.js";
+import "./widgets/NotebookEditWidget.js";
+import "./widgets/ReadWidget.js";
+import "./widgets/TodoWriteWidget.js";
+import "./widgets/WebFetchWidget.js";
+import "./widgets/WebSearchWidget.js";
+import "./widgets/WriteWidget.js";
+export { AgentProvider, useAgentContext, useChatStore } from "./AgentProvider.js";
+export { ChatInput } from "./ChatInput.js";
+export { CollapsibleCard } from "./CollapsibleCard.js";
+export { cn } from "./cn.js";
+export { MessageList } from "./MessageList.js";
+export { PendingPermissions } from "./PendingPermissions.js";
+export { getWidget, registerWidget, stripMcpPrefix } from "./registry.js";
+export { StatusDot } from "./StatusDot.js";
+export { createChatStore } from "./store.js";
+export { TextMessage } from "./TextMessage.js";
+export { ThinkingBlock } from "./ThinkingBlock.js";
+export { ThinkingIndicator } from "./ThinkingIndicator.js";
+export { ToolApprovalCard } from "./ToolApprovalCard.js";
+export { ToolCallCard } from "./ToolCallCard.js";
+export { UserQuestionCard } from "./UserQuestionCard.js";
+export { useAgent } from "./use-agent.js";

package/dist/react/markdown-overrides.d.ts

@@ -0,0 +1,2 @@
+import type { Components } from "react-markdown";
+export declare const markdownComponents: Partial<Components>;

package/dist/react/markdown-overrides.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const markdownComponents = {
+    p: ({ children }) => _jsx("p", { className: "mb-2 last:mb-0", children: children }),
+    ul: ({ children }) => _jsx("ul", { className: "mb-2 ml-4 list-disc last:mb-0", children: children }),
+    ol: ({ children }) => _jsx("ol", { className: "mb-2 ml-4 list-decimal last:mb-0", children: children }),
+    li: ({ children }) => _jsx("li", { className: "mb-0.5", children: children }),
+    strong: ({ children }) => _jsx("strong", { className: "font-semibold", children: children }),
+};

package/dist/react/registry.d.ts

@@ -0,0 +1,4 @@
+import type { WidgetRegistration } from "../types.js";
+export declare function registerWidget<TResult>(reg: WidgetRegistration<TResult>): void;
+export declare function getWidget(toolName: string): WidgetRegistration | undefined;
+export declare function stripMcpPrefix(name: string): string;

package/dist/react/registry.js

@@ -0,0 +1,10 @@
+const widgets = new Map();
+export function registerWidget(reg) {
+    widgets.set(reg.toolName, reg);
+}
+export function getWidget(toolName) {
+    return widgets.get(toolName);
+}
+export function stripMcpPrefix(name) {
+    return name.replace(/^mcp__[^_]+__/, "");
+}

package/dist/react/store.d.ts

@@ -0,0 +1,34 @@
+import { type StoreApi } from "zustand/vanilla";
+import type { ChatMessage, PermissionRequest } from "../types.js";
+interface ChatStoreState {
+    sessionId: string | null;
+    messages: ChatMessage[];
+    isStreaming: boolean;
+    isThinking: boolean;
+    streamingText: string;
+    streamingThinking: string;
+    pendingPermissions: PermissionRequest[];
+}
+interface ChatStoreActions {
+    setSessionId: (id: string) => void;
+    addUserMessage: (text: string) => void;
+    appendStreamingText: (text: string) => void;
+    appendStreamingThinking: (text: string) => void;
+    flushStreamingText: () => void;
+    flushStreamingThinking: () => void;
+    addSystemMessage: (text: string) => void;
+    startToolCall: (toolUseId: string, name: string) => void;
+    appendToolInput: (toolUseId: string, partialJson: string) => void;
+    finalizeToolCall: (toolUseId: string, name: string, input: Record<string, unknown>) => void;
+    completeToolCall: (toolUseId: string, result: string) => void;
+    errorToolCall: (toolUseId: string, error: string) => void;
+    setStreaming: (v: boolean) => void;
+    setThinking: (v: boolean) => void;
+    addPermissionRequest: (request: PermissionRequest) => void;
+    removePermissionRequest: (requestId: string) => void;
+    reset: () => void;
+}
+export type ChatStoreShape = ChatStoreState & ChatStoreActions;
+export type ChatStore = StoreApi<ChatStoreShape>;
+export declare function createChatStore(): ChatStore;
+export {};

package/dist/react/store.js

@@ -0,0 +1,141 @@
+import { immer } from "zustand/middleware/immer";
+import { createStore } from "zustand/vanilla";
+let nextId = 0;
+function findToolCall(messages, toolUseId) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const tc = messages[i].toolCalls;
+        if (tc?.length) {
+            const match = tc.find((t) => t.id === toolUseId);
+            if (match)
+                return match;
+        }
+    }
+    return undefined;
+}
+export function createChatStore() {
+    return createStore()(immer((set) => ({
+        sessionId: null,
+        messages: [],
+        isStreaming: false,
+        isThinking: false,
+        streamingText: "",
+        streamingThinking: "",
+        pendingPermissions: [],
+        setSessionId: (id) => set((s) => {
+            s.sessionId = id;
+        }),
+        addUserMessage: (text) => set((s) => {
+            s.messages.push({
+                id: `msg-${++nextId}`,
+                role: "user",
+                content: text,
+            });
+        }),
+        addSystemMessage: (text) => set((s) => {
+            s.messages.push({
+                id: `msg-${++nextId}`,
+                role: "system",
+                content: text,
+            });
+        }),
+        appendStreamingText: (text) => set((s) => {
+            s.streamingText += text;
+        }),
+        appendStreamingThinking: (text) => set((s) => {
+            s.streamingThinking += text;
+        }),
+        flushStreamingThinking: () => set((s) => {
+            if (s.streamingThinking) {
+                const last = s.messages[s.messages.length - 1];
+                if (last?.role === "assistant" && !last.toolCalls?.length) {
+                    last.thinking = (last.thinking ?? "") + s.streamingThinking;
+                }
+                else {
+                    s.messages.push({
+                        id: `msg-${++nextId}`,
+                        role: "assistant",
+                        content: "",
+                        thinking: s.streamingThinking,
+                    });
+                }
+                s.streamingThinking = "";
+            }
+        }),
+        flushStreamingText: () => set((s) => {
+            if (s.streamingText) {
+                const last = s.messages[s.messages.length - 1];
+                if (last?.role === "assistant" && !last.toolCalls?.length) {
+                    last.content += s.streamingText;
+                }
+                else {
+                    s.messages.push({
+                        id: `msg-${++nextId}`,
+                        role: "assistant",
+                        content: s.streamingText,
+                    });
+                }
+                s.streamingText = "";
+            }
+        }),
+        startToolCall: (toolUseId, name) => set((s) => {
+            s.messages.push({
+                id: `msg-${++nextId}`,
+                role: "assistant",
+                content: "",
+                toolCalls: [{ id: toolUseId, name, input: {}, status: "pending" }],
+            });
+        }),
+        appendToolInput: (toolUseId, partialJson) => set((s) => {
+            const tc = findToolCall(s.messages, toolUseId);
+            if (tc) {
+                tc.partialInput = (tc.partialInput ?? "") + partialJson;
+                tc.status = "streaming_input";
+            }
+        }),
+        finalizeToolCall: (toolUseId, name, input) => set((s) => {
+            const tc = findToolCall(s.messages, toolUseId);
+            if (tc) {
+                tc.name = name;
+                tc.input = input;
+                tc.status = "running";
+            }
+        }),
+        completeToolCall: (toolUseId, result) => set((s) => {
+            const tc = findToolCall(s.messages, toolUseId);
+            if (tc && tc.status !== "error") {
+                tc.result = result;
+                tc.status = "complete";
+            }
+        }),
+        errorToolCall: (toolUseId, error) => set((s) => {
+            const tc = findToolCall(s.messages, toolUseId);
+            if (tc) {
+                tc.error = error;
+                tc.status = "error";
+            }
+        }),
+        setStreaming: (v) => set((s) => {
+            s.isStreaming = v;
+        }),
+        setThinking: (v) => set((s) => {
+            s.isThinking = v;
+        }),
+        addPermissionRequest: (request) => set((s) => {
+            if (!s.pendingPermissions.some((p) => p.requestId === request.requestId)) {
+                s.pendingPermissions.push(request);
+            }
+        }),
+        removePermissionRequest: (requestId) => set((s) => {
+            s.pendingPermissions = s.pendingPermissions.filter((p) => p.requestId !== requestId);
+        }),
+        reset: () => set((s) => {
+            s.sessionId = null;
+            s.messages = [];
+            s.isStreaming = false;
+            s.isThinking = false;
+            s.streamingText = "";
+            s.streamingThinking = "";
+            s.pendingPermissions = [];
+        }),
+    })));
+}

package/dist/react/use-agent.d.ts

@@ -0,0 +1,12 @@
+import type { CustomEvent, PermissionResponse } from "../types.js";
+import type { ChatStore } from "./store.js";
+export interface UseAgentConfig {
+    endpoint?: string;
+    onCustomEvent?: (event: CustomEvent) => void;
+}
+export interface UseAgentReturn {
+    sessionId: string | null;
+    sendMessage: (text: string) => Promise<void>;
+    respondToPermission: (response: PermissionResponse) => Promise<void>;
+}
+export declare function useAgent(store: ChatStore, config?: UseAgentConfig): UseAgentReturn;