@gugacoder/agentic-chat 0.2.0

package/dist/display/index.js

@@ -0,0 +1,20 @@
+export { AlertRenderer } from "./AlertRenderer.js";
+export { MetricCardRenderer } from "./MetricCardRenderer.js";
+export { PriceHighlightRenderer } from "./PriceHighlightRenderer.js";
+export { FileCardRenderer } from "./FileCardRenderer.js";
+export { CodeBlockRenderer } from "./CodeBlockRenderer.js";
+export { SourcesListRenderer } from "./SourcesListRenderer.js";
+export { StepTimelineRenderer } from "./StepTimelineRenderer.js";
+export { ProgressStepsRenderer } from "./ProgressStepsRenderer.js";
+export { ChartRenderer } from "./ChartRenderer.js";
+export { CarouselRenderer } from "./CarouselRenderer.js";
+export { ProductCardRenderer } from "./ProductCardRenderer.js";
+export { ComparisonTableRenderer } from "./ComparisonTableRenderer.js";
+export { DataTableRenderer } from "./DataTableRenderer.js";
+export { SpreadsheetRenderer } from "./SpreadsheetRenderer.js";
+export { GalleryRenderer } from "./GalleryRenderer.js";
+export { ImageViewerRenderer } from "./ImageViewerRenderer.js";
+export { LinkPreviewRenderer } from "./LinkPreviewRenderer.js";
+export { MapViewRenderer } from "./MapViewRenderer.js";
+export { ChoiceButtonsRenderer } from "./ChoiceButtonsRenderer.js";
+export { defaultDisplayRenderers, resolveDisplayRenderer } from "./registry.js";

package/dist/display/registry.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentType } from "react";
+export type DisplayActionName = "metric" | "price" | "alert" | "choices" | "table" | "spreadsheet" | "comparison" | "carousel" | "gallery" | "sources" | "product" | "link" | "file" | "image" | "chart" | "map" | "code" | "progress" | "steps";
+export type DisplayRendererMap = Partial<Record<string, ComponentType<any>>>;
+export declare const defaultDisplayRenderers: Record<DisplayActionName, ComponentType<any>>;
+export declare function resolveDisplayRenderer(action: string, overrides?: DisplayRendererMap): ComponentType<any> | null;

package/dist/display/registry.js

@@ -0,0 +1,50 @@
+import { AlertRenderer } from "./AlertRenderer.js";
+import { MetricCardRenderer } from "./MetricCardRenderer.js";
+import { PriceHighlightRenderer } from "./PriceHighlightRenderer.js";
+import { FileCardRenderer } from "./FileCardRenderer.js";
+import { CodeBlockRenderer } from "./CodeBlockRenderer.js";
+import { SourcesListRenderer } from "./SourcesListRenderer.js";
+import { StepTimelineRenderer } from "./StepTimelineRenderer.js";
+import { ProgressStepsRenderer } from "./ProgressStepsRenderer.js";
+import { ChartRenderer } from "./ChartRenderer.js";
+import { CarouselRenderer } from "./CarouselRenderer.js";
+import { ProductCardRenderer } from "./ProductCardRenderer.js";
+import { ComparisonTableRenderer } from "./ComparisonTableRenderer.js";
+import { DataTableRenderer } from "./DataTableRenderer.js";
+import { SpreadsheetRenderer } from "./SpreadsheetRenderer.js";
+import { GalleryRenderer } from "./GalleryRenderer.js";
+import { ImageViewerRenderer } from "./ImageViewerRenderer.js";
+import { LinkPreviewRenderer } from "./LinkPreviewRenderer.js";
+import { MapViewRenderer } from "./MapViewRenderer.js";
+import { ChoiceButtonsRenderer } from "./ChoiceButtonsRenderer.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const defaultDisplayRenderers = {
+    // highlight
+    metric: MetricCardRenderer,
+    price: PriceHighlightRenderer,
+    alert: AlertRenderer,
+    choices: ChoiceButtonsRenderer,
+    // collection
+    table: DataTableRenderer,
+    spreadsheet: SpreadsheetRenderer,
+    comparison: ComparisonTableRenderer,
+    carousel: CarouselRenderer,
+    gallery: GalleryRenderer,
+    sources: SourcesListRenderer,
+    // card
+    product: ProductCardRenderer,
+    link: LinkPreviewRenderer,
+    file: FileCardRenderer,
+    image: ImageViewerRenderer,
+    // visual
+    chart: ChartRenderer,
+    map: MapViewRenderer,
+    code: CodeBlockRenderer,
+    progress: ProgressStepsRenderer,
+    steps: StepTimelineRenderer,
+};
+export function resolveDisplayRenderer(action, overrides) {
+    if (overrides?.[action])
+        return overrides[action];
+    return defaultDisplayRenderers[action] ?? null;
+}

