@uipath/packager-tool-flow 1.202.0-preview.141 → 1.202.0-preview.143

package/LICENSE.txt

@@ -0,0 +1,3 @@
+© 2026 UiPath
+Use of this product is subject (a) to the applicable licensing agreement available: https://www.uipath.com/legal/trust-and-security/legal-terms#content-1 and, (b) for paid products listed here https://licensing.uipath.com/: the licensing agreement agreed between you and UiPath.
+(UiPath means UiPath SRL with headquarters at 4 Vasile Alecsandri Str. and 11 Constantin Daniel Str., Building A, floors 5 and 6, District 1, Bucharest 010639, Romania and UiPath Inc. with principal place of business: One Vanderbilt Avenue, 60th Floor, New York, NY 10017)

package/dist/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,8 @@
+# Third-party notices for @uipath/packager-tool-flow
+
+This package is distributed as a bundle: the dependencies below are
+compiled into its `dist/` output rather than installed alongside it.
+Their licences and copyright notices are reproduced here in full, as
+those licences require.
+
+No third-party code is bundled into this package.

package/dist/index.js

@@ -32,14 +32,11 @@ import {
 // package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.202.0-preview.141",
+  version: "1.202.0-preview.143",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
-    ".": {
-      source: "./src/index.ts",
-      default: "./dist/index.js"
-    }
+    ".": "./dist/index.js"
   },
   repository: {
     type: "git",
@@ -68,11 +65,10 @@ var package_default = {
     lint: "biome check ."
   },
   files: [
-    "dist",
-    "src"
+    "dist"
   ],
   author: "",
-  license: "ISC",
+  license: "SEE LICENSE IN LICENSE.txt",
   peerDependencies: {
     "@uipath/filesystem": "workspace:*",
     "@uipath/flow-converter": "0.55.0-develop",
@@ -984,4 +980,4 @@ export {
   voiceConvertOptions
 };
 
-//# debugId=ACCA89657F92EE1E64756E2164756E21
+//# debugId=BB976B0E49EC023664756E2164756E21

package/package.json

@@ -1,13 +1,10 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "1.202.0-preview.141",
+    "version": "1.202.0-preview.143",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
-        ".": {
-            "source": "./src/index.ts",
-            "default": "./dist/index.js"
-        }
+        ".": "./dist/index.js"
     },
     "repository": {
         "type": "git",
@@ -19,11 +16,10 @@
     },
     "types": "./dist/index.d.ts",
     "files": [
-        "dist",
-        "src"
+        "dist"
     ],
     "author": "",
-    "license": "ISC",
+    "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
         "@uipath/filesystem": "1.202.0",
         "@uipath/flow-converter": "0.55.0-develop",
@@ -33,5 +29,5 @@
         "@uipath/solutionpackager-tool-core": "1.202.0",
         "@uipath/tool-agent": "^2.0.0"
     },
-    "gitHead": "2c2b4b3b218f18c26db78eb8cd9ab8002d2b5290"
+    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
 }

package/src/agent-input-encoding-utils.ts

