@codrstudio/openclaude-chat 0.1.0

package/dist/hooks/ChatProvider.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { useOpenClaudeChat, type UseOpenClaudeChatOptions } from "./useOpenClaudeChat.js";
+type ChatContextValue = ReturnType<typeof useOpenClaudeChat>;
+export interface ChatProviderProps extends UseOpenClaudeChatOptions {
+    children: React.ReactNode;
+}
+export declare function ChatProvider({ children, ...options }: ChatProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useChatContext(): ChatContextValue;
+export {};

package/dist/hooks/ChatProvider.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useOpenClaudeChat } from "./useOpenClaudeChat.js";
+const ChatContext = createContext(null);
+export function ChatProvider({ children, ...options }) {
+    const chat = useOpenClaudeChat(options);
+    return _jsx(ChatContext.Provider, { value: chat, children: children });
+}
+export function useChatContext() {
+    const ctx = useContext(ChatContext);
+    if (!ctx)
+        throw new Error("useChatContext must be used within ChatProvider");
+    return ctx;
+}

package/dist/hooks/useIsMobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(breakpoint?: number): boolean;

package/dist/hooks/useIsMobile.js

@@ -0,0 +1,12 @@
+import { useState, useEffect } from "react";
+export function useIsMobile(breakpoint = 768) {
+    const [isMobile, setIsMobile] = useState(false);
+    useEffect(() => {
+        const mql = window.matchMedia(`(max-width: ${breakpoint - 1}px)`);
+        const onChange = () => setIsMobile(mql.matches);
+        onChange();
+        mql.addEventListener("change", onChange);
+        return () => mql.removeEventListener("change", onChange);
+    }, [breakpoint]);
+    return isMobile;
+}

package/dist/hooks/useOpenClaudeChat.d.ts

@@ -0,0 +1,36 @@
+import type { Message } from "../types.js";
+export interface UseOpenClaudeChatOptions {
+    /** Base URL do servico que encapsula o openclaude-sdk. Ex: http://localhost:9500/api/v1/ai */
+    endpoint: string;
+    /** Optional bearer token. */
+    token?: string;
+    /**
+     * ID de sessao live. Caso omitido, o hook cria uma sessao nova via POST /sessions
+     * na primeira mensagem e expoe o id via `sessionId`.
+     */
+    sessionId?: string;
+    /** Mensagens iniciais (historico) para hidratar a UI. */
+    initialMessages?: Message[];
+    /** Options extras passadas ao servidor na criacao da sessao. */
+    sessionOptions?: Record<string, unknown>;
+    /** Options por turno. Passado como `turnOptions` no body do /prompt. */
+    turnOptions?: Record<string, unknown>;
+    /** Customiza fetch (ex: para injetar credenciais). */
+    fetcher?: typeof fetch;
+}
+export interface UseOpenClaudeChatReturn {
+    sessionId: string | null;
+    messages: Message[];
+    input: string;
+    setInput: (value: string) => void;
+    isLoading: boolean;
+    error: Error | null;
+    handleSubmit: (e?: {
+        preventDefault?: () => void;
+    }) => void;
+    sendMessage: (text: string) => Promise<void>;
+    stop: () => void;
+    reload: () => Promise<void>;
+    clear: () => void;
+}
+export declare function useOpenClaudeChat(options: UseOpenClaudeChatOptions): UseOpenClaudeChatReturn;

package/dist/hooks/useOpenClaudeChat.js

