@uipath/flow-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/{packager-tool-afd1wwf2.js → packager-tool-53c81nnr.js}

@@ -1,28 +1,23 @@
 import {
   addBinding,
   createBinding
-} from "./packager-tool-n8p9cay6.js";
+} from "./packager-tool-6azk3rex.js";
 import {
   isMaestroAutomateSentinel,
   resolveRuntimeProfile,
   withRuntimeProfile
-} from "./packager-tool-gctpkdzs.js";
-import {
-  getFileSystem
-} from "./packager-tool-2513jrxr.js";
+} from "./packager-tool-hhy1gr2k.js";
 import {
   NugetConstants,
   NugetPackager,
   Path,
   ProjectTool,
-  ProjectTypes,
   TemporaryStorageService,
-  ToolErrorCodes,
   ToolResult,
   ensureProjectId,
   toolsFactoryRepository,
   writeContentOperateFile
-} from "./packager-tool-b1xs6aty.js";
+} from "./packager-tool-stq8800d.js";
 import {
   en_default
 } from "./packager-tool-rs6jm14d.js";
@@ -36,21 +31,24 @@ import {
   encodeFlatName,
   getContainerChildProps,
   isSyntheticAgentInputId
-} from "./packager-tool-et7wj8kr.js";
+} from "./packager-tool-0w4es6rz.js";
 import {
   AGENT_PREFIX,
   VARIABLE_PATH_IDENTIFIER_PATTERN,
   VARIABLE_PATH_SELECTOR_PATTERN
-} from "./packager-tool-qa2xzxez.js";
+} from "./packager-tool-59s95scr.js";
 import {
+  AGENT_NODE_TYPES,
   FLAT_SEP,
   JS_EXPRESSION_PREFIX,
   MINIMUM_SUPPORTED_SCHEMA_VERSION,
   ProjectType,
   VALID_IDENTIFIER_PATTERN,
+  cliRules,
   coerceInputsViaSchema,
   coerceToExpressionValue,
   compareVersions,
+  conditionExpressionRule,
   decodeLiteral,
   deepEqual,
   fileFormatToInMemoryWorkflow,
@@ -62,9 +60,13 @@ import {
   inMemoryWorkflowToFileFormat,
   isAgentNodeType,
   isAgentResourceNodeType,
+  isBlockingSeverity,
   isExpressionValue,
   isVoiceAgentNodeType,
+  parseWorkflowJson,
   resolveRefs,
+  runRules,
+  toSerializedNodes,
   workflowSchemaV1_0,
   workflowSchemaV1_0_0,
   workflowSchemaV1_1,
@@ -77,9 +79,10 @@ import {
   workflowSchemaV1_7,
   workflowSchemaV1_8,
   workflowSchemaV1_9
-} from "./packager-tool-yxnepq2j.js";
+} from "./packager-tool-ysbskrta.js";
 import {
-  createI18nRegistrar
+  createI18nRegistrar,
+  registerFlowSchemaI18n
 } from "./packager-tool-p79yh9ww.js";
 import {
   applyMigrations,
@@ -90,7 +93,7 @@ import {
   getLatestVersion,
   instance,
   migrations
-} from "./packager-tool-pppzgwfw.js";
+} from "./packager-tool-n4vdjmjx.js";
 import {
   init_esm_shims
 } from "./packager-tool-6ejqwbw9.js";
@@ -98,6 +101,9 @@ import {
   __commonJS as __commonJS2,
   __toESM as __toESM2
 } from "./packager-tool-mcaf4ewf.js";
+import {
+  getFileSystem
+} from "./packager-tool-3h2ktz6q.js";
 import {
   __commonJS,
   __export,
@@ -3717,7 +3723,7 @@ var require_semver2 = __commonJS2({
 init_esm_shims();
 init_esm_shims();
 async function convert(flowJson, options) {
-  const { flowJsonToBpmnXml } = await import("./conversion-FQTRFHRX-xh98wp2q.js");
+  const { flowJsonToBpmnXml } = await import("./conversion-FQTRFHRX-1q7rk0te.js");
   return flowJsonToBpmnXml(flowJson, options);
 }
 init_esm_shims();
@@ -5559,6 +5565,18 @@ async function resolveWorkflowRefs(parsed, resolver, baseUri) {
   }
   return { resolved, refMap };
 }
+async function inlineFlowRefs(fs, content, filePath, logger) {
+  if (!content.includes('"$ref"'))
+    return content;
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return content;
+  }
+  const { resolved } = await resolveWorkflowRefs(parsed, createFlowRefResolver(fs, logger), filePath);
+  return JSON.stringify(resolved);
+}
 async function resolveAndMigrateWorkflow(parsed, resolver, baseUri, logger) {
   const { resolved, refMap } = await resolveWorkflowRefs(parsed, resolver, baseUri);
   const migrated = migrateRawWorkflow(resolved, logger);
@@ -5587,6 +5605,65 @@ async function readUtf8OrNull(fs, filePath) {
     return null;
   return typeof buffer === "string" ? buffer : new TextDecoder().decode(buffer);
 }
+async function resolveProjectFlowFile(fs, projectPath) {
+  const found = await tryResolveProjectFlowFile(fs, projectPath);
+  if (!found) {
+    throw new Error(`Missing .flow file in ${projectPath}`);
+  }
+  return found;
+}
+async function tryResolveProjectFlowFile(fs, projectPath) {
+  let uiproj;
+  try {
+    const raw = await fs.readFile(fs.path.join(projectPath, "project.uiproj"), "utf-8");
+    uiproj = JSON.parse(raw);
+  } catch {
+    uiproj = undefined;
+  }
+  const safeName = uiproj?.Name?.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return tryFindProjectFlowFile(fs, projectPath, uiproj?.MainFile, safeName);
+}
+async function findProjectFlowFile(fs, projectPath, mainFile, preferredBaseName) {
+  const found = await tryFindProjectFlowFile(fs, projectPath, mainFile, preferredBaseName);
+  if (!found) {
+    throw new Error(`Missing .flow file in ${projectPath}`);
+  }
+  return found;
+}
+async function tryFindProjectFlowFile(fs, projectPath, mainFile, preferredBaseName) {
+  if (mainFile?.endsWith(".flow")) {
+    const mainFilePath = fs.path.join(projectPath, mainFile);
+    if (isInsideDirectory(fs, projectPath, mainFilePath) && await fs.exists(mainFilePath)) {
+      return mainFilePath;
+    }
+  }
+  const preferred = preferredBaseName ? `${preferredBaseName}.flow`.toLowerCase() : undefined;
+  const candidateDirs = [
+    projectPath,
+    fs.path.join(projectPath, "content"),
+    fs.path.join(projectPath, "flow_files")
+  ];
+  for (const dir of candidateDirs) {
+    if (!await fs.exists(dir)) {
+      continue;
+    }
+    const stat = await fs.stat(dir);
+    if (!stat?.isDirectory()) {
+      continue;
+    }
+    const flowFiles = (await fs.readdir(dir)).filter((entry) => entry.endsWith(".flow"));
+    if (flowFiles.length === 0) {
+      continue;
+    }
+    const chosen = (preferred && flowFiles.find((f) => f.toLowerCase() === preferred)) ?? flowFiles[0];
+    return fs.path.join(dir, chosen);
+  }
+  return;
+}
+function isInsideDirectory(fs, directory, candidate) {
+  const relative = fs.path.relative(directory, candidate);
+  return relative !== "" && !/^\.\.(?:[\\/]|$)/.test(relative) && !fs.path.isAbsolute(relative);
+}
 
 // ../packager/packager-tool-flow/src/agent-input-encoding-utils.ts
 var SCHEMA_CONTAINER_MARKER2 = "x-uipath-container";
@@ -5651,6 +5728,19 @@ function readInlineAgentSource(node) {
   }
   return;
 }
+function agentJsonReader(fs, flowDir) {
+  return async (sourceId) => {
+    try {
+      const raw = await fs.readFile(fs.path.join(flowDir, sourceId, "agent.json"), "utf-8");
+      if (!raw)
+        return;
+      const agent = JSON.parse(raw);
+      return typeof agent === "object" && agent !== null && !Array.isArray(agent) ? agent : undefined;
+    } catch {
+      return;
+    }
+  };
+}
 function isInlineAgentNodeType(type) {
   return isAgentNodeType(type);
 }
@@ -5715,6 +5805,245 @@ function setPublishIntentOnInlineAgents(fileFormat) {
   }
 }
 
+// ../packager/packager-tool-flow/src/flow-validation.ts
+var validationMessagesRegistered = false;
+function ensureValidationMessages() {
+  if (validationMessagesRegistered)
+    return;
+  if (!instance.isInitialized) {
+    instance.init({
+      lng: "en",
+      fallbackLng: "en",
+      defaultNS: "validation",
+      resources: {},
+      interpolation: { escapeValue: false }
+    });
+  }
+  registerFlowSchemaI18n(instance);
+  validationMessagesRegistered = true;
+}
+function hydrateAgentNodeInputs(node, agent) {
+  if (!node.inputs)
+    node.inputs = {};
+  const inputs = node.inputs;
+  const settings = agent.settings;
+  if (isVoiceAgentNodeType(node.type)) {
+    const voiceSettings = isRecord7(settings) ? settings.voice : undefined;
+    if (isRecord7(voiceSettings) && inputs.voice === undefined) {
+      inputs.voice = voiceSettings;
+    }
+  }
+  const messages = agent.messages;
+  if (!Array.isArray(messages))
+    return;
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object")
+      continue;
+    const m = msg;
+    if (m.role === "system" && typeof m.content === "string") {
+      inputs.systemPrompt ??= m.content;
+    }
+    if (m.role === "user" && typeof m.content === "string") {
+      inputs.userPrompt ??= m.content;
+    }
+  }
+  if (settings && typeof settings === "object") {
+    const s = settings;
+    if (typeof s.temperature === "number" && inputs.temperature === undefined) {
+      inputs.temperature = s.temperature;
+    }
+    if (typeof s.maxTokens === "number" && inputs.maxTokenPerResponse === undefined) {
+      inputs.maxTokenPerResponse = s.maxTokens;
+    }
+    if (typeof s.model === "string" && inputs.model === undefined) {
+      inputs.model = s.model;
+    }
+  }
+}
+async function hydrateInlineAgents(nodes, readAgentJson) {
+  for (const node of nodes) {
+    if (!AGENT_NODE_TYPES.includes(node.type)) {
+      continue;
+    }
+    const source = readInlineAgentSource(node);
+    if (source === undefined || /[/\\.]/.test(source))
+      continue;
+    const agent = await readAgentJson(source);
+    if (agent)
+      hydrateAgentNodeInputs(node, agent);
+  }
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseFlowSource(content) {
+  ensureValidationMessages();
+  const parsed = parseWorkflowJson(content);
+  const { workflow, parseError, parseIssues } = parsed;
+  if (parseError || !workflow) {
+    const recoveredIssues = parseIssues && parseIssues.length > 0 ? parseIssues : parseError ? splitSchemaParseError(parseError) : null;
+    const fallback = [
+      {
+        path: "(root)",
+        message: parseError ?? "File is not valid JSON",
+        severity: "error"
+      }
+    ];
+    return {
+      ok: false,
+      issues: recoveredIssues && recoveredIssues.length > 0 ? recoveredIssues.map((pi) => ({
+        path: pi.path,
+        message: pi.message,
+        severity: "error"
+      })) : fallback
+    };
+  }
+  return {
+    ok: true,
+    workflow,
+    rawDefErrorHandling: extractSupportsErrorHandling(content)
+  };
+}
+function runDesignerRules(graph, options = {}) {
+  ensureValidationMessages();
+  const ctx = buildValidationContext(graph);
+  if (options.governanceEnforcements) {
+    ctx.governanceEnforcements = options.governanceEnforcements;
+  }
+  if (options.availableModelNames) {
+    ctx.availableModelNames = options.availableModelNames;
+  }
+  const dropped = new Set(["expression-ref"]);
+  if (options.isSubflow)
+    dropped.add("trigger-required");
+  const rules = cliRules.filter((r) => !dropped.has(r.id));
+  const ruleErrors = runRules([...rules, conditionExpressionRule, ...options.extraRules ?? []], ctx);
+  return ruleErrors.map(validationErrorToIssue);
+}
+async function validateFlowSource(content, readAgentJson) {
+  const parsed = parseFlowSource(content);
+  if (!parsed.ok) {
+    return parsed.issues;
+  }
+  const { workflow } = parsed;
+  const subflows = workflow.subflows ?? {};
+  if (readAgentJson) {
+    await hydrateInlineAgents(workflow.nodes, readAgentJson);
+    for (const entry of Object.values(subflows)) {
+      await hydrateInlineAgents(entry.nodes, readAgentJson);
+    }
+  }
+  const issues = runDesignerRules(workflow);
+  for (const [subflowId, entry] of Object.entries(subflows)) {
+    const subGraph = {
+      nodes: entry.nodes,
+      edges: entry.edges,
+      definitions: workflow.definitions,
+      variables: entry.variables
+    };
+    const prefix = `subflows[${subflowId}].`;
+    issues.push(...runDesignerRules(subGraph, { isSubflow: true }).map((issue) => ({
+      ...issue,
+      path: `${prefix}${issue.path}`
+    })));
+  }
+  return issues;
+}
+function extractSupportsErrorHandling(content) {
+  const map = new Map;
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    return map;
+  }
+  if (!raw || typeof raw !== "object")
+    return map;
+  const defs = raw.definitions;
+  if (!Array.isArray(defs))
+    return map;
+  for (const def of defs) {
+    if (!def || typeof def !== "object")
+      continue;
+    const d = def;
+    if (typeof d.nodeType === "string" && typeof d.version === "string" && d.supportsErrorHandling === true) {
+      map.set(`${d.nodeType}:${d.version}`, true);
+    }
+  }
+  return map;
+}
+function validationErrorToIssue(error) {
+  let path;
+  if (error.nodeId) {
+    path = error.fieldPath ? `nodes[${error.nodeId}].${error.fieldPath}` : `nodes[${error.nodeId}]`;
+  } else {
+    path = error.fieldPath ?? "(workflow)";
+  }
+  return {
+    path,
+    message: `[${error.code}] ${error.message}`,
+    severity: isBlockingSeverity(error.severity) ? "error" : "warning"
+  };
+}
+function buildValidationContext(flow) {
+  const nodes = toSerializedNodes(flow.nodes);
+  const edges = flow.edges.map((e) => ({
+    id: e.id,
+    source: e.sourceNodeId,
+    sourceHandle: e.sourcePort ?? null,
+    target: e.targetNodeId,
+    targetHandle: e.targetPort ?? null
+  }));
+  const manifests = new Map;
+  for (const def of flow.definitions) {
+    manifests.set(`${def.nodeType}:${def.version}`, {
+      nodeType: def.nodeType,
+      version: def.version,
+      category: def.category,
+      display: def.display,
+      handleConfiguration: def.handleConfiguration,
+      inputDefinition: def.inputDefinition,
+      outputDefinition: def.outputDefinition,
+      tags: def.tags
+    });
+  }
+  const outputVariableIds = [];
+  const variables = flow.variables;
+  if (variables?.globals) {
+    for (const v of variables.globals) {
+      if (v.direction === "out" || v.direction === "inout") {
+        outputVariableIds.push(v.id);
+      }
+    }
+  }
+  return {
+    nodes,
+    edges,
+    manifests,
+    outputVariableIds
+  };
+}
+function splitSchemaParseError(parseError) {
+  const header = "Schema validation failed:";
+  if (!parseError.startsWith(header)) {
+    return null;
+  }
+  const body = parseError.slice(header.length);
+  const lines = body.split(`
+`);
+  const issues = [];
+  for (const rawLine of lines) {
+    const match = /^\s*-\s+(.+?):\s(.*)$/.exec(rawLine);
+    if (!match)
+      continue;
+    const [, path, message] = match;
+    if (!path || !message)
+      continue;
+    issues.push({ path, message });
+  }
+  return issues.length > 0 ? issues : null;
+}
+
 // ../packager/packager-tool-flow/src/voice-agent-definitions.ts
 function nodeLabel(node) {
   const label = node.display?.label;
@@ -5784,7 +6113,7 @@ function assertVoiceAgentDefinitionsEmbedded(bpmn, nodes) {
 // ../packager/packager-tool-flow/package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.203.0-preview.205",
+  version: "1.204.0-preview.206",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -5801,8 +6130,9 @@ var package_default = {
   },
   types: "./dist/index.d.ts",
   scripts: {
-    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --sourcemap=linked && bun build ./src/maestro-automate-entry.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --sourcemap=linked && tsc --emitDeclarationOnly --outDir dist",
-    dev: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --watch",
+    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --external i18next --sourcemap=linked && bun build ./src/maestro-automate-entry.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --sourcemap=linked && tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck --outDir dist",
+    typecheck: "tsc --noEmit",
+    dev: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --external i18next --watch",
     test: "vitest run",
     "test:browser": "vitest run --config=vitest.browser.config.ts",
     "test:coverage": "vitest run --coverage",
@@ -5829,7 +6159,8 @@ var package_default = {
     "@uipath/flow-migrations": "0.56.2",
     "@uipath/flow-schema": "0.68.0",
     "@uipath/solutionpackager-tool-core": "workspace:*",
-    "@uipath/tool-agent": "^2.0.0"
+    "@uipath/tool-agent": "^2.0.0",
+    i18next: "^23.16.8"
   },
   devDependencies: {
     "@types/node": "^25.5.2",
@@ -5841,6 +6172,7 @@ var package_default = {
     "@vitest/browser": "^4.1.11",
     "@vitest/browser-playwright": "^4.1.11",
     "@vitest/coverage-v8": "^4.1.11",
+    i18next: "^23.16.8",
     playwright: "^1.57.0",
     typescript: "^7.0.2",
     vitest: "^4.1.11"
@@ -17682,6 +18014,21 @@ var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
   return builtAgents;
 };
 
+// ../packager/packager-tool-flow/src/flow-validation-hook.ts
+function splitIssueMessage(message) {
+  const match = /^\[([A-Z][A-Z0-9_]*)\]\s+(.*)$/s.exec(message);
+  return match?.[2] ? { code: match[1], description: match[2] } : { description: message };
+}
+function nodeIdFromIssuePath(path) {
+  let nodeId;
+  for (const match of path.matchAll(/nodes\[([^\]]+)\]/g)) {
+    if (match[1] !== undefined && !/^\d+$/.test(match[1])) {
+      nodeId = match[1];
+    }
+  }
+  return nodeId;
+}
+
 // ../packager/packager-tool-flow/src/operate-runtime-options.ts
 var CONVERSATION_TRIGGER_NODE_TYPE = "core.trigger.conversation";
 function operateRuntimeOptions(nodes) {
@@ -17693,6 +18040,9 @@ var FlowConstants = {
   EntryPointsFileName: "entry-points.json",
   BindingsV2FileName: "bindings_v2.json"
 };
+var FLOW_VALIDATION_FAILED = "FLOW_VALIDATION_FAILED";
+var FLOW_VALIDATION_SOURCE = "Validator";
+var SUBFLOW_PATH_SEGMENT = "subflows[";
 
 class FlowTool extends ProjectTool {
   _temporaryStorage;
@@ -17704,11 +18054,59 @@ class FlowTool extends ProjectTool {
     this.logger.info("Restore operation is not required for Flow projects");
     return ToolResult.success();
   }
-  async validateAsync(_options, _cancellationToken) {
-    this.logger.info("Validate operation is not required for Flow projects");
-    return ToolResult.success();
+  async validateAsync(options, _cancellationToken) {
+    return this.runValidation(options.projectPath);
+  }
+  async runValidation(projectPath) {
+    let flowFile;
+    let issues;
+    try {
+      flowFile = await tryResolveProjectFlowFile(this.fileSystem, projectPath);
+      if (flowFile === undefined) {
+        this.logger.info("Flow project has no .flow file; skipping Flow validation");
+        return ToolResult.success();
+      }
+      const content = await this.fileSystem.readFile(flowFile, "utf-8");
+      if (content === null) {
+        throw new Error(`Could not read ${flowFile}`);
+      }
+      this.logger.progress("Validating Flow project...");
+      const source = await inlineFlowRefs(this.fileSystem, content, flowFile, this.logger);
+      issues = await validateFlowSource(source, agentJsonReader(this.fileSystem, projectPath));
+    } catch (error40) {
+      const message = error40 instanceof Error ? error40.message : String(error40);
+      this.logger.warn(`Could not validate the Flow project, continuing without validation: ${message}`);
+      return ToolResult.success();
+    }
+    const flowFilePath = this.toProjectRelative(projectPath, flowFile);
+    const findings = issues.map((issue2) => toFlowFinding(issue2, flowFilePath));
+    const errors3 = issues.filter((issue2) => issue2.severity === "error");
+    for (const issue2 of issues) {
+      const line = `[${issue2.path}] ${issue2.message}`;
+      if (issue2.severity === "error") {
+        this.logger.error(line);
+      } else {
+        this.logger.warn(line);
+      }
+    }
+    const result = errors3.length === 0 ? ToolResult.success() : ToolResult.error(FLOW_VALIDATION_FAILED, `Flow validation failed for ${flowFilePath}: ${errors3.length} error(s).`, "Open the flow in the designer and fix the reported errors, " + "or run 'uip maestro flow validate <project-path>' for the full list.");
+    if (findings.length > 0) {
+      result.details = { ...result.details, findings };
+    }
+    return result;
+  }
+  toProjectRelative(projectPath, filePath) {
+    const root = `${Path.normalize(projectPath).replace(/\/$/, "")}/`;
+    const file2 = Path.normalize(filePath);
+    return file2.toLowerCase().startsWith(root.toLowerCase()) ? file2.slice(root.length) : Path.basename(file2);
   }
   async buildAsync(options, _cancellationToken) {
+    if (!options.skipValidate) {
+      const validationResult = await this.runValidation(options.projectPath);
+      if (!validationResult.isSuccess) {
+        return validationResult;
+      }
+    }
     const tempFolder = await this._temporaryStorage.getTempFolderPath();
     const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
     const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
@@ -17727,13 +18125,13 @@ class FlowTool extends ProjectTool {
       await this.createOperateFile(contentFolder, projectId, profile);
       this.logger.progress("Creating package-descriptor.json file...");
       await this.createPackageDescriptor(localBuildFolder, contentFolder);
-      return new ToolResult(ToolErrorCodes.Success, "done", [
+      return new ToolResult("SUCCESS" /* Success */, "done", [
         localBuildFolder
       ]);
     } catch (error40) {
       const errorMessage = error40 instanceof Error ? error40.toString() : String(error40);
       this.logger.error(errorMessage);
-      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while building Flow project files");
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while building Flow project files");
     }
   }
   async packAsync(options, cancellationToken) {
@@ -17749,13 +18147,13 @@ class FlowTool extends ProjectTool {
       const packager = new NugetPackager(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
       this.logger.progress("Package created successfully");
-      return new ToolResult(ToolErrorCodes.Success, "done", [
+      return new ToolResult("SUCCESS" /* Success */, "done", [
         result.outputPath
       ]);
     } catch (error40) {
       const errorMessage = error40 instanceof Error ? error40.toString() : String(error40);
       this.logger.error(errorMessage);
-      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while packing Flow project");
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while packing Flow project");
     }
   }
   async dispose() {
@@ -17962,7 +18360,7 @@ class FlowTool extends ProjectTool {
     await writeContentOperateFile(this.fileSystem, {
       contentFolder,
       projectId,
-      contentType: ProjectTypes.Flow
+      contentType: "Flow" /* Flow */
     });
     const operatePath = Path.join(contentFolder, NugetConstants.OperateFileName);
     const raw = await this.fileSystem.readFile(operatePath);
@@ -18002,10 +18400,23 @@ class FlowTool extends ProjectTool {
     await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
   }
 }
+function toFlowFinding(issue2, flowFilePath) {
+  const { code, description } = splitIssueMessage(issue2.message);
+  const nodeId = nodeIdFromIssuePath(issue2.path);
+  const pathAddsLocation = nodeId === undefined || issue2.path.includes(SUBFLOW_PATH_SEGMENT);
+  return {
+    Level: issue2.severity === "warning" ? "Warning" : "Error",
+    Source: FLOW_VALIDATION_SOURCE,
+    ...code !== undefined && { ErrorCode: code },
+    Description: pathAddsLocation ? `${issue2.path}: ${description}` : description,
+    FilePath: flowFilePath,
+    ...nodeId !== undefined && { ActivityIdRef: nodeId }
+  };
+}
 
 // ../packager/packager-tool-flow/src/flow-tool-factory.ts
 class FlowToolFactory {
-  supportedTypes = [ProjectTypes.Flow];
+  supportedTypes = ["Flow" /* Flow */];
   async createAsync(logger, fileSystem) {
     return new FlowTool(fileSystem, logger);
   }
@@ -18014,6 +18425,6 @@ class FlowToolFactory {
 // ../packager/packager-tool-flow/src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
 
-export { convertFlowToBpmn, buildInlineAgentContract, extractProcessGuid, createProcessBindings, replaceExporterVersion, registerFlowMigrationsI18n, getMigrationChain, migrateWorkflowToFloor, minimumSupportedVersion, runtimeVersion, runtimeMigrations, checkNodeMigrations, applyNodeMigrations, createFlowRefResolver, resolveWorkflowRefs, resolveAndMigrateWorkflow, canonicalAgentInputPath, collectAgentInputLeaves, readInlineAgentSource, isInlineAgentNodeType, hydrateInlineAgentInputVariables, setPublishIntentOnInlineAgents, operateRuntimeOptions, voiceConvertOptions, assertVoiceAgentDefinitionsEmbedded, FlowToolFactory };
+export { convertFlowToBpmn, buildInlineAgentContract, extractProcessGuid, createProcessBindings, replaceExporterVersion, registerFlowMigrationsI18n, getMigrationChain, migrateWorkflowToFloor, minimumSupportedVersion, runtimeVersion, runtimeMigrations, checkNodeMigrations, applyNodeMigrations, createFlowRefResolver, resolveWorkflowRefs, inlineFlowRefs, resolveAndMigrateWorkflow, resolveProjectFlowFile, findProjectFlowFile, canonicalAgentInputPath, collectAgentInputLeaves, readInlineAgentSource, isInlineAgentNodeType, hydrateInlineAgentInputVariables, setPublishIntentOnInlineAgents, hydrateAgentNodeInputs, parseFlowSource, runDesignerRules, operateRuntimeOptions, voiceConvertOptions, assertVoiceAgentDefinitionsEmbedded, FlowToolFactory };
 
-//# debugId=85413FF4B019362064756E2164756E21
+//# debugId=C8763BF0747ACD3064756E2164756E21

package/dist/{packager-tool-2c688mdj.js → packager-tool-57fak54h.js}

@@ -3,13 +3,13 @@ import {
   ReleasesApi,
   createOrchestratorConfig,
   resolveFolder
-} from "./packager-tool-p8j4zvrq.js";
+} from "./packager-tool-dp8vjby4.js";
 import {
   parseJsonInputOrFile
-} from "./packager-tool-h9d8c9rf.js";
+} from "./packager-tool-4zdhy0c3.js";
 import {
   getPersonalFolderKey
-} from "./packager-tool-9kx94sj5.js";
+} from "./packager-tool-x5qafkb7.js";
 import {
   ErrorDecision,
   MIN_INTERVAL_MS,
@@ -18,7 +18,7 @@ import {
   logger,
   pollUntil,
   processContext
-} from "./packager-tool-6k8s7pt9.js";
+} from "./packager-tool-r7xy9sew.js";
 
 // src/services/http-client.ts
 function buildCommonHeaders(config, options) {