@@ -1,104 +0,0 @@
-/**
- * Encoding-agnostic readers for the inline-agent input encoding (MST-12020).
- *
- * flow-workbench writes inline-agent input names in one of two schemes, gated by its
- * `services.agent-storage.nested-agent-input-schema` feature flag:
- *  - FLAT (shipped default): one top-level `inputSchema` property per input, `__`-joined
- *    (`script1__output__query`), prompts read `{{input.script1__output__query}}`.
- *  - NESTED (flag on): a nested object tree whose auto-created container nodes carry
- *    `x-uipath-container: true`, prompts read `{{input.script1.output.query}}` (the runtime
- *    template engine treats `.` as navigation).
- *
- * The CLI must read BOTH — an agent.json is whatever the authoring canvas last wrote — so these
- * helpers detect per file instead of consuming any flag. Detection is strictly the per-node
- * container marker: an object property WITHOUT the marker is a user-declared whole-object input
- * under either encoding and must be treated as one leaf, never unfolded.
- *
- * TODO: replace with flow-workbench's canonical helpers (`collectInlineAgentInputsFromAgent`,
- * `decodeFlatName`, `getContainerChildProps`) once they are re-exported from
- * `@uipath/flow-converter` — that package is the single source of truth for the encoding.
- */
-
-/** Marker flow-workbench stamps on auto-created container nodes of a NESTED inputSchema. */
-export const SCHEMA_CONTAINER_MARKER = "x-uipath-container";
-
-/** One bindable input leaf of an agent `inputSchema`, in both name forms. */
-export interface AgentInputLeaf {
-    /** Flat `__`-joined name — what a flat prompt token / flat JobArgument uses. */
-    flatKey: string;
-    /** Canonical dotted path — what a nested prompt token navigates. */
-    path: string;
-    /** Declared `type` of the leaf node, when present. */
-    type?: string;
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-    typeof value === "object" && value !== null && !Array.isArray(value);
-
-/** Children of a MARKED container node; `undefined` for leaves and declared whole-object inputs. */
-function containerChildren(prop: unknown): Record<string, unknown> | undefined {
-    if (!isRecord(prop)) return undefined;
-    if (prop[SCHEMA_CONTAINER_MARKER] !== true) return undefined;
-    const children = prop.properties;
-    return isRecord(children) ? children : undefined;
-}
-
-/** Canonical dotted form of an input name from either encoding (`a__b` and `a.b` → `a.b`). */
-export function canonicalAgentInputPath(name: string): string {
-    return name.split("__").join(".");
-}
-
-/**
- * Enumerate the bindable input leaves of an agent `inputSchema`, descending MARKED containers
- * (nested encoding) and passing flat / declared-object top-level keys through as single leaves.
- * Returns `[]` for an absent/empty/malformed schema.
- */
-export function collectAgentInputLeaves(
-    inputSchema: unknown,
-): AgentInputLeaf[] {
-    const properties = isRecord(inputSchema)
-        ? inputSchema.properties
-        : undefined;
-    if (!isRecord(properties)) return [];
-
-    const leaves: AgentInputLeaf[] = [];
-    const walk = (prop: unknown, segments: string[]): void => {
-        const children = containerChildren(prop);
-        if (!children) {
-            // Flat keys already carry their whole path in one segment; keep the
-            // stored spelling for flatKey and canonicalize for the dotted path.
-            const flatKey = segments.join("__");
-            leaves.push({
-                flatKey,
-                path: canonicalAgentInputPath(segments.join(".")),
-                type:
-                    isRecord(prop) && typeof prop.type === "string"
-                        ? prop.type
-                        : undefined,
-            });
-            return;
-        }
-        for (const [key, child] of Object.entries(children)) {
-            walk(child, [...segments, key]);
-        }
-    };
-    for (const [key, prop] of Object.entries(properties)) {
-        walk(prop, [key]);
-    }
-    return leaves;
-}
-
-/**
- * Source binding expression for one input leaf — the inverse of flow-workbench's encode:
- * a `metadata`-rooted path binds `$metadata.*`; everything else binds `$vars.*`.
- */
-export function leafToBinding(leaf: AgentInputLeaf): string {
-    const segments = leaf.path.split(".");
-    if (segments[0] === "metadata") {
-        // A whole-object `metadata` leaf (unmarked object) has no trailing
-        // segments — bind the root `$metadata`, not an invalid `$metadata.`.
-        const rest = segments.slice(1).join(".");
-        return rest ? `=$metadata.${rest}` : "=$metadata";
-    }
-    return `=$vars.${leaf.path}`;
-}

package/src/agents.ts

@@ -1,143 +0,0 @@
-import {
-    healResourceInputEncoding,
-    normalizeAgentInputEncoding,
-} from "@uipath/flow-converter";
-import type {
-    IFileSystem,
-    IToolLogger,
-} from "@uipath/solutionpackager-tool-core";
-import { Path } from "@uipath/solutionpackager-tool-core";
-import { type AgentBuildResult, buildAgent } from "@uipath/tool-agent/build";
-import { mergeAgentBindings, toBindingsResources } from "./bindings.js";
-
-export interface InlineAgentContract {
-    agentJson: Record<string, unknown>;
-    bindingsJson: {
-        version: string;
-        resources: Record<string, unknown>[];
-    };
-}
-
-/**
- * Build the execution contract for one inline agent with the same migration,
- * validation, and binding pipeline used by normal solution packaging. The
- * returned `agentJson` is healed to the flat input encoding (MST-12020) — see
- * {@link healAgentInputEncoding}.
- */
-export async function buildInlineAgentContract(config: {
-    fileSystem: IFileSystem;
-    logger: IToolLogger;
-    projectPath: string;
-    outputPath: string;
-}): Promise<InlineAgentContract> {
-    const built = await buildAgent({
-        ...config,
-        options: { writeBindings: false },
-    });
-
-    return {
-        agentJson: healAgentInputEncoding(
-            built.agent as Record<string, unknown>,
-        ),
-        bindingsJson: {
-            version: built.bindings.version,
-            resources: built.bindings.resources as unknown as Record<
-                string,
-                unknown
-            >[],
-        },
-    };
-}
-
-/**
- * Normalize a built inline-agent contract to the FLAT input encoding (MST-12020) —
- * the one heal every packaging path shares.
- *
- * The sidecar `agent.json` is whatever the authoring canvas last wrote: flat `__`
- * names, or — behind flow-workbench's `nested-agent-input-schema` flag — a nested
- * `x-uipath-container` tree with dotted prompt tokens. Flattens both halves: prompts
- * + `inputSchema` via the agent heal, and each embedded resource's `argumentPath`
- * via the resource heal. Applied by `buildInlineAgentContract` (flow-tool's
- * `flow pack`/`publish`) and by `processAgents` (solution packaging). Defaults to
- * 'flat', idempotent.
- */
-function healAgentInputEncoding(
-    agent: Record<string, unknown>,
-): Record<string, unknown> {
-    const normalized = normalizeAgentInputEncoding(agent);
-    const rawResources = normalized.resources;
-    const resources = Array.isArray(rawResources)
-        ? rawResources.map((resource) =>
-              resource &&
-              typeof resource === "object" &&
-              !Array.isArray(resource)
-                  ? healResourceInputEncoding(
-                        resource as Record<string, unknown>,
-                    )
-                  : resource,
-          )
-        : rawResources;
-    return { ...normalized, resources };
-}
-
-/**
- * Build every root-level agent directory into the content folder and merge
- * their binding resources. Returns each built agent.json keyed by its
- * directory name (the source UUID).
- */
-export const processAgents = async (
-    fileSystem: IFileSystem,
-    logger: IToolLogger,
-    projectPath: string,
-    contentFolder: string,
-): Promise<Map<string, Record<string, unknown>>> => {
-    const agentResults: AgentBuildResult[] = [];
-    const builtAgents = new Map<string, Record<string, unknown>>();
-
-    const entries = await fileSystem.readdir(projectPath);
-    for (const entry of entries) {
-        const sourceDir = Path.join(projectPath, entry);
-        const stat = await fileSystem.stat(sourceDir);
-        if (!stat?.isDirectory()) {
-            continue;
-        }
-
-        const agentJsonPath = Path.join(sourceDir, "agent.json");
-        if (!(await fileSystem.exists(agentJsonPath))) {
-            continue;
-        }
-
-        const outputDir = Path.join(contentFolder, entry);
-        logger.progress(`Processing agent: ${entry}...`);
-
-        const result = await buildAgent({
-            fileSystem,
-            projectPath: sourceDir,
-            outputPath: outputDir,
-            logger,
-        });
-        // buildAgent wrote the sidecar's encoding verbatim; normalize the deploy
-        // artifact to flat (MST-12020), matching `flow pack` / `publish`.
-        let agentJson = result.agent as Record<string, unknown>;
-        if (agentJson) {
-            agentJson = healAgentInputEncoding(agentJson);
-            await fileSystem.writeFile(
-                Path.join(outputDir, "agent.json"),
-                JSON.stringify(agentJson, null, 2),
-            );
-        }
-        agentResults.push(result);
-        builtAgents.set(entry, agentJson);
-    }
-
-    const agentBindingResources = agentResults.flatMap(toBindingsResources);
-    if (agentBindingResources.length > 0) {
-        await mergeAgentBindings(
-            fileSystem,
-            contentFolder,
-            agentBindingResources,
-        );
-    }
-
-    return builtAgents;
-};

package/src/bindings.ts

@@ -1,64 +0,0 @@
-import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-import { Path } from "@uipath/solutionpackager-tool-core";
-import type { AgentBuildResult } from "@uipath/tool-agent/build";
-
-export interface BindingsResource {
-    resource: string;
-    key: string;
-    [other: string]: unknown;
-}
-
-export interface Bindings {
-    version: string;
-    resources: BindingsResource[];
-}
-
-const BINDINGS_V2_FILE_NAME = "bindings_v2.json";
-
-export const toBindingsResources = (
-    result: AgentBuildResult,
-): BindingsResource[] => result.bindings.resources.map((r) => ({ ...r }));
-
-/**
- * Merge agent binding resources into the flow's bindings_v2.json.
- * Deduplicates by (resource, key) tuple, keeping the first occurrence.
- */
-export const mergeAgentBindings = async (
-    fileSystem: IFileSystem,
-    contentFolder: string,
-    agentBindingResources: BindingsResource[],
-): Promise<void> => {
-    const bindingsPath = Path.join(contentFolder, BINDINGS_V2_FILE_NAME);
-
-    let existing: Bindings = { version: "2.0", resources: [] };
-
-    const bindingsExists = await fileSystem.exists(bindingsPath);
-    if (bindingsExists) {
-        const content = await fileSystem.readFile(bindingsPath);
-        if (content) {
-            try {
-                const parsed = JSON.parse(new TextDecoder().decode(content));
-                if (Array.isArray(parsed?.resources)) {
-                    existing = parsed;
-                }
-            } catch {
-                // Invalid JSON, start fresh
-            }
-        }
-    }
-
-    const dedupKey = (b: BindingsResource) =>
-        JSON.stringify([b.resource, b.key]);
-
-    const seen = new Set(existing.resources.map(dedupKey));
-
-    for (const binding of agentBindingResources) {
-        const key = dedupKey(binding);
-        if (!seen.has(key)) {
-            seen.add(key);
-            existing.resources.push(binding);
-        }
-    }
-
-    await fileSystem.writeFile(bindingsPath, JSON.stringify(existing, null, 2));
-};