package/dist/hooks/ChatProvider.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { useBackboneChat, type UseBackboneChatOptions } from "./useBackboneChat.js";
+type ChatContextValue = ReturnType<typeof useBackboneChat>;
+export interface ChatProviderProps extends Omit<UseBackboneChatOptions, "initialMessages"> {
+    initialMessages?: UseBackboneChatOptions["initialMessages"];
+    children: React.ReactNode;
+}
+export declare function ChatProvider({ endpoint, token, sessionId, initialMessages, children }: 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 { useBackboneChat } from "./useBackboneChat.js";
+const ChatContext = createContext(null);
+export function ChatProvider({ endpoint, token, sessionId, initialMessages, children }) {
+    const chat = useBackboneChat({ endpoint, token, sessionId, initialMessages });
+    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/useBackboneChat.d.ts

@@ -0,0 +1,37 @@
+import type { Message } from "@ai-sdk/react";
+import type React from "react";
+export type { Message };
+export interface UseBackboneChatOptions {
+    endpoint: string;
+    token: string;
+    sessionId: string;
+    initialMessages?: Message[];
+    enableRichContent?: boolean;
+}
+export declare function useBackboneChat(options: UseBackboneChatOptions): {
+    error: Error;
+    handleSubmit: (e: React.FormEvent, attachments?: Array<{
+        file: File;
+    }>) => void;
+    reload: (chatRequestOptions?: import("@ai-sdk/ui-utils").ChatRequestOptions) => Promise<string>;
+    isUploading: boolean;
+    buildAttachmentUrl: (ref: string) => string;
+    messages: import("@ai-sdk/ui-utils").UIMessage[];
+    append: (message: Message | import("@ai-sdk/ui-utils").CreateMessage, chatRequestOptions?: import("@ai-sdk/ui-utils").ChatRequestOptions) => Promise<string | null | undefined>;
+    stop: () => void;
+    experimental_resume: () => void;
+    setMessages: (messages: Message[] | ((messages: Message[]) => Message[])) => void;
+    input: string;
+    setInput: React.Dispatch<React.SetStateAction<string>>;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement> | React.ChangeEvent<HTMLTextAreaElement>) => void;
+    metadata?: Object;
+    isLoading: boolean;
+    status: "submitted" | "streaming" | "ready" | "error";
+    data?: import("@ai-sdk/ui-utils").JSONValue[];
+    setData: (data: import("@ai-sdk/ui-utils").JSONValue[] | undefined | ((data: import("@ai-sdk/ui-utils").JSONValue[] | undefined) => import("@ai-sdk/ui-utils").JSONValue[] | undefined)) => void;
+    id: string;
+    addToolResult: ({ toolCallId, result, }: {
+        toolCallId: string;
+        result: any;
+    }) => void;
+};

package/dist/hooks/useBackboneChat.js

@@ -0,0 +1,121 @@
+import { useChat } from "@ai-sdk/react";
+import { useRef, useEffect, useState, useCallback } from "react";
+const RESPONSE_TIMEOUT_MS = 30_000;
+export function useBackboneChat(options) {
+    const [syntheticError, setSyntheticError] = useState(null);
+    const [isUploading, setIsUploading] = useState(false);
+    const timeoutRef = useRef(null);
+    const prevLoadingRef = useRef(false);
+    const pendingFilesRef = useRef([]);
+    const clearTimer = useCallback(() => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+            timeoutRef.current = null;
+        }
+    }, []);
+    const rich = options.enableRichContent !== false;
+    const chat = useChat({
+        api: `${options.endpoint}/api/v1/ai/conversations/${options.sessionId}/messages?format=datastream${rich ? "&rich=true" : ""}`,
+        headers: { Authorization: `Bearer ${options.token}` },
+        initialMessages: options.initialMessages,
+        fetch: async (url, init) => {
+            if (pendingFilesRef.current.length > 0) {
+                const files = pendingFilesRef.current;
+                pendingFilesRef.current = [];
+                const body = JSON.parse(init?.body || "{}");
+                const messages = body.messages ?? [];
+                const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+                const messageText = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : "";
+                const formData = new FormData();
+                if (messageText)
+                    formData.append("message", messageText);
+                for (const file of files) {
+                    formData.append("files", file);
+                }
+                const initHeaders = new Headers((init?.headers ?? {}));
+                initHeaders.delete("Content-Type");
+                const res = await fetch(url, {
+                    method: "POST",
+                    headers: initHeaders,
+                    body: formData,
+                });
+                if (!res.ok) {
+                    let errorMsg = `Erro ${res.status}`;
+                    try {
+                        const text = await res.text();
+                        if (text)
+                            errorMsg = text;
+                    }
+                    catch { /* ignore */ }
+                    throw new Error(errorMsg);
+                }
+                return res;
+            }
+            return fetch(url, init);
+        },
+        onError: () => {
+            clearTimer();
+            setIsUploading(false);
+            setSyntheticError(null);
+        },
+        onFinish: () => {
+            clearTimer();
+            setIsUploading(false);
+            setSyntheticError(null);
+        },
+    });
+    const buildAttachmentUrl = useCallback((ref) => {
+        const base = `${options.endpoint}/api/v1/ai/conversations/${options.sessionId}/attachments/${encodeURIComponent(ref)}`;
+        return options.token ? `${base}?token=${encodeURIComponent(options.token)}` : base;
+    }, [options.endpoint, options.sessionId, options.token]);
+    const { isLoading, messages, stop } = chat;
+    // --- Camada 2: timeout de resposta ---
+    // Inicia timer quando começa a carregar; reseta a cada chunk recebido
+    useEffect(() => {
+        if (isLoading) {
+            clearTimer();
+            timeoutRef.current = setTimeout(() => {
+                stop();
+                setSyntheticError(new Error("Tempo limite atingido. O servidor nao respondeu."));
+            }, RESPONSE_TIMEOUT_MS);
+        }
+        else {
+            clearTimer();
+        }
+        return clearTimer;
+    }, [isLoading, stop, clearTimer]);
+    // Reset timeout quando mensagens mudam (dados chegando)
+    useEffect(() => {
+        if (isLoading && messages.length > 0) {
+            clearTimer();
+            timeoutRef.current = setTimeout(() => {
+                stop();
+                setSyntheticError(new Error("Tempo limite atingido. O servidor nao respondeu."));
+            }, RESPONSE_TIMEOUT_MS);
+        }
+    }, [messages, isLoading, stop, clearTimer]);
+    // --- Camada 3: deteccao de resposta vazia ---
+    useEffect(() => {
+        if (prevLoadingRef.current && !isLoading) {
+            const lastMessage = messages[messages.length - 1];
+            if (!chat.error && lastMessage?.role === "user") {
+                setSyntheticError(new Error("Nenhuma resposta recebida. Tente novamente."));
+            }
+        }
+        prevLoadingRef.current = isLoading;
+    }, [isLoading, messages, chat.error]);
+    const error = chat.error ?? syntheticError;
+    const handleSubmit = useCallback((e, attachments) => {
+        setSyntheticError(null);
+        if (attachments && attachments.length > 0) {
+            pendingFilesRef.current = attachments.map((a) => a.file);
+            setIsUploading(true);
+        }
+        return chat.handleSubmit(e);
+    }, [chat.handleSubmit]);
+    const reload = useCallback((...args) => {
+        setSyntheticError(null);
+        return chat.reload(...args);
+    }, [chat.reload]);
+    return { ...chat, error, handleSubmit, reload, isUploading, buildAttachmentUrl };
+}

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

