@uipath/apollo-wind 2.67.1 → 2.69.0

package/dist/components/ui/thinking-indicator.cjs

@@ -0,0 +1,146 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    thinkingIndicatorVariants: ()=>thinkingIndicatorVariants,
+    DEFAULT_THINKING_INDICATOR_STRINGS: ()=>DEFAULT_THINKING_INDICATOR_STRINGS,
+    ThinkingIndicator: ()=>ThinkingIndicator
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_class_variance_authority_namespaceObject = require("class-variance-authority");
+const external_lucide_react_namespaceObject = require("lucide-react");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const REDUCED_MOTION_QUERY = '(prefers-reduced-motion: reduce)';
+function getPrefersReducedMotion() {
+    if ("u" < typeof window || 'function' != typeof window.matchMedia) return false;
+    return window.matchMedia(REDUCED_MOTION_QUERY).matches;
+}
+function usePrefersReducedMotion() {
+    const [reduced, setReduced] = external_react_namespaceObject.useState(getPrefersReducedMotion);
+    external_react_namespaceObject.useEffect(()=>{
+        if ('function' != typeof window.matchMedia) return;
+        const mql = window.matchMedia(REDUCED_MOTION_QUERY);
+        const onChange = ()=>setReduced(mql.matches);
+        mql.addEventListener('change', onChange);
+        return ()=>mql.removeEventListener('change', onChange);
+    }, []);
+    return reduced;
+}
+const thinkingIndicatorVariants = (0, external_class_variance_authority_namespaceObject.cva)('inline-flex max-w-full min-w-0 items-center text-muted-foreground', {
+    variants: {
+        size: {
+            sm: 'gap-1.5 text-xs [&_[data-slot=thinking-indicator-icon]]:size-3.5',
+            md: 'gap-2 text-sm [&_[data-slot=thinking-indicator-icon]]:size-4'
+        }
+    },
+    defaultVariants: {
+        size: 'md'
+    }
+});
+const DEFAULT_THINKING_INDICATOR_STRINGS = {
+    label: 'Thinking'
+};
+const ThinkingIndicator = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, size = 'md', label, messages, interval = 2500, strings, icon, 'aria-label': ariaLabel, ...props }, ref)=>{
+    const text = {
+        ...DEFAULT_THINKING_INDICATOR_STRINGS,
+        ...strings
+    };
+    const staticLabel = label ?? text.label;
+    const name = ariaLabel ?? staticLabel;
+    const labels = messages && messages.length > 0 ? messages : [
+        staticLabel
+    ];
+    const reducedMotion = usePrefersReducedMotion();
+    const rotates = labels.length > 1 && !reducedMotion && interval > 0;
+    const rotationKey = `${rotates}\u0000${labels.join('\u0000')}`;
+    const [index, setIndex] = external_react_namespaceObject.useState(0);
+    const [prevRotationKey, setPrevRotationKey] = external_react_namespaceObject.useState(rotationKey);
+    if (rotationKey !== prevRotationKey) {
+        setPrevRotationKey(rotationKey);
+        setIndex(0);
+    }
+    external_react_namespaceObject.useEffect(()=>{
+        if (!rotates) return;
+        const id = window.setInterval(()=>{
+            setIndex((current)=>(current + 1) % labels.length);
+        }, interval);
+        return ()=>window.clearInterval(id);
+    }, [
+        rotates,
+        labels.length,
+        interval,
+        rotationKey
+    ]);
+    const activeIndex = index < labels.length ? index : 0;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+        ref: ref,
+        "data-slot": "thinking-indicator",
+        "data-size": size,
+        role: "status",
+        "aria-label": name,
+        className: (0, index_cjs_namespaceObject.cn)(thinkingIndicatorVariants({
+            size
+        }), className),
+        ...props,
+        children: [
+            null !== icon && false !== icon && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                "data-slot": "thinking-indicator-icon",
+                "aria-hidden": "true",
+                className: "inline-flex shrink-0 items-center justify-center [&>svg]:size-full",
+                children: icon ?? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.Sparkles, {
+                    className: "text-primary animate-pulse motion-reduce:animate-none"
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                "data-slot": "thinking-indicator-label",
+                "aria-hidden": "true",
+                className: "grid min-w-0",
+                children: labels.map((item, i)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                        "data-active": i === activeIndex,
+                        className: "shimmer col-start-1 row-start-1 truncate transition-opacity duration-300 data-[active=false]:opacity-0 motion-reduce:transition-none",
+                        children: item
+                    }, i))
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                className: "sr-only",
+                children: name
+            })
+        ]
+    });
+});
+ThinkingIndicator.displayName = 'ThinkingIndicator';
+exports.DEFAULT_THINKING_INDICATOR_STRINGS = __webpack_exports__.DEFAULT_THINKING_INDICATOR_STRINGS;
+exports.ThinkingIndicator = __webpack_exports__.ThinkingIndicator;
+exports.thinkingIndicatorVariants = __webpack_exports__.thinkingIndicatorVariants;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_THINKING_INDICATOR_STRINGS",
+    "ThinkingIndicator",
+    "thinkingIndicatorVariants"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/thinking-indicator.d.ts

