@uipath/agent-tool 1.202.0 → 1.202.1-preview.168

package/dist/{packager-tool-wmd0pbnz.js → packager-tool-pv87pnq1.js}

@@ -1,6 +1,6 @@
 import {
   en_default
-} from "./packager-tool-a42jnpy5.js";
+} from "./packager-tool-4mna26cc.js";
 import {
   __glob
 } from "./packager-tool-c23zrhj8.js";
@@ -13,7 +13,7 @@ import {
   isSolutionUploadHttpError,
   migrateLegacyToolGuardrailPolicies,
   resolveStudioWebConfig
-} from "./packager-tool-kpf6eryr.js";
+} from "./packager-tool-6kkp5bq2.js";
 import {
   OutputFormatter,
   RESULTS,
@@ -27,21 +27,21 @@ import {
   getSdkUserAgentToken,
   installSdkUserAgentHeader,
   logger,
+  parseBoundedInt,
   prepareProjectLocation,
   processContext,
   tryRegisterProjectInParentSolution
-} from "./packager-tool-p1yrrbpt.js";
+} from "./packager-tool-b20zvjv7.js";
 import {
   currentAgentStorageSchema,
   currentEvaluationSetStorageSchema,
   currentFeatureStorageSchema,
   currentResourceStorageSchema,
   currentStorageSchema,
-  currentStorageSchemaMigration,
   generateBindings,
   getLatestVersion,
   migrations
-} from "./packager-tool-0srzfhdr.js";
+} from "./packager-tool-mc1499dc.js";
 import {
   __commonJS,
   __export,
@@ -6989,7 +6989,7 @@ var require_index_cjs = __commonJS(function(exports, module) {
 var package_default = {
   name: "@uipath/agent-tool",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0",
+  version: "1.202.1-preview.168",
   description: "cli plugin for creating and managing UiPath low-code agents",
   private: false,
   repository: {
@@ -7032,7 +7032,7 @@ var package_default = {
     "@uipath/auth": "workspace:*",
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-schema": "0.57.4-develop",
+    "@uipath/flow-schema": "0.68.0",
     "@uipath/integrationservice-sdk": "workspace:*",
     "@uipath/llmgw-sdk": "workspace:*",
     "@uipath/orchestrator-sdk": "workspace:*",
@@ -7432,7 +7432,7 @@ class VoidApiResponse {
 var package_default2 = {
   name: "@uipath/agent-sdk",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0",
+  version: "1.202.1-preview.168",
   description: "SDK for the UiPath Agent Runtime API — evaluation execution and debug sessions.",
   repository: {
     type: "git",
@@ -12793,7 +12793,7 @@ var registerGuardrailCommands = (program) => {
 
 // src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-4vpac2gy.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-g54778e4.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 
@@ -13926,7 +13926,7 @@ var registerModelCommands = (program) => {
   });
 };
 
-// ../../node_modules/@uipath/flow-schema/dist/chunk-IUN2JAAB.js
+// ../../node_modules/@uipath/flow-schema/dist/chunk-4P5M5KWK.js
 var SUPPORTED_LOCALES = ["en", "es", "pt", "de", "fr", "ja", "ko", "ru", "tr", "ro", "zh-CN", "zh-TW", "pt-BR", "es-MX"];
 function normalizeCasing(locale) {
   const [language, country] = locale.split("-");
@@ -13977,20 +13977,20 @@ function createI18nRegistrar(options) {
   };
 }
 var globImport_locales_json = __glob({
-  "../../locales/de.json": () => import("./de-5KVP66U6-1bnf4zt5.js"),
-  "../../locales/en.json": () => import("./en-X3S6IZ5J-nhkg6pwn.js"),
-  "../../locales/es-MX.json": () => import("./es-MX-XAVLOQW3-q00km2y7.js"),
-  "../../locales/es.json": () => import("./es-VFPNVMP5-bx2c337j.js"),
-  "../../locales/fr.json": () => import("./fr-E5MDO4EG-c3mkty2t.js"),
-  "../../locales/ja.json": () => import("./ja-DPO5PPLO-mysfmznx.js"),
-  "../../locales/ko.json": () => import("./ko-ITOPNIYI-hmxd2asd.js"),
-  "../../locales/pt-BR.json": () => import("./pt-BR-BXURWX4W-bwfcwhk1.js"),
-  "../../locales/pt.json": () => import("./pt-YI4VE4YQ-wdkn2dcf.js"),
-  "../../locales/ro.json": () => import("./ro-RKXZUG7Z-nndrrsq7.js"),
+  "../../locales/de.json": () => import("./de-MUJPA4EB-209jpeqe.js"),
+  "../../locales/en.json": () => import("./en-GN2ZGWUE-03z2df4k.js"),
+  "../../locales/es-MX.json": () => import("./es-MX-2MYFZU7X-6v0q5rbn.js"),
+  "../../locales/es.json": () => import("./es-7SE7HX2X-qda7whn6.js"),
+  "../../locales/fr.json": () => import("./fr-MDFKNZ4C-qmypp92m.js"),
+  "../../locales/ja.json": () => import("./ja-UTQEAP34-hvyf683h.js"),
+  "../../locales/ko.json": () => import("./ko-AXCHW2OK-pkwdcbmx.js"),
+  "../../locales/pt-BR.json": () => import("./pt-BR-Y6K6XHXK-37a932vp.js"),
+  "../../locales/pt.json": () => import("./pt-3DIO5QWG-hb763vct.js"),
+  "../../locales/ro.json": () => import("./ro-BWR3ONRR-jmap5ajd.js"),
   "../../locales/ru.json": () => import("./ru-WBLQ5B2U-8r3c7v6d.js"),
-  "../../locales/tr.json": () => import("./tr-AA6O2WSR-86ba4bdf.js"),
-  "../../locales/zh-CN.json": () => import("./zh-CN-R2KLHXQV-agqr45ds.js"),
-  "../../locales/zh-TW.json": () => import("./zh-TW-RJGCQANM-w0x3qc1p.js")
+  "../../locales/tr.json": () => import("./tr-5IIHSFW5-stsb3dar.js"),
+  "../../locales/zh-CN.json": () => import("./zh-CN-R2KU4U5L-q4yhc33t.js"),
+  "../../locales/zh-TW.json": () => import("./zh-TW-GNKMELBF-r4ay2475.js")
 });
 var VALIDATION_NAMESPACE = "validation";
 var registerFlowSchemaI18n = createI18nRegistrar({
@@ -28275,8 +28275,17 @@ function date4(params) {
 
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default2());
-// ../../node_modules/@uipath/flow-schema/dist/chunk-E6I5CCCH.js
-var import_ajv = __toESM(require_ajv(), 1);
+// ../../node_modules/@uipath/flow-schema/dist/chunk-GWRTD4DY.js
+var expressionFieldTypeSchema = exports_external.enum(["string", "number", "boolean", "object", "array", "null"]);
+var expressionModeSchema = exports_external.enum(["literal", "jsExpression"]);
+var expressionValueSchema = exports_external.object({
+  type: expressionModeSchema,
+  expression: exports_external.string(),
+  fieldType: expressionFieldTypeSchema
+}).strict();
+var expressionLikeSchema = exports_external.union([exports_external.string(), expressionValueSchema]);
+
+// ../../node_modules/@uipath/flow-schema/dist/chunk-M4DXYS4M.js
 var import_ajv_errors = __toESM(require_dist(), 1);
 
 // ../../node_modules/i18next/dist/esm/i18next.js
@@ -31507,7 +31516,7 @@ var ternary = {
 };
 jsep.plugins.register(ternary);
 
-// ../../node_modules/@uipath/flow-schema/dist/chunk-E6I5CCCH.js
+// ../../node_modules/@uipath/flow-schema/dist/chunk-M4DXYS4M.js
 var agentEnforcementsSchema = exports_external.object({
   maxTokens: exports_external.number().nullable(),
   maxTemperature: exports_external.number().nullable(),
@@ -31515,2104 +31524,224 @@ var agentEnforcementsSchema = exports_external.object({
   shouldEnforceHumanInTheLoop: exports_external.boolean().optional(),
   maxIterations: exports_external.number().nullable().optional()
 });
-var JS_EXPRESSION_PREFIX = "=js:";
-var expressionFieldTypeSchema = exports_external.enum(["string", "number", "boolean", "object", "array", "null"]);
-var expressionModeSchema = exports_external.enum(["literal", "jsExpression"]);
-var expressionValueSchema = exports_external.object({
-  type: expressionModeSchema,
-  expression: exports_external.string(),
-  fieldType: expressionFieldTypeSchema
-}).strict();
-var expressionLikeSchema = exports_external.union([exports_external.string(), expressionValueSchema]);
-function isExpressionValue(v) {
-  return expressionValueSchema.safeParse(v).success;
-}
-function isEmptyExpressionValue(ev) {
-  return ev.expression.trim() === "";
-}
-function inferFieldType(value) {
-  if (Array.isArray(value))
-    return "array";
-  if (value === null)
-    return "null";
-  const t13 = typeof value;
-  if (t13 === "string" || t13 === "number" || t13 === "boolean" || t13 === "object")
-    return t13;
-  return "string";
-}
-function encodeLiteral(raw, fieldType) {
-  switch (fieldType) {
-    case "string":
-      if (typeof raw === "string")
-        return raw;
-      if (raw == null)
-        return "";
-      if (typeof raw === "object") {
-        try {
-          return JSON.stringify(raw);
-        } catch {
-          return String(raw);
-        }
-      }
-      return String(raw);
-    case "number":
-    case "boolean":
-      return raw == null ? "" : String(raw);
-    case "null":
-      return "null";
-    case "object":
-    case "array":
-      return JSON.stringify(raw ?? null);
-  }
-}
-function decodeLiteral(ev) {
-  if (ev.type === "jsExpression")
-    return ev.expression;
-  switch (ev.fieldType) {
-    case "string":
-      return ev.expression;
-    case "number":
-      return ev.expression === "" ? undefined : Number(ev.expression);
-    case "boolean":
-      return ev.expression === "" ? undefined : ev.expression === "true";
-    case "null":
-      return null;
-    case "object":
-    case "array":
-      if (ev.expression === "")
-        return;
-      try {
-        return JSON.parse(ev.expression);
-      } catch {
-        return;
-      }
-  }
-}
-function coerceToExpressionValue(value, fieldType) {
-  if (isExpressionValue(value))
-    return value;
-  const resolvedFieldType = fieldType ?? inferFieldType(value);
-  if (typeof value === "string") {
-    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
-      return {
-        type: "jsExpression",
-        expression: value.slice(JS_EXPRESSION_PREFIX.length),
-        fieldType: resolvedFieldType
-      };
-    }
-    return { type: "literal", expression: value, fieldType: resolvedFieldType };
-  }
-  return { type: "literal", expression: encodeLiteral(value, resolvedFieldType), fieldType: resolvedFieldType };
-}
-function getJsExpressionBody(value) {
-  if (isExpressionValue(value)) {
-    return value.type === "jsExpression" ? value.expression : undefined;
-  }
-  if (typeof value === "string" && value.startsWith(JS_EXPRESSION_PREFIX)) {
-    return value.slice(JS_EXPRESSION_PREFIX.length);
-  }
-  return;
-}
-function hasMustacheInterpolation(s) {
-  const stripped = s.replace(/\\\{/g, "").replace(/\\\}/g, "");
-  return /\{\{[^{}]+\}\}/.test(stripped);
-}
 var t2 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function isExpression(value) {
-  if (isExpressionValue(value))
-    return value.type === "jsExpression";
-  return typeof value === "string" && value.startsWith(JS_EXPRESSION_PREFIX);
-}
-var VALUE_SOURCE_MODES = /* @__PURE__ */ new Set(["text-builder", "variable", "prompt"]);
-function isValueSourceShape(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const obj = value;
-  return VALUE_SOURCE_MODES.has(obj.mode) && (("textValue" in obj) || ("promptValue" in obj) || ("argumentPath" in obj));
-}
-function decodeLiteralForValidation(value) {
-  if (value === null || value === undefined)
-    return value;
-  if (isExpressionValue(value)) {
-    if (value.type === "jsExpression")
-      return value.expression === "" ? "" : value;
-    return decodeLiteral(value);
-  }
-  if (Array.isArray(value))
-    return value.map(decodeLiteralForValidation);
-  if (typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = decodeLiteralForValidation(v);
-    }
-    return out;
-  }
-  return value;
-}
-function decodeLiteralsForValidation(inputs) {
-  return decodeLiteralForValidation(inputs);
-}
-var ajvInstance;
-function getAjv() {
-  if (!ajvInstance) {
-    ajvInstance = new import_ajv.default({ allErrors: true, strict: false });
-    import_ajv_errors.default(ajvInstance);
-  }
-  return ajvInstance;
-}
-var nodeValidatorCache = /* @__PURE__ */ new Map;
-function isJsonSchema(def) {
-  return def.type === "object" && typeof def.properties === "object" && def.properties !== null;
-}
-function normalizeInputDefinition(def) {
-  if (isJsonSchema(def))
-    return def;
-  return {
-    type: "object",
-    properties: def
-  };
-}
-function getNodeValidator(manifestKey, inputDefinition) {
-  const cached2 = nodeValidatorCache.get(manifestKey);
-  if (cached2)
-    return cached2;
-  const normalized = normalizeInputDefinition(inputDefinition);
-  const enriched = enrichRequiredStrings(normalized);
-  try {
-    const validate = getAjv().compile(enriched);
-    nodeValidatorCache.set(manifestKey, validate);
-    return validate;
-  } catch {
-    return null;
-  }
-}
-function enrichRequiredStrings(schema) {
-  const properties = schema.properties;
-  const required2 = schema.required ?? [];
-  if (!properties || required2.length === 0)
-    return schema;
-  const enrichedProps = {};
-  let changed = false;
-  for (const [key, propSchema] of Object.entries(properties)) {
-    if (required2.includes(key) && propSchema.type === "string" && !("minLength" in propSchema)) {
-      enrichedProps[key] = { ...propSchema, minLength: 1 };
-      changed = true;
-    } else {
-      enrichedProps[key] = propSchema;
-    }
-  }
-  if (!changed)
-    return schema;
-  return { ...schema, properties: enrichedProps };
-}
-function schemaErrorsToValidationErrors(errors3, nodeId, nodeLabel, fieldPrefix, inputs, resolveErrorMessageKey, fieldLabels) {
-  const result = [];
-  const seen = /* @__PURE__ */ new Set;
-  for (const error51 of errors3) {
-    if (error51.keyword === "if")
-      continue;
-    if (inputs && error51.keyword !== "required") {
-      const value = resolveValueByInstancePath(inputs, error51.instancePath);
-      if (isExpression(value))
-        continue;
-      if (error51.keyword === "type" && isValueSourceShape(value))
-        continue;
-      if (error51.keyword === "type" && (value === null || typeof value === "string")) {
-        const expected = error51.params?.type;
-        if (expected === "object" || expected === "array")
-          continue;
-      }
-    }
-    if (inputs && error51.keyword === "required") {
-      const container = resolveValueByInstancePath(inputs, error51.instancePath);
-      if (isExpression(container))
-        continue;
-    }
-    const fieldPath = resolveFieldPath(error51, fieldPrefix);
-    const dedupeKey = `${fieldPath}:${error51.keyword}`;
-    if (seen.has(dedupeKey))
-      continue;
-    seen.add(dedupeKey);
-    const message = formatErrorMessage(error51, nodeLabel, fieldPath, fieldLabels);
-    let i18n13;
-    if (error51.keyword === "errorMessage") {
-      const i18nKey = resolveErrorMessageKey?.(error51);
-      i18n13 = i18nKey ? { key: i18nKey } : undefined;
-    } else {
-      const { key, params } = getSchemaErrorI18n(error51, nodeLabel, fieldPath, fieldLabels);
-      i18n13 = { key, ns: VALIDATION_NAMESPACE, params };
-    }
-    result.push({
-      code: ajvKeywordToCode(error51.keyword),
-      message,
-      severity: "error",
-      nodeId,
-      fieldPath: fieldPath ? `inputs.${fieldPath}` : undefined,
-      layer: fieldPath ? "field" : "node",
-      i18n: i18n13
-    });
-  }
-  return result;
-}
-function resolveValueByInstancePath(obj, instancePath) {
-  if (!instancePath)
-    return obj;
-  const segments = instancePath.split("/").filter(Boolean);
-  let current = obj;
-  for (const seg of segments) {
-    if (current == null || typeof current !== "object")
-      return;
-    current = current[seg];
-  }
-  return current;
-}
-function instancePathToFieldPath(instancePath) {
-  const segments = instancePath.split("/").filter(Boolean);
-  let result = "";
-  for (const seg of segments) {
-    if (/^\d+$/.test(seg)) {
-      result += `[${seg}]`;
-    } else {
-      result += result ? `.${seg}` : seg;
-    }
-  }
-  return result;
-}
-function resolveFieldPath(error51, fieldPrefix) {
-  if (error51.keyword === "required") {
-    const missing = error51.params.missingProperty;
-    const basePath = instancePathToFieldPath(error51.instancePath);
-    return basePath ? `${basePath}.${missing}` : missing;
-  }
-  const path3 = instancePathToFieldPath(error51.instancePath);
-  if (fieldPrefix && path3)
-    return path3.startsWith("[") ? `${fieldPrefix}${path3}` : `${fieldPrefix}.${path3}`;
-  return fieldPrefix || path3;
-}
-function getSchemaErrorI18n(error51, nodeLabel, fieldPath, fieldLabels) {
-  const rawKey = fieldPath.split(".").pop() ?? fieldPath;
-  const isTopLevel = !fieldPath.includes(".") && !fieldPath.includes("[");
-  const fieldName = isTopLevel ? fieldLabels?.[rawKey] ?? rawKey : rawKey;
-  switch (error51.keyword) {
-    case "required": {
-      const missing = error51.params.missingProperty;
-      const missingLabel = error51.instancePath === "" ? fieldLabels?.[missing] ?? missing : missing;
-      return {
-        key: "schemaValidator_required_message",
-        params: { fieldName: missingLabel, nodeLabel, defaultValue: '"{{fieldName}}" is required on "{{nodeLabel}}"' }
-      };
-    }
-    case "minLength":
-      return {
-        key: "schemaValidator_required_message",
-        params: { fieldName, nodeLabel, defaultValue: '"{{fieldName}}" is required on "{{nodeLabel}}"' }
-      };
-    case "type":
-      return {
-        key: "schemaValidator_typeMismatch_message",
-        params: {
-          fieldName,
-          nodeLabel,
-          type: error51.params.type,
-          defaultValue: '"{{fieldName}}" on "{{nodeLabel}}" expects {{type}}'
-        }
-      };
-    case "enum":
-      return {
-        key: "schemaValidator_invalidEnum_message",
-        params: { fieldName, nodeLabel, defaultValue: '"{{fieldName}}" on "{{nodeLabel}}" must be one of the allowed values' }
-      };
-    case "pattern":
-      return {
-        key: "schemaValidator_invalidPattern_message",
-        params: { fieldName, nodeLabel, defaultValue: '"{{fieldName}}" on "{{nodeLabel}}" has invalid format' }
-      };
-    case "minimum":
-    case "maximum":
-      return {
-        key: "schemaValidator_outOfRange_message",
-        params: { fieldName, nodeLabel, detail: error51.message ?? "", defaultValue: '"{{fieldName}}" on "{{nodeLabel}}" {{detail}}' }
-      };
-    default:
-      return error51.message ? {
-        key: "schemaValidator_genericKeyword_message",
-        params: { fieldName, nodeLabel, detail: error51.message, defaultValue: '"{{fieldName}}" on "{{nodeLabel}}": {{detail}}' }
-      } : {
-        key: "schemaValidator_invalidField_message",
-        params: { fieldName, nodeLabel, defaultValue: '"{{fieldName}}" on "{{nodeLabel}}" is invalid' }
-      };
-  }
-}
-function formatErrorMessage(error51, nodeLabel, fieldPath, fieldLabels) {
-  if (error51.keyword === "errorMessage") {
-    return error51.message ?? "Validation error";
-  }
-  const { key, params } = getSchemaErrorI18n(error51, nodeLabel, fieldPath, fieldLabels);
-  return t2(key, params);
-}
-function ajvKeywordToCode(keyword) {
-  switch (keyword) {
-    case "required":
-    case "minLength":
-      return "REQUIRED_FIELD";
-    case "type":
-      return "TYPE_MISMATCH";
-    case "enum":
-      return "INVALID_ENUM";
-    case "pattern":
-      return "INVALID_PATTERN";
-    case "minimum":
-    case "maximum":
-    case "exclusiveMinimum":
-    case "exclusiveMaximum":
-      return "OUT_OF_RANGE";
-    case "errorMessage":
-      return "SCHEMA_ERROR";
-    default:
-      return "SCHEMA_ERROR";
-  }
-}
 var t22 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized(key, params, defaultValue) {
-  return {
-    message: t22(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-function readStringField(value) {
-  if (isExpressionValue(value))
-    return value.expression;
-  return typeof value === "string" ? value : "";
-}
-function getManifestForNode(node, manifests) {
-  const version2 = node.data.typeVersion || "1.0.0";
-  return manifests.get(`${node.type}:${version2}`);
-}
-function getNodeLabel(node, manifest) {
-  const displayLabel = node.data.display?.label;
-  return displayLabel || node.data.label || manifest?.display?.label || node.type;
-}
-function resolvePath(path3, context) {
-  return path3.split(".").reduce((obj, key) => {
-    if (obj == null || typeof obj !== "object")
-      return;
-    return obj[key];
-  }, context);
-}
-function resolveTemplate(template, context) {
-  if (!template.includes("{"))
-    return template;
-  return template.replace(/\{([^{}]+)\}/g, (_, expr) => {
-    const parts = expr.split("||").map((p) => p.trim());
-    for (const part of parts) {
-      const strMatch = part.match(/^'([^']*)'$/) || part.match(/^"([^"]*)"$/);
-      if (strMatch)
-        return strMatch[1];
-      const val = resolvePath(part, context);
-      if (val != null && val !== "")
-        return String(val);
-    }
-    return "";
-  });
-}
-function isTriggerNodeType(nodeType2) {
-  if (typeof nodeType2 !== "string")
-    return false;
-  return nodeType2.startsWith("core.trigger") || nodeType2.toLowerCase().includes("trigger");
-}
-function isEndNodeType(nodeType2) {
-  return nodeType2 === "core.control.end" || nodeType2 === "core.logic.terminate" || nodeType2 === "core.control.response";
-}
-var DOWHILE_NODE_TYPE = "core.logic.dowhile";
-var DOWHILE_MAX_LIMIT = 1e4;
-var DOWHILE_MIN_LIMIT = 1;
-function parseDoWhileLimit(raw) {
-  if (raw === undefined || raw === null)
-    return;
-  const decoded = decodeLiteral(coerceToExpressionValue(raw, "number"));
-  if (decoded === undefined)
-    return;
-  if (typeof decoded === "number")
-    return decoded;
-  if (typeof decoded !== "string")
-    return NaN;
-  const body = decoded.trim();
-  if (!body)
-    return;
-  const parsed = Number(body);
-  return Number.isNaN(parsed) ? undefined : parsed;
-}
-var DECISION_NODE_TYPE = "core.logic.decision";
-var SWITCH_NODE_TYPE = "core.logic.switch";
-var MERGE_NODE_TYPE = "core.logic.merge";
-function supportsVariableUpdates(nodeType2) {
-  return nodeType2 !== DECISION_NODE_TYPE && nodeType2 !== SWITCH_NODE_TYPE && nodeType2 !== MERGE_NODE_TYPE;
-}
 var AUTONOMOUS_AGENT_NODE_TYPE = "uipath.agent.autonomous";
 var CONVERSATIONAL_AGENT_NODE_TYPE = "uipath.agent.conversational";
 var VOICE_AGENT_NODE_TYPE = "uipath.agent.voice";
 var AGENT_NODE_TYPES = [AUTONOMOUS_AGENT_NODE_TYPE, CONVERSATIONAL_AGENT_NODE_TYPE, VOICE_AGENT_NODE_TYPE];
-function isConversationalOrVoiceAgentNodeType(nodeType2) {
-  if (!nodeType2)
-    return false;
-  return [CONVERSATIONAL_AGENT_NODE_TYPE, VOICE_AGENT_NODE_TYPE].some((t13) => nodeType2 === t13 || nodeType2.startsWith(`${t13}.`));
-}
-function isVoiceAgentNodeType(nodeType2) {
-  return nodeType2 === VOICE_AGENT_NODE_TYPE;
-}
-function isAutonomousAgentNodeType(nodeType2) {
-  return nodeType2 === AUTONOMOUS_AGENT_NODE_TYPE;
-}
-function isConversationalAgentNode(node) {
-  if (isConversationalOrVoiceAgentNodeType(node.type))
-    return true;
-  if (!isAgentNodeType(node.type) && !isPublishedAgentNodeType(node.type))
-    return false;
-  const inputs = node.data?.inputs;
-  return inputs?.isConversational === true;
-}
 function isAgentNodeType(nodeType2) {
   if (!nodeType2)
     return false;
   return AGENT_NODE_TYPES.some((t13) => nodeType2 === t13 || nodeType2.startsWith(`${t13}.`));
 }
-var PUBLISHED_AGENT_NODE_TYPE_PREFIX = "uipath.core.agent.";
-function isPublishedAgentNodeType(nodeType2) {
-  if (!nodeType2)
-    return false;
-  return nodeType2.startsWith(PUBLISHED_AGENT_NODE_TYPE_PREFIX);
-}
-function isAgentToolNodeType(nodeType2) {
-  if (!nodeType2)
-    return false;
-  return nodeType2.startsWith("uipath.agent.resource.tool") && !nodeType2.startsWith("uipath.agent.resource.tool.mcp") && !nodeType2.startsWith("uipath.agent.resource.tool.a2a");
-}
-var AGENT_RESOURCE_PREFIX = "uipath.agent.resource.";
-function isAgentResourceNodeType(nodeType2) {
-  if (!nodeType2)
-    return false;
-  return nodeType2.startsWith(AGENT_RESOURCE_PREFIX);
-}
-var CONVERSATIONAL_VOICE_END_CALL_NODE_TYPE = "uipath.conversational.voice.end-call";
-function manifestExposesCallContext(manifest) {
-  const properties = manifest.inputDefinition?.properties;
-  return !!properties && Object.prototype.hasOwnProperty.call(properties, "callContext");
-}
-function isCallContextEmpty(callContext) {
-  if (isExpressionValue(callContext))
-    return isEmptyExpressionValue(callContext);
-  if (typeof callContext === "string")
-    return callContext.trim().length === 0;
-  if (Array.isArray(callContext))
-    return callContext.length === 0;
-  if (callContext == null || typeof callContext !== "object")
-    return true;
-  return Object.keys(callContext).length === 0;
-}
-function isValidCallContextBinding(callContext) {
-  if (isExpressionValue(callContext))
-    return callContext.type === "jsExpression" && !isEmptyExpressionValue(callContext);
-  if (typeof callContext === "string") {
-    const trimmed = callContext.trim();
-    return trimmed.startsWith("=") && trimmed.length > 1;
-  }
-  return callContext != null && typeof callContext === "object" && !Array.isArray(callContext) && Object.keys(callContext).length > 0;
-}
-var SCHEMA_PATH_PROPERTY_RE = /\/properties\/([^/]+)\/errorMessage$/;
-function makeResolverFromMap(propMap) {
-  if (!propMap)
-    return;
-  return (error51) => {
-    const propName = SCHEMA_PATH_PROPERTY_RE.exec(error51.schemaPath)?.[1];
-    return propName ? propMap[propName] : undefined;
-  };
-}
-function buildSeverityOverrides(inputDefinition) {
-  const props = inputDefinition.properties;
-  if (!props)
-    return null;
-  let map2 = null;
-  for (const [key, schema] of Object.entries(props)) {
-    if (schema.validationSeverity && typeof schema.validationSeverity === "string") {
-      if (!map2)
-        map2 = /* @__PURE__ */ new Map;
-      map2.set(key, schema.validationSeverity);
-    }
-  }
-  return map2;
-}
-var schemaValidationRule = {
-  id: "schema-validation",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    const severityCache = /* @__PURE__ */ new Map;
-    for (const node of ctx.nodes) {
-      const manifest = getManifestForNode(node, ctx.manifests);
-      if (!manifest?.inputDefinition)
-        continue;
-      const manifestKey = `${manifest.nodeType}:${manifest.version}`;
-      const validator = getNodeValidator(manifestKey, manifest.inputDefinition);
-      if (!validator)
-        continue;
-      const inputs = node.data.inputs ?? {};
-      const decodedInputs = decodeLiteralsForValidation(inputs);
-      const valid = validator(decodedInputs);
-      if (!valid && validator.errors) {
-        const resolveErrorMessageKey = makeResolverFromMap(ctx.errorMessageKeysByNodeType?.[manifest.nodeType]);
-        const nodeErrors = schemaErrorsToValidationErrors(validator.errors, node.id, getNodeLabel(node, manifest), undefined, decodedInputs, resolveErrorMessageKey, manifest.fieldLabels);
-        if (!severityCache.has(manifestKey)) {
-          severityCache.set(manifestKey, buildSeverityOverrides(manifest.inputDefinition));
-        }
-        const overrides = severityCache.get(manifestKey);
-        if (overrides) {
-          for (const err of nodeErrors) {
-            if (err.fieldPath) {
-              const fieldName = err.fieldPath.replace(/^inputs\./, "").split(".")[0];
-              const severity = overrides.get(fieldName);
-              if (severity)
-                err.severity = severity;
-            }
-          }
-        }
-        errors3.push(...nodeErrors);
-      }
-    }
-    return errors3;
-  }
-};
-var minConnectionsRule = {
-  id: "min-connections",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    const sourceEdgeCounts = /* @__PURE__ */ new Map;
-    const targetEdgeCounts = /* @__PURE__ */ new Map;
-    for (const e of ctx.edges) {
-      const sourceKey = `${e.source}:${e.sourceHandle ?? ""}`;
-      sourceEdgeCounts.set(sourceKey, (sourceEdgeCounts.get(sourceKey) ?? 0) + 1);
-      const targetKey = `${e.target}:${e.targetHandle ?? ""}`;
-      targetEdgeCounts.set(targetKey, (targetEdgeCounts.get(targetKey) ?? 0) + 1);
-    }
-    for (const node of ctx.nodes) {
-      const manifest = getManifestForNode(node, ctx.manifests);
-      if (!manifest)
-        continue;
-      for (const handleGroup of manifest.handleConfiguration) {
-        for (const handle of handleGroup.handles) {
-          if (!handle.constraints?.minConnections)
-            continue;
-          const countMap = handle.type === "source" ? sourceEdgeCounts : targetEdgeCounts;
-          const handleKey = `${node.id}:${handle.id ?? ""}`;
-          let connectionCount = countMap.get(handleKey) ?? 0;
-          if (handle.id != null) {
-            connectionCount += countMap.get(`${node.id}:`) ?? 0;
-          }
-          if (connectionCount < handle.constraints.minConnections) {
-            const nodeLabel = getNodeLabel(node, manifest);
-            const handleLabel = handle.label ? resolveTemplate(handle.label, node.data) : handle.id;
-            const severity = handle.constraints.severity ?? "error";
-            const customMessage = handle.constraints.validationMessage ? resolveTemplate(handle.constraints.validationMessage, node.data) : undefined;
-            errors3.push({
-              code: "MIN_CONNECTIONS",
-              message: customMessage ?? `"${nodeLabel}" handle "${handleLabel}" requires at least ${handle.constraints.minConnections} connection(s)`,
-              severity,
-              nodeId: node.id,
-              layer: "node"
-            });
-          }
-        }
-      }
-    }
-    return errors3;
-  }
-};
 var t3 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized2(key, params, defaultValue) {
-  return {
-    message: t3(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-var triggerRequiredRule = {
-  id: "trigger-required",
-  severity: "error",
-  validate(ctx) {
-    const hasTrigger = ctx.nodes.some((node) => isTriggerNodeType(node.type));
-    if (!hasTrigger) {
-      return [
-        {
-          code: "TRIGGER_REQUIRED",
-          ...localized2("triggerRequired_message", {}, "Process must have at least one trigger node"),
-          severity: "error",
-          nodeId: "",
-          layer: "workflow"
-        }
-      ];
-    }
-    return [];
-  }
-};
 var t4 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized3(key, params, defaultValue) {
-  return {
-    message: t4(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-var TRANSFORM_NODE_TYPES = /* @__PURE__ */ new Set([
-  "core.action.transform",
-  "core.action.transform.map",
-  "core.action.transform.filter",
-  "core.action.transform.group-by"
-]);
-function validateFilterConfig(config2, nodeLabel, nodeId) {
-  const errors3 = [];
-  const filters = Array.isArray(config2.filters) ? config2.filters : [];
-  if (filters.length === 0) {
-    errors3.push({
-      code: "DATA_TRANSFORM_INCOMPLETE",
-      ...localized3("dataTransform_filterNoConditions_message", { nodeLabel }, '"{{nodeLabel}}" filter operation has no conditions'),
-      severity: "error",
-      nodeId,
-      fieldPath: "inputs.operations",
-      layer: "field"
-    });
-    return errors3;
-  }
-  for (const filter of filters) {
-    if (filter.field === null || filter.field === undefined) {
-      errors3.push({
-        code: "DATA_TRANSFORM_INCOMPLETE",
-        ...localized3("dataTransform_filterMissingField_message", { nodeLabel }, '"{{nodeLabel}}" filter condition is missing a field'),
-        severity: "error",
-        nodeId,
-        fieldPath: "inputs.operations",
-        layer: "field"
-      });
-    }
-  }
-  return errors3;
-}
-function validateMapConfig(config2, nodeLabel, nodeId) {
-  const errors3 = [];
-  const mappings = Array.isArray(config2.mappings) ? config2.mappings : [];
-  const keepOriginalFields = config2.keepOriginalFields !== false;
-  if (!keepOriginalFields && mappings.length === 0) {
-    errors3.push({
-      code: "DATA_TRANSFORM_INCOMPLETE",
-      ...localized3("dataTransform_mapNoMappings_message", { nodeLabel }, '"{{nodeLabel}}" map operation needs at least one field mapping when original fields are not kept'),
-      severity: "error",
-      nodeId,
-      fieldPath: "inputs.operations",
-      layer: "field"
-    });
-    return errors3;
-  }
-  for (const mapping of mappings) {
-    if (mapping.field === null || mapping.field === undefined) {
-      errors3.push({
-        code: "DATA_TRANSFORM_INCOMPLETE",
-        ...localized3("dataTransform_mapMissingField_message", { nodeLabel }, '"{{nodeLabel}}" map field mapping is missing a field'),
-        severity: "error",
-        nodeId,
-        fieldPath: "inputs.operations",
-        layer: "field"
-      });
-    }
-  }
-  return errors3;
-}
-function validateGroupByConfig(config2, nodeLabel, nodeId) {
-  const errors3 = [];
-  if (config2.groupByField === null || config2.groupByField === undefined) {
-    errors3.push({
-      code: "DATA_TRANSFORM_INCOMPLETE",
-      ...localized3("dataTransform_groupByMissingField_message", { nodeLabel }, '"{{nodeLabel}}" group by operation is missing the group by field'),
-      severity: "error",
-      nodeId,
-      fieldPath: "inputs.operations",
-      layer: "field"
-    });
-    return errors3;
-  }
-  const aggregations = Array.isArray(config2.aggregations) ? config2.aggregations : [];
-  for (const agg of aggregations) {
-    const operation = agg.operation;
-    const fieldRequired = operation !== "count";
-    if (fieldRequired && (agg.field === null || agg.field === undefined)) {
-      errors3.push({
-        code: "DATA_TRANSFORM_INCOMPLETE",
-        ...localized3("dataTransform_groupByAggMissingField_message", { nodeLabel }, '"{{nodeLabel}}" group by aggregation is missing a field'),
-        severity: "error",
-        nodeId,
-        fieldPath: "inputs.operations",
-        layer: "field"
-      });
-    }
-    if (!readStringField(agg.alias).trim()) {
-      errors3.push({
-        code: "DATA_TRANSFORM_INCOMPLETE",
-        ...localized3("dataTransform_groupByAggMissingOutputName_message", { nodeLabel }, '"{{nodeLabel}}" group by aggregation is missing an output name'),
-        severity: "error",
-        nodeId,
-        fieldPath: "inputs.operations",
-        layer: "field"
-      });
-    }
-  }
-  return errors3;
-}
-function validateCustomScriptConfig(config2, nodeLabel, nodeId) {
-  if (!readStringField(config2.script).trim()) {
-    return [
-      {
-        code: "DATA_TRANSFORM_INCOMPLETE",
-        ...localized3("dataTransform_customScriptMissing_message", { nodeLabel }, '"{{nodeLabel}}" custom script operation has no script'),
-        severity: "error",
-        nodeId,
-        fieldPath: "inputs.operations",
-        layer: "field"
-      }
-    ];
-  }
-  return [];
-}
-function validateOperation(op, nodeLabel, nodeId) {
-  const config2 = op.config;
-  if (!config2 || typeof config2 !== "object")
-    return [];
-  switch (op.type) {
-    case "filter":
-      return validateFilterConfig(config2, nodeLabel, nodeId);
-    case "map":
-      return validateMapConfig(config2, nodeLabel, nodeId);
-    case "groupBy":
-      return validateGroupByConfig(config2, nodeLabel, nodeId);
-    case "customScript":
-      return validateCustomScriptConfig(config2, nodeLabel, nodeId);
-    default:
-      return [];
-  }
-}
-var dataTransformRule = {
-  id: "data-transform",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      if (!TRANSFORM_NODE_TYPES.has(node.type))
-        continue;
-      const manifest = getManifestForNode(node, ctx.manifests);
-      const nodeLabel = getNodeLabel(node, manifest);
-      const inputs = node.data.inputs ?? {};
-      if (!readStringField(inputs.collection).trim()) {
-        errors3.push({
-          code: "DATA_TRANSFORM_INCOMPLETE",
-          ...localized3("dataTransform_missingCollection_message", { nodeLabel }, '"{{nodeLabel}}" is missing a collection variable'),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.collection",
-          layer: "field"
-        });
-      }
-      const operations = Array.isArray(inputs.operations) ? inputs.operations : [];
-      if (operations.length === 0) {
-        errors3.push({
-          code: "DATA_TRANSFORM_INCOMPLETE",
-          ...localized3("dataTransform_noOperations_message", { nodeLabel }, '"{{nodeLabel}}" has no operations configured'),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.operations",
-          layer: "field"
-        });
-        continue;
-      }
-      for (const op of operations) {
-        errors3.push(...validateOperation(op, nodeLabel, node.id));
-      }
-    }
-    return errors3;
-  }
-};
 var t5 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized4(key, params, defaultValue) {
-  return {
-    message: t5(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-var outputMappingRule = {
-  id: "output-mapping",
-  severity: "warning",
-  validate(ctx) {
-    const outputVarIds = ctx.outputVariableIds;
-    if (!outputVarIds || outputVarIds.length === 0)
-      return [];
-    const errors3 = [];
-    const endNodes = ctx.nodes.filter((n) => isEndNodeType(n.type));
-    if (endNodes.length === 0)
-      return [];
-    for (const node of endNodes) {
-      const manifest = getManifestForNode(node, ctx.manifests);
-      const nodeLabel = getNodeLabel(node, manifest);
-      const outputs = node.data.outputs ?? {};
-      for (const varId of outputVarIds) {
-        if (!readStringField(outputs[varId]?.source).trim()) {
-          errors3.push({
-            code: "MISSING_OUTPUT_MAPPING",
-            ...localized4("outputMapping_missing_message", { nodeLabel, varId }, '"{{nodeLabel}}" is missing output mapping for "{{varId}}"'),
-            severity: "warning",
-            nodeId: node.id,
-            fieldPath: `outputs.${varId}.source`,
-            layer: "node"
-          });
-        }
-      }
-    }
-    return errors3;
-  }
-};
-var ESCALATION_QUICK_FORM_NODE_TYPE = "uipath.agent.resource.escalation.quick-form";
 var ESCALATION_TASK_TYPE = {
   AppTask: "app-task",
   QuickForm: "quick-form",
   DocumentValidationTask: "document-validation-task"
 };
 var ESCALATION_TASK_TYPES = new Set(Object.values(ESCALATION_TASK_TYPE));
-function resolveEscalationTaskType(nodeType2, inputsType) {
-  if (nodeType2 === ESCALATION_QUICK_FORM_NODE_TYPE)
-    return ESCALATION_TASK_TYPE.QuickForm;
-  if (typeof inputsType === "string" && ESCALATION_TASK_TYPES.has(inputsType))
-    return inputsType;
-  return ESCALATION_TASK_TYPE.AppTask;
-}
-var isToolNode = (nodeType2) => {
-  return nodeType2.startsWith("uipath.agent.resource.tool.");
-};
-var isContextNode = (nodeType2) => {
-  return nodeType2.startsWith("uipath.agent.resource.context.");
-};
-var isEscalationNode = (nodeType2) => {
-  return nodeType2.startsWith("uipath.agent.resource.escalation");
-};
-var isMemoryNode = (nodeType2) => {
-  return nodeType2.startsWith("uipath.agent.resource.memory.");
-};
-var isAgentResourceNode = (nodeType2) => {
-  return isToolNode(nodeType2) || isContextNode(nodeType2) || isEscalationNode(nodeType2) || isMemoryNode(nodeType2);
-};
 var DEFAULT_STORAGE_VERSION = currentStorageSchema.version;
-var _defaultAgentContent;
-function getDefaultAgentContent() {
-  if (!_defaultAgentContent) {
-    const entry = currentStorageSchemaMigration.defaultStorageContents.files.find((f) => f.name === "agent.json");
-    if (!entry) {
-      throw new Error("@uipath/agents-storage-schemas: missing agent.json in defaultStorageContents");
-    }
-    _defaultAgentContent = entry.content;
-  }
-  return _defaultAgentContent;
-}
 var t6 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized5(key, params, defaultValue) {
-  return {
-    message: t6(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-function getNodeType(node) {
-  return node.data?.type ?? node.type ?? "";
-}
-function isAgentNode(node) {
-  return isAgentNodeType(getNodeType(node));
-}
-function isEscalationNode2(node) {
-  return isEscalationNode(getNodeType(node));
-}
-function isAgentResourceNode2(node) {
-  return isAgentResourceNodeType(getNodeType(node));
-}
-function checkTemperature(node, gov) {
-  if (gov.maxTemperature == null || gov.maxTemperature <= 0)
-    return null;
-  const temperature = Number(node.data?.inputs?.temperature ?? 0);
-  if (temperature <= gov.maxTemperature)
-    return null;
-  return {
-    code: "GOVERNANCE_TEMPERATURE_EXCEEDED",
-    ...localized5("governance_temperatureExceeded_message", { maxTemperature: gov.maxTemperature, policyName: gov.policyName }, "Temperature exceeds {{maxTemperature}}. Rule enforced by governance policy: {{policyName}}"),
-    severity: "error",
-    nodeId: node.id,
-    fieldPath: "inputs.temperature",
-    layer: "field"
-  };
-}
-function checkMaxTokens(node, gov) {
-  if (gov.maxTokens == null || gov.maxTokens <= 0)
-    return null;
-  const maxTokens = Number(node.data?.inputs?.maxTokenPerResponse ?? 0);
-  if (maxTokens <= gov.maxTokens)
-    return null;
-  return {
-    code: "GOVERNANCE_MAX_TOKENS_EXCEEDED",
-    ...localized5("governance_maxTokensExceeded_message", { maxTokens: gov.maxTokens, policyName: gov.policyName }, "Max tokens per response exceeds {{maxTokens}}. Rule enforced by governance policy: {{policyName}}"),
-    severity: "error",
-    nodeId: node.id,
-    fieldPath: "inputs.maxTokenPerResponse",
-    layer: "field"
-  };
-}
-function checkMaxIterations(node, gov) {
-  if (gov.maxIterations == null || gov.maxIterations <= 0)
-    return null;
-  const defaultMaxIterations = getDefaultAgentContent().settings.maxIterations ?? 0;
-  const maxIterations = Number(node.data?.inputs?.maxIterations ?? defaultMaxIterations);
-  if (maxIterations <= gov.maxIterations)
-    return null;
-  return {
-    code: "GOVERNANCE_MAX_ITERATIONS_EXCEEDED",
-    ...localized5("governance_maxIterationsExceeded_message", { maxIterations: gov.maxIterations, policyName: gov.policyName }, "Max iterations exceeds {{maxIterations}}. Rule enforced by governance policy: {{policyName}}"),
-    severity: "error",
-    nodeId: node.id,
-    fieldPath: "inputs.maxIterations",
-    layer: "field"
-  };
-}
-function hasEscalationGuardrail(node) {
-  const inputs = node.data?.inputs;
-  const guardrails = inputs?.guardrails;
-  if (!Array.isArray(guardrails))
-    return false;
-  return guardrails.some((g) => {
-    if (typeof g !== "object" || g === null)
-      return false;
-    const action = g.action;
-    return !!action && action.$actionType === "escalate";
-  });
-}
-function checkModelAvailability(node, availableModelNames, policyName) {
-  const model = node.data?.inputs?.model;
-  if (!model || typeof model !== "string") {
-    if (availableModelNames.includes(getDefaultAgentContent().settings.model))
-      return null;
-    return {
-      code: "MODEL_NOT_AVAILABLE",
-      ...localized5("governance_noAllowedModel_message", { policyName }, "No allowed model selected, enforced by governance policy: {{policyName}}"),
-      severity: "error",
-      nodeId: node.id,
-      fieldPath: "inputs.model",
-      layer: "field"
-    };
-  }
-  if (availableModelNames.includes(model))
-    return null;
-  return {
-    code: "MODEL_NOT_AVAILABLE",
-    ...localized5("governance_modelNotAvailable_message", { model, policyName }, "{{model}} model is not allowed, enforced by governance policy: {{policyName}}"),
-    severity: "error",
-    nodeId: node.id,
-    fieldPath: "inputs.model",
-    layer: "field"
-  };
-}
-function checkHitl(node, gov, nodes, edges) {
-  if (!gov.shouldEnforceHumanInTheLoop)
-    return null;
-  const hasEscalationResource = edges.some((edge) => edge.source === node.id && edge.sourceHandle === "escalation" && nodes.some((n) => n.id === edge.target && isEscalationNode2(n)));
-  if (hasEscalationResource)
-    return null;
-  if (hasEscalationGuardrail(node))
-    return null;
-  const linkedTargetIds = new Set(edges.filter((edge) => edge.source === node.id).map((edge) => edge.target));
-  const hasLinkedEscalationGuardrail = nodes.some((n) => linkedTargetIds.has(n.id) && isAgentResourceNode2(n) && hasEscalationGuardrail(n));
-  if (hasLinkedEscalationGuardrail)
-    return null;
-  return {
-    code: "GOVERNANCE_HITL_REQUIRED",
-    ...localized5("governance_hitlRequired_message", { policyName: gov.policyName }, "Agent must have at least one escalation resource or a guardrail with HITL action. Rule enforced by governance policy: {{policyName}}"),
-    severity: "error",
-    nodeId: node.id,
-    layer: "node",
-    publishOnly: true
-  };
-}
-var governanceRule = {
-  id: "governance",
-  severity: "error",
-  validate(ctx) {
-    const gov = ctx.governanceEnforcements;
-    const availableModels = ctx.availableModelNames;
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      if (!isAgentNode(node))
-        continue;
-      if (isVoiceAgentNodeType(getNodeType(node)))
-        continue;
-      if (gov) {
-        const tempErr = checkTemperature(node, gov);
-        if (tempErr)
-          errors3.push(tempErr);
-        const tokensErr = checkMaxTokens(node, gov);
-        if (tokensErr)
-          errors3.push(tokensErr);
-        const iterationsErr = checkMaxIterations(node, gov);
-        if (iterationsErr)
-          errors3.push(iterationsErr);
-        const hitlErr = checkHitl(node, gov, ctx.nodes, ctx.edges);
-        if (hitlErr)
-          errors3.push(hitlErr);
-      }
-      if (availableModels !== undefined) {
-        const modelErr = checkModelAvailability(node, availableModels, gov?.policyName ?? "tenant model policy");
-        if (modelErr)
-          errors3.push(modelErr);
-      }
-    }
-    return errors3;
-  }
-};
-function getHitlFieldChannelKey(field) {
-  if (field.label)
-    return field.label;
-  if (field.id)
-    return field.id;
-  return null;
-}
-function isHitlInputDirectionField(field) {
-  return (field.direction ?? "input") === "input" || field.direction === "inOut";
-}
-function isHitlOutputDirectionField(field) {
-  return field.direction === "output" || field.direction === "inOut";
-}
-function collectDuplicateChannelKeys(fields) {
-  const seen = /* @__PURE__ */ new Set;
-  const duplicates = /* @__PURE__ */ new Set;
-  for (const field of fields) {
-    const key = getHitlFieldChannelKey(field);
-    if (key === null)
-      continue;
-    if (seen.has(key))
-      duplicates.add(key);
-    seen.add(key);
-  }
-  return [...duplicates];
-}
-function findDuplicateHitlChannelKeys(schema) {
-  const fields = schema?.fields ?? [];
-  const inputSide = collectDuplicateChannelKeys(fields.filter(isHitlInputDirectionField));
-  const outputSide = collectDuplicateChannelKeys(fields.filter(isHitlOutputDirectionField));
-  return [.../* @__PURE__ */ new Set([...inputSide, ...outputSide])];
-}
 var t7 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized6(key, params, defaultValue) {
-  return {
-    message: t7(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-var escalationValidationRule = {
-  id: "escalation-validation",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      if (!isEscalationNode(node.type))
-        continue;
-      const inputs = node.data.inputs ?? {};
-      const manifest = getManifestForNode(node, ctx.manifests);
-      const label = getNodeLabel(node, manifest);
-      const isQuickForm = resolveEscalationTaskType(node.type, inputs.type) === ESCALATION_TASK_TYPE.QuickForm;
-      if (!readStringField(inputs.name).trim()) {
-        errors3.push({
-          code: "ESCALATION_NAME_REQUIRED",
-          ...localized6("escalation_nameRequired_message", { label }, "{{label}}: Escalation name is required"),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.name",
-          layer: "node"
-        });
-      }
-      if (isQuickForm) {
-        for (const fieldLabel of findDuplicateHitlChannelKeys(inputs.schema)) {
-          errors3.push({
-            code: "ESCALATION_QUICK_FORM_DUPLICATE_FIELD_LABEL",
-            ...localized6("escalation_quickFormDuplicateFieldLabel_message", { label, fieldLabel }, '{{label}}: Multiple fields are labeled "{{fieldLabel}}" — the escalation task would keep only one of them. Make field labels unique'),
-            severity: "error",
-            nodeId: node.id,
-            fieldPath: "inputs.schema",
-            layer: "field"
-          });
-        }
-      }
-      if (!isQuickForm) {
-        const app = inputs.app;
-        if (!app?.appName) {
-          errors3.push({
-            code: "ESCALATION_APP_REQUIRED",
-            ...localized6("escalation_appRequired_message", { label }, "Select an action app"),
-            severity: "error",
-            nodeId: node.id,
-            fieldPath: "inputs.app",
-            layer: "node"
-          });
-        }
-      }
-      if (inputs.agentMemory === true) {
-        const fieldSettings = inputs.memoryFieldSettings;
-        if (!Array.isArray(fieldSettings) || fieldSettings.length === 0) {
-          errors3.push({
-            code: "ESCALATION_MEMORY_ARGUMENT_REQUIRED",
-            ...localized6("escalation_memoryArgumentRequired_message", { label }, "{{label}}: Add at least one argument for agent memory, or turn agent memory off"),
-            severity: "error",
-            nodeId: node.id,
-            fieldPath: "inputs.memoryFieldSettings",
-            layer: "node"
-          });
-        }
-      }
-      const recipients = inputs.recipients;
-      const hasValidRecipient = Array.isArray(recipients) && recipients.length > 0 && recipients.some((r) => r.value && String(r.value).trim() !== "");
-      if (!hasValidRecipient) {
-        errors3.push({
-          code: "ESCALATION_RECIPIENT_REQUIRED",
-          ...localized6("escalation_recipientRequired_message", { label }, "{{label}}: Escalation recipient is required"),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.recipients",
-          layer: "node"
-        });
-      }
-    }
-    return errors3;
-  }
-};
 var t8 = instance.getFixedT(null, VALIDATION_NAMESPACE);
 var t9 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized8(key, params, defaultValue) {
-  return {
-    message: t9(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-var INPUT_REF_REGEX = /\{\{\s*\$agent\.([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/g;
 var VARS_PATH_CAPTURE = String.raw`[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*`;
 var VARS_REF_REGEX = new RegExp(String.raw`\{\{\s*\$vars\.(${VARS_PATH_CAPTURE})\s*\}\}`, "g");
 var RAW_VARS_REF_REGEX = new RegExp(String.raw`(?<!\w)\$vars\.(${VARS_PATH_CAPTURE})`, "g");
-function getNodeType2(node) {
-  return node.data?.type ?? node.type ?? "";
-}
-function collectStringsDeep(value, out = []) {
-  if (typeof value === "string")
-    out.push(value);
-  else if (Array.isArray(value))
-    for (const item of value)
-      collectStringsDeep(item, out);
-  else if (value && typeof value === "object")
-    for (const item of Object.values(value))
-      collectStringsDeep(item, out);
-  return out;
-}
-function extractMatches(text, regex) {
-  const refs = /* @__PURE__ */ new Set;
-  regex.lastIndex = 0;
-  let match;
-  while ((match = regex.exec(text)) !== null) {
-    refs.add(match[1]);
-  }
-  return refs;
-}
-var agentInputRefsRule = {
-  id: "agent-input-refs",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    const knownRootSegments = ctx.workflowVariableIds ? new Set(ctx.workflowVariableIds) : null;
-    if (knownRootSegments) {
-      for (const n of ctx.nodes)
-        knownRootSegments.add(n.id);
-    }
-    const nodeById = new Map(ctx.nodes.map((n) => [n.id, n]));
-    for (const node of ctx.nodes) {
-      if (!isAgentNodeType(getNodeType2(node)))
-        continue;
-      const inputs = node.data?.inputs;
-      if (!inputs)
-        continue;
-      const systemPrompt = typeof inputs.systemPrompt === "string" ? inputs.systemPrompt : "";
-      const userPrompt = typeof inputs.userPrompt === "string" ? inputs.userPrompt : "";
-      const inputRefs = /* @__PURE__ */ new Set;
-      for (const ref of extractMatches(systemPrompt, INPUT_REF_REGEX))
-        inputRefs.add(ref);
-      for (const ref of extractMatches(userPrompt, INPUT_REF_REGEX))
-        inputRefs.add(ref);
-      for (const ref of inputRefs) {
-        errors3.push({
-          code: "AGENT_RESERVED_INPUT_REF",
-          ...localized8("agentInputRefs_reservedNamespace_message", { ref }, '"$agent.{{ref}}" is a Flow-internal agent-runtime namespace and cannot be used directly in prompts. Reference the flow variable via "$vars.{{ref}}" or "$metadata.{{ref}}" instead.'),
-          severity: "error",
-          nodeId: node.id,
-          layer: "node"
-        });
-      }
-      const mustacheVarsRefs = /* @__PURE__ */ new Set;
-      for (const ref of extractMatches(systemPrompt, VARS_REF_REGEX))
-        mustacheVarsRefs.add(ref);
-      for (const ref of extractMatches(userPrompt, VARS_REF_REGEX))
-        mustacheVarsRefs.add(ref);
-      const rootCheckRefs = new Set(mustacheVarsRefs);
-      for (const ref of extractMatches(systemPrompt, RAW_VARS_REF_REGEX))
-        rootCheckRefs.add(ref);
-      for (const ref of extractMatches(userPrompt, RAW_VARS_REF_REGEX))
-        rootCheckRefs.add(ref);
-      for (const edge of ctx.edges) {
-        if (edge.source !== node.id)
-          continue;
-        const target = nodeById.get(edge.target);
-        if (!target || !isAgentResourceNode(getNodeType2(target)))
-          continue;
-        for (const s of collectStringsDeep(target.data?.inputs ?? undefined)) {
-          for (const ref of extractMatches(s, RAW_VARS_REF_REGEX))
-            rootCheckRefs.add(ref);
-        }
-      }
-      const stripIndex = (s) => s.replace(/\[\d+\]/g, "");
-      const reportedProblems = /* @__PURE__ */ new Set;
-      const flaggedRoots = /* @__PURE__ */ new Set;
-      for (const ref of rootCheckRefs) {
-        const segments = ref.split(".");
-        const rootSegment = stripIndex(segments[0]);
-        if (rootSegment === "metadata") {
-          flaggedRoots.add(rootSegment);
-          if (reportedProblems.has("metadata"))
-            continue;
-          reportedProblems.add("metadata");
-          errors3.push({
-            code: "AGENT_RESERVED_METADATA_ROOT",
-            ...localized8("agentInputRefs_reservedMetadataRoot_message", { ref }, 'Prompt references "$vars.{{ref}}", but a variable or node named "metadata" collides with the "$metadata" namespace once serialized for the agent and cannot round-trip. Rename it to something other than "metadata".'),
-            severity: "error",
-            nodeId: node.id,
-            layer: "node"
-          });
-          continue;
-        }
-        const indexed = /\[\d+\]/.test(ref);
-        const offending = (indexed ? segments : [segments[0]]).map(stripIndex).find((s) => s.includes("__"));
-        if (offending) {
-          flaggedRoots.add(rootSegment);
-          if (reportedProblems.has(offending))
-            continue;
-          reportedProblems.add(offending);
-          errors3.push({
-            code: "AGENT_AMBIGUOUS_UNDERSCORE_ROOT",
-            ...localized8("agentInputRefs_ambiguousUnderscoreRoot_message", { ref, rootSegment: offending }, 'Prompt references "$vars.{{ref}}", but the name "{{rootSegment}}" contains "__", which is reserved as the agent-input encoding separator and cannot round-trip. Rename it to remove the double underscore.'),
-            severity: "error",
-            nodeId: node.id,
-            layer: "node"
-          });
-        }
-      }
-      if (knownRootSegments) {
-        for (const ref of mustacheVarsRefs) {
-          const rootSegment = stripIndex(ref.split(".")[0]);
-          if (flaggedRoots.has(rootSegment) || knownRootSegments.has(rootSegment))
-            continue;
-          errors3.push({
-            code: "AGENT_UNRESOLVED_VARS_REF",
-            ...localized8("agentInputRefs_unresolvedRef_message", { ref, rootSegment }, 'Prompt references "$vars.{{ref}}" but no workflow variable or node "{{rootSegment}}" exists. Add the variable/node to the flow or remove the reference.'),
-            severity: "error",
-            nodeId: node.id,
-            layer: "node"
-          });
-        }
+var JobAttachmentSchema = {
+  type: "object",
+  "x-uipath-resource-kind": "JobAttachment",
+  properties: {
+    ID: {
+      type: "string",
+      description: "Orchestrator attachment key"
+    },
+    FullName: {
+      type: "string",
+      description: "File name"
+    },
+    MimeType: {
+      type: "string",
+      description: 'The MIME type of the content, such as "application/json" or "image/png"'
+    },
+    Metadata: {
+      type: "object",
+      description: "Dictionary of metadata",
+      additionalProperties: {
+        type: "string"
       }
     }
-    return errors3;
-  }
+  },
+  required: ["ID"]
 };
-function getNodeType3(node) {
-  return node.data?.type ?? node.type ?? "";
-}
-function getToolDisplayName(node, manifest) {
-  const label = node.data?.display?.label;
-  const inputsName = node.data?.inputs?.name;
-  return typeof label === "string" && label || typeof inputsName === "string" && inputsName || manifest?.display?.label || "Tool";
-}
-function getConnectedNodeIds(nodeId, edges) {
-  const ids = /* @__PURE__ */ new Set;
-  for (const edge of edges) {
-    if (edge.source === nodeId)
-      ids.add(edge.target);
-    if (edge.target === nodeId)
-      ids.add(edge.source);
-  }
-  return ids;
-}
-function groupToolsByName(toolNodes, ctx) {
-  const nameToNodes = /* @__PURE__ */ new Map;
-  for (const toolNode of toolNodes) {
-    const version2 = toolNode.data?.typeVersion || "1.0.0";
-    const manifest = ctx.manifests.get(`${getNodeType3(toolNode)}:${version2}`);
-    const name = getToolDisplayName(toolNode, manifest);
-    const group = nameToNodes.get(name);
-    if (group) {
-      group.push(toolNode);
-    } else {
-      nameToNodes.set(name, [toolNode]);
-    }
-  }
-  return nameToNodes;
-}
-function emitDuplicateErrors(nameToNodes) {
-  const errors3 = [];
-  for (const [name, dupes] of nameToNodes) {
-    if (dupes.length <= 1)
-      continue;
-    for (const toolNode of dupes) {
-      errors3.push({
-        code: "AGENT_DUPLICATE_TOOL_NAME",
-        ...localized("agentDuplicateToolNames_duplicateName_message", { name }, 'Tool name "{{name}}" is used by multiple tools on this agent. Each tool must have a unique name.'),
-        severity: "error",
-        nodeId: toolNode.id,
-        fieldPath: "display.label",
-        layer: "node"
-      });
-    }
-  }
-  return errors3;
-}
-var agentDuplicateToolNamesRule = {
-  id: "agent-duplicate-tool-names",
-  severity: "error",
-  validate(ctx) {
-    const agentNodes = ctx.nodes.filter((n) => isAgentNodeType(getNodeType3(n)));
-    const errors3 = [];
-    for (const agentNode of agentNodes) {
-      const connectedIds = getConnectedNodeIds(agentNode.id, ctx.edges);
-      const toolNodes = ctx.nodes.filter((n) => connectedIds.has(n.id) && isAgentToolNodeType(getNodeType3(n)));
-      if (toolNodes.length === 0)
-        continue;
-      errors3.push(...emitDuplicateErrors(groupToolsByName(toolNodes, ctx)));
-    }
-    return errors3;
-  }
-};
-var HITL_NODE_TYPE = "uipath.human-in-the-loop";
-var HITL_QUICK_FORM_NODE_TYPE = "uipath.human-in-the-loop.quick-form";
-var HITL_CODED_ACTION_NODE_TYPE = "uipath.human-in-the-loop.coded-action-app";
-var HITL_DOC_VALIDATION_NODE_TYPE = "uipath.human-in-the-loop.document-validation";
-var DYNAMIC_EXTRACT_NODE_TYPE = "uipath.ixp.extract-document-builder";
-var FORM_TRIGGER_NODE_TYPE = "core.trigger.form";
-var HITL_NODE_TYPES = /* @__PURE__ */ new Set([
-  HITL_QUICK_FORM_NODE_TYPE,
-  HITL_CODED_ACTION_NODE_TYPE,
-  HITL_DOC_VALIDATION_NODE_TYPE,
-  HITL_NODE_TYPE
-]);
-function isHitlNodeType(t13) {
-  return HITL_NODE_TYPES.has(t13);
-}
-var HITL_VARS_REF = /\$?vars\.([A-Za-z_$][\w$]*)/g;
-function nodeType(node) {
-  return node.data?.type ?? node.type ?? "";
-}
-function addUpdateTargets(updates, out) {
-  if (!Array.isArray(updates))
-    return;
-  for (const update of updates) {
-    const id = update?.variableId;
-    if (typeof id === "string" && id)
-      out.add(id);
-  }
-}
-function addEndOutputTargets(node, out) {
-  const outputs = node.data?.outputs;
-  if (!isEndNodeType(nodeType(node)) || !outputs || typeof outputs !== "object")
-    return;
-  for (const [globalId, mapping] of Object.entries(outputs)) {
-    if (readStringField(mapping?.source).trim() !== "")
-      out.add(globalId);
-  }
-}
-function addHitlMapTargets(node, out) {
-  if (!isHitlNodeType(nodeType(node)))
-    return;
-  const variableMap = node.data?.inputs?.variableMap;
-  if (!variableMap || typeof variableMap !== "object")
-    return;
-  for (const expression of Object.values(variableMap)) {
-    if (typeof expression !== "string")
-      continue;
-    HITL_VARS_REF.lastIndex = 0;
-    let match;
-    while ((match = HITL_VARS_REF.exec(expression)) !== null)
-      out.add(match[1]);
-  }
-}
-function collectWrittenGlobalIds(nodes, workflowVariables) {
-  const written = /* @__PURE__ */ new Set;
-  const unsupportedNodeIds = new Set(nodes.filter((node) => !supportsVariableUpdates(nodeType(node))).map((node) => node.id));
-  for (const [nodeId, updates] of Object.entries(workflowVariables?.variableUpdates ?? {})) {
-    if (unsupportedNodeIds.has(nodeId))
-      continue;
-    addUpdateTargets(updates, written);
-  }
-  for (const node of nodes) {
-    if (supportsVariableUpdates(nodeType(node)))
-      addUpdateTargets(node.data?.variableUpdates, written);
-    addEndOutputTargets(node, written);
-    addHitlMapTargets(node, written);
-  }
-  return written;
-}
-var VARS_REF = /\$vars\.([A-Za-z_$][\w$]*)/g;
-function getNodeType4(node) {
-  return node.data?.type ?? node.type ?? "";
-}
-function collectStrings(value, out) {
-  if (typeof value === "string") {
-    out.push(value);
-  } else if (Array.isArray(value)) {
-    for (const v of value)
-      collectStrings(v, out);
-  } else if (value && typeof value === "object") {
-    for (const v of Object.values(value))
-      collectStrings(v, out);
-  }
-}
-function collectBindingStrings(value, out) {
-  if (value == null)
-    return;
-  if (typeof value === "string") {
-    if (value.includes("{{"))
-      out.push(value);
-  } else if (isExpressionValue(value)) {
-    out.push(value.expression);
-  } else if (Array.isArray(value)) {
-    for (const v of value)
-      collectBindingStrings(v, out);
-  } else if (typeof value === "object") {
-    for (const v of Object.values(value))
-      collectBindingStrings(v, out);
-  }
-}
-var agentEmptyVarRule = {
-  id: "agent-empty-var",
-  severity: "warning",
-  validate(ctx) {
-    const orphanIds = collectOrphanGlobalIds(ctx);
-    if (orphanIds.size === 0)
-      return [];
-    const errors3 = [];
-    for (const agent of ctx.nodes.filter((n) => isAgentNodeType(getNodeType4(n)))) {
-      errors3.push(...emitEmptyVarWarnings(agent, collectAgentScanStrings(agent, ctx), orphanIds));
-    }
-    return errors3;
-  }
-};
-function collectOrphanGlobalIds(ctx) {
-  const globals = ctx.workflowVariables?.globals ?? [];
-  if (globals.length === 0)
-    return /* @__PURE__ */ new Set;
-  const written = collectWrittenGlobalIds(ctx.nodes, ctx.workflowVariables);
-  return new Set(globals.filter((g) => g.direction !== "in" && g.defaultValue === undefined && !written.has(g.id)).map((g) => g.id));
-}
-function collectAgentScanStrings(agent, ctx) {
-  const strings = [];
-  const inputs = agent.data?.inputs;
-  if (inputs) {
-    collectStrings(inputs.systemPrompt, strings);
-    collectStrings(inputs.userPrompt, strings);
-  }
-  const neighbourIds = /* @__PURE__ */ new Set;
-  for (const e of ctx.edges) {
-    if (e.source === agent.id && e.target)
-      neighbourIds.add(e.target);
-    else if (e.target === agent.id && e.source)
-      neighbourIds.add(e.source);
-  }
-  for (const n of ctx.nodes) {
-    if (!neighbourIds.has(n.id) || !isAgentResourceNodeType(getNodeType4(n)))
-      continue;
-    collectBindingStrings(n.data?.inputs, strings);
-  }
-  return strings;
-}
-function emitEmptyVarWarnings(agent, strings, orphanIds) {
-  const errors3 = [];
-  const flagged = /* @__PURE__ */ new Set;
-  for (const s of strings) {
-    VARS_REF.lastIndex = 0;
-    let match;
-    while ((match = VARS_REF.exec(s)) !== null) {
-      const root = match[1];
-      if (!orphanIds.has(root) || flagged.has(root))
-        continue;
-      flagged.add(root);
-      errors3.push({
-        code: "AGENT_INPUT_EMPTY_VAR",
-        ...localized("agentEmptyVar_unwrittenVariable_message", { root }, `Agent uses "$vars.{{root}}" but no node assigns a value to "{{root}}", so it will be empty at runtime. Bind it to a node output (e.g. a connector's "<node>.output") or give it a value source.`),
-        severity: "warning",
-        nodeId: agent.id,
-        layer: "field"
-      });
-    }
-  }
-  return errors3;
-}
-var VARS_REF_REGEX2 = /\$vars\.([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)/g;
-function pathExistsOnOutputSchema(schema, segments) {
-  let cursor = schema;
-  for (let i = 0;i < segments.length; i++) {
-    const seg = segments[i];
-    if (cursor == null) {
-      return { valid: true };
-    }
-    if (typeof cursor !== "object") {
-      return { valid: false, missingSegment: seg, matchedDepth: i };
-    }
-    const obj = cursor;
-    let propsContainer;
-    let additionalProps;
-    const inlineProps = obj.properties;
-    if (inlineProps && typeof inlineProps === "object") {
-      propsContainer = inlineProps;
-      additionalProps = obj.additionalProperties;
-    } else if (obj.schema && typeof obj.schema === "object") {
-      const schemaObj = obj.schema;
-      const wrappedProps = schemaObj.properties;
-      if (wrappedProps && typeof wrappedProps === "object") {
-        propsContainer = wrappedProps;
-        additionalProps = schemaObj.additionalProperties;
-      }
-    }
-    if (!propsContainer) {
-      const declaredType = obj.type;
-      if (typeof declaredType === "string" && declaredType !== "object" && declaredType !== "array" && !obj.items) {
-        return { valid: false, missingSegment: seg, matchedDepth: i };
-      }
-      return { valid: true };
-    }
-    const next = propsContainer[seg];
-    if (next === undefined) {
-      if (additionalProps === false) {
-        return { valid: false, missingSegment: seg, matchedDepth: i };
+var ANALYZE_FILES_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachments: {
+        type: "array",
+        items: JobAttachmentSchema,
+        description: "Array of files, documents, images, or other attachments to process"
+      },
+      analysisTask: {
+        type: "string",
+        description: "The task, question, or instruction for processing the files (e.g., 'summarize this document', 'extract key points', 'what is in this image')"
       }
-      return { valid: true };
-    }
-    cursor = next;
-  }
-  return { valid: true };
-}
-function* iterateJsExpressionBodies(value, pathPrefix) {
-  const body = getJsExpressionBody(value);
-  if (body !== undefined) {
-    yield { body, path: pathPrefix };
-    return;
-  }
-  if (isExpressionValue(value) || typeof value === "string")
-    return;
-  if (Array.isArray(value)) {
-    for (let i = 0;i < value.length; i++) {
-      yield* iterateJsExpressionBodies(value[i], `${pathPrefix}[${i}]`);
-    }
-  } else if (value && typeof value === "object") {
-    for (const [k, v] of Object.entries(value)) {
-      yield* iterateJsExpressionBodies(v, pathPrefix ? `${pathPrefix}.${k}` : k);
-    }
-  }
-}
-var expressionRefRule = {
-  id: "expression-ref",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    const knownRoots = /* @__PURE__ */ new Set;
-    for (const id of ctx.workflowVariableIds ?? [])
-      knownRoots.add(id);
-    const nodeIds = /* @__PURE__ */ new Set;
-    const nodesById = /* @__PURE__ */ new Map;
-    for (const node of ctx.nodes) {
-      knownRoots.add(node.id);
-      nodeIds.add(node.id);
-      nodesById.set(node.id, node);
-    }
-    const hasWorkflowVarsContext = ctx.workflowVariableIds !== undefined;
-    if (knownRoots.size === 0)
-      return errors3;
-    for (const node of ctx.nodes) {
-      const inputs = node.data?.inputs;
-      if (inputs == null || typeof inputs !== "object")
-        continue;
-      const nodeLabel = getNodeLabel(node, getManifestForNode(node, ctx.manifests));
-      for (const { body, path: fieldPath } of iterateJsExpressionBodies(inputs, "inputs")) {
-        VARS_REF_REGEX2.lastIndex = 0;
-        const seenInThisExpr = /* @__PURE__ */ new Set;
-        let match;
-        while ((match = VARS_REF_REGEX2.exec(body)) !== null) {
-          const fullRef = match[1];
-          if (seenInThisExpr.has(fullRef))
-            continue;
-          seenInThisExpr.add(fullRef);
-          const segments = fullRef.split(".");
-          const rootSegment = segments[0];
-          if (!knownRoots.has(rootSegment)) {
-            if (!hasWorkflowVarsContext)
-              continue;
-            errors3.push({
-              code: "EXPR_UNRESOLVED_REF",
-              message: `Expression in "${nodeLabel}" references "$vars.${rootSegment}" but no workflow variable or node "${rootSegment}" exists. Add the variable/node to the flow or remove the reference.`,
-              severity: "error",
-              nodeId: node.id,
-              fieldPath,
-              layer: "field"
-            });
-            continue;
-          }
-          if (!nodeIds.has(rootSegment) || segments.length < 2)
-            continue;
-          const producerNode = nodesById.get(rootSegment);
-          if (!producerNode)
-            continue;
-          const producerManifest = getManifestForNode(producerNode, ctx.manifests);
-          const outputDef = producerManifest?.outputDefinition;
-          if (!outputDef || typeof outputDef !== "object")
-            continue;
-          const outputVarName = segments[1];
-          const outputSchema = outputDef[outputVarName];
-          if (outputSchema === undefined) {
-            const available = Object.keys(outputDef);
-            errors3.push({
-              code: "EXPR_INVALID_OUTPUT_PATH",
-              message: `Expression in "${nodeLabel}" references "$vars.${fullRef}" but node "${rootSegment}" has no output named "${outputVarName}". Available outputs: ${available.length > 0 ? available.join(", ") : "(none)"}.`,
-              severity: "error",
-              nodeId: node.id,
-              fieldPath,
-              layer: "field"
-            });
-            continue;
-          }
-          if (segments.length < 3)
-            continue;
-          const deepPath = segments.slice(2);
-          const result = pathExistsOnOutputSchema(outputSchema, deepPath);
-          if (!result.valid) {
-            const matchedSoFar = [outputVarName, ...deepPath.slice(0, result.matchedDepth ?? 0)].join(".");
-            errors3.push({
-              code: "EXPR_INVALID_OUTPUT_PATH",
-              message: `Expression in "${nodeLabel}" references "$vars.${fullRef}" but field "${result.missingSegment}" is not declared on node "${rootSegment}"'s output schema (matched up to "${matchedSoFar}").`,
-              severity: "error",
-              nodeId: node.id,
-              fieldPath,
-              layer: "field"
-            });
-          }
-        }
+    },
+    required: ["attachments", "analysisTask"]
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      analysis: {
+        type: "string",
+        description: "Analysis result of the attachments (analysis, summary, extracted information, etc.)"
       }
-    }
-    return errors3;
-  }
-};
-var conversationalRequiredFieldsRule = {
-  id: "conversational-required-fields",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      if (!isConversationalAgentNode(node))
-        continue;
-      const inputs = node.data.inputs ?? {};
-      if (isVoiceAgentNodeType(node.type))
-        continue;
-      const settings = inputs.conversationalAgentSettings ?? {};
-      const isEmpty = readStringField(settings.conversationId).trim() === "";
-      if (!isEmpty)
-        continue;
-      const manifest = getManifestForNode(node, ctx.manifests);
-      const label = getNodeLabel(node, manifest);
-      errors3.push({
-        code: "CONVERSATIONAL_CONVERSATION_ID_REQUIRED",
-        message: `${label}: Conversation ID is required`,
-        severity: "error",
-        nodeId: node.id,
-        fieldPath: "inputs.conversationalAgentSettings.conversationId",
-        layer: "node"
-      });
-    }
-    return errors3;
+    },
+    required: ["analysis"]
   }
 };
-var conversationalVoiceCallContextRule = {
-  id: "conversational-voice-call-context",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      const inputs = node.data.inputs ?? {};
-      if (!isVoiceAgentNodeType(node.type))
-        continue;
-      const manifest = getManifestForNode(node, ctx.manifests);
-      const label = getNodeLabel(node, manifest);
-      if (isCallContextEmpty(inputs.callContext)) {
-        errors3.push({
-          code: "CONVERSATIONAL_VOICE_CALL_CONTEXT_REQUIRED",
-          ...localized("conversationalVoice_callContextRequired_message", { label }, "{{label}}: Call context is required when voice is enabled"),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.callContext",
-          layer: "node"
-        });
-        continue;
+var SUMMARIZE_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachment: {
+        type: "object",
+        title: "Source",
+        description: "File or document to summarize",
+        properties: JobAttachmentSchema.properties,
+        required: JobAttachmentSchema.required
       }
-      if (!isValidCallContextBinding(inputs.callContext)) {
-        errors3.push({
-          code: "CONVERSATIONAL_VOICE_CALL_CONTEXT_INVALID",
-          ...localized("conversationalVoice_callContextInvalid_message", { label }, "{{label}}: Call context must be bound to a call context object"),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.callContext",
-          layer: "node"
-        });
+    },
+    required: ["attachment"]
+  },
+  outputSchema: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The content of the analyzed attachment"
+        }
       }
     }
-    return errors3;
   }
 };
-var conversationalVoiceEndCallContextRule = {
-  id: "conversational-voice-end-call-context",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      if (node.type !== CONVERSATIONAL_VOICE_END_CALL_NODE_TYPE)
-        continue;
-      const manifest = getManifestForNode(node, ctx.manifests);
-      if (!manifest || !manifestExposesCallContext(manifest))
-        continue;
-      const inputs = node.data.inputs ?? {};
-      if (isValidCallContextBinding(inputs.callContext))
-        continue;
-      const label = getNodeLabel(node, manifest);
-      errors3.push({
-        code: "CONVERSATIONAL_VOICE_END_CALL_CONTEXT_INVALID",
-        ...localized("conversationalVoiceEndCall_callContextInvalid_message", { label }, "{{label}}: Call context must be bound to a call context object"),
-        severity: "error",
-        nodeId: node.id,
-        fieldPath: "inputs.callContext",
-        layer: "node"
-      });
-    }
-    return errors3;
-  }
-};
-var agentOutputRequiredRule = {
-  id: "agent-output-required",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      if (!isAutonomousAgentNodeType(node.type))
-        continue;
-      const inputs = node.data.inputs ?? {};
-      const outputs = inputs.agentOutputVariables;
-      if (Array.isArray(outputs) && outputs.length > 0)
-        continue;
-      const manifest = getManifestForNode(node, ctx.manifests);
-      const label = getNodeLabel(node, manifest);
-      errors3.push({
-        code: "AGENT_OUTPUT_REQUIRED",
-        message: `${label}: Agent must define at least one output variable`,
-        severity: "error",
-        nodeId: node.id,
-        fieldPath: "inputs.agentOutputVariables",
-        layer: "node"
-      });
-    }
-    return errors3;
-  }
-};
-var t10 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized9(key, params, defaultValue) {
-  return {
-    message: t10(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
-}
-var hitlQuickFormRule = {
-  id: "hitl-quick-form",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      const nodeType2 = node.data?.type ?? node.type ?? "";
-      if (nodeType2 !== HITL_QUICK_FORM_NODE_TYPE && nodeType2 !== FORM_TRIGGER_NODE_TYPE)
-        continue;
-      const inputs = node.data?.inputs;
-      const schema = inputs?.schema;
-      const fields = Array.isArray(schema?.fields) ? schema.fields : [];
-      if (fields.length === 0) {
-        errors3.push({
-          code: "HITL_QUICK_FORM_EMPTY_SCHEMA",
-          ...localized9("hitlQuickForm_emptySchema_message", {}, "Add at least one field"),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.schema",
-          layer: "field"
-        });
-        continue;
+var BATCH_TRANSFORM_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachment: {
+        type: "object",
+        title: "Source",
+        description: "CSV file to transform",
+        properties: JobAttachmentSchema.properties,
+        required: JobAttachmentSchema.required
       }
-      fields.forEach((field, index) => {
-        const label = field && typeof field === "object" && !Array.isArray(field) ? field.label : undefined;
-        if (!readStringField(label).trim()) {
-          errors3.push({
-            code: "HITL_QUICK_FORM_FIELD_LABEL_REQUIRED",
-            ...localized9("hitlQuickForm_fieldLabelRequired_message", {}, "Field label is required"),
-            severity: "error",
-            nodeId: node.id,
-            fieldPath: `inputs.schema.fields[${index}].label`,
-            layer: "field"
-          });
+    },
+    required: ["attachment"]
+  },
+  outputSchema: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The content of the transformed row"
         }
-      });
+      }
     }
-    return errors3;
   }
 };
-var hitlCompletedRule = {
-  id: "hitl-completed",
-  severity: "warning",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      const nodeType2 = node.data?.type ?? node.type ?? "";
-      if (!isHitlNodeType(nodeType2))
-        continue;
-      const hasOutgoingEdge = ctx.edges.some((e) => e.source === node.id && (e.sourceHandle === "completed" || e.sourceHandle?.startsWith("outcome-")));
-      if (hasOutgoingEdge)
-        continue;
-      errors3.push({
-        code: "HITL_COMPLETED_UNWIRED",
-        message: `HITL node "${node.id}" has no outgoing edge. The runtime stalls indefinitely if no outcome is wired.`,
-        severity: "warning",
-        nodeId: node.id,
-        fieldPath: "handles",
-        layer: "node"
-      });
+var nameValuePairSchema = (nameDescription, valueDescription) => ({
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
+      description: nameDescription
+    },
+    value: {
+      type: "string",
+      description: valueDescription
     }
-    return errors3;
-  }
-};
-var t11 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized10(key, defaultValue) {
-  return {
-    message: t11(key, { defaultValue }),
-    i18n: { key, params: {}, ns: VALIDATION_NAMESPACE }
-  };
-}
-var CUSTOM_RENDER_TYPE = "custom";
-var hitlDocValidationRule = {
-  id: "hitl-doc-validation",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      const nodeType2 = node.data?.type ?? node.type ?? "";
-      if (nodeType2 !== HITL_DOC_VALIDATION_NODE_TYPE)
-        continue;
-      const inputs = node.data?.inputs;
-      const renderType = inputs?.["validationRenderType"];
-      const extractionResult = readStringField(inputs?.["extractionResult"]).trim();
-      if (!extractionResult) {
-        errors3.push({
-          code: "HITL_DOC_VALIDATION_EXTRACTION_RESULT_REQUIRED",
-          ...localized10("hitlDocValidation_extractionResultRequired_message", "Extraction result is required"),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.extractionResult",
-          layer: "field"
-        });
-      }
-      if (renderType === CUSTOM_RENDER_TYPE) {
-        const taxonomy = readStringField(inputs?.["taxonomy"]).trim();
-        if (!taxonomy) {
-          errors3.push({
-            code: "HITL_DOC_VALIDATION_TAXONOMY_REQUIRED",
-            ...localized10("hitlDocValidation_taxonomyRequired_message", "Taxonomy is required when using a custom app"),
-            severity: "error",
-            nodeId: node.id,
-            fieldPath: "inputs.taxonomy",
-            layer: "field"
-          });
-        }
+  },
+  required: ["name", "value"]
+});
+var HTTP_REQUEST_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The absolute URL to send the request to."
+      },
+      method: {
+        type: "string",
+        description: "HTTP method to use, one of: GET, POST, PUT, PATCH, DELETE."
+      },
+      headers: {
+        type: "array",
+        description: "Request headers as a list of name/value pairs.",
+        items: nameValuePairSchema("Header name.", "Header value.")
+      },
+      params: {
+        type: "array",
+        description: "Query-string parameters as a list of name/value pairs.",
+        items: nameValuePairSchema("Parameter name.", "Parameter value.")
+      },
+      body: {
+        type: "string",
+        description: "Request body sent as-is. Provide JSON as a string and set a Content-Type header if the endpoint expects JSON."
+      },
+      timeout: {
+        type: "number",
+        description: "Request timeout in seconds."
       }
-    }
-    return errors3;
-  }
-};
-var IXP_SCHEMA_EDITOR_DRAFT_EXTENSION = "x-uipath-schema-editor-draft";
-var IXP_SCHEMA_EDITOR_ISSUES_EXTENSION = "x-uipath-schema-editor-issues";
-var IXP_SCHEMA_INVALID_ERROR_CODE = "IXP_SCHEMA_INVALID";
-function asRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function readIxpSchemaEditorDraft(value) {
-  const schema = asRecord(value);
-  if (!schema || !Object.hasOwn(schema, IXP_SCHEMA_EDITOR_DRAFT_EXTENSION)) {
-    return;
-  }
-  const rawIssues = schema[IXP_SCHEMA_EDITOR_ISSUES_EXTENSION];
-  const issues = Array.isArray(rawIssues) ? rawIssues : [];
-  const issueMessages = issues.flatMap((issue2) => {
-    const message = asRecord(issue2)?.message;
-    return typeof message === "string" && message.trim().length > 0 ? [message.trim()] : [];
-  });
-  return {
-    draft: schema[IXP_SCHEMA_EDITOR_DRAFT_EXTENSION],
-    issues,
-    issueMessages
-  };
-}
-function createSchemaDraftError(node, nodeLabel, detail) {
-  const localization = detail ? localized("ixpSchemaDraft_invalidWithDetail_message", { nodeLabel, detail }, 'Schema is not valid on "{{nodeLabel}}": {{detail}}') : localized("ixpSchemaDraft_invalid_message", { nodeLabel }, 'Schema is not valid on "{{nodeLabel}}".');
-  return {
-    code: IXP_SCHEMA_INVALID_ERROR_CODE,
-    ...localization,
-    severity: "error",
-    nodeId: node.id,
-    nodeLabel,
-    layer: "node"
-  };
-}
-function validateNodeSchemaDraft(node, ctx) {
-  const nodeType2 = node.data?.type ?? node.type ?? "";
-  if (nodeType2 !== DYNAMIC_EXTRACT_NODE_TYPE)
-    return [];
-  const inputs = node.data?.inputs;
-  const editorDraft = readIxpSchemaEditorDraft(inputs?.schemaDocument);
-  if (!editorDraft)
-    return [];
-  const manifest = getManifestForNode(node, ctx.manifests);
-  const nodeLabel = getNodeLabel(node, manifest);
-  const details = editorDraft.issueMessages.length > 0 ? editorDraft.issueMessages : [undefined];
-  return details.map((detail) => createSchemaDraftError(node, nodeLabel, detail));
-}
-var ixpSchemaDraftRule = {
-  id: "ixp-schema-draft",
-  severity: "error",
-  validate(ctx) {
-    return ctx.nodes.flatMap((node) => validateNodeSchemaDraft(node, ctx));
+    },
+    required: ["url"]
+  },
+  outputSchema: {
+    type: "object",
+    properties: {}
   }
 };
-var SCRIPT_NODE_TYPES = /* @__PURE__ */ new Set(["core.action.script"]);
-var scriptMustacheRule = {
-  id: "script-mustache",
-  severity: "warning",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      const inputs = node.data.inputs ?? {};
-      let fieldPath;
-      if (SCRIPT_NODE_TYPES.has(node.type)) {
-        if (hasMustacheInterpolation(readStringField(inputs.script))) {
-          fieldPath = "inputs.script";
-        }
-      } else if (TRANSFORM_NODE_TYPES.has(node.type)) {
-        const operations = Array.isArray(inputs.operations) ? inputs.operations : [];
-        if (operations.some((op) => op?.type === "customScript" && hasMustacheInterpolation(readStringField(op.config?.script)))) {
-          fieldPath = "inputs.operations";
-        }
-      }
-      if (fieldPath) {
-        errors3.push({
-          code: "SCRIPT_MUSTACHE_SYNTAX",
-          ...localized("scriptBody_mustache_message", {}, "Reference variables directly without double braces"),
-          severity: "warning",
-          nodeId: node.id,
-          fieldPath,
-          layer: "field"
-        });
-      }
-    }
-    return errors3;
-  }
+var BUILT_IN_TOOL_SCHEMAS = {
+  "uipath.agent.resource.tool.builtin.analyzefiles": ANALYZE_FILES_SCHEMA,
+  "uipath.agent.resource.tool.builtin.summarize": SUMMARIZE_SCHEMA,
+  "uipath.agent.resource.tool.builtin.batchtransform": BATCH_TRANSFORM_SCHEMA,
+  "uipath.agent.resource.tool.builtin.httprequest": HTTP_REQUEST_SCHEMA
 };
-function getNodeType5(node) {
-  return node.data?.type ?? node.type ?? "";
+var FILE_SCHEMA_FIELDS = Object.keys(JobAttachmentSchema.properties ?? {});
+function isFileShapedInputNode(node) {
+  if (!node || typeof node !== "object")
+    return false;
+  const n = node;
+  if (n["x-uipath-resource-kind"] === "JobAttachment")
+    return true;
+  if (typeof n.$ref === "string" && n.$ref.toLowerCase().includes("job-attachment"))
+    return true;
+  if (n.type === "file" || n.type === "octet-stream")
+    return true;
+  if (n.properties && FILE_SCHEMA_FIELDS.every((field) => (field in n.properties)))
+    return true;
+  return isFileShapedInputNode(n.items);
 }
-var singleConversationTriggerRule = {
-  id: "single-conversation-trigger",
-  severity: "error",
-  validate(ctx) {
-    const triggers = ctx.nodes.filter((n) => getNodeType5(n) === "core.trigger.conversation");
-    if (triggers.length <= 1)
-      return [];
-    return triggers.map((node) => ({
-      code: "SINGLE_CONVERSATION_TRIGGER",
-      ...localized("singleConversationTrigger_message", {}, "Only one conversation trigger is allowed per process. Remove the extra trigger."),
-      severity: "error",
-      nodeId: node.id,
-      layer: "node"
-    }));
-  }
-};
-var t12 = instance.getFixedT(null, VALIDATION_NAMESPACE);
-function localized11(key, params, defaultValue) {
-  return {
-    message: t12(key, { ...params, defaultValue }),
-    i18n: { key, params, ns: VALIDATION_NAMESPACE }
-  };
+function schemaAcceptsFileInput(inputSchema) {
+  const properties = inputSchema?.properties;
+  if (!properties)
+    return false;
+  return Object.values(properties).some(isFileShapedInputNode);
 }
-var doWhileLimitRule = {
-  id: "dowhile-limit",
-  severity: "error",
-  validate(ctx) {
-    const errors3 = [];
-    for (const node of ctx.nodes) {
-      const nodeType2 = node.data?.type ?? node.type ?? "";
-      if (nodeType2 !== DOWHILE_NODE_TYPE)
-        continue;
-      const inputs = node.data?.inputs;
-      const limit = parseDoWhileLimit(inputs?.limit);
-      if (limit === undefined)
-        continue;
-      if (!Number.isInteger(limit) || limit < DOWHILE_MIN_LIMIT || limit > DOWHILE_MAX_LIMIT) {
-        errors3.push({
-          code: "DOWHILE_LIMIT_OUT_OF_RANGE",
-          ...localized11("doWhile_limitOutOfRange_message", { min: DOWHILE_MIN_LIMIT, max: DOWHILE_MAX_LIMIT }, `Set maximum iterations between ${DOWHILE_MIN_LIMIT} and ${DOWHILE_MAX_LIMIT}`),
-          severity: "error",
-          nodeId: node.id,
-          fieldPath: "inputs.limit",
-          layer: "field"
-        });
-      }
-    }
-    return errors3;
-  }
-};
-var generalRules = [
-  schemaValidationRule,
-  minConnectionsRule,
-  triggerRequiredRule,
-  outputMappingRule,
-  dataTransformRule,
-  governanceRule,
-  escalationValidationRule,
-  agentInputRefsRule,
-  agentDuplicateToolNamesRule,
-  agentEmptyVarRule,
-  conversationalRequiredFieldsRule,
-  conversationalVoiceCallContextRule,
-  conversationalVoiceEndCallContextRule,
-  agentOutputRequiredRule,
-  hitlQuickFormRule,
-  hitlCompletedRule,
-  hitlDocValidationRule,
-  ixpSchemaDraftRule,
-  scriptMustacheRule,
-  singleConversationTriggerRule,
-  doWhileLimitRule
-];
-var cliRules = [...generalRules, expressionRefRule];
+var FILE_CAPABLE_BUILTIN_TOOL_TYPES = new Set(Object.entries(BUILT_IN_TOOL_SCHEMAS).filter(([, schemas3]) => schemaAcceptsFileInput(schemas3.inputSchema)).map(([nodeType2]) => nodeType2));
+var t10 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t11 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t12 = instance.getFixedT(null, VALIDATION_NAMESPACE);
 
 // ../../node_modules/@uipath/flow-schema/dist/index.js
 var import_object = __toESM(require_index_cjs(), 1);
@@ -33936,6 +32065,7 @@ var nodeSchema2 = nodeSchema.extend({
   typeVersion: exports_external.string().regex(/^\d+\.\d+(\.\d+)?$/, 'Version must be in format "x.y" or "x.y.z"')
 });
 var nodeManifestSchema2 = exports_external.lazy(() => nodeManifestSchema.extend({
+  display: nodeDisplayManifestSchema.extend({ isPreview: exports_external.boolean().optional() }),
   projectId: exports_external.string().optional(),
   entryPointPath: exports_external.string().optional(),
   unsupportedRuntime: exports_external.boolean().optional(),
@@ -34160,6 +32290,8 @@ var CRON_TOKEN = "(?:\\d+[LW]?|[A-Z]{3}|LW|L|W|\\?|\\*)";
 var CRON_FIELD = `${CRON_TOKEN}(?:[,/#-]${CRON_TOKEN})*`;
 var QUARTZ_CRON_RE = new RegExp(`^\\s*${CRON_FIELD}(?:\\s+${CRON_FIELD}){5,6}\\s*$`);
 var FORM_TRIGGER_RESOURCE = "FormTrigger";
+var JOB_ATTACHMENT_DEFINITION_KEY = "job-attachment";
+var JOB_ATTACHMENT_REF = `#/definitions/${JOB_ATTACHMENT_DEFINITION_KEY}`;
 var mergeBindingResources = (resources) => {
   const seen = /* @__PURE__ */ new Map;
   const result = [];
@@ -34215,138 +32347,6 @@ var DEFAULT_CONVERSATIONAL_VOICE_SETTINGS = {
   persona: DEFAULT_CONVERSATIONAL_VOICE_MODEL_ENTRY.personas[0],
   agentSpeaksFirst: DEFAULT_VOICE_AGENT_SPEAKS_FIRST
 };
-var JobAttachmentSchema = {
-  type: "object",
-  "x-uipath-resource-kind": "JobAttachment",
-  properties: {
-    ID: {
-      type: "string",
-      description: "Orchestrator attachment key"
-    },
-    FullName: {
-      type: "string",
-      description: "File name"
-    },
-    MimeType: {
-      type: "string",
-      description: 'The MIME type of the content, such as "application/json" or "image/png"'
-    },
-    Metadata: {
-      type: "object",
-      description: "Dictionary of metadata",
-      additionalProperties: {
-        type: "string"
-      }
-    }
-  },
-  required: ["ID"]
-};
-var SUMMARIZE_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      attachment: {
-        type: "object",
-        title: "Source",
-        description: "File or document to summarize",
-        properties: JobAttachmentSchema.properties,
-        required: JobAttachmentSchema.required
-      }
-    },
-    required: ["attachment"]
-  },
-  outputSchema: {
-    type: "array",
-    items: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "The content of the analyzed attachment"
-        }
-      }
-    }
-  }
-};
-var BATCH_TRANSFORM_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      attachment: {
-        type: "object",
-        title: "Source",
-        description: "CSV file to transform",
-        properties: JobAttachmentSchema.properties,
-        required: JobAttachmentSchema.required
-      }
-    },
-    required: ["attachment"]
-  },
-  outputSchema: {
-    type: "array",
-    items: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "The content of the transformed row"
-        }
-      }
-    }
-  }
-};
-var nameValuePairSchema = (nameDescription, valueDescription) => ({
-  type: "object",
-  properties: {
-    name: {
-      type: "string",
-      description: nameDescription
-    },
-    value: {
-      type: "string",
-      description: valueDescription
-    }
-  },
-  required: ["name", "value"]
-});
-var HTTP_REQUEST_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description: "The absolute URL to send the request to."
-      },
-      method: {
-        type: "string",
-        description: "HTTP method to use, one of: GET, POST, PUT, PATCH, DELETE."
-      },
-      headers: {
-        type: "array",
-        description: "Request headers as a list of name/value pairs.",
-        items: nameValuePairSchema("Header name.", "Header value.")
-      },
-      params: {
-        type: "array",
-        description: "Query-string parameters as a list of name/value pairs.",
-        items: nameValuePairSchema("Parameter name.", "Parameter value.")
-      },
-      body: {
-        type: "string",
-        description: "Request body sent as-is. Provide JSON as a string and set a Content-Type header if the endpoint expects JSON."
-      },
-      timeout: {
-        type: "number",
-        description: "Request timeout in seconds."
-      }
-    },
-    required: ["url"]
-  },
-  outputSchema: {
-    type: "object",
-    properties: {}
-  }
-};
 
 // ../../node_modules/@uipath/tool-agent/dist/agent-bindings.js
 function generateBindings2(agent, resources, features) {
@@ -35285,7 +33285,7 @@ class TextApiResponse {
 var package_default3 = {
   name: "@uipath/integrationservice-sdk",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0",
+  version: "1.202.1-preview.168",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -43106,6 +41106,21 @@ var KNOWN_CATEGORIES = [
   "code",
   "general"
 ];
+var GRADES = [
+  "A+",
+  "A",
+  "A-",
+  "B+",
+  "B",
+  "B-",
+  "C+",
+  "C",
+  "C-",
+  "D+",
+  "D",
+  "D-",
+  "F"
+];
 function listCategories() {
   return [...KNOWN_CATEGORIES];
 }
@@ -44960,6 +42975,116 @@ function buildInvalidAgentJsonIssue(loaded) {
     suggestedFix: "Verify agent.json exists and is valid, properly encoded JSON."
   };
 }
+var REVIEW_HISTORY_FILE = "review-history.json";
+var MAX_REVIEW_HISTORY_ENTRIES = 25;
+var isGrade = (value) => typeof value === "string" && GRADES.includes(value);
+var validateEntry = (entry, index) => {
+  if (typeof entry !== "object" || entry === null) {
+    return `[${index}]: expected an object`;
+  }
+  const { grade, runAt, errors: errors3, warnings } = entry;
+  if (!isGrade(grade)) {
+    return `[${index}].grade: expected one of ${GRADES.join(", ")}`;
+  }
+  if (typeof runAt !== "string") {
+    return `[${index}].runAt: expected a string`;
+  }
+  for (const [name, count] of [
+    ["errors", errors3],
+    ["warnings", warnings]
+  ]) {
+    if (count !== undefined && typeof count !== "number") {
+      return `[${index}].${name}: expected a number`;
+    }
+  }
+  return;
+};
+var parseHistory = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return { success: false, error: `invalid JSON: ${message}` };
+  }
+  if (!Array.isArray(parsed)) {
+    return { success: false, error: "expected a JSON array of entries" };
+  }
+  for (const [index, entry] of parsed.entries()) {
+    const error51 = validateEntry(entry, index);
+    if (error51 !== undefined) {
+      return { success: false, error: error51 };
+    }
+  }
+  return { success: true, data: parsed };
+};
+var parseRunAt = (entry) => {
+  const time3 = Date.parse(entry.runAt);
+  return Number.isNaN(time3) ? Number.NEGATIVE_INFINITY : time3;
+};
+var writeAtomically = async (file2, content, fs7) => {
+  const tempFile = `${file2}.${globalThis.crypto.randomUUID()}.tmp`;
+  try {
+    await fs7.writeFile(tempFile, content);
+    await fs7.rename(tempFile, file2);
+  } catch (err2) {
+    await fs7.rm(tempFile).catch(() => {
+      return;
+    });
+    throw err2;
+  }
+};
+var appendEntry = async (file2, grade, input, fs7) => {
+  let history = [];
+  const raw = await fs7.readFile(file2, "utf-8");
+  if (raw !== null) {
+    const parsed = parseHistory(raw);
+    if (!parsed.success) {
+      return {
+        ok: false,
+        error: "MALFORMED_HISTORY",
+        file: file2,
+        detail: parsed.error
+      };
+    }
+    history = parsed.data;
+  }
+  const entry = {
+    grade,
+    runAt: new Date().toISOString(),
+    ...input.errors !== undefined && { errors: input.errors },
+    ...input.warnings !== undefined && { warnings: input.warnings }
+  };
+  const newTime = Date.parse(entry.runAt);
+  let index = 0;
+  while (index < history.length && parseRunAt(history[index]) > newTime) {
+    index++;
+  }
+  history.splice(index, 0, entry);
+  if (history.length > MAX_REVIEW_HISTORY_ENTRIES) {
+    history.length = MAX_REVIEW_HISTORY_ENTRIES;
+  }
+  await writeAtomically(file2, `${JSON.stringify(history, null, 2)}
+`, fs7);
+  return { ok: true, entry, history };
+};
+var recordReview = async (projectPath, input, fs7) => {
+  const grade = input.grade.toUpperCase();
+  if (!isGrade(grade)) {
+    return { ok: false, error: "INVALID_GRADE", allowed: GRADES };
+  }
+  const stats = await fs7.stat(projectPath);
+  if (!stats?.isDirectory()) {
+    return { ok: false, error: "NOT_A_DIRECTORY", projectPath };
+  }
+  const file2 = fs7.path.join(projectPath, REVIEW_HISTORY_FILE);
+  const release = await fs7.acquireLock(file2);
+  try {
+    return await appendEntry(file2, grade, input, fs7);
+  } finally {
+    await release();
+  }
+};
 
 // src/services/guardrail-catalog-service.ts
 var LLM_AS_JUDGE_VALIDATOR = "llm_as_judge";
