@neeter/react 0.6.0

package/dist/cn.d.ts

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

package/dist/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/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/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/index.d.ts

@@ -0,0 +1,29 @@
+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, } from "@neeter/types";
+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 type { WidgetProps, WidgetRegistration } from "./types.js";
+export { UserQuestionCard } from "./UserQuestionCard.js";
+export { type UseAgentConfig, type UseAgentReturn, useAgent } from "./use-agent.js";

package/dist/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/markdown-overrides.d.ts

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

package/dist/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/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/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/store.d.ts

@@ -0,0 +1,34 @@
+import type { ChatMessage, PermissionRequest } from "@neeter/types";
+import { type StoreApi } from "zustand/vanilla";
+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/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/types.d.ts

@@ -0,0 +1,19 @@
+import type { ToolCallPhase } from "@neeter/types";
+import type { ComponentType } from "react";
+export interface WidgetProps<TResult = unknown> {
+    phase: ToolCallPhase;
+    toolUseId: string;
+    input: Record<string, unknown>;
+    partialInput?: string;
+    result?: TResult;
+    error?: string;
+}
+export interface WidgetRegistration<TResult = unknown> {
+    toolName: string;
+    label: string;
+    richLabel?: (result: TResult, input: Record<string, unknown>) => string | null;
+    inputRenderer?: ComponentType<{
+        input: Record<string, unknown>;
+    }>;
+    component: ComponentType<WidgetProps<TResult>>;
+}

package/dist/types.js

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

package/dist/use-agent.d.ts

@@ -0,0 +1,12 @@
+import type { CustomEvent, PermissionResponse } from "@neeter/types";
+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;

package/dist/use-agent.js

@@ -0,0 +1,119 @@
+import { useCallback, useEffect, useRef, useSyncExternalStore } from "react";
+export function useAgent(store, config) {
+    const endpoint = config?.endpoint ?? "/api";
+    const onCustomEvent = config?.onCustomEvent;
+    const eventSourceRef = useRef(null);
+    const sessionId = useSyncExternalStore(store.subscribe, () => store.getState().sessionId);
+    useEffect(() => {
+        let cancelled = false;
+        async function init() {
+            const res = await fetch(`${endpoint}/sessions`, { method: "POST" });
+            const data = await res.json();
+            if (!cancelled)
+                store.getState().setSessionId(data.sessionId);
+        }
+        init();
+        return () => {
+            cancelled = true;
+        };
+    }, [endpoint, store]);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        const es = new EventSource(`${endpoint}/sessions/${sessionId}/events`);
+        eventSourceRef.current = es;
+        es.addEventListener("message_start", () => {
+            store.getState().setThinking(true);
+        });
+        es.addEventListener("thinking_delta", (e) => {
+            const { text } = JSON.parse(e.data);
+            store.getState().appendStreamingThinking(text);
+        });
+        es.addEventListener("text_delta", (e) => {
+            store.getState().setThinking(false);
+            store.getState().flushStreamingThinking();
+            const { text } = JSON.parse(e.data);
+            store.getState().appendStreamingText(text);
+        });
+        es.addEventListener("tool_start", (e) => {
+            store.getState().setThinking(false);
+            store.getState().flushStreamingThinking();
+            store.getState().flushStreamingText();
+            const { id, name } = JSON.parse(e.data);
+            store.getState().startToolCall(id, name);
+        });
+        es.addEventListener("tool_input_delta", (e) => {
+            const { id, partialJson } = JSON.parse(e.data);
+            store.getState().appendToolInput(id, partialJson);
+        });
+        es.addEventListener("tool_call", (e) => {
+            store.getState().flushStreamingText();
+            const { id, name, input } = JSON.parse(e.data);
+            store.getState().finalizeToolCall(id, name, input);
+        });
+        es.addEventListener("tool_result", (e) => {
+            const { toolUseId, result } = JSON.parse(e.data);
+            store.getState().completeToolCall(toolUseId, result);
+            if (store.getState().isStreaming) {
+                store.getState().setThinking(true);
+            }
+        });
+        es.addEventListener("permission_request", (e) => {
+            const request = JSON.parse(e.data);
+            store.getState().addPermissionRequest(request);
+        });
+        es.addEventListener("session_error", (e) => {
+            store.getState().flushStreamingThinking();
+            store.getState().flushStreamingText();
+            store.getState().setThinking(false);
+            const { subtype } = JSON.parse(e.data);
+            store.getState().addSystemMessage(`Session ended: ${subtype}`);
+            store.getState().setStreaming(false);
+        });
+        es.addEventListener("turn_complete", () => {
+            store.getState().flushStreamingThinking();
+            store.getState().flushStreamingText();
+            store.getState().setThinking(false);
+            store.getState().setStreaming(false);
+        });
+        es.addEventListener("error", () => {
+            if (es.readyState === EventSource.CLOSED) {
+                store.getState().flushStreamingThinking();
+                store.getState().flushStreamingText();
+                store.getState().setStreaming(false);
+            }
+        });
+        if (onCustomEvent) {
+            es.addEventListener("custom", (e) => {
+                onCustomEvent(JSON.parse(e.data));
+            });
+        }
+        return () => {
+            es.close();
+            eventSourceRef.current = null;
+        };
+    }, [sessionId, endpoint, store, onCustomEvent]);
+    const sendMessage = useCallback(async (text) => {
+        if (!sessionId)
+            return;
+        store.getState().addUserMessage(text);
+        store.getState().setStreaming(true);
+        store.getState().setThinking(true);
+        await fetch(`${endpoint}/sessions/${sessionId}/messages`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ text }),
+        });
+    }, [sessionId, endpoint, store]);
+    const respondToPermission = useCallback(async (response) => {
+        if (!sessionId)
+            return;
+        store.getState().removePermissionRequest(response.requestId);
+        await fetch(`${endpoint}/sessions/${sessionId}/permissions`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(response),
+        });
+    }, [sessionId, endpoint, store]);
+    return { sessionId, sendMessage, respondToPermission };
+}

