@uipath/apollo-wind 2.22.0 → 2.24.0

package/dist/components/ui/prompt-editor/prompt-editor.js

@@ -0,0 +1,368 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { LexicalComposer } from "@lexical/react/LexicalComposer";
+import { ContentEditable } from "@lexical/react/LexicalContentEditable";
+import { LexicalErrorBoundary } from "@lexical/react/LexicalErrorBoundary";
+import { HistoryPlugin } from "@lexical/react/LexicalHistoryPlugin";
+import { OnChangePlugin } from "@lexical/react/LexicalOnChangePlugin";
+import { PlainTextPlugin } from "@lexical/react/LexicalPlainTextPlugin";
+import { $getSelection, $isRangeSelection } from "lexical";
+import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { TooltipProvider } from "../tooltip.js";
+import { EditorToolbar } from "./components/EditorToolbar.js";
+import { MarkdownPreview } from "./components/MarkdownPreview.js";
+import { InputTokenNode, OutputTokenNode, ResourceTokenNode, StateTokenNode } from "./nodes/index.js";
+import { AutocompletePlugin } from "./plugins/AutocompletePlugin.js";
+import { CopyPastePlugin } from "./plugins/CopyPastePlugin.js";
+import { EditorRefPlugin } from "./plugins/EditorRefPlugin.js";
+import { MultilinePlugin } from "./plugins/MultilinePlugin.js";
+import { NodeSelectionFixPlugin } from "./plugins/NodeSelectionFixPlugin.js";
+import { RenameTokensPlugin } from "./plugins/RenameTokensPlugin.js";
+import { ToolbarActionsPlugin } from "./plugins/ToolbarActionsPlugin.js";
+import { ValidateTokensPlugin } from "./plugins/ValidateTokensPlugin.js";
+import { ValueSyncPlugin } from "./plugins/ValueSyncPlugin.js";
+import { VariableDropPlugin } from "./plugins/VariableDropPlugin.js";
+import { $getEditorTokensInternal, $insertTokenAtCursor, $setEditorTokensInternal, areTokensEqual } from "./utils/index.js";
+const DEFAULT_MIN_ROWS = 4;
+const DEFAULT_MAX_ROWS = 20;
+const LINE_HEIGHT = 20;
+const EMPTY_AUTOCOMPLETE_OPTIONS = [];
+const EMPTY_TOKENS = [];
+const toTokenArray = (v)=>void 0 === v ? void 0 : Array.isArray(v) ? v : EMPTY_TOKENS;
+const EditorInner = /*#__PURE__*/ forwardRef(({ initialValue, value, onChange, autoCompleteOptions = EMPTY_AUTOCOMPLETE_OPTIONS, multiline = true, minRows = DEFAULT_MIN_ROWS, maxRows = DEFAULT_MAX_ROWS, placeholder, disabled, ariaLabel, fillHeight, borderless, mapVarDropToToken, toolbarActionsRef, showToolbar }, ref)=>{
+    const editorRef = useRef(null);
+    const [isEmpty, setIsEmpty] = useState(()=>{
+        const seed = initialValue ?? value;
+        return !seed || 0 === seed.length;
+    });
+    const initializedRef = useRef(false);
+    const onChangeRef = useRef(onChange);
+    const isEmptyRef = useRef(isEmpty);
+    const debounceTimerRef = useRef(null);
+    const pendingTokensRef = useRef(null);
+    const lastEmittedValueRef = useRef(null);
+    const isMountedRef = useRef(true);
+    const isSyncingRef = useRef(false);
+    onChangeRef.current = onChange;
+    isEmptyRef.current = isEmpty;
+    useImperativeHandle(ref, ()=>({
+            setTokens: (tokens)=>{
+                if (editorRef.current) editorRef.current.update(()=>{
+                    $setEditorTokensInternal(tokens);
+                });
+                else onChangeRef.current?.(tokens);
+            },
+            insertAutocompleteTrigger: ()=>{
+                const editor = editorRef.current;
+                if (!editor) return;
+                editor.focus();
+                editor.update(()=>{
+                    const selection = $getSelection();
+                    if ($isRangeSelection(selection)) selection.insertRawText('$');
+                });
+            },
+            insertVariableToken: (option)=>{
+                const editor = editorRef.current;
+                if (!editor) return;
+                editor.focus();
+                editor.update(()=>{
+                    $insertTokenAtCursor(option);
+                });
+            }
+        }), []);
+    const contentEditableStyle = useMemo(()=>{
+        const verticalPadding = 8;
+        const textColor = borderless ? 'inherit' : 'var(--color-foreground)';
+        const base = {
+            width: '100%',
+            outline: 'none',
+            userSelect: 'text',
+            boxSizing: 'border-box',
+            padding: '8px 12px',
+            fontFamily: "'Noto Sans', sans-serif",
+            fontSize: '14px',
+            lineHeight: `${LINE_HEIGHT}px`,
+            color: textColor
+        };
+        if (!multiline) return {
+            ...base,
+            height: '36px',
+            maxHeight: '36px',
+            overflowX: 'auto',
+            overflowY: 'hidden',
+            whiteSpace: 'nowrap'
+        };
+        const effectiveMinRows = Math.min(minRows, maxRows);
+        const minHeight = effectiveMinRows * LINE_HEIGHT + 2 * verticalPadding;
+        const maxHeight = maxRows * LINE_HEIGHT + 2 * verticalPadding;
+        return {
+            ...base,
+            minHeight: `${minHeight}px`,
+            ...fillHeight ? {
+                flex: 1
+            } : {
+                maxHeight: `${maxHeight}px`
+            },
+            overflowY: 'auto'
+        };
+    }, [
+        multiline,
+        minRows,
+        maxRows,
+        fillHeight,
+        borderless
+    ]);
+    const handleEditorRef = useCallback((editor)=>{
+        editorRef.current = editor;
+    }, []);
+    const handleChange = useCallback(()=>{
+        if (!editorRef.current) return;
+        editorRef.current.getEditorState().read(()=>{
+            const tokens = $getEditorTokensInternal();
+            const newIsEmpty = 0 === tokens.length || 1 === tokens.length && 'text' === tokens[0].type && '' === tokens[0].value;
+            if (newIsEmpty !== isEmptyRef.current) setIsEmpty(newIsEmpty);
+            if (!isSyncingRef.current) pendingTokensRef.current = tokens;
+        });
+        if (isSyncingRef.current || !onChangeRef.current) return;
+        if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = setTimeout(()=>{
+            if (!isMountedRef.current || !pendingTokensRef.current || !onChangeRef.current || !editorRef.current || isSyncingRef.current) return;
+            lastEmittedValueRef.current = pendingTokensRef.current;
+            onChangeRef.current(pendingTokensRef.current);
+            pendingTokensRef.current = null;
+        }, 0);
+    }, []);
+    useEffect(()=>{
+        if (value && lastEmittedValueRef.current && !areTokensEqual(value, lastEmittedValueRef.current)) lastEmittedValueRef.current = null;
+    }, [
+        value
+    ]);
+    useEffect(()=>{
+        isMountedRef.current = true;
+        return ()=>{
+            isMountedRef.current = false;
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+                debounceTimerRef.current = null;
+            }
+            pendingTokensRef.current = null;
+        };
+    }, []);
+    useEffect(()=>{
+        const seed = initialValue ?? value;
+        if (!editorRef.current || !seed || initializedRef.current) return;
+        const valueToSet = seed;
+        queueMicrotask(()=>{
+            if (!editorRef.current || initializedRef.current) return;
+            editorRef.current.update(()=>{
+                $setEditorTokensInternal(valueToSet);
+                setIsEmpty(0 === valueToSet.length);
+                initializedRef.current = true;
+            });
+        });
+    }, []);
+    useEffect(()=>{
+        if (!editorRef.current) return;
+        editorRef.current.setEditable(!disabled);
+    }, [
+        disabled
+    ]);
+    const options = Array.isArray(autoCompleteOptions) ? autoCompleteOptions : EMPTY_AUTOCOMPLETE_OPTIONS;
+    const wrapperClassName = borderless ? 'flex flex-col w-full relative' : `prompt-editor-shell flex flex-col w-full relative border bg-background ${showToolbar ? 'border-t-0 rounded-b-md' : 'rounded-md'}`;
+    return /*#__PURE__*/ jsxs("div", {
+        className: wrapperClassName,
+        style: {
+            fontFamily: "'Noto Sans', sans-serif",
+            fontSize: '14px',
+            lineHeight: '20px',
+            ...fillHeight ? {
+                flex: 1,
+                minHeight: 0
+            } : {}
+        },
+        children: [
+            /*#__PURE__*/ jsx("style", {
+                children: `
+          .prompt-editor-paragraph { padding: 0; margin: 0; }
+          ${borderless ? '' : '.prompt-editor-shell:focus-within { border-color: var(--color-ring); box-shadow: 0 0 0 1px var(--color-ring); }'}
+          .prompt-editor-root *::selection { background-color: color-mix(in srgb, var(--color-primary) 30%, transparent); }
+        `
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "prompt-editor-root",
+                style: {
+                    position: 'relative',
+                    ...fillHeight ? {
+                        flex: 1,
+                        display: 'flex',
+                        flexDirection: 'column',
+                        minHeight: 0
+                    } : {}
+                },
+                children: [
+                    /*#__PURE__*/ jsx(PlainTextPlugin, {
+                        contentEditable: /*#__PURE__*/ jsx(ContentEditable, {
+                            style: contentEditableStyle,
+                            ariaLabel: ariaLabel
+                        }),
+                        placeholder: null,
+                        ErrorBoundary: LexicalErrorBoundary
+                    }),
+                    placeholder && isEmpty && /*#__PURE__*/ jsx("div", {
+                        style: {
+                            position: 'absolute',
+                            top: '8px',
+                            left: '12px',
+                            right: '12px',
+                            pointerEvents: 'none',
+                            userSelect: 'none',
+                            fontFamily: "'Noto Sans', sans-serif",
+                            fontSize: '14px',
+                            lineHeight: '20px',
+                            ...multiline ? {} : {
+                                whiteSpace: 'nowrap',
+                                overflow: 'hidden',
+                                textOverflow: 'ellipsis'
+                            }
+                        },
+                        className: "text-muted-foreground/60",
+                        children: placeholder
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(HistoryPlugin, {}),
+            /*#__PURE__*/ jsx(NodeSelectionFixPlugin, {}),
+            /*#__PURE__*/ jsx(CopyPastePlugin, {}),
+            /*#__PURE__*/ jsx(EditorRefPlugin, {
+                onRef: handleEditorRef
+            }),
+            /*#__PURE__*/ jsx(ValueSyncPlugin, {
+                value: value,
+                editorRef: editorRef,
+                lastEmittedValueRef: lastEmittedValueRef,
+                isSyncingRef: isSyncingRef
+            }),
+            /*#__PURE__*/ jsx(MultilinePlugin, {
+                multiline: multiline
+            }),
+            /*#__PURE__*/ jsx(OnChangePlugin, {
+                ignoreSelectionChange: true,
+                onChange: handleChange
+            }),
+            /*#__PURE__*/ jsx(ToolbarActionsPlugin, {
+                actionsRef: toolbarActionsRef
+            }),
+            options.length > 0 && /*#__PURE__*/ jsx(AutocompletePlugin, {
+                options: options
+            }),
+            /*#__PURE__*/ jsx(ValidateTokensPlugin, {
+                options: options
+            }),
+            options.length > 0 && /*#__PURE__*/ jsx(RenameTokensPlugin, {
+                options: options,
+                onChange: onChange
+            }),
+            mapVarDropToToken && /*#__PURE__*/ jsx(VariableDropPlugin, {
+                mapVarDropToToken: mapVarDropToToken,
+                disabled: disabled
+            })
+        ]
+    });
+});
+EditorInner.displayName = 'PromptEditorInner';
+const PromptEditor = ({ value: rawValue, initialValue: rawInitialValue, onChange, multiline = true, minRows = DEFAULT_MIN_ROWS, maxRows = DEFAULT_MAX_ROWS, placeholder, disabled, ariaLabel, autoCompleteOptions, showToolbar = false, mode: controlledMode, onModeChange, onFullscreen, editorRef, fillHeight, borderless, mapVarDropToToken })=>{
+    const value = toTokenArray(rawValue);
+    const initialValue = toTokenArray(rawInitialValue);
+    const [internalMode, setInternalMode] = useState('edit');
+    const mode = controlledMode ?? internalMode;
+    const toolbarActionsRef = useRef(null);
+    const [uncontrolledPreviewTokens, setUncontrolledPreviewTokens] = useState(initialValue ?? []);
+    const handleModeChange = useCallback((newMode)=>{
+        if (onModeChange) onModeChange(newMode);
+        else setInternalMode(newMode);
+    }, [
+        onModeChange
+    ]);
+    const initialConfig = useMemo(()=>({
+            namespace: 'PromptEditor',
+            theme: {
+                paragraph: 'prompt-editor-paragraph'
+            },
+            onError: (error)=>console.error('PromptEditor error:', error),
+            nodes: [
+                InputTokenNode,
+                OutputTokenNode,
+                StateTokenNode,
+                ResourceTokenNode
+            ]
+        }), []);
+    const isControlled = void 0 !== value;
+    const previewTokens = isControlled ? value : uncontrolledPreviewTokens;
+    const handleEditorChange = useCallback((tokens)=>{
+        if (!isControlled) setUncontrolledPreviewTokens(tokens);
+        onChange?.(tokens);
+    }, [
+        isControlled,
+        onChange
+    ]);
+    return /*#__PURE__*/ jsx(TooltipProvider, {
+        children: /*#__PURE__*/ jsxs("div", {
+            style: {
+                display: 'flex',
+                flexDirection: 'column',
+                width: '100%',
+                ...fillHeight ? {
+                    flex: 1,
+                    minHeight: 0
+                } : {}
+            },
+            children: [
+                showToolbar && /*#__PURE__*/ jsx(EditorToolbar, {
+                    mode: mode,
+                    disabled: disabled,
+                    actionsRef: toolbarActionsRef,
+                    onModeChange: handleModeChange,
+                    onFullscreen: onFullscreen
+                }),
+                'preview' === mode && /*#__PURE__*/ jsx("div", {
+                    className: borderless ? void 0 : `border bg-background ${showToolbar ? 'border-t-0 rounded-b-md' : 'rounded-md'}`,
+                    children: /*#__PURE__*/ jsx(MarkdownPreview, {
+                        tokens: previewTokens,
+                        minRows: minRows
+                    })
+                }),
+                /*#__PURE__*/ jsx("div", {
+                    style: {
+                        display: 'preview' === mode ? 'none' : 'flex',
+                        flexDirection: 'column',
+                        ...fillHeight ? {
+                            flex: 1,
+                            minHeight: 0
+                        } : {}
+                    },
+                    children: /*#__PURE__*/ jsx(LexicalComposer, {
+                        initialConfig: initialConfig,
+                        children: /*#__PURE__*/ jsx(EditorInner, {
+                            ref: editorRef,
+                            autoCompleteOptions: autoCompleteOptions,
+                            disabled: disabled,
+                            ariaLabel: ariaLabel,
+                            initialValue: initialValue,
+                            maxRows: maxRows,
+                            minRows: minRows,
+                            multiline: multiline,
+                            placeholder: placeholder,
+                            fillHeight: fillHeight,
+                            borderless: borderless,
+                            mapVarDropToToken: mapVarDropToToken,
+                            showToolbar: showToolbar,
+                            toolbarActionsRef: toolbarActionsRef,
+                            value: value,
+                            onChange: handleEditorChange
+                        })
+                    })
+                })
+            ]
+        })
+    });
+};
+export { PromptEditor };

package/dist/components/ui/prompt-editor/types.cjs

@@ -0,0 +1,74 @@
+"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__, {
+    getPromptEditorTokenColors: ()=>getPromptEditorTokenColors,
+    getPromptEditorTokenTypeLabel: ()=>getPromptEditorTokenTypeLabel,
+    isPromptEditorNonTextToken: ()=>isPromptEditorNonTextToken,
+    isPromptEditorTextToken: ()=>isPromptEditorTextToken
+});
+const getPromptEditorTokenColors = ()=>({
+        valid: {
+            background: 'var(--color-primary-lighter)',
+            border: 'var(--color-primary)',
+            text: 'var(--color-foreground)',
+            icon: 'var(--color-primary)'
+        },
+        invalid: {
+            background: 'var(--color-error-background)',
+            border: 'var(--color-error)',
+            text: 'var(--color-error-text)',
+            icon: 'var(--color-error-icon)'
+        }
+    });
+const getPromptEditorTokenTypeLabel = (type)=>{
+    switch(type){
+        case 'input':
+            return 'Input variable';
+        case 'output':
+            return 'Output variable';
+        case 'state':
+            return 'State variable';
+        case 'resource':
+            return 'Resource';
+        default:
+            return 'Text';
+    }
+};
+const isPromptEditorTextToken = (token)=>'text' === token.type;
+const isPromptEditorNonTextToken = (token)=>'text' !== token.type;
+exports.getPromptEditorTokenColors = __webpack_exports__.getPromptEditorTokenColors;
+exports.getPromptEditorTokenTypeLabel = __webpack_exports__.getPromptEditorTokenTypeLabel;
+exports.isPromptEditorNonTextToken = __webpack_exports__.isPromptEditorNonTextToken;
+exports.isPromptEditorTextToken = __webpack_exports__.isPromptEditorTextToken;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getPromptEditorTokenColors",
+    "getPromptEditorTokenTypeLabel",
+    "isPromptEditorNonTextToken",
+    "isPromptEditorTextToken"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/types.d.ts

@@ -0,0 +1,58 @@
+export type PromptEditorTokenType = 'input' | 'output' | 'state' | 'resource' | 'text';
+interface BaseToken {
+    type: PromptEditorTokenType;
+    /**
+     * Variable path **without** a leading `$` — e.g. `vars.firstName`, `state.retryCount`. apollo-wind
+     * owns this no-`$` convention (unlike flow-workbench's `$vars.firstName`). Serialization and
+     * `ValidateTokensPlugin` compare these by exact string equality against
+     * {@link PromptEditorAutoCompleteOption.value}, so the two must use the same `$`-less form.
+     */
+    value: string;
+}
+export interface PromptEditorTextToken extends BaseToken {
+    type: 'text';
+}
+export interface PromptEditorInputToken extends BaseToken {
+    type: 'input';
+}
+export interface PromptEditorOutputToken extends BaseToken {
+    type: 'output';
+}
+export interface PromptEditorStateToken extends BaseToken {
+    type: 'state';
+}
+export interface PromptEditorResourceToken extends BaseToken {
+    type: 'resource';
+}
+export type PromptEditorToken = PromptEditorInputToken | PromptEditorOutputToken | PromptEditorStateToken | PromptEditorResourceToken | PromptEditorTextToken;
+export interface PromptEditorAutoCompleteOption {
+    type: Exclude<PromptEditorTokenType, 'text'>;
+    /** Variable path without a leading `$` (e.g. `vars.firstName`). See {@link PromptEditorToken} value. */
+    value: string;
+}
+export type PromptEditorMode = 'edit' | 'preview';
+export interface PromptEditorToolbarActionsRef {
+    formatBold: () => void;
+    formatItalic: () => void;
+    formatStrikethrough: () => void;
+    formatNumberedList: () => void;
+    formatBulletedList: () => void;
+}
+export type PromptEditorToolbarFormatAction = 'bold' | 'bulletedList' | 'italic' | 'numberedList' | 'strikethrough';
+export interface PromptEditorTokenColorConfig {
+    background: string;
+    border: string;
+    text: string;
+    icon: string;
+}
+/**
+ * Two-state palette: invalid = red, valid = blue. Backed by apollo-wind's semantic design tokens,
+ * which already resolve per light/dark theme via CSS — no JS theme detection needed.
+ */
+export declare const getPromptEditorTokenColors: () => Record<"valid" | "invalid", PromptEditorTokenColorConfig>;
+/** Human-readable label for a token type, used in the chip's hover tooltip. */
+export declare const getPromptEditorTokenTypeLabel: (type: PromptEditorTokenType) => string;
+export type PromptEditorDiffType = 'added' | 'removed';
+export declare const isPromptEditorTextToken: (token: PromptEditorToken) => token is PromptEditorTextToken;
+export declare const isPromptEditorNonTextToken: (token: PromptEditorToken) => token is Exclude<PromptEditorToken, PromptEditorTextToken>;
+export {};

package/dist/components/ui/prompt-editor/types.js

@@ -0,0 +1,31 @@
+const getPromptEditorTokenColors = ()=>({
+        valid: {
+            background: 'var(--color-primary-lighter)',
+            border: 'var(--color-primary)',
+            text: 'var(--color-foreground)',
+            icon: 'var(--color-primary)'
+        },
+        invalid: {
+            background: 'var(--color-error-background)',
+            border: 'var(--color-error)',
+            text: 'var(--color-error-text)',
+            icon: 'var(--color-error-icon)'
+        }
+    });
+const getPromptEditorTokenTypeLabel = (type)=>{
+    switch(type){
+        case 'input':
+            return 'Input variable';
+        case 'output':
+            return 'Output variable';
+        case 'state':
+            return 'State variable';
+        case 'resource':
+            return 'Resource';
+        default:
+            return 'Text';
+    }
+};
+const isPromptEditorTextToken = (token)=>'text' === token.type;
+const isPromptEditorNonTextToken = (token)=>'text' !== token.type;
+export { getPromptEditorTokenColors, getPromptEditorTokenTypeLabel, isPromptEditorNonTextToken, isPromptEditorTextToken };

package/dist/components/ui/prompt-editor/utils/autocomplete-segments.cjs

@@ -0,0 +1,60 @@
+"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__, {
+    VARIABLE_PATH_REGEX: ()=>VARIABLE_PATH_REGEX,
+    inferTokenTypeFromPath: ()=>inferTokenTypeFromPath,
+    shouldSuppressOpenForDismissed: ()=>shouldSuppressOpenForDismissed
+});
+const NAMESPACE_TOKEN_TYPE = {
+    state: 'state',
+    resource: 'resource'
+};
+const inferTokenTypeFromPath = (path, options)=>{
+    for (const opt of options)if (opt.value === path) return opt.type;
+    const segments = path.split('.');
+    while(segments.length > 1){
+        segments.pop();
+        const prefix = segments.join('.');
+        for (const opt of options)if (opt.value === prefix) return opt.type;
+    }
+    return NAMESPACE_TOKEN_TYPE[path.split('.')[0]] ?? 'input';
+};
+const VARIABLE_PATH_REGEX = /^(?:vars|metadata|agent|state|resource)\.[a-zA-Z_][a-zA-Z0-9_.]*$/;
+function shouldSuppressOpenForDismissed(trigger, dismissed) {
+    if (!dismissed) return false;
+    return dismissed.nodeKey === trigger.nodeKey && dismissed.triggerIndex === trigger.triggerIndex;
+}
+exports.VARIABLE_PATH_REGEX = __webpack_exports__.VARIABLE_PATH_REGEX;
+exports.inferTokenTypeFromPath = __webpack_exports__.inferTokenTypeFromPath;
+exports.shouldSuppressOpenForDismissed = __webpack_exports__.shouldSuppressOpenForDismissed;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "VARIABLE_PATH_REGEX",
+    "inferTokenTypeFromPath",
+    "shouldSuppressOpenForDismissed"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/utils/autocomplete-segments.d.ts