@@ -45146,6 +43271,122 @@ var registerReviewCommand = (program) => {
   });
 };
 
+// src/commands/review-history.ts
+var CODES2 = {
+  success: "AgentReviewHistoryAdd",
+  invalidGrade: "AgentReviewHistoryAddInvalidGrade",
+  invalidPath: "AgentReviewHistoryAddInvalidPath",
+  malformedHistory: "AgentReviewHistoryAddMalformedHistory",
+  failed: "AgentReviewHistoryAddFailed"
+};
+var ADD_EXAMPLES = [
+  {
+    Description: "Record a review grade for a project at a specific path",
+    Command: "uip agent review-history add B ./my-agent",
+    Output: {
+      Code: CODES2.success,
+      Data: {
+        ProjectDir: "./my-agent",
+        Grade: "B",
+        RunAt: "2026-09-02T10:00:00.000Z",
+        HistoryCount: 1
+      }
+    }
+  },
+  {
+    Description: "Record a grade with finding counts",
+    Command: "uip agent review-history add C --errors 2 --warnings 5",
+    Output: {
+      Code: CODES2.success,
+      Data: {
+        ProjectDir: ".",
+        Grade: "C",
+        RunAt: "2026-09-02T10:00:00.000Z",
+        Errors: 2,
+        Warnings: 5,
+        HistoryCount: 3
+      }
+    }
+  }
+];
+var COUNT_BOUNDS = { min: 0, max: Number.MAX_SAFE_INTEGER };
+var parseCount = (flag) => (raw) => parseBoundedInt(raw, flag, COUNT_BOUNDS);
+var reportFailure = (rawGrade, outcome) => {
+  switch (outcome.error) {
+    case "INVALID_GRADE":
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.invalidGrade,
+        ErrorCode: "invalid_argument",
+        Message: `\`${rawGrade}\` is not a recordable grade.`,
+        Instructions: `Pass one of: ${outcome.allowed.join(", ")}.`
+      });
+      return;
+    case "NOT_A_DIRECTORY":
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.invalidPath,
+        ErrorCode: "invalid_argument",
+        Message: `\`${outcome.projectPath}\` is not an existing directory.`,
+        Instructions: "Pass the agent project directory as [path], or run from inside it."
+      });
+      return;
+    case "MALFORMED_HISTORY":
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.malformedHistory,
+        ErrorCode: "configuration_error",
+        Message: `\`${outcome.file}\` exists but is not a JSON array of review entries: ${outcome.detail}`,
+        Instructions: "Fix the file so it parses as a JSON array, or delete it to start a fresh history, then rerun."
+      });
+      return;
+  }
+};
+var registerReviewHistoryCommands = (program) => {
+  const reviewHistory = program.command("review-history").description(`Manage the review grades recorded in the project's ${REVIEW_HISTORY_FILE}`);
+  reviewHistory.command("add").description(`Record a review grade in the project's ${REVIEW_HISTORY_FILE}. ` + `Keeps the newest ${MAX_REVIEW_HISTORY_ENTRIES} entries, most recent first. Does not run the review.`).argument("<grade>", "Letter grade to record (A to F)").argument("[path]", "Agent project directory", ".").option("--errors <count>", "Number of error findings to record", parseCount("--errors")).option("--warnings <count>", "Number of warning findings to record", parseCount("--warnings")).examples(ADD_EXAMPLES).trackedAction(processContext, async (grade, targetPath, options) => {
+    const fs7 = getFileSystem();
+    const projectPath = fs7.path.resolve(targetPath);
+    const [err2, outcome] = await catchError(recordReview(projectPath, {
+      grade,
+      errors: options.errors,
+      warnings: options.warnings
+    }, fs7));
+    if (err2) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.failed,
+        Message: `Recording the review failed: ${extractErrorMessageSync(err2)}`,
+        Instructions: "Verify the project directory is writable. " + "Run `uip agent review-history add --help` for usage."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!outcome.ok) {
+      reportFailure(grade, outcome);
+      processContext.exit(1);
+      return;
+    }
+    const { entry, history } = outcome;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: CODES2.success,
+      Data: {
+        ProjectDir: projectPath,
+        Grade: entry.grade,
+        RunAt: entry.runAt,
+        ...entry.errors !== undefined && {
+          Errors: entry.errors
+        },
+        ...entry.warnings !== undefined && {
+          Warnings: entry.warnings
+        },
+        HistoryCount: history.length
+      }
+    });
+  });
+};
+
 // src/commands/tool-list.ts
 var TOOL_LIST_EXAMPLES = [
   {
@@ -45212,6 +43453,7 @@ var registerCommands = async (program) => {
   registerValidateCommand(program);
   registerRefreshCommand(program);
   registerReviewCommand(program);
+  registerReviewHistoryCommands(program);
   registerToolListCommand(program);
   registerMemoryCommands(program);
   registerEvalCommands(program);
@@ -45222,4 +43464,4 @@ var registerCommands = async (program) => {
 
 export { metadata, registerCommands };
 
-//# debugId=62D660E34E218DB464756E2164756E21
+//# debugId=A04E229D84238E3F64756E2164756E21