package/dist/widgets/AskUserQuestionWidget.d.ts

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

package/dist/widgets/AskUserQuestionWidget.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { registerWidget } from "../registry.js";
+function parseAnswers(result) {
+    if (typeof result !== "string")
+        return null;
+    const answers = {};
+    // Format: "question"="answer"
+    const re = /"(.+?)"="(.+?)"/g;
+    for (let match = re.exec(result); match !== null; match = re.exec(result)) {
+        answers[match[1]] = match[2];
+    }
+    if (Object.keys(answers).length === 0)
+        return null;
+    return answers;
+}
+function AskUserQuestionWidget({ input, result }) {
+    const questions = (input.questions ?? []);
+    const answers = parseAnswers(result);
+    if (!questions.length || !answers)
+        return null;
+    return (_jsx("div", { className: "space-y-1.5 py-1 text-xs", children: questions.map((q) => {
+            const answer = answers[q.question];
+            return (_jsxs("div", { children: [_jsx("span", { className: "text-muted-foreground", children: q.question }), answer && _jsx("span", { className: "ml-1.5 font-medium text-foreground", children: answer })] }, q.question));
+        }) }));
+}
+registerWidget({
+    toolName: "AskUserQuestion",
+    label: "Question",
+    richLabel: (result, input) => {
+        const questions = (input.questions ?? []);
+        const answers = parseAnswers(result);
+        if (!questions.length || !answers)
+            return null;
+        const first = questions[0];
+        const answer = answers[first.question];
+        if (!answer)
+            return null;
+        const label = first.header ?? "Answer";
+        return `${label}: ${answer}`;
+    },
+    component: AskUserQuestionWidget,
+});

package/dist/widgets/BashWidget.d.ts

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

package/dist/widgets/BashWidget.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { registerWidget } from "../registry.js";
+function BashInputRenderer({ input }) {
+    const command = typeof input.command === "string" ? input.command : null;
+    const description = typeof input.description === "string" ? input.description : null;
+    if (!command)
+        return null;
+    return (_jsxs("div", { className: "mt-1.5 space-y-1", children: [description && _jsx("div", { className: "text-xs text-muted-foreground", children: description }), _jsx("pre", { className: "text-[11px] leading-snug text-muted-foreground bg-accent rounded px-2 py-1 overflow-x-auto whitespace-pre-wrap break-all", children: _jsx("code", { children: command }) })] }));
+}
+function BashWidget({ result, input, phase }) {
+    const command = typeof input.command === "string" ? input.command : null;
+    if (phase === "running" || phase === "pending") {
+        return (_jsxs("div", { className: "py-1 space-y-1 text-xs", children: [command && (_jsx("pre", { className: "leading-snug text-muted-foreground bg-accent rounded px-2 py-1 overflow-x-auto whitespace-pre-wrap break-all", children: _jsxs("code", { children: ["$ ", command] }) })), _jsx("span", { className: "animate-pulse text-muted-foreground", children: "Running\u2026" })] }));
+    }
+    if (typeof result !== "string" || !result)
+        return null;
+    return (_jsx("div", { className: "py-1 text-xs", children: _jsx("pre", { className: "leading-snug text-foreground bg-accent rounded px-2 py-1.5 overflow-x-auto whitespace-pre-wrap break-all max-h-[300px] overflow-y-auto", children: _jsxs("code", { children: [command && (_jsxs("span", { className: "text-muted-foreground", children: ["$ ", command, "\n"] })), result] }) }) }));
+}
+registerWidget({
+    toolName: "Bash",
+    label: "Bash",
+    richLabel: (_r, input) => {
+        const desc = typeof input.description === "string" ? input.description : null;
+        const cmd = typeof input.command === "string" ? input.command : null;
+        if (desc)
+            return desc;
+        if (cmd)
+            return cmd.length > 60 ? `${cmd.slice(0, 57)}...` : cmd;
+        return null;
+    },
+    inputRenderer: BashInputRenderer,
+    component: BashWidget,
+});