@@ -0,0 +1,38 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const thinkingIndicatorVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ThinkingIndicatorStrings {
+    /** Default visible label, and the accessible name unless `label` or `aria-label` is set. */
+    label: string;
+}
+export declare const DEFAULT_THINKING_INDICATOR_STRINGS: ThinkingIndicatorStrings;
+export interface ThinkingIndicatorProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof thinkingIndicatorVariants> {
+    /** A single label. Also the accessible name when `messages` rotate. */
+    label?: string;
+    /** Labels to cycle through. The first shows immediately; reduced motion keeps it there. */
+    messages?: string[];
+    /** Milliseconds each of `messages` stays on screen. */
+    interval?: number;
+    /** Overrides for any subset of the English strings. An explicit `aria-label` wins over both. */
+    strings?: Partial<ThinkingIndicatorStrings>;
+    /**
+     * Replaces the pulsing sparkle; `null` or `false` shows the label alone. A custom icon brings
+     * its own colour and animation and is sized by the indicator's `size`.
+     */
+    icon?: React.ReactNode;
+}
+/**
+ * A "the assistant is working" row for a conversation: a pulsing sparkle and a shimmering label.
+ * Pass `messages` to cycle through progress labels ("Searching", "Reading files") every
+ * `interval` ms with a crossfade.
+ *
+ * Screen readers get one stable name (`label`, else `strings.label`) on a `role="status"` root,
+ * and the visual label is `aria-hidden`. Rotating labels are decoration, so announcing each one
+ * would only add noise. Announce real progress with `LiveRegion` instead.
+ *
+ * Under `prefers-reduced-motion` the icon and shimmer are static and the labels do not rotate.
+ */
+declare const ThinkingIndicator: React.ForwardRefExoticComponent<ThinkingIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+export { ThinkingIndicator, thinkingIndicatorVariants };

package/dist/components/ui/thinking-indicator.js

