@uipath/packager-tool-flow 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/flow-io.d.ts

@@ -42,6 +42,15 @@ export declare function resolveWorkflowRefs(parsed: unknown, resolver: ResolveRe
     resolved: unknown;
     refMap: RefMap;
 }>;
+/**
+ * A `.flow`'s text with its `$ref` chunks inlined — the document the build
+ * packs — for a validator that parses text. The schema parser strips an
+ * unresolved `$ref`, so a chunked subflow fails the parse and a chunked
+ * variable set silently disappears. Text with no `$ref` comes back as it
+ * was, and so does text that is not JSON, for the validator to report.
+ * Throws as {@link resolveWorkflowRefs} does.
+ */
+export declare function inlineFlowRefs(fs: IFileSystem, content: string, filePath: string, logger?: FlowIoLogger): Promise<string>;
 /**
  * The full read pipeline for a parsed `.flow` document: resolve `$ref`
  * chunks, project to the fleet write floor, convert to the in-memory
@@ -75,3 +84,43 @@ export interface ReadFlowWorkflowOptions {
  * otherwise the process-wide `getFileSystem()` is used.
  */
 export declare function readFlowWorkflow(filePath: string, options?: ReadFlowWorkflowOptions): Promise<Workflow>;
+/**
+ * Resolve the `.flow` a project runs: `MainFile` first, then `<Name>.flow`,
+ * then any `.flow` in the project. One resolver so the pack gate, the debug
+ * run, the conversational pre-flight and local eval preparation all read the
+ * same file. An unreadable `project.uiproj` degrades to the plain search
+ * rather than failing.
+ *
+ * Takes the file system as a parameter: the packager hands in the one it was
+ * constructed with, which in a browser host is not the Node one.
+ */
+export declare function resolveProjectFlowFile(fs: IFileSystem, projectPath: string): Promise<string>;
+/**
+ * {@link resolveProjectFlowFile}, answering `undefined` for a project that
+ * has no `.flow` instead of throwing. See {@link tryFindProjectFlowFile} for
+ * why the two answers stay apart.
+ */
+export declare function tryResolveProjectFlowFile(fs: IFileSystem, projectPath: string): Promise<string | undefined>;
+/**
+ * Locate a flow project's `.flow` source file. Prefers the `project.uiproj`
+ * `MainFile` when it names a `.flow` inside the project, then the first
+ * `.flow` found in the project root, `content/`, or `flow_files/`.
+ *
+ * Studio Web-exported solutions ship the flow as `new.flow` (not
+ * `<ProjectName>.flow`) with `MainFile: null`, so callers must NOT assume the
+ * file is named after the project. When a directory holds multiple `.flow`s,
+ * pass `preferredBaseName` (the project name) to disambiguate to
+ * `<preferredBaseName>.flow` deterministically. Throws when no `.flow` is found.
+ */
+export declare function findProjectFlowFile(fs: IFileSystem, projectPath: string, mainFile?: string | null, preferredBaseName?: string): Promise<string>;
+/**
+ * {@link findProjectFlowFile}, except that a project with no `.flow` answers
+ * `undefined` rather than throwing.
+ *
+ * For a caller to whom "this project has none" is an ordinary outcome — a
+ * Lite or Maestro Automate project packs fine without one. Reading the
+ * directory can still throw (EACCES, EIO); that is not the same answer and
+ * must not be flattened into it, or an unreadable project reads as an empty
+ * one.
+ */
+export declare function tryFindProjectFlowFile(fs: IFileSystem, projectPath: string, mainFile?: string | null, preferredBaseName?: string): Promise<string | undefined>;

package/dist/flow-tool.d.ts

