@uipath/apollo-wind 2.68.0 → 2.69.0

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
+});

package/dist/components/ui/tool-call.d.ts

@@ -0,0 +1,75 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import { CollapsibleContent } from './collapsible';
+import { type JsonTreeViewStrings } from './json-tree-view';
+export type ToolCallStatus = 'pending' | 'executing' | 'completed' | 'failed';
+export interface ToolCallStrings {
+    pending: string;
+    executing: string;
+    completed: string;
+    failed: string;
+    /** Status line while the call is pending or executing. */
+    running: (name: string) => string;
+    /** Status line once the call has finished. `duration` is pre-formatted, e.g. "1.23 seconds". */
+    ran: (name: string, duration?: string) => string;
+    input: string;
+    output: string;
+    errors: string;
+}
+export declare const DEFAULT_TOOL_CALL_STRINGS: ToolCallStrings;
+declare const toolCallVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ToolCallProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof toolCallVariants> {
+    status: ToolCallStatus;
+    /** Controlled open state of the body. */
+    open?: boolean;
+    /** Initial open state when uncontrolled. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Overrides for any subset of the English strings. */
+    strings?: Partial<ToolCallStrings>;
+    /** Overrides for the JSON tree's strings, merged over any outer `JsonTreeViewProvider`. */
+    jsonTreeStrings?: Partial<JsonTreeViewStrings>;
+}
+/**
+ * One agent tool call, laid out like the Material ApToolCall: a status line ("Ran 'x' for 1.2
+ * seconds") that toggles an indented body of collapsible sections (input, errors, output, or any
+ * `ToolCallSection`). The body is not rendered while closed. Omit `ToolCallContent` for a
+ * name-only line (the toggle hides itself).
+ */
+declare const ToolCall: React.ForwardRefExoticComponent<ToolCallProps & React.RefAttributes<HTMLDivElement>>;
+export interface ToolCallHeaderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Tool name, as it should read inside the status line. */
+    name: string;
+    /** Pre-formatted elapsed time, e.g. "1.23 seconds". Shown once the call has finished. */
+    duration?: string;
+}
+declare const ToolCallHeader: React.ForwardRefExoticComponent<ToolCallHeaderProps & React.RefAttributes<HTMLDivElement>>;
+export type ToolCallContentProps = React.ComponentPropsWithoutRef<typeof CollapsibleContent>;
+declare const ToolCallContent: React.ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-collapsible").CollapsibleContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface ToolCallSectionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    title: React.ReactNode;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Initial open state when uncontrolled. Sections start closed, like ApToolCall's. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+/** A collapsible section of the body, for input/output/errors or custom ones such as traces. */
+declare const ToolCallSection: React.ForwardRefExoticComponent<ToolCallSectionProps & React.RefAttributes<HTMLDivElement>>;
+/** Returns a node to replace the default rendering, or `undefined` to keep it. */
+export type ToolCallRenderValue = (value: unknown) => React.ReactNode | undefined;
+export interface ToolCallValueProps extends Omit<ToolCallSectionProps, 'title' | 'children'> {
+    /**
+     * Arrays and plain objects render as a read-only JSON tree with nested values folded; anything
+     * else as text. `undefined` and `null` hide the section, as ApToolCall hides empty data.
+     */
+    value: unknown;
+    /** Custom renderer, e.g. a syntax-highlighted code block. */
+    renderValue?: ToolCallRenderValue;
+}
+declare const ToolCallInput: React.ForwardRefExoticComponent<ToolCallValueProps & React.RefAttributes<HTMLDivElement>>;
+declare const ToolCallOutput: React.ForwardRefExoticComponent<ToolCallValueProps & React.RefAttributes<HTMLDivElement>>;
+declare const ToolCallError: React.ForwardRefExoticComponent<ToolCallValueProps & React.RefAttributes<HTMLDivElement>>;
+export { ToolCall, ToolCallHeader, ToolCallContent, ToolCallSection, ToolCallInput, ToolCallOutput, ToolCallError, toolCallVariants, };