@@ -0,0 +1,361 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+// ─────────────────────────────────────────────────────────────────────────────
+function extractTextFromParts(parts) {
+    return parts
+        .filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("\n");
+}
+// ─────────────────────────────────────────────────────────────────────────────
+export function useOpenClaudeChat(options) {
+    const { endpoint, token, sessionId: providedSessionId, initialMessages, sessionOptions, turnOptions, fetcher, } = options;
+    const [sessionId, setSessionId] = useState(providedSessionId ?? null);
+    const [messages, setMessages] = useState(initialMessages ?? []);
+    const [input, setInput] = useState("");
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const abortRef = useRef(null);
+    const lastSentRef = useRef(null);
+    const doFetch = fetcher ?? fetch;
+    // ──────────────────────────────────────────────────────────────
+    // Garante sessao live
+    const ensureSession = useCallback(async () => {
+        if (sessionId)
+            return sessionId;
+        const headers = { "Content-Type": "application/json" };
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
+        const res = await doFetch(`${endpoint}/sessions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ options: sessionOptions ?? {} }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to create session: HTTP ${res.status}`);
+        }
+        const data = (await res.json());
+        setSessionId(data.sessionId);
+        return data.sessionId;
+    }, [sessionId, endpoint, token, sessionOptions, doFetch]);
+    // ──────────────────────────────────────────────────────────────
+    // Stream parser — consome SSE do endpoint /sessions/:id/prompt
+    // Contrato: SEMPRE promove um assistantId no setMessages e SEMPRE retorna
+    // o numero de partes acumuladas. O chamador decide se isso configura erro
+    // (ex: zero partes = resposta vazia, mesmo com HTTP 200).
+    const streamPrompt = useCallback(async (sid, text) => {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "text/event-stream",
+        };
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
+        const ctrl = new AbortController();
+        abortRef.current = ctrl;
+        // Watchdog de stall — se nao chegar NENHUM byte SSE (incluindo ping) em
+        // STALL_MS, considera sessao morta e aborta. Subimos pra 90s pra tolerar
+        // chat agentico (LLM pode pensar muito entre tool calls). O servidor
+        // emite `event: ping` periodicamente como heartbeat — qualquer chunk SSE
+        // (ping ou message) renova esse timer via armStall().
+        const STALL_MS = 90_000;
+        let stallTimer = null;
+        const armStall = () => {
+            if (stallTimer)
+                clearTimeout(stallTimer);
+            stallTimer = setTimeout(() => {
+                try {
+                    ctrl.abort(new Error("stall-timeout"));
+                }
+                catch { /* noop */ }
+            }, STALL_MS);
+        };
+        const disarmStall = () => {
+            if (stallTimer)
+                clearTimeout(stallTimer);
+            stallTimer = null;
+        };
+        // Cria placeholder assistant ANTES do fetch — garante feedback visual imediato
+        // mesmo em caso de rede lenta ou erro no fetch.
+        const assistantId = `asst-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        setMessages((prev) => [
+            ...prev,
+            { id: assistantId, role: "assistant", content: "", parts: [] },
+        ]);
+        armStall();
+        let res;
+        try {
+            res = await doFetch(`${endpoint}/sessions/${encodeURIComponent(sid)}/prompt`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ prompt: text, turnOptions }),
+                signal: ctrl.signal,
+            });
+        }
+        catch (err) {
+            disarmStall();
+            throw err;
+        }
+        if (!res.ok || !res.body) {
+            disarmStall();
+            const errText = await res.text().catch(() => `HTTP ${res.status}`);
+            throw new Error(errText || `HTTP ${res.status}`);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        // Buffer acumulado de partes — fonte da verdade para esta sessao de stream.
+        // Mantemos fora do functional updater do setMessages (o React 19 StrictMode
+        // chama o updater mais de uma vez e mutar estado compartilhado dentro dele
+        // leva a blocos perdidos).
+        const accumulatedParts = [];
+        const toolPartByCallId = new Map();
+        const commit = () => {
+            const snapshot = accumulatedParts.map((p) => ({ ...p }));
+            setMessages((prev) => {
+                const idx = prev.findIndex((m) => m.id === assistantId);
+                if (idx === -1)
+                    return prev;
+                const next = prev.slice();
+                next[idx] = {
+                    ...prev[idx],
+                    parts: snapshot,
+                    content: extractTextFromParts(snapshot),
+                };
+                return next;
+            });
+        };
+        const handleEvent = (eventName, dataStr) => {
+            if (eventName === "error") {
+                try {
+                    const payload = JSON.parse(dataStr);
+                    throw new Error(payload.message ?? "Stream error");
+                }
+                catch (err) {
+                    throw err instanceof Error ? err : new Error(String(err));
+                }
+            }
+            if (eventName === "done")
+                return;
+            // Heartbeat do servidor — `event: ping` apenas serve para manter o
+            // stall watchdog renovado durante pausas longas do agente. Nao tem
+            // payload util; o efeito ja foi aplicado no loop ao chamar armStall()
+            // a cada chunk recebido. Apenas retornamos sem processar.
+            if (eventName === "ping" || eventName === "keepalive" || eventName === "heartbeat")
+                return;
+            if (eventName !== "message")
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(dataStr);
+            }
+            catch {
+                return;
+            }
+            if (msg.type === "assistant") {
+                const assistant = msg;
+                const blocks = assistant.message?.content ?? [];
+                for (const block of blocks) {
+                    if (block.type === "text") {
+                        accumulatedParts.push({ type: "text", text: block.text });
+                    }
+                    else if (block.type === "tool_use") {
+                        if (toolPartByCallId.has(block.id))
+                            continue;
+                        const part = {
+                            type: "tool-invocation",
+                            toolInvocation: {
+                                toolName: block.name,
+                                toolCallId: block.id,
+                                state: "call",
+                                args: block.input,
+                            },
+                        };
+                        toolPartByCallId.set(block.id, part);
+                        accumulatedParts.push(part);
+                    }
+                }
+                commit();
+                return;
+            }
+            if (msg.type === "user") {
+                // Normalmente traz tool_result com ref a tool_use anterior.
+                const userMsg = msg;
+                const content = userMsg.message?.content;
+                if (Array.isArray(content)) {
+                    let changed = false;
+                    for (const block of content) {
+                        if (block.type === "tool_result") {
+                            const part = toolPartByCallId.get(block.tool_use_id);
+                            if (part) {
+                                part.toolInvocation = {
+                                    ...part.toolInvocation,
+                                    state: "result",
+                                    result: block.content,
+                                    isError: block.is_error,
+                                };
+                                changed = true;
+                            }
+                        }
+                    }
+                    if (changed)
+                        commit();
+                }
+                return;
+            }
+            if (msg.type === "result") {
+                // fim do turno — nada a fazer aqui; o loop quebra no "done"
+                return;
+            }
+        };
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                armStall(); // reset watchdog a cada chunk que chega
+                buffer += decoder.decode(value, { stream: true });
+                // SSE frames: "event: X\ndata: Y\n\n"
+                let boundary;
+                while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+                    const frame = buffer.slice(0, boundary);
+                    buffer = buffer.slice(boundary + 2);
+                    let eventName = "message";
+                    const dataLines = [];
+                    for (const line of frame.split("\n")) {
+                        if (line.startsWith("event:"))
+                            eventName = line.slice(6).trim();
+                        else if (line.startsWith("data:"))
+                            dataLines.push(line.slice(5).trimStart());
+                    }
+                    if (dataLines.length === 0)
+                        continue;
+                    handleEvent(eventName, dataLines.join("\n"));
+                }
+            }
+        }
+        finally {
+            disarmStall();
+            abortRef.current = null;
+        }
+        return { assistantId, partCount: accumulatedParts.length };
+    }, [endpoint, token, turnOptions, doFetch]);
+    // ──────────────────────────────────────────────────────────────
+    // Helper: garante que NUNCA fica uma bolha de assistant vazia pendurada.
+    // Se o turno terminou em erro ou em stream vazio, removemos o placeholder
+    // (para o ErrorNote abaixo da mensagem do usuario aparecer) ou injetamos
+    // um bloco de texto com a mensagem de erro para o usuario.
+    const dropEmptyAssistant = useCallback((assistantId) => {
+        if (!assistantId)
+            return;
+        setMessages((prev) => {
+            const idx = prev.findIndex((m) => m.id === assistantId);
+            if (idx === -1)
+                return prev;
+            const msg = prev[idx];
+            if (msg.role === "assistant" && msg.parts.length === 0) {
+                const next = prev.slice();
+                next.splice(idx, 1);
+                return next;
+            }
+            return prev;
+        });
+    }, []);
+    const sendMessage = useCallback(async (text) => {
+        const trimmed = text.trim();
+        if (!trimmed || isLoading)
+            return;
+        setError(null);
+        lastSentRef.current = trimmed;
+        const userId = `user-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        setMessages((prev) => [
+            ...prev,
+            {
+                id: userId,
+                role: "user",
+                content: trimmed,
+                parts: [{ type: "text", text: trimmed }],
+            },
+        ]);
+        setIsLoading(true);
+        // NOTE: removido o `HARD_LIMIT_MS` do turno inteiro. Em chat agentico o
+        // agente pode pensar/rodar tools por minutos sem ser uma falha. A unica
+        // razao para abortar e:
+        //   - usuario clicou stop() (flag __userStop)
+        //   - stall watchdog (sem nenhum byte SSE em STALL_MS, incluindo pings
+        //     do servidor — heartbeat server-push e como sabemos que a sessao
+        //     ainda esta viva mesmo durante pausas longas do LLM)
+        //   - servidor emitiu `event: error` ou fechou o stream com 0 partes
+        let assistantIdForCleanup = null;
+        try {
+            const sid = await ensureSession();
+            const { assistantId, partCount } = await streamPrompt(sid, trimmed);
+            assistantIdForCleanup = assistantId;
+            if (partCount === 0) {
+                // Servidor fechou o stream sem emitir nenhum bloco — erro "macio".
+                throw new Error("O servidor nao retornou nenhum conteudo. Verifique se o provider de LLM esta configurado.");
+            }
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            // Aborts originados do `stop()` do usuario sao intencionais — nao viram erro.
+            const isUserStop = e.name === "AbortError" && e.__userStop;
+            if (!isUserStop) {
+                // Se foi stall/timeout de abort, troca a mensagem por algo legivel.
+                const msg = e.name === "AbortError"
+                    ? "Tempo esgotado aguardando resposta do servidor."
+                    : e.message || "Falha desconhecida ao processar mensagem.";
+                setError(new Error(msg));
+            }
+            dropEmptyAssistant(assistantIdForCleanup);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [isLoading, ensureSession, streamPrompt, dropEmptyAssistant]);
+    const handleSubmit = useCallback((e) => {
+        e?.preventDefault?.();
+        const text = input;
+        setInput("");
+        void sendMessage(text);
+    }, [input, sendMessage]);
+    const stop = useCallback(() => {
+        const err = new Error("User stopped stream");
+        err.name = "AbortError";
+        err.__userStop = true;
+        abortRef.current?.abort(err);
+        abortRef.current = null;
+        setIsLoading(false);
+    }, []);
+    const reload = useCallback(async () => {
+        if (!lastSentRef.current)
+            return;
+        // remove a ultima mensagem do assistant (se existir) antes de re-enviar
+        setMessages((prev) => {
+            if (prev.length === 0)
+                return prev;
+            const last = prev[prev.length - 1];
+            return last.role === "assistant" ? prev.slice(0, -1) : prev;
+        });
+        await sendMessage(lastSentRef.current);
+    }, [sendMessage]);
+    const clear = useCallback(() => {
+        setMessages([]);
+        setError(null);
+        lastSentRef.current = null;
+    }, []);
+    useEffect(() => {
+        return () => abortRef.current?.abort();
+    }, []);
+    return {
+        sessionId,
+        messages,
+        input,
+        setInput,
+        isLoading,
+        error,
+        handleSubmit,
+        sendMessage,
+        stop,
+        reload,
+        clear,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+export type { Message, MessagePart, MessageRole, TextPart, ReasoningPart, ToolInvocationPart, ToolInvocationState, } from "./types.js";
+export { Chat } from "./components/Chat.js";
+export type { ChatProps } from "./components/Chat.js";
+export { useOpenClaudeChat } from "./hooks/useOpenClaudeChat.js";
+export type { UseOpenClaudeChatOptions, UseOpenClaudeChatReturn, } from "./hooks/useOpenClaudeChat.js";
+export { ChatProvider, useChatContext } from "./hooks/ChatProvider.js";
+export type { ChatProviderProps } from "./hooks/ChatProvider.js";
+export { Markdown } from "./components/Markdown.js";
+export { StreamingIndicator } from "./components/StreamingIndicator.js";
+export { ErrorNote } from "./components/ErrorNote.js";
+export type { ErrorNoteProps } from "./components/ErrorNote.js";
+export { MessageBubble } from "./components/MessageBubble.js";
+export type { MessageBubbleProps } from "./components/MessageBubble.js";
+export { MessageList } from "./components/MessageList.js";
+export type { MessageListProps } from "./components/MessageList.js";
+export { MessageInput } from "./components/MessageInput.js";
+export type { MessageInputProps, Attachment } from "./components/MessageInput.js";
+export { PartRenderer } from "./parts/PartRenderer.js";
+export type { PartRendererProps } from "./parts/PartRenderer.js";
+export { ReasoningBlock } from "./parts/ReasoningBlock.js";
+export type { ReasoningBlockProps } from "./parts/ReasoningBlock.js";
+export { ToolActivity, defaultToolIconMap } from "./parts/ToolActivity.js";
+export type { ToolActivityProps, ToolActivityState } from "./parts/ToolActivity.js";
+export { ToolResult } from "./parts/ToolResult.js";
+export type { ToolResultProps } from "./parts/ToolResult.js";
+export { AlertRenderer } from "./display/AlertRenderer.js";
+export { MetricCardRenderer } from "./display/MetricCardRenderer.js";
+export { PriceHighlightRenderer } from "./display/PriceHighlightRenderer.js";
+export { FileCardRenderer } from "./display/FileCardRenderer.js";
+export { CodeBlockRenderer } from "./display/CodeBlockRenderer.js";
+export { SourcesListRenderer } from "./display/SourcesListRenderer.js";
+export { StepTimelineRenderer } from "./display/StepTimelineRenderer.js";
+export { ProgressStepsRenderer } from "./display/ProgressStepsRenderer.js";
+export { ChartRenderer } from "./display/ChartRenderer.js";
+export { CarouselRenderer } from "./display/CarouselRenderer.js";
+export { ProductCardRenderer } from "./display/ProductCardRenderer.js";
+export { ComparisonTableRenderer } from "./display/ComparisonTableRenderer.js";
+export { DataTableRenderer } from "./display/DataTableRenderer.js";
+export { SpreadsheetRenderer } from "./display/SpreadsheetRenderer.js";
+export { GalleryRenderer } from "./display/GalleryRenderer.js";
+export { ImageViewerRenderer } from "./display/ImageViewerRenderer.js";
+export { LinkPreviewRenderer } from "./display/LinkPreviewRenderer.js";
+export { MapViewRenderer } from "./display/MapViewRenderer.js";
+export { ChoiceButtonsRenderer } from "./display/ChoiceButtonsRenderer.js";
+export { defaultDisplayRenderers, resolveDisplayRenderer } from "./display/registry.js";
+export type { DisplayRendererMap, DisplayActionName } from "./display/registry.js";
+export { useIsMobile } from "./hooks/useIsMobile.js";

package/dist/index.js

@@ -0,0 +1,42 @@
+// @codrstudio/openclaude-chat — barrel
+// Componente principal
+export { Chat } from "./components/Chat.js";
+// Hook + Provider
+export { useOpenClaudeChat } from "./hooks/useOpenClaudeChat.js";
+export { ChatProvider, useChatContext } from "./hooks/ChatProvider.js";
+// Subcomponentes
+export { Markdown } from "./components/Markdown.js";
+export { StreamingIndicator } from "./components/StreamingIndicator.js";
+export { ErrorNote } from "./components/ErrorNote.js";
+export { MessageBubble } from "./components/MessageBubble.js";
+export { MessageList } from "./components/MessageList.js";
+export { MessageInput } from "./components/MessageInput.js";
+// Parts
+export { PartRenderer } from "./parts/PartRenderer.js";
+export { ReasoningBlock } from "./parts/ReasoningBlock.js";
+export { ToolActivity, defaultToolIconMap } from "./parts/ToolActivity.js";
+export { ToolResult } from "./parts/ToolResult.js";
+// Display renderers
+export { AlertRenderer } from "./display/AlertRenderer.js";
+export { MetricCardRenderer } from "./display/MetricCardRenderer.js";
+export { PriceHighlightRenderer } from "./display/PriceHighlightRenderer.js";
+export { FileCardRenderer } from "./display/FileCardRenderer.js";
+export { CodeBlockRenderer } from "./display/CodeBlockRenderer.js";
+export { SourcesListRenderer } from "./display/SourcesListRenderer.js";
+export { StepTimelineRenderer } from "./display/StepTimelineRenderer.js";
+export { ProgressStepsRenderer } from "./display/ProgressStepsRenderer.js";
+export { ChartRenderer } from "./display/ChartRenderer.js";
+export { CarouselRenderer } from "./display/CarouselRenderer.js";
+export { ProductCardRenderer } from "./display/ProductCardRenderer.js";
+export { ComparisonTableRenderer } from "./display/ComparisonTableRenderer.js";
+export { DataTableRenderer } from "./display/DataTableRenderer.js";
+export { SpreadsheetRenderer } from "./display/SpreadsheetRenderer.js";
+export { GalleryRenderer } from "./display/GalleryRenderer.js";
+export { ImageViewerRenderer } from "./display/ImageViewerRenderer.js";
+export { LinkPreviewRenderer } from "./display/LinkPreviewRenderer.js";
+export { MapViewRenderer } from "./display/MapViewRenderer.js";
+export { ChoiceButtonsRenderer } from "./display/ChoiceButtonsRenderer.js";
+// Registry
+export { defaultDisplayRenderers, resolveDisplayRenderer } from "./display/registry.js";
+// useIsMobile helper reuse
+export { useIsMobile } from "./hooks/useIsMobile.js";

package/dist/lib/utils.d.ts

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

package/dist/lib/utils.js

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

package/dist/parts/PartErrorBoundary.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+interface State {
+    hasError: boolean;
+    message?: string;
+}
+interface Props {
+    children: React.ReactNode;
+    label?: string;
+}
+/**
+ * Isola o crash de um renderer (ex: display widget com input invalido) pra
+ * evitar que um unico bloco derrube a arvore React inteira. O chat continua
+ * renderizando os outros parts, e no lugar do part quebrado mostra um aviso.
+ */
+export declare class PartErrorBoundary extends React.Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: unknown): State;
+    componentDidCatch(error: unknown, info: unknown): void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>> | import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/dist/parts/PartErrorBoundary.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { AlertTriangle } from "lucide-react";
+/**
+ * Isola o crash de um renderer (ex: display widget com input invalido) pra
+ * evitar que um unico bloco derrube a arvore React inteira. O chat continua
+ * renderizando os outros parts, e no lugar do part quebrado mostra um aviso.
+ */
+export class PartErrorBoundary extends React.Component {
+    state = { hasError: false };
+    static getDerivedStateFromError(error) {
+        return {
+            hasError: true,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+    componentDidCatch(error, info) {
+        // eslint-disable-next-line no-console
+        console.warn("[openclaude-chat] part renderer failed:", error, info);
+    }
+    render() {
+        if (this.state.hasError) {
+            return (_jsxs("div", { role: "alert", className: "flex items-start gap-2 rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-xs text-destructive", children: [_jsx(AlertTriangle, { className: "size-3.5 shrink-0 mt-0.5" }), _jsxs("span", { className: "flex-1 min-w-0 break-words font-mono", children: [this.props.label ? `[${this.props.label}] ` : "", this.state.message ?? "Falha ao renderizar bloco"] })] }));
+        }
+        return this.props.children;
+    }
+}

package/dist/parts/PartRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { DisplayRendererMap } from "../display/registry.js";
+import type { MessagePart } from "../types.js";
+export interface PartRendererProps {
+    part: MessagePart;
+    isStreaming?: boolean;
+    displayRenderers?: DisplayRendererMap;
+}
+export declare const PartRenderer: import("react").NamedExoticComponent<PartRendererProps>;