package/dist/widgets/EditWidget.d.ts

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

package/dist/widgets/EditWidget.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { registerWidget } from "../registry.js";
+function basename(filePath) {
+    return filePath.split("/").pop() ?? filePath;
+}
+function EditInputRenderer({ input }) {
+    const filePath = typeof input.file_path === "string" ? input.file_path : null;
+    const oldStr = typeof input.old_string === "string" ? input.old_string : null;
+    const newStr = typeof input.new_string === "string" ? input.new_string : null;
+    if (!filePath || oldStr == null || newStr == null)
+        return null;
+    return (_jsxs("div", { className: "mt-1.5 space-y-1.5", children: [_jsx("div", { className: "text-xs text-muted-foreground font-mono truncate", children: filePath }), _jsxs("div", { className: "text-[11px] leading-snug rounded overflow-hidden border border-border", children: [oldStr && (_jsx("pre", { className: "bg-red-500/10 text-red-700 dark:text-red-400 px-2 py-1 overflow-x-auto whitespace-pre-wrap break-all", children: _jsx("code", { children: oldStr.split("\n").map((line, i) => (
+                            // biome-ignore lint/suspicious/noArrayIndexKey: static split lines
+                            _jsxs("span", { children: [i > 0 && "\n", "- ", line] }, i))) }) })), newStr && (_jsx("pre", { className: "bg-green-500/10 text-green-700 dark:text-green-400 px-2 py-1 overflow-x-auto whitespace-pre-wrap break-all", children: _jsx("code", { children: newStr.split("\n").map((line, i) => (
+                            // biome-ignore lint/suspicious/noArrayIndexKey: static split lines
+                            _jsxs("span", { children: [i > 0 && "\n", "+ ", line] }, i))) }) }))] })] }));
+}
+function EditWidget({ result, input, phase }) {
+    const filePath = typeof input.file_path === "string" ? input.file_path : null;
+    if (phase === "running" || phase === "pending") {
+        return (_jsx("div", { className: "flex items-center gap-2 text-xs text-muted-foreground py-1", children: _jsxs("span", { className: "animate-pulse", children: ["Editing ", filePath ? basename(filePath) : "file", "\u2026"] }) }));
+    }
+    if (typeof result !== "string" || !result)
+        return null;
+    return _jsx("div", { className: "py-1 text-xs text-muted-foreground", children: result });
+}
+registerWidget({
+    toolName: "Edit",
+    label: "Edit",
+    richLabel: (_r, input) => {
+        const filePath = typeof input.file_path === "string" ? input.file_path : null;
+        return filePath ? basename(filePath) : null;
+    },
+    inputRenderer: EditInputRenderer,
+    component: EditWidget,
+});

package/dist/widgets/GlobWidget.d.ts

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

package/dist/widgets/GlobWidget.js

@@ -0,0 +1,31 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { registerWidget } from "../registry.js";
+function GlobInputRenderer({ input }) {
+    const pattern = typeof input.pattern === "string" ? input.pattern : null;
+    const path = typeof input.path === "string" ? input.path : null;
+    if (!pattern)
+        return null;
+    return (_jsx("div", { className: "mt-1.5 space-y-1", children: _jsx("pre", { className: "text-[11px] leading-snug text-muted-foreground bg-accent rounded px-2 py-1 overflow-x-auto whitespace-pre-wrap break-all", children: _jsxs("code", { children: [pattern, path ? ` in ${path}` : ""] }) }) }));
+}
+function GlobWidget({ result, input, phase }) {
+    const pattern = typeof input.pattern === "string" ? input.pattern : null;
+    if (phase === "running" || phase === "pending") {
+        return (_jsx("div", { className: "flex items-center gap-2 text-xs text-muted-foreground py-1", children: _jsxs("span", { className: "animate-pulse", children: ["Matching ", pattern ? pattern : "files", "\u2026"] }) }));
+    }
+    if (typeof result !== "string" || !result)
+        return null;
+    const lines = result.split("\n").filter(Boolean);
+    return (_jsxs("div", { className: "py-1 text-xs", children: [_jsxs("div", { className: "text-muted-foreground mb-1", children: [lines.length, " ", lines.length === 1 ? "match" : "matches"] }), _jsx("pre", { className: "leading-snug text-foreground bg-accent rounded px-2 py-1.5 overflow-x-auto whitespace-pre-wrap break-all max-h-[300px] overflow-y-auto", children: _jsx("code", { children: lines.join("\n") }) })] }));
+}
+registerWidget({
+    toolName: "Glob",
+    label: "Glob",
+    richLabel: (_r, input) => {
+        const pattern = typeof input.pattern === "string" ? input.pattern : null;
+        if (pattern)
+            return pattern.length > 50 ? `${pattern.slice(0, 47)}...` : pattern;
+        return null;
+    },
+    inputRenderer: GlobInputRenderer,
+    component: GlobWidget,
+});

package/dist/widgets/GrepWidget.d.ts

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