@uipath/flow-tool 1.201.0-preview.131 → 1.201.0-preview.133

package/dist/packager-tool-m6x5sczh.js

@@ -0,0 +1,899 @@
+import {
+  METADATA_IDENTIFIER,
+  METADATA_PREFIX,
+  VARIABLE_PATH_IDENTIFIER_PATTERN,
+  VARIABLE_PATH_PATTERN,
+  VARIABLE_PATH_SELECTOR_PATTERN,
+  VARS_PREFIX
+} from "./packager-tool-vdd02vns.js";
+import {
+  FLAT_SEP,
+  JobAttachmentSchema,
+  isAgentNodeType,
+  isExpressionValue,
+  isJobAttachmentRef,
+  stripAutoDerivedFieldBindings
+} from "./packager-tool-78a3szsp.js";
+import {
+  init_esm_shims
+} from "./packager-tool-6ejqwbw9.js";
+
+// ../../node_modules/@uipath/flow-converter/dist/chunk-WBQ4J5MN.js
+init_esm_shims();
+var DEFAULT_AGENT_INPUT_ENCODING = "flat";
+init_esm_shims();
+var SCHEMA_CONTAINER_MARKER = "x-uipath-container";
+function getContainerChildProps(prop) {
+  if (prop?.type !== "object")
+    return;
+  if (prop[SCHEMA_CONTAINER_MARKER] !== true)
+    return;
+  const childProps = prop.properties;
+  if (!childProps || Object.keys(childProps).length === 0)
+    return;
+  return childProps;
+}
+init_esm_shims();
+var CONNECTOR_PARAM_BUCKET_KEYS = ["pathParameters", "queryParameters", "multipartParameters", "bodyParameters"];
+var extractAgentInputName = (source) => {
+  if (!source)
+    return;
+  const trimmed = source.trim();
+  const patterns = [
+    /^\{\{\s*\$agent\.([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\s*\}\}$/,
+    /^=js:\s*\$agent\.([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\s*$/,
+    /^=js:\(\s*\$agent\.([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\s*\)$/,
+    /^=js:`\$\{\s*\$agent\.([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\s*\}`$/,
+    /^=\$agent\.([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)$/,
+    /^\$agent\.([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)$/
+  ];
+  for (const pattern of patterns) {
+    const match = pattern.exec(trimmed);
+    if (match)
+      return match[1];
+  }
+  return;
+};
+var SINGLE_REF = String.raw`\$(?:vars|metadata|agent)\.[a-zA-Z_][\w.]*`;
+var SINGLE_BINDING_PATTERNS = [
+  new RegExp(String.raw`^\{\{\s*${SINGLE_REF}\s*\}\}$`),
+  new RegExp(String.raw`^=js:\s*${SINGLE_REF}\s*$`),
+  new RegExp(String.raw`^=js:\(\s*${SINGLE_REF}\s*\)$`),
+  new RegExp(String.raw`^=js:\`\$\{\s*${SINGLE_REF}\s*\}\`$`),
+  new RegExp(`^=${SINGLE_REF}$`),
+  new RegExp(`^${SINGLE_REF}$`)
+];
+var SOURCE_TOKEN = /(?<!\w)\$(?:vars|metadata)\./;
+var isCompositeConnectorValue = (value) => {
+  if (typeof value !== "string")
+    return false;
+  const referencesSource = SOURCE_TOKEN.test(value) || value.includes("$agent.");
+  if (!referencesSource)
+    return false;
+  const trimmed = value.trim();
+  return !SINGLE_BINDING_PATTERNS.some((pattern) => pattern.test(trimmed));
+};
+var COMPOSITE_CONNECTOR_INFIX = "__connectorArg__";
+var sanitizeSyntheticSegment = (s) => s.replace(/\W+/g, "_");
+var FILES_INPUT_PREFIX = "files_";
+var filesInputKey = (nodeId) => `${FILES_INPUT_PREFIX}${nodeId}`;
+var compositeConnectorInputKey = (nodeId, fieldName) => {
+  const key = `${sanitizeSyntheticSegment(nodeId)}${COMPOSITE_CONNECTOR_INFIX}${sanitizeSyntheticSegment(fieldName)}`;
+  return /^[a-zA-Z_]/.test(key) ? key : `_${key}`;
+};
+var isSyntheticAgentInputId = (id) => id.includes(COMPOSITE_CONNECTOR_INFIX) || id.startsWith(FILES_INPUT_PREFIX);
+var collectCompositeConnectorInputs = (node) => {
+  const inputs = node.data?.inputs ?? node.inputs;
+  const detail = inputs?.detail;
+  if (!detail)
+    return [];
+  const out = [];
+  for (const bucketKey of CONNECTOR_PARAM_BUCKET_KEYS) {
+    const bucket = detail[bucketKey];
+    if (!bucket || typeof bucket !== "object")
+      continue;
+    for (const [fieldName, value] of Object.entries(bucket)) {
+      if (!isCompositeConnectorValue(value))
+        continue;
+      out.push({
+        id: compositeConnectorInputKey(node.id, fieldName),
+        type: "string",
+        binding: value,
+        description: `Composite connector binding for ${fieldName}`
+      });
+    }
+  }
+  return out;
+};
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+var UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var isUnsafeKey = (key) => UNSAFE_PROPERTY_KEYS.has(key);
+init_esm_shims();
+function isLabeledWrapper(val) {
+  return val != null && typeof val === "object" && !Array.isArray(val) && !isExpressionValue(val) && "value" in val;
+}
+function unwrapFlowExpression(val) {
+  if (isLabeledWrapper(val))
+    return unwrapFlowExpression(val.value);
+  if (isExpressionValue(val))
+    return val.expression;
+  if (typeof val === "string")
+    return val;
+  return "";
+}
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+var MUSTACHE_SOURCE_TOKEN_REGEX = new RegExp(String.raw`\{\{\s*\$(vars|metadata)\.(${VARIABLE_PATH_PATTERN})\s*\}\}`, "g");
+var RAW_SOURCE_TOKEN_REGEX = new RegExp(String.raw`(?<!\w)\$(vars|metadata)\.(${VARIABLE_PATH_PATTERN})`, "g");
+var MUSTACHE_INPUT_TOKEN_REGEX = new RegExp(String.raw`\{\{\s*\$agent\.(${VARIABLE_PATH_IDENTIFIER_PATTERN})(${VARIABLE_PATH_SELECTOR_PATTERN})\s*\}\}`, "g");
+var RAW_INPUT_TOKEN_REGEX = new RegExp(String.raw`(?<!\w)\$agent\.(${VARIABLE_PATH_IDENTIFIER_PATTERN})(${VARIABLE_PATH_SELECTOR_PATTERN})(?!\w)`, "g");
+var MUSTACHE_RUNTIME_INPUT_TOKEN_REGEX = new RegExp(String.raw`\{\{\s*input\.(${VARIABLE_PATH_IDENTIFIER_PATTERN})(${VARIABLE_PATH_SELECTOR_PATTERN})\s*\}\}`, "g");
+var SOURCE_BINDING_REGEX = new RegExp(String.raw`^\$?(vars|metadata)\.(${VARIABLE_PATH_PATTERN})$`);
+function encodeFlatName(prefix, path, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  if (encoding === "flat" || /\[\d+\]/.test(path)) {
+    const segments2 = Array.from(path.matchAll(new RegExp(String.raw`${VARIABLE_PATH_IDENTIFIER_PATTERN}|\[(\d+)\]`, "g")), (match) => match[1] ?? match[0]);
+    const parts2 = prefix === VARS_PREFIX ? segments2 : [METADATA_IDENTIFIER, ...segments2];
+    return parts2.join(FLAT_SEP);
+  }
+  const segments = path.split(".").filter(Boolean);
+  const parts = prefix === VARS_PREFIX ? segments : [METADATA_IDENTIFIER, ...segments];
+  return parts.join(".");
+}
+function decodeFlatName(flatName) {
+  if (flatName.includes(".")) {
+    const dotIndex = flatName.indexOf(".");
+    if (flatName.slice(0, dotIndex) === METADATA_IDENTIFIER) {
+      return { prefix: METADATA_PREFIX, path: flatName.slice(dotIndex + 1) };
+    }
+    return { prefix: VARS_PREFIX, path: flatName };
+  }
+  const decodePath = (encoded) => encoded.split(FLAT_SEP).filter(Boolean).reduce((path, segment) => {
+    if (/^\d+$/.test(segment))
+      return `${path}[${segment}]`;
+    if (!path)
+      return segment;
+    return `${path}.${segment}`;
+  }, "");
+  const metadataPrefix = `${METADATA_IDENTIFIER}${FLAT_SEP}`;
+  if (flatName === METADATA_IDENTIFIER) {
+    return { prefix: METADATA_PREFIX, path: "" };
+  }
+  if (flatName.startsWith(metadataPrefix)) {
+    return { prefix: METADATA_PREFIX, path: decodePath(flatName.slice(metadataPrefix.length)) };
+  }
+  return { prefix: VARS_PREFIX, path: decodePath(flatName) };
+}
+function extractSourceRefs(text, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  if (!text || typeof text !== "string")
+    return [];
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set;
+  const emit = (prefixId, path) => {
+    const prefix = `$${prefixId}`;
+    const flatName = encodeFlatName(prefix, path, encoding);
+    if (seen.has(flatName))
+      return;
+    seen.add(flatName);
+    refs.push({ prefix, path, flatName, binding: `=${prefix}.${path}` });
+  };
+  let match;
+  MUSTACHE_SOURCE_TOKEN_REGEX.lastIndex = 0;
+  while ((match = MUSTACHE_SOURCE_TOKEN_REGEX.exec(text)) !== null) {
+    emit(match[1], match[2]);
+  }
+  RAW_SOURCE_TOKEN_REGEX.lastIndex = 0;
+  while ((match = RAW_SOURCE_TOKEN_REGEX.exec(text)) !== null) {
+    emit(match[1], match[2]);
+  }
+  return refs;
+}
+function rewriteInputTokensToSource(text, bindingsByFlatName) {
+  if (!text || typeof text !== "string")
+    return text;
+  const resolveSource = (flatName) => {
+    const explicit = bindingsByFlatName?.get(flatName);
+    if (explicit) {
+      const raw = explicit.startsWith("=") ? explicit.slice(1) : explicit;
+      const prefixMatch = SOURCE_BINDING_REGEX.exec(raw);
+      if (prefixMatch) {
+        return { prefix: `$${prefixMatch[1]}`, path: prefixMatch[2] };
+      }
+    }
+    return decodeFlatName(flatName);
+  };
+  let out = text.replace(MUSTACHE_INPUT_TOKEN_REGEX, (_full, flatName, selector) => {
+    const decoded = resolveSource(flatName);
+    if (!decoded.path)
+      return `{{ ${decoded.prefix}${selector} }}`;
+    return `{{ ${decoded.prefix}.${decoded.path}${selector} }}`;
+  });
+  out = out.replace(RAW_INPUT_TOKEN_REGEX, (_full, flatName, selector) => {
+    const decoded = resolveSource(flatName);
+    if (!decoded.path)
+      return `${decoded.prefix}${selector}`;
+    return `${decoded.prefix}.${decoded.path}${selector}`;
+  });
+  return out;
+}
+function rewriteRuntimeInputTokensToSource(text, bindings) {
+  if (!text || typeof text !== "string")
+    return text;
+  const canvasForm = text.replace(MUSTACHE_RUNTIME_INPUT_TOKEN_REGEX, "{{ $$agent.$1$2 }}");
+  return rewriteInputTokensToSource(canvasForm, bindings);
+}
+function buildBindingMap(inputVariables) {
+  const map = /* @__PURE__ */ new Map;
+  if (!inputVariables)
+    return map;
+  for (const v of inputVariables) {
+    if (v.id && v.binding)
+      map.set(v.id, v.binding);
+  }
+  return map;
+}
+var UnresolvedAgentInputTypeError = class extends Error {
+  constructor(ref) {
+    super(`Cannot resolve type for inline-agent input '${ref.flatName}' (from ${ref.prefix}.${ref.path}): no matching variable in workflow.variables.globals or workflow.variables.nodes. Declare the variable so the agent.json inputSchema can be typed.`);
+    this.name = "UnresolvedAgentInputTypeError";
+    this.ref = ref;
+  }
+};
+var AmbiguousAgentInputRootError = class extends Error {
+  constructor(ref, reason) {
+    const stripIndex = (s) => s.replace(/\[\d+\]/g, "");
+    const segments = ref.path.split(".");
+    const offending = reason === "underscore" ? segments.map(stripIndex).find((s) => s.includes(FLAT_SEP)) ?? stripIndex(segments[0]) : stripIndex(segments[0]);
+    super(reason === "metadata" ? `Inline-agent input references "$vars.${ref.path}", but a variable or node named "metadata" collides with the "$metadata" namespace once serialized and cannot round-trip. Rename it to something other than "metadata".` : `Inline-agent input references "$vars.${ref.path}", but the name "${offending}" contains "__", reserved as the agent-input encoding separator, so it cannot round-trip. Rename it to remove the double underscore.`);
+    this.name = "AmbiguousAgentInputRootError";
+    this.ref = ref;
+    this.i18n = reason === "metadata" ? { key: "agentInputRefs_reservedMetadataRoot_message", params: { ref: ref.path }, ns: "validation" } : { key: "agentInputRefs_ambiguousUnderscoreRoot_message", params: { ref: ref.path, rootSegment: offending }, ns: "validation" };
+  }
+};
+function detectAmbiguousAgentInputRoot(ref, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  if (ref.prefix !== VARS_PREFIX)
+    return;
+  const stripIndex = (s) => s.replace(/\[\d+\]/g, "");
+  const segments = ref.path.split(".");
+  if (stripIndex(segments[0]) === METADATA_IDENTIFIER)
+    return "metadata";
+  const flatEncoded = encoding === "flat" || /\[\d+\]/.test(ref.path);
+  const segmentsToCheck = flatEncoded ? segments : [segments[0]];
+  if (segmentsToCheck.some((s) => stripIndex(s).includes(FLAT_SEP)))
+    return "underscore";
+  return;
+}
+function assertNoAmbiguousAgentInputRoot(refs, encoding) {
+  for (const ref of refs) {
+    const reason = detectAmbiguousAgentInputRoot(ref, encoding);
+    if (reason)
+      throw new AmbiguousAgentInputRootError(ref, reason);
+  }
+}
+function buildVariableLookup(globals, nodeVars, scoped = []) {
+  const map = /* @__PURE__ */ new Map;
+  for (const s of scoped)
+    map.set(s.path, { type: s.type, schema: s.schema });
+  for (const n of nodeVars)
+    map.set(n.id, { type: n.type, schema: n.schema });
+  for (const g of globals) {
+    const key = g.direction === "in" && g.triggerNodeId ? `${g.triggerNodeId}.output.${g.id}` : g.id;
+    map.set(key, { type: g.type, schema: g.schema });
+  }
+  return map;
+}
+var TRAILING_VARIABLE_PATH_SELECTOR_REGEX = new RegExp(String.raw`(?:\.(${VARIABLE_PATH_IDENTIFIER_PATTERN})|\[(\d+)\])$`);
+function removeTrailingPathSelector(path) {
+  const selector = TRAILING_VARIABLE_PATH_SELECTOR_REGEX.exec(path);
+  if (selector?.index === undefined)
+    return;
+  return {
+    path: path.slice(0, selector.index),
+    segment: selector[1] ?? Number(selector[2])
+  };
+}
+function findLongestPrefixMatch(path, map) {
+  let candidate = path;
+  const reversedTail = [];
+  while (candidate) {
+    const entry = map.get(candidate);
+    if (entry) {
+      reversedTail.reverse();
+      return { entry, tail: reversedTail };
+    }
+    const trailingSelector = removeTrailingPathSelector(candidate);
+    if (!trailingSelector)
+      return;
+    reversedTail.push(trailingSelector.segment);
+    candidate = trailingSelector.path;
+  }
+  return;
+}
+function asSchemaNode(value) {
+  return value && typeof value === "object" ? value : undefined;
+}
+function getSchemaChild(node, segment) {
+  if (typeof segment === "number")
+    return node.items;
+  const properties = asSchemaNode(node.properties);
+  if (properties && segment in properties)
+    return properties[segment];
+  return node.additionalProperties;
+}
+function walkSchemaForLeaf(schema, segments) {
+  let current = asSchemaNode(schema);
+  for (const segment of segments) {
+    if (!current)
+      return;
+    current = asSchemaNode(getSchemaChild(current, segment));
+  }
+  return current;
+}
+function buildAgentInputTypeResolver(workflowVariables, options) {
+  const globals = workflowVariables?.globals ?? [];
+  const nodeVars = workflowVariables?.nodes ?? [];
+  const lookup = buildVariableLookup(globals, nodeVars, options?.scopedVariables);
+  const warnedRefs = /* @__PURE__ */ new Set;
+  return (ref) => {
+    if (ref.prefix !== VARS_PREFIX)
+      return "string";
+    const result = findLongestPrefixMatch(ref.path, lookup);
+    if (!result) {
+      if (options?.onUnresolved === "fallback") {
+        const refName = `${ref.prefix}.${ref.path}`;
+        if (!warnedRefs.has(refName)) {
+          warnedRefs.add(refName);
+          console.warn(`[agent-cluster-rewrite] '${refName}' matches no workflow variable — emitting a typeless agent input`);
+        }
+        return normalizeJsonSchemaType("any");
+      }
+      throw new UnresolvedAgentInputTypeError(ref);
+    }
+    const { entry, tail } = result;
+    if (tail.length === 0)
+      return normalizeJsonSchemaType(entry.type);
+    const schema = walkSchemaForLeaf(entry.schema, tail);
+    const schemaType = typeof schema?.type === "string" ? schema.type : undefined;
+    return normalizeJsonSchemaType(schemaType ?? "any");
+  };
+}
+function normalizeJsonSchemaType(type) {
+  if (type === "octet-stream")
+    return "object";
+  if (type === "any")
+    return "any";
+  return type;
+}
+function canPruneAgentInputs(inputs) {
+  return typeof inputs?.systemPrompt === "string" || typeof inputs?.userPrompt === "string";
+}
+function canonicalLegacyId(entry, encoding) {
+  const raw = entry.binding?.startsWith("=") ? entry.binding.slice(1) : entry.binding;
+  if (!raw || !SOURCE_BINDING_REGEX.test(raw))
+    return entry.id;
+  const { prefix, path } = decodeFlatName(entry.id);
+  return encodeFlatName(prefix, path, encoding);
+}
+function deriveLegacyEntry(entry, refByFlatName, resolveSourceType, pruneUnreferenced, encoding) {
+  const id = canonicalLegacyId(entry, encoding);
+  const ref = refByFlatName.get(id);
+  if (!ref && pruneUnreferenced)
+    return null;
+  let resolvedType;
+  if (ref && resolveSourceType) {
+    try {
+      resolvedType = resolveSourceType(ref);
+    } catch (error) {
+      if (!(error instanceof UnresolvedAgentInputTypeError))
+        throw error;
+      resolvedType = undefined;
+    }
+  }
+  return {
+    id,
+    type: (resolvedType && resolvedType !== "any" ? resolvedType : entry.type) || "string",
+    binding: entry.binding ?? "",
+    description: entry.description ?? "",
+    ...entry.schema ? { schema: entry.schema } : {}
+  };
+}
+function deriveAgentInputVariables(refs, legacy, resolveSourceType, pruneUnreferenced, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set;
+  const refByFlatName = new Map(refs.map((r) => [r.flatName, r]));
+  for (const entry of legacy ?? []) {
+    if (!entry.id)
+      continue;
+    const derived = deriveLegacyEntry(entry, refByFlatName, resolveSourceType, pruneUnreferenced, encoding);
+    if (!derived || seen.has(derived.id))
+      continue;
+    result.push(derived);
+    seen.add(derived.id);
+  }
+  for (const ref of refs) {
+    if (seen.has(ref.flatName))
+      continue;
+    result.push({
+      id: ref.flatName,
+      type: resolveSourceType?.(ref) ?? "string",
+      binding: ref.binding,
+      description: `Bound from ${ref.prefix}.${ref.path}`
+    });
+    seen.add(ref.flatName);
+  }
+  return result;
+}
+function scanSourceRefsDeep(values, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  const seen = /* @__PURE__ */ new Map;
+  const visit = (v) => {
+    if (v == null)
+      return;
+    if (typeof v === "string") {
+      for (const ref of extractSourceRefs(v, encoding)) {
+        if (!seen.has(ref.flatName))
+          seen.set(ref.flatName, ref);
+      }
+      return;
+    }
+    if (Array.isArray(v)) {
+      for (const item of v)
+        visit(item);
+      return;
+    }
+    if (typeof v === "object") {
+      for (const item of Object.values(v))
+        visit(item);
+    }
+  };
+  for (const value of values)
+    visit(value);
+  return Array.from(seen.values());
+}
+var LOOP_MEMBER_TO_ITERATOR_FIELD = {
+  currentItem: { field: "item", type: "any" },
+  currentIteration: { field: "loopCounter", type: "number" }
+};
+function tryBuildLoopBinding(ref, ancestorLoopInfo) {
+  if (ref.prefix !== VARS_PREFIX)
+    return;
+  const segments = ref.path.split(".");
+  if (segments.length < 2)
+    return;
+  const loopId = segments[0];
+  const member = segments[1];
+  const info = ancestorLoopInfo.get(loopId);
+  if (!info)
+    return;
+  const tail = segments.slice(2).join(".");
+  const suffix = tail ? `.${tail}` : "";
+  let binding;
+  let type;
+  if (member === "collection") {
+    if (!info.collectionExpr)
+      return;
+    binding = `${info.collectionExpr}${suffix}`;
+    type = "array";
+  } else {
+    const mapping = LOOP_MEMBER_TO_ITERATOR_FIELD[member];
+    if (!mapping)
+      return;
+    binding = `=iterator[${info.index}].${mapping.field}${suffix}`;
+    type = mapping.type;
+  }
+  return {
+    id: ref.flatName,
+    type,
+    binding,
+    description: `Bound from ${ref.prefix}.${ref.path}`
+  };
+}
+function partitionRefsByLoopBinding(refs, ancestorLoopInfo) {
+  const loopVariables = [];
+  const nonLoopRefs = [];
+  if (!ancestorLoopInfo || ancestorLoopInfo.size === 0) {
+    return { loopVariables, nonLoopRefs: [...refs] };
+  }
+  for (const ref of refs) {
+    const loopEntry = tryBuildLoopBinding(ref, ancestorLoopInfo);
+    if (loopEntry)
+      loopVariables.push(loopEntry);
+    else
+      nonLoopRefs.push(ref);
+  }
+  return { loopVariables, nonLoopRefs };
+}
+function scanInputsWithoutAutoDerivedBindings(inputs) {
+  const schema = inputs.schema;
+  if (!schema || !Array.isArray(schema.fields))
+    return inputs;
+  const stripped = stripAutoDerivedFieldBindings(schema);
+  return stripped === schema ? inputs : { ...inputs, schema: stripped };
+}
+function scanAgentClusterRefs(agent, nodesById, edges, resolveSourceType, ancestorLoopInfo, pruneUnreferenced, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  const inputs = agent.data?.inputs ?? {};
+  const rawSystemPrompt = typeof inputs.systemPrompt === "string" ? inputs.systemPrompt : "";
+  const rawUserPrompt = typeof inputs.userPrompt === "string" ? inputs.userPrompt : "";
+  const canPrune = canPruneAgentInputs(inputs);
+  const bindingMap = buildBindingMap(Array.isArray(inputs.agentInputVariables) ? inputs.agentInputVariables : undefined);
+  const systemPrompt = rewriteRuntimeInputTokensToSource(rawSystemPrompt, bindingMap);
+  const userPrompt = rewriteRuntimeInputTokensToSource(rawUserPrompt, bindingMap);
+  const descendantInputs = [];
+  for (const descId of collectArtifactDescendants(agent.id, edges)) {
+    const descNode = nodesById.get(descId);
+    if (descNode?.data?.inputs)
+      descendantInputs.push(rewriteStringsDeep(scanInputsWithoutAutoDerivedBindings(descNode.data.inputs), (s) => rewriteRuntimeInputTokensToSource(s, bindingMap)));
+  }
+  const refs = scanSourceRefsDeep([systemPrompt, userPrompt, ...descendantInputs], encoding);
+  assertNoAmbiguousAgentInputRoot(refs, encoding);
+  const legacy = Array.isArray(inputs.agentInputVariables) ? inputs.agentInputVariables.filter((v) => !!v.id) : [];
+  const { loopVariables, nonLoopRefs } = partitionRefsByLoopBinding(refs, ancestorLoopInfo);
+  const standardVariables = deriveAgentInputVariables(nonLoopRefs, legacy, resolveSourceType, pruneUnreferenced && canPrune, encoding);
+  const seen = new Set(standardVariables.map((v) => v.id));
+  const variables = [...standardVariables];
+  for (const v of loopVariables) {
+    if (seen.has(v.id))
+      continue;
+    variables.push(v);
+    seen.add(v.id);
+  }
+  return { refs, variables };
+}
+function collectInlineAgentClusterInputs(agentNodeId, nodes, edges, workflowVariables, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  const empty = { refs: [], variables: [] };
+  const agent = nodes.find((n) => n.id === agentNodeId);
+  if (!agent)
+    return empty;
+  const type = agent.data?.type ?? agent.type;
+  if (!isAgentNodeType(type))
+    return empty;
+  const nodesById = new Map(nodes.map((n) => [n.id, n]));
+  return scanAgentClusterRefs(agent, nodesById, edges, buildAgentInputTypeResolver(workflowVariables), undefined, undefined, encoding);
+}
+function collectInlineAgentInputsFromAgent(agent) {
+  const refs = [];
+  const variables = [];
+  const properties = agent?.inputSchema?.properties;
+  if (!properties)
+    return { refs, variables };
+  const emitLeaf = (flatName, prop) => {
+    const type = isJobAttachmentRef(prop) ? "file" : prop?.type || "string";
+    if (isSyntheticAgentInputId(flatName)) {
+      variables.push({ id: flatName, type, binding: "", description: prop?.description ?? "" });
+      return;
+    }
+    const { prefix, path } = decodeFlatName(flatName);
+    const sourceForm = path ? `${prefix}.${path}` : prefix;
+    const binding = `=${sourceForm}`;
+    const description = prop?.description ?? `Bound from ${sourceForm}`;
+    refs.push({ prefix, path, flatName, binding });
+    variables.push({ id: flatName, type, binding, description });
+  };
+  const visit = (key, prop, pathPrefix) => {
+    const flatName = pathPrefix ? `${pathPrefix}.${key}` : key;
+    const childProps = getContainerChildProps(prop);
+    if (childProps) {
+      for (const [childKey, childProp] of Object.entries(childProps))
+        visit(childKey, childProp, flatName);
+      return;
+    }
+    emitLeaf(flatName, prop);
+  };
+  for (const [key, prop] of Object.entries(properties))
+    visit(key, prop, "");
+  return { refs, variables };
+}
+function collectArtifactDescendants(rootId, edges) {
+  const artifactChildrenByParent = /* @__PURE__ */ new Map;
+  for (const edge of edges) {
+    if (edge.type !== "artifact")
+      continue;
+    const list = artifactChildrenByParent.get(edge.source) ?? [];
+    list.push(edge.target);
+    artifactChildrenByParent.set(edge.source, list);
+  }
+  const out = /* @__PURE__ */ new Set;
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id)
+      break;
+    const children = artifactChildrenByParent.get(id);
+    if (!children)
+      continue;
+    for (const child of children) {
+      if (out.has(child))
+        continue;
+      out.add(child);
+      queue.push(child);
+    }
+  }
+  return out;
+}
+var ANALYZEFILES_NODE_TYPE = "uipath.agent.resource.tool.builtin.analyzefiles";
+function isArrayTypedRef(ref, resolveSourceType, ancestorLoopInfo) {
+  const loopEntry = ancestorLoopInfo ? tryBuildLoopBinding(ref, ancestorLoopInfo) : undefined;
+  if (loopEntry)
+    return loopEntry.type === "array";
+  return resolveSourceType?.(ref) === "array";
+}
+function mergeAnalyzeFilesInputs(variables, agentId, nodesById, edges, encoding = DEFAULT_AGENT_INPUT_ENCODING, resolveSourceType, ancestorLoopInfo) {
+  let descendants = collectArtifactDescendants(agentId, edges);
+  if (descendants.size === 0) {
+    descendants = new Set(edges.filter((e) => e.source === agentId).map((e) => e.target));
+  }
+  const supersededVarIds = /* @__PURE__ */ new Set;
+  const syntheticVars = [];
+  for (const descId of descendants) {
+    const node = nodesById.get(descId);
+    if (!node)
+      continue;
+    const nodeType = node.data?.type ?? node.type;
+    if (nodeType !== ANALYZEFILES_NODE_TYPE)
+      continue;
+    const nodeInputs = node.data?.inputs ?? node.inputs;
+    const rawItems = nodeInputs?.itemsDescription;
+    if (!Array.isArray(rawItems) || rawItems.length < 1)
+      continue;
+    const fileBindings = [];
+    for (const item of rawItems) {
+      const text = unwrapFlowExpression(item);
+      if (!text.trim())
+        continue;
+      const refs = extractSourceRefs(text, encoding);
+      for (const ref of refs) {
+        supersededVarIds.add(ref.flatName);
+        fileBindings.push(isArrayTypedRef(ref, resolveSourceType, ancestorLoopInfo) ? `...$vars.${ref.path}` : `$vars.${ref.path}`);
+      }
+    }
+    if (fileBindings.length === 0)
+      continue;
+    const existingIds = new Set(variables.map((v) => v.id));
+    let syntheticId = filesInputKey(descId);
+    while (existingIds.has(syntheticId)) {
+      syntheticId = `_${syntheticId}`;
+    }
+    syntheticVars.push({
+      id: syntheticId,
+      type: "array",
+      binding: `=[${fileBindings.join(", ")}]`,
+      description: "Combined file attachments for Analyze Files tool",
+      schema: {
+        type: "array",
+        items: { $ref: "#/definitions/job-attachment" },
+        definitions: { "job-attachment": JobAttachmentSchema }
+      }
+    });
+  }
+  if (syntheticVars.length === 0)
+    return variables;
+  const filtered = variables.filter((v) => !supersededVarIds.has(v.id));
+  return [...filtered, ...syntheticVars];
+}
+function mergeCompositeConnectorInputs(variables, agentId, nodesById, edges) {
+  let descendants = collectArtifactDescendants(agentId, edges);
+  if (descendants.size === 0) {
+    descendants = new Set(edges.filter((e) => e.source === agentId).map((e) => e.target));
+  }
+  const existingIds = new Set(variables.map((v) => v.id));
+  const synthetic = [];
+  for (const descId of descendants) {
+    const node = nodesById.get(descId);
+    const nodeType = node?.data?.type ?? node?.type;
+    if (!node || !nodeType?.startsWith("uipath.agent.resource.tool.connector"))
+      continue;
+    for (const input of collectCompositeConnectorInputs(node)) {
+      if (existingIds.has(input.id))
+        continue;
+      existingIds.add(input.id);
+      synthetic.push(input);
+    }
+  }
+  return synthetic.length === 0 ? variables : [...variables, ...synthetic];
+}
+function deriveMergedAgentInputVariables(rawVariables, agentId, nodes, edges, encoding = DEFAULT_AGENT_INPUT_ENCODING, resolveSourceType) {
+  const nodesById = new Map(nodes.map((n) => [n.id, n]));
+  const withFiles = mergeAnalyzeFilesInputs(rawVariables, agentId, nodesById, edges, encoding, resolveSourceType);
+  return mergeCompositeConnectorInputs(withFiles, agentId, nodesById, edges);
+}
+function preDeriveAgentInputDefinitions(nodes, edges, options = {}) {
+  const { resolveSourceType, pruneUnreferenced, processedAgentIds, getAncestorLoops, encoding = DEFAULT_AGENT_INPUT_ENCODING } = options;
+  const nodesById = /* @__PURE__ */ new Map;
+  for (const n of nodes)
+    nodesById.set(n.id, n);
+  for (const agent of nodes) {
+    const type = agent.data?.type ?? agent.type;
+    if (!isAgentNodeType(type))
+      continue;
+    if (!agent.data)
+      continue;
+    if (processedAgentIds?.has(agent.id))
+      continue;
+    const ancestorLoops = getAncestorLoops?.(agent.id) ?? [];
+    let ancestorLoopInfo;
+    if (ancestorLoops.length > 0) {
+      ancestorLoopInfo = /* @__PURE__ */ new Map;
+      ancestorLoops.forEach((loop, idx) => ancestorLoopInfo.set(loop.id, { index: idx, collectionExpr: loop.collectionExpr }));
+    }
+    const { variables } = scanAgentClusterRefs(agent, nodesById, edges, resolveSourceType, ancestorLoopInfo, pruneUnreferenced, encoding);
+    const withFiles = mergeAnalyzeFilesInputs(variables, agent.id, nodesById, edges, encoding, resolveSourceType, ancestorLoopInfo);
+    const mergedVariables = mergeCompositeConnectorInputs(withFiles, agent.id, nodesById, edges);
+    if (!agent.data.inputs)
+      agent.data.inputs = {};
+    agent.data.inputs.derivedInputDefinition = buildDerivedInputDefinition(mergedVariables, encoding);
+    processedAgentIds?.add(agent.id);
+  }
+}
+function toJsExpression(binding) {
+  if (!binding)
+    return binding;
+  if (binding.startsWith("=js:"))
+    return binding;
+  if (binding.startsWith("="))
+    return `=js:${binding.slice(1)}`;
+  return `=js:${binding}`;
+}
+function bindingExprBody(binding) {
+  if (!binding)
+    return binding;
+  if (binding.startsWith("=js:"))
+    return binding.slice(4);
+  if (binding.startsWith("="))
+    return binding.slice(1);
+  return binding;
+}
+function objectLiteralKey(key) {
+  const isSafeIdent = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+  if (isSafeIdent && key !== "__proto__")
+    return key;
+  return `[${JSON.stringify(key)}]`;
+}
+var ExprLeaf = class {
+  constructor(body) {
+    this.body = body;
+  }
+};
+function insertValueLeaf(root, path, exprBody) {
+  let node = root;
+  for (let i = 0;i < path.length - 1; i++) {
+    const existing = node.get(path[i]);
+    if (existing instanceof ExprLeaf)
+      return;
+    if (existing) {
+      node = existing;
+    } else {
+      const child = /* @__PURE__ */ new Map;
+      node.set(path[i], child);
+      node = child;
+    }
+  }
+  const last = path.at(-1);
+  if (node.get(last) instanceof Map)
+    return;
+  node.set(last, new ExprLeaf(exprBody));
+}
+function emitValueTree(node) {
+  if (node instanceof ExprLeaf)
+    return node.body;
+  const parts = [];
+  for (const [key, child] of node)
+    parts.push(`${objectLiteralKey(key)}: ${emitValueTree(child)}`);
+  return `{${parts.join(", ")}}`;
+}
+function buildRootObjectLiteral(entries) {
+  const root = /* @__PURE__ */ new Map;
+  for (const { path, exprBody } of [...entries].sort((a, b) => a.path.length - b.path.length)) {
+    if (path.length > 0)
+      insertValueLeaf(root, path, exprBody);
+  }
+  return emitValueTree(root);
+}
+function warnIfArrayRootDrop(rootType, id, root, segs) {
+  if (rootType !== "array")
+    return;
+  console.warn(`[agent-cluster-rewrite] dropping agent input "${id}": root "${root}" is an array, so the runtime cannot navigate ".${segs.slice(1).join(".")}" off it. Bind "$vars.${id}" to a workflow variable instead.`);
+}
+function flatInputEntry(d) {
+  if (!d.binding)
+    return null;
+  const entry = { name: d.id, value: toJsExpression(d.binding) };
+  if (d.type && d.type !== "string")
+    entry.type = d.type;
+  return entry;
+}
+function buildDerivedInputDefinition(variables, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+  return encoding === "flat" ? buildFlatInputDefinition(variables) : buildNestedInputDefinition(variables);
+}
+function buildFlatInputDefinition(variables) {
+  const flat = [];
+  const seen = /* @__PURE__ */ new Set;
+  for (const d of variables) {
+    let name = d.id;
+    if (!isSyntheticAgentInputId(d.id)) {
+      const { prefix, path } = decodeFlatName(d.id);
+      name = encodeFlatName(prefix, path, "flat");
+    }
+    const entry = flatInputEntry({ ...d, id: name });
+    if (!entry || seen.has(entry.name))
+      continue;
+    seen.add(entry.name);
+    flat.push(entry);
+  }
+  return flat;
+}
+function buildNestedInputDefinition(variables) {
+  const rootOrder = [];
+  const rootGroups = /* @__PURE__ */ new Map;
+  const flat = [];
+  const wholeRoots = new Set(variables.filter((d) => !d.id.includes(".") && d.binding).map((d) => d.id));
+  const typeById = new Map(variables.map((d) => [d.id, d.type]));
+  for (const d of variables) {
+    const segs = d.id.split(".");
+    const root = segs[0];
+    if (segs.length === 1) {
+      const entry = flatInputEntry(d);
+      if (entry)
+        flat.push(entry);
+      continue;
+    }
+    if (wholeRoots.has(root)) {
+      warnIfArrayRootDrop(typeById.get(root), d.id, root, segs);
+      continue;
+    }
+    if (!d.binding)
+      continue;
+    let group = rootGroups.get(root);
+    if (!group) {
+      group = [];
+      rootGroups.set(root, group);
+      rootOrder.push(root);
+    }
+    group.push({ path: segs.slice(1), exprBody: bindingExprBody(d.binding) });
+  }
+  const nested = rootOrder.map((root) => ({
+    name: root,
+    type: "object",
+    value: `=js:(${buildRootObjectLiteral(rootGroups.get(root) ?? [])})`
+  }));
+  return [...nested, ...flat];
+}
+function rewriteStringsDeep(value, fn) {
+  if (value == null)
+    return value;
+  if (typeof value === "string")
+    return fn(value);
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((v) => {
+      const nv = rewriteStringsDeep(v, fn);
+      if (nv !== v)
+        changed = true;
+      return nv;
+    });
+    return changed ? next : value;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    let changed = false;
+    const next = {};
+    for (const [k, v] of entries) {
+      const nv = rewriteStringsDeep(v, fn);
+      if (nv !== v)
+        changed = true;
+      next[k] = nv;
+    }
+    return changed ? next : value;
+  }
+  return value;
+}
+
+export { DEFAULT_AGENT_INPUT_ENCODING, SCHEMA_CONTAINER_MARKER, getContainerChildProps, extractAgentInputName, isCompositeConnectorValue, compositeConnectorInputKey, collectCompositeConnectorInputs, isUnsafeKey, rewriteInputTokensToSource, UnresolvedAgentInputTypeError, AmbiguousAgentInputRootError, detectAmbiguousAgentInputRoot, buildAgentInputTypeResolver, canPruneAgentInputs, deriveAgentInputVariables, scanSourceRefsDeep, collectInlineAgentClusterInputs, collectInlineAgentInputsFromAgent, collectArtifactDescendants, mergeCompositeConnectorInputs, deriveMergedAgentInputVariables, preDeriveAgentInputDefinitions, buildDerivedInputDefinition, rewriteStringsDeep };
+
+//# debugId=F0A5A094082DBDFB64756E2164756E21