@@ -0,0 +1,106 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { Sparkles } from "lucide-react";
+import { forwardRef, useEffect, useState } from "react";
+import { cn } from "../../lib/index.js";
+const REDUCED_MOTION_QUERY = '(prefers-reduced-motion: reduce)';
+function getPrefersReducedMotion() {
+    if ("u" < typeof window || 'function' != typeof window.matchMedia) return false;
+    return window.matchMedia(REDUCED_MOTION_QUERY).matches;
+}
+function usePrefersReducedMotion() {
+    const [reduced, setReduced] = useState(getPrefersReducedMotion);
+    useEffect(()=>{
+        if ('function' != typeof window.matchMedia) return;
+        const mql = window.matchMedia(REDUCED_MOTION_QUERY);
+        const onChange = ()=>setReduced(mql.matches);
+        mql.addEventListener('change', onChange);
+        return ()=>mql.removeEventListener('change', onChange);
+    }, []);
+    return reduced;
+}
+const thinkingIndicatorVariants = cva('inline-flex max-w-full min-w-0 items-center text-muted-foreground', {
+    variants: {
+        size: {
+            sm: 'gap-1.5 text-xs [&_[data-slot=thinking-indicator-icon]]:size-3.5',
+            md: 'gap-2 text-sm [&_[data-slot=thinking-indicator-icon]]:size-4'
+        }
+    },
+    defaultVariants: {
+        size: 'md'
+    }
+});
+const DEFAULT_THINKING_INDICATOR_STRINGS = {
+    label: 'Thinking'
+};
+const ThinkingIndicator = /*#__PURE__*/ forwardRef(({ className, size = 'md', label, messages, interval = 2500, strings, icon, 'aria-label': ariaLabel, ...props }, ref)=>{
+    const text = {
+        ...DEFAULT_THINKING_INDICATOR_STRINGS,
+        ...strings
+    };
+    const staticLabel = label ?? text.label;
+    const name = ariaLabel ?? staticLabel;
+    const labels = messages && messages.length > 0 ? messages : [
+        staticLabel
+    ];
+    const reducedMotion = usePrefersReducedMotion();
+    const rotates = labels.length > 1 && !reducedMotion && interval > 0;
+    const rotationKey = `${rotates}\u0000${labels.join('\u0000')}`;
+    const [index, setIndex] = useState(0);
+    const [prevRotationKey, setPrevRotationKey] = useState(rotationKey);
+    if (rotationKey !== prevRotationKey) {
+        setPrevRotationKey(rotationKey);
+        setIndex(0);
+    }
+    useEffect(()=>{
+        if (!rotates) return;
+        const id = window.setInterval(()=>{
+            setIndex((current)=>(current + 1) % labels.length);
+        }, interval);
+        return ()=>window.clearInterval(id);
+    }, [
+        rotates,
+        labels.length,
+        interval,
+        rotationKey
+    ]);
+    const activeIndex = index < labels.length ? index : 0;
+    return /*#__PURE__*/ jsxs("div", {
+        ref: ref,
+        "data-slot": "thinking-indicator",
+        "data-size": size,
+        role: "status",
+        "aria-label": name,
+        className: cn(thinkingIndicatorVariants({
+            size
+        }), className),
+        ...props,
+        children: [
+            null !== icon && false !== icon && /*#__PURE__*/ jsx("span", {
+                "data-slot": "thinking-indicator-icon",
+                "aria-hidden": "true",
+                className: "inline-flex shrink-0 items-center justify-center [&>svg]:size-full",
+                children: icon ?? /*#__PURE__*/ jsx(Sparkles, {
+                    className: "text-primary animate-pulse motion-reduce:animate-none"
+                })
+            }),
+            /*#__PURE__*/ jsx("span", {
+                "data-slot": "thinking-indicator-label",
+                "aria-hidden": "true",
+                className: "grid min-w-0",
+                children: labels.map((item, i)=>/*#__PURE__*/ jsx("span", {
+                        "data-active": i === activeIndex,
+                        className: "shimmer col-start-1 row-start-1 truncate transition-opacity duration-300 data-[active=false]:opacity-0 motion-reduce:transition-none",
+                        children: item
+                    }, i))
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "sr-only",
+                children: name
+            })
+        ]
+    });
+});
+ThinkingIndicator.displayName = 'ThinkingIndicator';
+export { DEFAULT_THINKING_INDICATOR_STRINGS, ThinkingIndicator, thinkingIndicatorVariants };

package/dist/components/ui/tool-call.cjs