@@ -0,0 +1,47 @@
+export { Chat } from "./components/Chat.js";
+export type { ChatProps } from "./components/Chat.js";
+export { useBackboneChat } from "./hooks/useBackboneChat.js";
+export type { UseBackboneChatOptions, Message } from "./hooks/useBackboneChat.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 { ConversationList, ConversationBar, useConversations, useIsMobile, formatRelativeTime, buildInitialMessages, groupConversations, } from "./conversations/index.js";
+export type { ConversationListProps, ConversationBarProps, UseConversationsOptions, UseConversationsReturn, Conversation, BackendMessage, } from "./conversations/index.js";

package/dist/index.js

@@ -0,0 +1,40 @@
+// @codrstudio/agentic-chat
+// Barrel exports
+// Componente principal
+export { Chat } from "./components/Chat.js";
+export { useBackboneChat } from "./hooks/useBackboneChat.js";
+export { ChatProvider, useChatContext } from "./hooks/ChatProvider.js";
+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";
+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";
+// Display Registry
+export { defaultDisplayRenderers, resolveDisplayRenderer } from "./display/registry.js";
+// Conversation management
+export { ConversationList, ConversationBar, useConversations, useIsMobile, formatRelativeTime, buildInitialMessages, groupConversations, } from "./conversations/index.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/PartRenderer.d.ts