@@ -7,7 +7,36 @@ export declare class FlowTool extends ProjectTool {
     private readonly _temporaryStorage;
     constructor(fileSystem: IFileSystem, logger: IToolLogger);
     restoreAsync(_options: IProjectRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
-    validateAsync(_options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    validateAsync(options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Validate the project's `.flow` with the designer's rules, and turn what
+     * they found into a result the solution packager can put on the wire.
+     *
+     * Every issue becomes a finding, warnings included — Studio renders the
+     * severity, and a warning row next to the error that blocked the publish
+     * is worth more than the error alone. Only errors decide the verdict.
+     *
+     * The rules are the designer's own (`validateFlowSource`), so a flow that
+     * packs here is one the designer draws clean — in every host, Studio Web
+     * included, because nothing has to be supplied from outside. The CLI's
+     * extra authoring checks stay in `uip maestro flow validate`.
+     *
+     * Two ways this ends without a verdict, both building as before: no
+     * `.flow` in the project (a Lite or Maestro Automate project, which is
+     * ordinary, hence info not warn); and a `.flow` that cannot be read,
+     * `$ref` chunks that cannot be resolved (a cycle), or a rule that
+     * throws — an infrastructure failure rather than a verdict on
+     * the flow, logged and continued, because refusing to pack over it would
+     * break packs that work today.
+     */
+    private runValidation;
+    /**
+     * `flowFilePath` as the finding contract wants it — relative to the
+     * project, forward slashes. Studio refuses to navigate a path that
+     * escapes the project directory, so anything that would is reduced to the
+     * bare file name, which still names the file in the Error List.
+     */
+    private toProjectRelative;
     buildAsync(options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     dispose(): Promise<void>;

package/dist/flow-validation-hook.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The shape of a Flow validation issue, and the two helpers that turn one
+ * into a finding Studio can navigate: `splitIssueMessage` peels the rule code
+ * off the text, `nodeIdFromIssuePath` finds the node the issue is about.
+ *
+ * Issues come from `validateFlowSource` (the pack gate) and from flow-tool's
+ * `FlowValidateService`, whose `ValidationIssue` has the same shape.
+ */
+export type FlowValidationSeverity = "error" | "warning";
+/** One problem found in a `.flow`. */
+export interface FlowValidationIssue {
+    /**
+     * Dot path into the flow — `nodes[<node-id>].inputs.<field>`, or
+     * `subflows[<subflow-id>].nodes[<node-id>]…` inside a subflow.
+     */
+    path: string;
+    /**
+     * Human-readable text. Rules that carry a code prefix it as `[CODE] `;
+     * {@link splitIssueMessage} peels that back off for the finding contract.
+     */
+    message: string;
+    severity: FlowValidationSeverity;
+}
+/**
+ * Split `[CODE] text` into its parts, so the finding contract can carry the
+ * code in `ErrorCode` and leave `Description` readable. Rules that emit no
+ * code (the per-node validators) come back with `code: undefined` and the
+ * message untouched.
+ */
+export declare function splitIssueMessage(message: string): {
+    code?: string;
+    description: string;
+};
+/**
+ * The node a dot path points at, or `undefined` for a workflow-scoped issue.
+ * The last `nodes[…]` segment wins, so a subflow-prefixed path yields the node
+ * inside the subflow rather than the subflow id.
+ *
+ * A purely numeric segment is an array index, not an id: a schema-parse issue
+ * carries a Zod path, and flow-schema's `formatZodPath` renders those as
+ * `nodes[0].type`. Treating the `0` as a node id would have Studio claim the
+ * row, fail to focus a node by that name, and — because the id read as
+ * present — drop the path from the description, leaving nothing to locate the
+ * problem by.
+ */
+export declare function nodeIdFromIssuePath(path: string): string | undefined;

package/dist/flow-validation.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The designer's validation rules, run over a `.flow` without the designer.
+ *
+ * This is what decides whether a Flow project packs: parse the file against
+ * the flow schema, load each inline agent's prompts and settings from its
+ * `agent.json` the way the designer does, then run `@uipath/flow-schema`'s
+ * rule set — the same rules the canvas runs — over the root graph and every
+ * subflow. No network or login, and file access only through the file system
+ * the caller hands in, so it runs wherever the packager does: the CLI,
+ * desktop Studio, and Studio Web.
+ *
+ * `uip maestro flow validate` runs the same two steps (via
+ * {@link parseFlowSource} and {@link runDesignerRules}) and adds its own
+ * authoring checks around them. Those extra checks are for flows written by
+ * agents or by hand, which the designer never shows, so they stay out of the
+ * pack verdict.
+ */
+import { type ParsedWorkflow, type ValidationRule, type WorkflowValidationContext, type WorkflowVariables } from "@uipath/flow-schema";
+import type { FlowValidationIssue } from "./flow-validation-hook.js";
+import { type ReadAgentJson } from "./inline-agent-utils.js";
+/** Graph shape shared by root workflow and each subflow entry; avoids `as ParsedWorkflow` over `unknown[]`. */
+export interface FlowGraph {
+    nodes: Array<{
+        id: string;
+        type: string;
+        typeVersion?: string;
+        display?: {
+            label?: string;
+        } & Record<string, unknown>;
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
+        model?: Record<string, unknown>;
+    }>;
+    edges: Array<{
+        id: string;
+        sourceNodeId: string;
+        sourcePort: string;
+        targetNodeId: string;
+        targetPort: string;
+    }>;
+    definitions: Array<{
+        nodeType: string;
+        version: string;
+        category?: string;
+        display?: {
+            label: string;
+        };
+        handleConfiguration: unknown[];
+        inputDefinition?: Record<string, unknown>;
+        outputDefinition?: Record<string, unknown>;
+        /** BPMN element the node lowers to at runtime, e.g. `bpmn:ParallelGateway`. */
+        model?: {
+            type?: string;
+        } & Record<string, unknown>;
+        tags?: string[];
+    }>;
+    variables?: WorkflowVariables;
+    /** Top-level binding registry that `<bindings.{name}>` placeholders resolve against. */
+    bindings?: Array<Record<string, unknown>>;
+}
+/** A `.flow` that parsed, or the issues explaining why it did not. */
+export type ParsedFlowSource = {
+    ok: true;
+    workflow: ParsedWorkflow;
+    /**
+     * `supportsErrorHandling` per `nodeType:version`, recovered from the
+     * raw JSON — the schema parser strips it, and the edge-handle check
+     * needs it to honour the implicit `error` source port.
+     */
+    rawDefErrorHandling: Map<string, boolean>;
+} | {
+    ok: false;
+    issues: FlowValidationIssue[];
+};
+export interface DesignerRuleOptions {
+    /**
+     * The graph is a subflow body (a loop body, a nested call activity), so
+     * rules scoped to the whole workflow — `trigger-required` — do not apply.
+     */
+    isSubflow?: boolean;
+    governanceEnforcements?: WorkflowValidationContext["governanceEnforcements"];
+    availableModelNames?: WorkflowValidationContext["availableModelNames"];
+    /** Appended after the designer's rules. */
+    extraRules?: readonly ValidationRule[];
+}
+/**
+ * Copy onto an inline agent's node what the designer shows on it, which the
+ * `.flow` keeps in the agent's own `agent.json`: the system and user prompts
+ * from its messages, and model / temperature / token limit from its settings
+ * (voice settings too, for a voice agent). Without this every stored inline
+ * agent reads as missing its prompts and model. A value already on the node
+ * is never overwritten, and the first system and first user message win.
+ */
+export declare function hydrateAgentNodeInputs(node: {
+    type: string;
+    inputs?: Record<string, unknown>;
+}, agent: Record<string, unknown>): void;
+/**
+ * Parse and validate against flow schema. `parseWorkflowJson` returns a
+ * structured `parseIssues` array (one entry per Zod issue) on flow-schema
+ * versions ≥ the one shipping the side-channel; on older versions only the
+ * joined `parseError` string is populated. The cast below keeps us
+ * forward-compatible without forcing a dep bump: when the field arrives we
+ * emit one issue per Zod issue with its real path; otherwise we split the
+ * formatted multi-line `parseError` string ourselves so each issue keeps its
+ * Zod path (UiPath/cli#2029). Only when neither shape is available do we
+ * collapse to a single `(root)` issue (legacy / non-schema errors like JSON
+ * parse failures). flow-workbench PR #1479.
+ */
+export declare function parseFlowSource(content: string): ParsedFlowSource;
+/**
+ * The designer's rules over one graph. Paths come back relative to the graph
+ * — a caller validating a subflow prefixes them.
+ *
+ * Semantic validation using built-in rules from flow-schema.
+ * conditionExpressionRule is deliberately excluded from cliRules on the
+ * canvas (it runs as a main-thread fallback there); with no competing
+ * validator here we opt it in, to catch malformed HTTP/Decision/Switch
+ * condition expressions. triggerRequiredRule is scoped to the root workflow
+ * only — subflows (loop bodies, nested call activities) are not expected to
+ * carry their own trigger. expression-ref is dropped everywhere: it treats
+ * the `any` that script, transform and loop `currentItem` outputs declare as
+ * a closed primitive, so it refuses deep reads of them, and reads the
+ * manifest rather than the `.flow`, so no author can suppress it. The canvas
+ * dropped it over the same false positives (MST-9593); flow-workbench#3638
+ * removes it from `cliRules`, after which this filter matches nothing.
+ */
+export declare function runDesignerRules(graph: FlowGraph, options?: DesignerRuleOptions): FlowValidationIssue[];
+/**
+ * {@link parseFlowSource}, then {@link runDesignerRules} over the root graph
+ * and every subflow — with each inline agent first hydrated from its
+ * `agent.json` through `readAgentJson`, as the designer shows it. This is the
+ * pack verdict: any `error` fails the pack.
+ */
+export declare function validateFlowSource(content: string, readAgentJson?: ReadAgentJson): Promise<FlowValidationIssue[]>;

package/dist/index.d.ts

@@ -2,10 +2,12 @@ export { type AgentInputLeaf, canonicalAgentInputPath, collectAgentInputLeaves,
 export { buildInlineAgentContract, type InlineAgentContract, } from "./agents.js";
 export { createProcessBindings, ensureProcessBindings, extractProcessGuid, } from "./ensure-process-bindings.js";
 export { replaceExporterVersion } from "./exporter-version.js";
-export { createFlowRefResolver, type FlowIoLogger, migrateRawWorkflow, readFlowWorkflow, resolveAndMigrateWorkflow, resolveWorkflowRefs, } from "./flow-io.js";
+export { createFlowRefResolver, type FlowIoLogger, findProjectFlowFile, inlineFlowRefs, migrateRawWorkflow, readFlowWorkflow, resolveAndMigrateWorkflow, resolveProjectFlowFile, resolveWorkflowRefs, tryFindProjectFlowFile, tryResolveProjectFlowFile, } from "./flow-io.js";
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
-export { type AgentInputVariable, hydrateInlineAgentInputVariables, isInlineAgentNodeType, readInlineAgentSource, reconcileInlineAgentInputVariables, setPublishIntentOnInlineAgents, } from "./inline-agent-utils.js";
+export { type DesignerRuleOptions, type FlowGraph, hydrateAgentNodeInputs, type ParsedFlowSource, parseFlowSource, runDesignerRules, validateFlowSource, } from "./flow-validation.js";
+export type { FlowValidationIssue, FlowValidationSeverity, } from "./flow-validation-hook.js";
+export { type AgentInputVariable, agentJsonReader, hydrateInlineAgentInputVariables, isInlineAgentNodeType, type ReadAgentJson, readInlineAgentSource, reconcileInlineAgentInputVariables, setPublishIntentOnInlineAgents, } from "./inline-agent-utils.js";
 export { applyRuntimeProfile, isMaestroAutomateSentinel, RuntimeProfile, resolveRuntimeProfile, resolveRuntimeProfileForFlowFile, withRuntimeProfile, } from "./maestro-automate.js";
 export { operateRuntimeOptions } from "./operate-runtime-options.js";
 export { assertVoiceAgentDefinitionsEmbedded, type VoiceAgentFlowNode, voiceConvertOptions, } from "./voice-agent-definitions.js";

package/dist/index.js

@@ -32,7 +32,7 @@ import {
 // package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.203.0-preview.212",
+  version: "1.204.0-preview.211",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -49,8 +49,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",
@@ -77,7 +78,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",
@@ -89,6 +91,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"
@@ -428,6 +431,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);
@@ -456,6 +471,79 @@ 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);
+}
+
+// src/flow-validation.ts
+import {
+  AGENT_NODE_TYPES,
+  cliRules,
+  conditionExpressionRule,
+  isBlockingSeverity,
+  isVoiceAgentNodeType as isVoiceAgentNodeType2,
+  parseWorkflowJson,
+  registerFlowSchemaI18n,
+  runRules,
+  toSerializedNodes
+} from "@uipath/flow-schema";
+import i18next from "i18next";
 
 // src/inline-agent-utils.ts
 import { isAgentNodeType, isVoiceAgentNodeType } from "@uipath/flow-schema";
@@ -523,6 +611,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);
 }
@@ -587,6 +688,260 @@ function setPublishIntentOnInlineAgents(fileFormat) {
   }
 }
 
+// src/flow-validation.ts
+var validationMessagesRegistered = false;
+function ensureValidationMessages() {
+  if (validationMessagesRegistered)
+    return;
+  if (!i18next.isInitialized) {
+    i18next.init({
+      lng: "en",
+      fallbackLng: "en",
+      defaultNS: "validation",
+      resources: {},
+      interpolation: { escapeValue: false }
+    });
+  }
+  registerFlowSchemaI18n(i18next);
+  validationMessagesRegistered = true;
+}
+function hydrateAgentNodeInputs(node, agent) {
+  if (!node.inputs)
+    node.inputs = {};
+  const inputs = node.inputs;
+  const settings = agent.settings;
+  if (isVoiceAgentNodeType2(node.type)) {
+    const voiceSettings = isRecord2(settings) ? settings.voice : undefined;
+    if (isRecord2(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 isRecord2(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;
+}
+
+// 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;
+}
+
 // src/maestro-automate.ts
 import { Path as Path3 } from "@uipath/solutionpackager-tool-core";
 var SENTINEL_FILE_NAME = ".maestro_automate";
@@ -641,7 +996,7 @@ function operateRuntimeOptions(nodes) {
 }
 
 // src/voice-agent-definitions.ts
-import { isVoiceAgentNodeType as isVoiceAgentNodeType2 } from "@uipath/flow-schema";
+import { isVoiceAgentNodeType as isVoiceAgentNodeType3 } from "@uipath/flow-schema";
 function nodeLabel(node) {
   const label = node.display?.label;
   return typeof label === "string" && label.length > 0 ? label : node.id;
@@ -649,7 +1004,7 @@ function nodeLabel(node) {
 function collectVoiceAgentNodes(nodes) {
   const result = [];
   for (const node of nodes) {
-    if (!isVoiceAgentNodeType2(node.type))
+    if (!isVoiceAgentNodeType3(node.type))
       continue;
     const source = readInlineAgentSource(node);
     if (!source) {
@@ -680,7 +1035,7 @@ function assertNoSubflowVoiceAgents(flowJson) {
   const workflow = JSON.parse(flowJson);
   for (const [subflowId, entry] of Object.entries(workflow.subflows ?? {})) {
     for (const node of entry.nodes ?? []) {
-      if (!isVoiceAgentNodeType2(node.type))
+      if (!isVoiceAgentNodeType3(node.type))
         continue;
       throw new Error(`Voice agent node "${nodeLabel(node)}" is inside subflow "${subflowId}". ` + "Voice agent nodes are not supported inside subflows — move it to the top-level flow.");
     }
@@ -713,6 +1068,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;
@@ -724,11 +1082,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 (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      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((issue) => toFlowFinding(issue, flowFilePath));
+    const errors = issues.filter((issue) => issue.severity === "error");
+    for (const issue of issues) {
+      const line = `[${issue.path}] ${issue.message}`;
+      if (issue.severity === "error") {
+        this.logger.error(line);
+      } else {
+        this.logger.warn(line);
+      }
+    }
+    const result = errors.length === 0 ? ToolResult.success() : ToolResult.error(FLOW_VALIDATION_FAILED, `Flow validation failed for ${flowFilePath}: ${errors.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 = `${Path4.normalize(projectPath).replace(/\/$/, "")}/`;
+    const file = Path4.normalize(filePath);
+    return file.toLowerCase().startsWith(root.toLowerCase()) ? file.slice(root.length) : Path4.basename(file);
   }
   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 = Path4.join(tempFolder, NugetConstants.OutputFolderName);
     const contentFolder = Path4.join(localBuildFolder, NugetConstants.ContentFolderName);
@@ -1022,6 +1428,19 @@ class FlowTool extends ProjectTool {
     await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
   }
 }
+function toFlowFinding(issue, flowFilePath) {
+  const { code, description } = splitIssueMessage(issue.message);
+  const nodeId = nodeIdFromIssuePath(issue.path);
+  const pathAddsLocation = nodeId === undefined || issue.path.includes(SUBFLOW_PATH_SEGMENT);
+  return {
+    Level: issue.severity === "warning" ? "Warning" : "Error",
+    Source: FLOW_VALIDATION_SOURCE,
+    ...code !== undefined && { ErrorCode: code },
+    Description: pathAddsLocation ? `${issue.path}: ${description}` : description,
+    FilePath: flowFilePath,
+    ...nodeId !== undefined && { ActivityIdRef: nodeId }
+  };
+}
 
 // src/flow-tool-factory.ts
 class FlowToolFactory {
@@ -1038,6 +1457,7 @@ export {
   FlowToolFactory,
   RuntimeProfile,
   SCHEMA_CONTAINER_MARKER,
+  agentJsonReader,
   applyRuntimeProfile,
   assertVoiceAgentDefinitionsEmbedded,
   buildInlineAgentContract,
@@ -1047,23 +1467,32 @@ export {
   createProcessBindings,
   ensureProcessBindings,
   extractProcessGuid,
+  findProjectFlowFile,
+  hydrateAgentNodeInputs,
   hydrateInlineAgentInputVariables,
+  inlineFlowRefs,
   isInlineAgentNodeType,
   isMaestroAutomateSentinel,
   leafToBinding,
   migrateRawWorkflow,
   operateRuntimeOptions,
+  parseFlowSource,
   readFlowWorkflow,
   readInlineAgentSource,
   reconcileInlineAgentInputVariables,
   replaceExporterVersion,
   resolveAndMigrateWorkflow,
+  resolveProjectFlowFile,
   resolveRuntimeProfile,
   resolveRuntimeProfileForFlowFile,
   resolveWorkflowRefs,
+  runDesignerRules,
   setPublishIntentOnInlineAgents,
+  tryFindProjectFlowFile,
+  tryResolveProjectFlowFile,
+  validateFlowSource,
   voiceConvertOptions,
   withRuntimeProfile
 };
 
-//# debugId=57F20301CD791DCF64756E2164756E21
+//# debugId=00A47C9E92F8453364756E2164756E21

package/dist/inline-agent-utils.d.ts

@@ -1,3 +1,4 @@
+import type { IFileSystem } from "@uipath/filesystem";
 /**
  * Resolve the inline-agent's projectId UUID from a flow node. Falls back to
  * the legacy `model.source` / `agentProjectId` aliases so packaging tolerates
@@ -8,6 +9,14 @@ export declare function readInlineAgentSource(node: {
     inputs?: Record<string, unknown>;
     model?: Record<string, unknown>;
 }): string | undefined;
+/**
+ * An inline agent's `agent.json`, looked up by the agent's source id.
+ * `undefined` when there is none, or it cannot be read or parsed — the agent
+ * then stays as stored and the rules report what it is missing.
+ */
+export type ReadAgentJson = (sourceId: string) => Promise<Record<string, unknown> | undefined>;
+/** Reads `<flowDir>/<sourceId>/agent.json` through the caller's file system. */
+export declare function agentJsonReader(fs: IFileSystem, flowDir: string): ReadAgentJson;
 /** True for a known inline-agent node type. */
 export declare function isInlineAgentNodeType(type: string | undefined): boolean;
 /** One flow-node `agentInputVariables[]` entry. */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "1.203.0-preview.212",
+    "version": "1.204.0-preview.211",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
@@ -22,13 +22,14 @@
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/filesystem": "1.203.0",
+        "@uipath/filesystem": "1.204.0",
         "@uipath/flow-converter": "0.69.3",
         "@uipath/flow-core": "0.115.4-develop",
         "@uipath/flow-migrations": "0.56.2",
         "@uipath/flow-schema": "0.68.0",
-        "@uipath/solutionpackager-tool-core": "1.203.0",
-        "@uipath/tool-agent": "^2.0.0"
+        "@uipath/solutionpackager-tool-core": "1.204.0",
+        "@uipath/tool-agent": "^2.0.0",
+        "i18next": "^23.16.8"
     },
-    "gitHead": "15094ce85cf76c59a54affbed3304febc271f41a"
+    "gitHead": "275e01f1f6098d4c3bc9673f5225f33372822534"
 }