@@ -0,0 +1,29 @@
+import type { PromptEditorAutoCompleteOption, PromptEditorTokenType } from '../types';
+/**
+ * Infer the token type for a typed-but-unmatched path by walking up parent prefixes in the option set.
+ * Mirrors `findVariableForPath`'s ancestor-fallback shape so a free-form chip inherits the closest
+ * known parent's type. With no matching ancestor, falls back to the leading namespace (`state.*` →
+ * `state`, `resource.*` → `resource`) so those chips get the right node type even before a matching
+ * option exists; everything else (`vars.*`, `metadata.*`, `agent.*`) defaults to `'input'`.
+ */
+export declare const inferTokenTypeFromPath: (path: string, options: PromptEditorAutoCompleteOption[]) => Exclude<PromptEditorTokenType, "text">;
+/**
+ * Recognised free-form path syntax for committing typed-but-unmatched paths as chips. Covers the
+ * namespaces apollo-wind's public token types/options use — `vars`/`metadata`/`agent` plus `state`
+ * and `resource` (the `state.*` / `resource.*` examples in the stories), so free-form state/resource
+ * paths can be committed the same as input/output ones.
+ */
+export declare const VARIABLE_PATH_REGEX: RegExp;
+/** Identifier for the `$` position the picker was last dismissed for. */
+export interface TriggerKey {
+    triggerIndex: number;
+    nodeKey: string;
+}
+/**
+ * Decide whether the autocomplete should suppress reopening. After the user dismisses the picker
+ * (Escape, click-outside), we remember the dismissed `$` position and don't reopen for it on a
+ * cursor-only return — gives the user a window to Backspace the `$` without the picker grabbing
+ * focus again. Once the editor's text changes (any new typing), the dismissal sentinel is cleared
+ * and the next valid trigger opens the picker fresh.
+ */
+export declare function shouldSuppressOpenForDismissed(trigger: TriggerKey, dismissed: TriggerKey | null): boolean;

package/dist/components/ui/prompt-editor/utils/autocomplete-segments.js

@@ -0,0 +1,20 @@
+const NAMESPACE_TOKEN_TYPE = {
+    state: 'state',
+    resource: 'resource'
+};
+const inferTokenTypeFromPath = (path, options)=>{
+    for (const opt of options)if (opt.value === path) return opt.type;
+    const segments = path.split('.');
+    while(segments.length > 1){
+        segments.pop();
+        const prefix = segments.join('.');
+        for (const opt of options)if (opt.value === prefix) return opt.type;
+    }
+    return NAMESPACE_TOKEN_TYPE[path.split('.')[0]] ?? 'input';
+};
+const VARIABLE_PATH_REGEX = /^(?:vars|metadata|agent|state|resource)\.[a-zA-Z_][a-zA-Z0-9_.]*$/;
+function shouldSuppressOpenForDismissed(trigger, dismissed) {
+    if (!dismissed) return false;
+    return dismissed.nodeKey === trigger.nodeKey && dismissed.triggerIndex === trigger.triggerIndex;
+}
+export { VARIABLE_PATH_REGEX, inferTokenTypeFromPath, shouldSuppressOpenForDismissed };