@@ -0,0 +1,40 @@
+import type { DisplayRendererMap } from "../display/registry.js";
+type TextPart = {
+    type: "text";
+    text: string;
+};
+type ReasoningPart = {
+    type: "reasoning";
+    reasoning: string;
+};
+type ToolInvocationPart = {
+    type: "tool-invocation";
+    toolInvocation: {
+        toolName: string;
+        toolCallId?: string;
+        state: "call" | "partial-call" | "result";
+        args?: Record<string, unknown>;
+        result?: unknown;
+    };
+};
+type ImageAttachmentPart = {
+    type: "image";
+    _ref?: string;
+    mimeType?: string;
+};
+type FileAttachmentPart = {
+    type: "file";
+    _ref?: string;
+    mimeType?: string;
+};
+type MessagePart = TextPart | ReasoningPart | ToolInvocationPart | ImageAttachmentPart | FileAttachmentPart | {
+    type: string;
+};
+export interface PartRendererProps {
+    part: MessagePart;
+    isStreaming?: boolean;
+    displayRenderers?: DisplayRendererMap;
+    attachmentUrl?: (ref: string) => string;
+}
+export declare const PartRenderer: import("react").NamedExoticComponent<PartRendererProps>;
+export {};

package/dist/parts/PartRenderer.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, useState } from "react";
+import { Paperclip, FileText, ChevronDown } from "lucide-react";
+import { Markdown } from "../components/Markdown.js";
+import { LazyRender } from "../components/LazyRender.js";
+import { ReasoningBlock } from "./ReasoningBlock.js";
+import { ToolActivity } from "./ToolActivity.js";
+import { ToolResult } from "./ToolResult.js";
+import { resolveDisplayRenderer } from "../display/registry.js";
+import { Collapsible, CollapsibleTrigger, CollapsibleContent } from "../ui/collapsible.js";
+import { cn } from "../lib/utils.js";
+const HEAVY_RENDERERS = new Set([
+    "chart", "map", "table",
+    "spreadsheet", "gallery", "image",
+]);
+// ─── Attachment sub-components ────────────────────────────────────────────────
+function AttachmentImage({ src }) {
+    const [open, setOpen] = useState(false);
+    return (_jsxs(_Fragment, { children: [_jsx("img", { src: src, loading: "lazy", alt: "Imagem anexada", className: "max-w-xs rounded-lg border cursor-pointer object-cover", onClick: () => setOpen(true) }), open && (_jsx("div", { className: "fixed inset-0 z-50 flex items-center justify-center bg-black/80", onClick: () => setOpen(false), children: _jsx("img", { src: src, alt: "Imagem em tamanho real", className: "max-w-[90vw] max-h-[90vh] rounded-lg", onClick: (e) => e.stopPropagation() }) }))] }));
+}
+function AudioAttachment({ src }) {
+    return (_jsx("audio", { controls: true, src: src, className: "max-w-xs w-full" }));
+}
+function PdfChip({ src, filename }) {
+    return (_jsxs("a", { href: src, target: "_blank", rel: "noopener noreferrer", className: "inline-flex items-center gap-2 rounded-lg border bg-muted px-3 py-2 text-sm hover:bg-muted/80 transition-colors", children: [_jsx(FileText, { className: "h-4 w-4 shrink-0 text-muted-foreground" }), _jsx("span", { className: "max-w-[200px] truncate", children: filename })] }));
+}
+function AttachmentTextBlock({ filename, content }) {
+    const [open, setOpen] = useState(false);
+    const lines = content.split("\n");
+    const preview = lines.slice(0, 3).join("\n") + (lines.length > 3 && !open ? "\n…" : "");
+    return (_jsxs(Collapsible, { open: open, onOpenChange: setOpen, className: "rounded-lg border text-xs overflow-hidden", children: [_jsxs("div", { className: "flex items-center gap-2 px-3 py-2 bg-muted/50 border-b", children: [_jsx(Paperclip, { className: "h-3.5 w-3.5 shrink-0 text-muted-foreground" }), _jsx("span", { className: "flex-1 truncate font-medium", children: filename }), _jsx(CollapsibleTrigger, { asChild: true, children: _jsx("button", { type: "button", className: "text-muted-foreground hover:text-foreground transition-colors", "aria-label": open ? "Recolher" : "Expandir", children: _jsx(ChevronDown, { className: cn("h-3.5 w-3.5 transition-transform", open && "rotate-180") }) }) })] }), _jsx("pre", { className: "px-3 py-2 text-muted-foreground whitespace-pre-wrap break-words", children: preview }), _jsx(CollapsibleContent, { children: _jsx("pre", { className: "px-3 py-2 max-h-40 overflow-auto whitespace-pre-wrap break-words border-t", children: content }) })] }));
+}
+// ─── Main renderer ────────────────────────────────────────────────────────────
+export const PartRenderer = memo(function PartRenderer({ part, isStreaming, displayRenderers, attachmentUrl }) {
+    switch (part.type) {
+        case "text": {
+            const p = part;
+            // Pre-processed attachment text: "[📎 filename]\ncontent"
+            if (p.text.startsWith("[📎")) {
+                const firstNewline = p.text.indexOf("\n");
+                const header = firstNewline >= 0 ? p.text.slice(0, firstNewline) : p.text;
+                const body = firstNewline >= 0 ? p.text.slice(firstNewline + 1) : "";
+                const match = header.match(/^\[📎\s+(.+?)\]?$/);
+                const filename = match?.[1] ?? header;
+                return _jsx(AttachmentTextBlock, { filename: filename, content: body });
+            }
+            return _jsx(Markdown, { children: p.text });
+        }
+        case "reasoning": {
+            const p = part;
+            return _jsx(ReasoningBlock, { content: p.reasoning, isStreaming: isStreaming });
+        }
+        case "tool-invocation": {
+            const { toolInvocation } = part;
+            const isDisplay = toolInvocation.toolName.startsWith("display_");
+            if (isDisplay && toolInvocation.state === "result") {
+                const result = toolInvocation.result;
+                const action = toolInvocation.toolName.replace("display_", "");
+                const Renderer = resolveDisplayRenderer(action, displayRenderers);
+                if (Renderer) {
+                    const rendered = _jsx(Renderer, { ...result });
+                    if (!isStreaming && action && HEAVY_RENDERERS.has(action)) {
+                        return _jsx(LazyRender, { children: rendered });
+                    }
+                    return rendered;
+                }
+            }
+            if (toolInvocation.state === "result") {
+                return (_jsx(ToolResult, { toolName: toolInvocation.toolName, result: toolInvocation.result }));
+            }
+            return (_jsx(ToolActivity, { toolName: toolInvocation.toolName, state: toolInvocation.state, args: toolInvocation.args }));
+        }
+        case "image": {
+            const p = part;
+            if (!p._ref || !attachmentUrl)
+                return null;
+            return _jsx(AttachmentImage, { src: attachmentUrl(p._ref) });
+        }
+        case "file": {
+            const p = part;
+            if (!p._ref || !attachmentUrl)
+                return null;
+            const src = attachmentUrl(p._ref);
+            if (p.mimeType?.startsWith("audio/")) {
+                return _jsx(AudioAttachment, { src: src });
+            }
+            if (p.mimeType === "application/pdf") {
+                // Extract a human-readable filename from the att_ts_hex.ext pattern
+                const filename = p._ref.replace(/^att_\d+_[0-9a-f]+\./, "") || p._ref;
+                return _jsx(PdfChip, { src: src, filename: filename });
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+});

package/dist/parts/ReasoningBlock.d.ts

@@ -0,0 +1,6 @@
+export interface ReasoningBlockProps {
+    content: string;
+    isStreaming?: boolean;
+    className?: string;
+}
+export declare function ReasoningBlock({ content, isStreaming, className }: ReasoningBlockProps): import("react/jsx-runtime").JSX.Element;

package/dist/parts/ReasoningBlock.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Brain, ChevronDown, ChevronRight } from "lucide-react";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../ui/collapsible.js";
+export function ReasoningBlock({ content, isStreaming = false, className }) {
+    const [expanded, setExpanded] = useState(isStreaming);
+    useEffect(() => {
+        if (isStreaming) {
+            setExpanded(true);
+        }
+        else {
+            setExpanded(false);
+        }
+    }, [isStreaming]);
+    return (_jsx(Collapsible, { open: expanded, onOpenChange: setExpanded, className: className, children: _jsxs("div", { className: "border border-purple-500/30 bg-purple-500/5 rounded-md text-sm overflow-hidden", children: [_jsxs(CollapsibleTrigger, { className: "flex items-center gap-2 px-3 py-2 w-full text-left font-medium text-purple-400 hover:bg-purple-500/10 cursor-pointer", children: [_jsx(Brain, { className: "h-3.5 w-3.5", "aria-hidden": "true" }), _jsx("span", { className: "font-mono text-xs", children: "reasoning:" }), expanded
+                            ? _jsx(ChevronDown, { className: "h-3.5 w-3.5 ml-auto", "aria-hidden": "true" })
+                            : _jsx(ChevronRight, { className: "h-3.5 w-3.5 ml-auto", "aria-hidden": "true" })] }), _jsx(CollapsibleContent, { children: _jsx("div", { className: "max-h-96 overflow-y-auto px-3 py-3 text-purple-300/80 whitespace-pre-wrap break-words border-t border-purple-500/20 text-xs", children: content }) })] }) }));
+}

package/dist/parts/ToolActivity.d.ts

@@ -0,0 +1,11 @@
+import { type LucideIcon } from "lucide-react";
+export type ToolActivityState = "call" | "partial-call" | "result";
+export interface ToolActivityProps {
+    toolName: string;
+    state: ToolActivityState;
+    args?: Record<string, unknown>;
+    className?: string;
+    iconMap?: Partial<Record<string, LucideIcon>>;
+}
+export declare const defaultToolIconMap: Record<string, LucideIcon>;
+export declare function ToolActivity({ toolName, state, args, className, iconMap }: ToolActivityProps): import("react/jsx-runtime").JSX.Element;

package/dist/parts/ToolActivity.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Check, Download, FileText, FilePlus, FolderSearch, Globe, Loader2, Pencil, Search, Terminal, Wrench } from "lucide-react";
+import { cn } from "../lib/utils.js";
+export const defaultToolIconMap = {
+    WebSearch: Globe,
+    Bash: Terminal,
+    Read: FileText,
+    Edit: Pencil,
+    Write: FilePlus,
+    Grep: Search,
+    Glob: FolderSearch,
+    WebFetch: Download,
+    ListDir: FolderSearch,
+};
+function formatToolName(name) {
+    return name
+        .replace(/_/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function resolveIcon(toolName, iconMap) {
+    return iconMap[toolName] ?? Wrench;
+}
+function formatArgs(toolName, args) {
+    if (!args)
+        return null;
+    if (toolName === "Bash" && args.command)
+        return String(args.command);
+    if (toolName === "Read" && args.path)
+        return String(args.path);
+    if (toolName === "Edit" && args.file_path)
+        return String(args.file_path);
+    if (toolName === "Write" && args.file_path)
+        return String(args.file_path);
+    if (toolName === "Grep" && args.pattern)
+        return String(args.pattern);
+    if (toolName === "Glob" && args.pattern)
+        return String(args.pattern);
+    if (toolName === "WebSearch" && args.query)
+        return String(args.query);
+    if (toolName === "ListDir" && args.path)
+        return String(args.path);
+    return null;
+}
+export function ToolActivity({ toolName, state, args, className, iconMap }) {
+    const mergedIconMap = iconMap ? { ...defaultToolIconMap, ...iconMap } : defaultToolIconMap;
+    const Icon = resolveIcon(toolName, mergedIconMap);
+    const isActive = state === "call" || state === "partial-call";
+    const displayName = formatToolName(toolName);
+    const argsPreview = formatArgs(toolName, args);
+    return (_jsxs("div", { className: cn("flex items-center gap-2 rounded-md border px-3 py-2 text-sm", "border-amber-500/30 bg-amber-500/5", className), children: [_jsx("span", { className: "text-amber-500 shrink-0", "aria-hidden": "true", children: _jsx(Icon, { size: 14 }) }), _jsx("span", { className: "font-medium font-mono text-amber-500", children: displayName }), argsPreview && (_jsx("span", { className: "truncate text-xs text-muted-foreground font-mono max-w-[300px]", children: argsPreview })), _jsx("span", { className: "ml-auto text-muted-foreground", children: isActive ? (_jsx(Loader2, { size: 14, className: "animate-spin text-amber-500", "aria-label": "Executando..." })) : (_jsx(Check, { size: 14, className: "text-green-500", "aria-label": "Concluido" })) })] }));
+}

package/dist/parts/ToolResult.d.ts

@@ -0,0 +1,7 @@
+export interface ToolResultProps {
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+    className?: string;
+}
+export declare function ToolResult({ toolName, result, isError, className }: ToolResultProps): import("react/jsx-runtime").JSX.Element;