@@ -0,0 +1,359 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ToolCallInput: ()=>ToolCallInput,
+    ToolCall: ()=>ToolCall,
+    ToolCallOutput: ()=>ToolCallOutput,
+    ToolCallError: ()=>ToolCallError,
+    DEFAULT_TOOL_CALL_STRINGS: ()=>DEFAULT_TOOL_CALL_STRINGS,
+    toolCallVariants: ()=>toolCallVariants,
+    ToolCallHeader: ()=>ToolCallHeader,
+    ToolCallContent: ()=>ToolCallContent,
+    ToolCallSection: ()=>ToolCallSection
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_class_variance_authority_namespaceObject = require("class-variance-authority");
+const external_lucide_react_namespaceObject = require("lucide-react");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const external_collapsible_cjs_namespaceObject = require("./collapsible.cjs");
+const external_json_tree_view_index_cjs_namespaceObject = require("./json-tree-view/index.cjs");
+const DEFAULT_TOOL_CALL_STRINGS = {
+    pending: 'Pending',
+    executing: 'Running',
+    completed: 'Completed',
+    failed: 'Failed',
+    running: (name)=>`Running '${name}'`,
+    ran: (name, duration)=>duration ? `Ran '${name}' for ${duration}` : `Ran '${name}'`,
+    input: 'Input',
+    output: 'Output',
+    errors: 'Errors'
+};
+const ToolCallContext = /*#__PURE__*/ external_react_namespaceObject.createContext(null);
+function useToolCallContext(component) {
+    const context = external_react_namespaceObject.useContext(ToolCallContext);
+    if (!context) throw new Error(`${component} must be used within a ToolCall`);
+    return context;
+}
+function mergeStrings(overrides) {
+    const merged = {
+        ...DEFAULT_TOOL_CALL_STRINGS
+    };
+    if (!overrides) return merged;
+    for (const key of Object.keys(overrides)){
+        const value = overrides[key];
+        if (void 0 !== value) merged[key] = value;
+    }
+    return merged;
+}
+const useIsomorphicLayoutEffect = "u" < typeof window ? external_react_namespaceObject.useEffect : external_react_namespaceObject.useLayoutEffect;
+const TOGGLE_CLASSES = 'flex w-full min-w-0 items-center gap-2 rounded p-1 text-left transition-colors hover:text-foreground focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring motion-reduce:transition-none';
+const toolCallVariants = (0, external_class_variance_authority_namespaceObject.cva)('group/tool-call flex w-full min-w-0 flex-col text-muted-foreground', {
+    variants: {
+        size: {
+            sm: 'p-2 text-xs',
+            md: 'p-3 text-sm'
+        }
+    },
+    defaultVariants: {
+        size: 'md'
+    }
+});
+const ToolCall = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, status, size = 'md', open, defaultOpen, onOpenChange, strings, jsonTreeStrings, ...props }, ref)=>{
+    const [contentCount, setContentCount] = external_react_namespaceObject.useState(0);
+    const registerContent = external_react_namespaceObject.useCallback(()=>{
+        setContentCount((count)=>count + 1);
+        return ()=>setContentCount((count)=>count - 1);
+    }, []);
+    const context = external_react_namespaceObject.useMemo(()=>({
+            status,
+            strings: mergeStrings(strings),
+            jsonTreeStrings,
+            hasContent: contentCount > 0,
+            registerContent
+        }), [
+        status,
+        strings,
+        jsonTreeStrings,
+        contentCount,
+        registerContent
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ToolCallContext.Provider, {
+        value: context,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_collapsible_cjs_namespaceObject.Collapsible, {
+            asChild: true,
+            open: open,
+            defaultOpen: defaultOpen,
+            onOpenChange: onOpenChange,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                ref: ref,
+                "data-slot": "tool-call",
+                "data-status": status,
+                "data-size": size,
+                className: (0, index_cjs_namespaceObject.cn)(toolCallVariants({
+                    size
+                }), className),
+                ...props
+            })
+        })
+    });
+});
+ToolCall.displayName = 'ToolCall';
+const STATUS_ICONS = {
+    pending: external_lucide_react_namespaceObject.Clock,
+    executing: external_lucide_react_namespaceObject.Loader2,
+    completed: external_lucide_react_namespaceObject.CircleCheck,
+    failed: external_lucide_react_namespaceObject.CircleX
+};
+const toolCallStatusIconVariants = (0, external_class_variance_authority_namespaceObject.cva)('size-5 shrink-0 group-data-[size=sm]/tool-call:size-4', {
+    variants: {
+        status: {
+            pending: 'text-muted-foreground',
+            executing: 'animate-spin text-primary motion-reduce:animate-none',
+            completed: 'text-success',
+            failed: 'text-destructive'
+        }
+    }
+});
+const ToolCallHeader = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, name, duration, ...props }, ref)=>{
+    const { status, strings, hasContent } = useToolCallContext('ToolCallHeader');
+    const StatusIcon = STATUS_ICONS[status];
+    const finished = 'completed' === status || 'failed' === status;
+    const line = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StatusIcon, {
+                "data-slot": "tool-call-status-icon",
+                "aria-hidden": "true",
+                className: toolCallStatusIconVariants({
+                    status
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                "data-slot": "tool-call-status",
+                className: "sr-only",
+                children: strings[status]
+            }),
+            ' ',
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                "data-slot": "tool-call-label",
+                className: "min-w-0 wrap-break-word",
+                children: finished ? strings.ran(name, duration) : strings.running(name)
+            })
+        ]
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: ref,
+        "data-slot": "tool-call-header",
+        className: (0, index_cjs_namespaceObject.cn)('flex min-w-0', className),
+        ...props,
+        children: hasContent ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_collapsible_cjs_namespaceObject.CollapsibleTrigger, {
+            "data-slot": "tool-call-toggle",
+            className: (0, index_cjs_namespaceObject.cn)('group/tool-call-toggle', TOGGLE_CLASSES),
+            children: [
+                line,
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.ChevronDown, {
+                    "aria-hidden": "true",
+                    className: "size-4 shrink-0 transition-transform motion-reduce:transition-none group-data-[state=open]/tool-call-toggle:rotate-180"
+                })
+            ]
+        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+            className: "flex min-w-0 items-center gap-2 p-1",
+            children: line
+        })
+    });
+});
+ToolCallHeader.displayName = 'ToolCallHeader';
+const ToolCallContent = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>{
+    const { registerContent } = useToolCallContext('ToolCallContent');
+    useIsomorphicLayoutEffect(()=>registerContent(), [
+        registerContent
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_collapsible_cjs_namespaceObject.CollapsibleContent, {
+        ref: ref,
+        "data-slot": "tool-call-content",
+        className: (0, index_cjs_namespaceObject.cn)('mt-2 ml-3 flex min-w-0 flex-col border-l pl-3 group-data-[size=sm]/tool-call:ml-2 group-data-[size=sm]/tool-call:pl-2', className),
+        ...props
+    });
+});
+ToolCallContent.displayName = 'ToolCallContent';
+const ToolCallSection = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, title, open, defaultOpen = false, onOpenChange, children, ...props }, ref)=>{
+    useToolCallContext('ToolCallSection');
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_collapsible_cjs_namespaceObject.Collapsible, {
+        asChild: true,
+        open: open,
+        defaultOpen: defaultOpen,
+        onOpenChange: onOpenChange,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+            ref: ref,
+            "data-slot": "tool-call-section",
+            className: (0, index_cjs_namespaceObject.cn)('flex min-w-0 flex-col', className),
+            ...props,
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_collapsible_cjs_namespaceObject.CollapsibleTrigger, {
+                    "data-slot": "tool-call-section-toggle",
+                    className: (0, index_cjs_namespaceObject.cn)('group/tool-call-section-toggle', TOGGLE_CLASSES),
+                    children: [
+                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.ChevronRight, {
+                            "aria-hidden": "true",
+                            className: "size-4 shrink-0 transition-transform motion-reduce:transition-none group-data-[state=open]/tool-call-section-toggle:rotate-90"
+                        }),
+                        title
+                    ]
+                }),
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_collapsible_cjs_namespaceObject.CollapsibleContent, {
+                    "data-slot": "tool-call-section-content",
+                    className: "ml-7 min-w-0",
+                    children: children
+                })
+            ]
+        })
+    });
+});
+ToolCallSection.displayName = 'ToolCallSection';
+function isJsonContainer(value) {
+    if (Array.isArray(value)) return true;
+    if ('object' != typeof value || null === value) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || null === prototype;
+}
+const VIRTUALIZE_NODE_COUNT = 200;
+function countNodes(nodes) {
+    let count = 0;
+    const stack = [
+        ...nodes
+    ];
+    while(stack.length > 0){
+        const node = stack.pop();
+        count += 1;
+        if (node.children) stack.push(...node.children);
+    }
+    return count;
+}
+function ToolCallJsonValue({ value }) {
+    const { jsonTreeStrings } = useToolCallContext('ToolCallJsonValue');
+    const nodes = external_react_namespaceObject.useMemo(()=>(0, external_json_tree_view_index_cjs_namespaceObject.buildJsonTree)({
+            value
+        }), [
+        value
+    ]);
+    const [opened, setOpened] = external_react_namespaceObject.useState({});
+    const collapsed = external_react_namespaceObject.useMemo(()=>Object.fromEntries((0, external_json_tree_view_index_cjs_namespaceObject.collectContainerPaths)(nodes).map(({ path })=>[
+                path,
+                !opened[path]
+            ])), [
+        nodes,
+        opened
+    ]);
+    const toggle = external_react_namespaceObject.useCallback((path)=>setOpened((prev)=>({
+                ...prev,
+                [path]: !prev[path]
+            })), []);
+    const virtualized = external_react_namespaceObject.useMemo(()=>countNodes(nodes) > VIRTUALIZE_NODE_COUNT, [
+        nodes
+    ]);
+    const [scrollElement, setScrollElement] = external_react_namespaceObject.useState(null);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: setScrollElement,
+        "data-slot": "tool-call-value",
+        className: "my-2 max-h-80 overflow-auto rounded-md border bg-background",
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_json_tree_view_index_cjs_namespaceObject.JsonTreeView, {
+            nodes: nodes,
+            collapsed: collapsed,
+            onToggleCollapsed: toggle,
+            readOnly: true,
+            strings: jsonTreeStrings,
+            virtualized: virtualized,
+            scrollElement: virtualized ? scrollElement : void 0
+        })
+    });
+}
+function ToolCallTextValue({ value }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        tabIndex: 0,
+        "data-slot": "tool-call-value",
+        className: "my-2 max-h-45 overflow-y-auto rounded bg-muted px-3 py-2 text-xs wrap-break-word whitespace-pre-wrap outline-hidden focus-visible:ring-2 focus-visible:ring-ring",
+        children: String(value)
+    });
+}
+function ToolCallValue({ value, renderValue }) {
+    const custom = renderValue?.(value);
+    if (void 0 !== custom) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: custom
+    });
+    if (!isJsonContainer(value)) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ToolCallTextValue, {
+        value: value
+    });
+    if (0 === Object.keys(value).length) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ToolCallTextValue, {
+        value: Array.isArray(value) ? '[]' : '{}'
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ToolCallJsonValue, {
+        value: value
+    });
+}
+function createValueSection(slot, titleKey, displayName) {
+    const Section = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ value, renderValue, ...props }, ref)=>{
+        const { strings } = useToolCallContext(displayName);
+        if (null == value) return null;
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ToolCallSection, {
+            ref: ref,
+            "data-slot": `tool-call-${slot}`,
+            title: strings[titleKey],
+            ...props,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ToolCallValue, {
+                value: value,
+                renderValue: renderValue
+            })
+        });
+    });
+    Section.displayName = displayName;
+    return Section;
+}
+const ToolCallInput = createValueSection('input', 'input', 'ToolCallInput');
+const ToolCallOutput = createValueSection('output', 'output', 'ToolCallOutput');
+const ToolCallError = createValueSection('error', 'errors', 'ToolCallError');
+exports.DEFAULT_TOOL_CALL_STRINGS = __webpack_exports__.DEFAULT_TOOL_CALL_STRINGS;
+exports.ToolCall = __webpack_exports__.ToolCall;
+exports.ToolCallContent = __webpack_exports__.ToolCallContent;
+exports.ToolCallError = __webpack_exports__.ToolCallError;
+exports.ToolCallHeader = __webpack_exports__.ToolCallHeader;
+exports.ToolCallInput = __webpack_exports__.ToolCallInput;
+exports.ToolCallOutput = __webpack_exports__.ToolCallOutput;
+exports.ToolCallSection = __webpack_exports__.ToolCallSection;
+exports.toolCallVariants = __webpack_exports__.toolCallVariants;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_TOOL_CALL_STRINGS",
+    "ToolCall",
+    "ToolCallContent",
+    "ToolCallError",
+    "ToolCallHeader",
+    "ToolCallInput",
+    "ToolCallOutput",
+    "ToolCallSection",
+    "toolCallVariants"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});