@uipath/packager-tool-flow 0.0.18 → 0.0.20

package/dist/ensure-process-bindings.d.ts

@@ -0,0 +1,15 @@
+import type { Workflow } from "@uipath/flow-core";
+import type { IToolLogger } from "@uipath/solutionpackager-tool-core";
+/**
+ * Safety net: ensure every process/agent node in the workflow has corresponding
+ * entries in the workflow `bindings` array and that `<bindings.*>` placeholders
+ * in model.context are resolved to `=bindings.<id>` references.
+ *
+ * This handles flows authored outside the CLI (e.g. direct file edits or
+ * skill-generated files) where `addNodeToFlow` was never called, so the
+ * binding creation / resolution step was skipped.
+ *
+ * Mutates the workflow in place. Safe to call multiple times — already-resolved
+ * nodes are skipped.
+ */
+export declare function ensureProcessBindings(workflow: Workflow, logger: IToolLogger): number;

package/dist/flow-io.d.ts

@@ -0,0 +1,27 @@
+import { type IFileSystem } from "@uipath/filesystem";
+import { type Workflow } from "@uipath/flow-schema";
+export type FlowIoLogger = {
+    warn: (message: string) => void;
+};
+export interface ReadFlowWorkflowOptions {
+    /** Filesystem to read from. Defaults to `getFileSystem()`. */
+    fs?: IFileSystem;
+    /** Logger for non-fatal `$ref` resolution failures. */
+    logger?: FlowIoLogger;
+}
+/**
+ * Read a `.flow` file, resolve any `$ref` chunk references, and convert
+ * to an in-memory Workflow.
+ *
+ * Flow files may be split across sibling chunk files (layout.json,
+ * shared-vars.json, subflows/) via JSON `$ref` objects. These must be
+ * resolved before calling the schema validator, since unknown keys
+ * (including `$ref`) are stripped at parse time. Missing ref targets
+ * log a warning (fail-soft) and resolve to `null`; the resulting
+ * workflow may be partial.
+ *
+ * Pass `options.fs` when calling from an environment that injects its
+ * own filesystem (e.g., a packaging tool bundled for the browser);
+ * otherwise the process-wide `getFileSystem()` is used.
+ */
+export declare function readFlowWorkflow(filePath: string, options?: ReadFlowWorkflowOptions): Promise<Workflow>;

package/dist/flow-tool.d.ts

@@ -11,6 +11,14 @@ export declare class FlowTool extends ProjectTool {
     buildAsync(options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     dispose(): Promise<void>;
+    /**
+     * Read the .flow file from the content folder, resolve any unresolved
+     * process bindings, and write the updated workflow back.
+     *
+     * This is the solution pack safety net — flows authored outside the CLI
+     * may have `<bindings.*>` placeholders that need resolving before packaging.
+     */
+    private resolveProcessBindings;
     /**
      * Read the .flow file from the content folder, convert to BPMN, and
      * generate entry-points.json, bindings_v2.json, and the BPMN file.

package/dist/index.d.ts

@@ -1,2 +1,4 @@
+export { type FlowIoLogger, readFlowWorkflow } from "./flow-io.js";
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
+export { setPublishIntentOnInlineAgents } from "./inline-agent-utils.js";

package/dist/index.js

@@ -14,6 +14,7 @@ import {
   generateOperateJson,
   getBindingResources,
   getEntryPoints,
+  inMemoryWorkflowToFileFormat,
   ProjectType
 } from "@uipath/flow-schema";
 import {
@@ -92,6 +93,162 @@ var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
   }
 };
 
+// src/ensure-process-bindings.ts
+import { addBinding, createBinding } from "@uipath/flow-core";
+var PROCESS_NODE_PREFIXES = [
+  "uipath.core.rpa-workflow.",
+  "uipath.agent.resource.tool.process.",
+  "uipath.core.agent.",
+  "uipath.core.api-workflow."
+];
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+function isProcessNode(nodeType) {
+  return PROCESS_NODE_PREFIXES.some((prefix) => nodeType?.startsWith(prefix));
+}
+function extractProcessGuid(nodeType) {
+  const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
+  if (!match) {
+    throw new Error(`Invalid process node type: "${nodeType}". ` + "Expected a known prefix followed by a process GUID.");
+  }
+  return match[1];
+}
+function createProcessBindings(manifest) {
+  const processGuid = extractProcessGuid(manifest.nodeType);
+  const model = manifest.model;
+  const processName = model?.bindings?.values?.name ?? "";
+  const folderPath = model?.bindings?.values?.folderPath;
+  if (folderPath == null) {
+    throw new Error("Manifest is missing model.bindings.values.folderPath. " + "Cannot create process bindings without a folder path.");
+  }
+  const subType = model?.bindings?.resourceSubType ?? "Process";
+  const resourceKey = model?.bindings?.resourceKey ?? processGuid;
+  const nameBinding = createBinding({
+    name: "name",
+    value: processName,
+    resource: "process",
+    resourceKey,
+    propertyAttribute: "name",
+    resourceSubType: subType
+  });
+  const folderBinding = createBinding({
+    name: "folderPath",
+    value: folderPath,
+    resource: "process",
+    resourceKey,
+    propertyAttribute: "folderPath",
+    resourceSubType: subType
+  });
+  if (folderPath === "" && folderBinding.default === undefined) {
+    folderBinding.default = "";
+  }
+  return { nameBinding, folderBinding };
+}
+function resolveContextPlaceholders(context, storedName, storedFolder) {
+  if (!context)
+    return;
+  for (const entry of context) {
+    if (entry.name === "name" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+      entry.default = storedName.default;
+      entry.value = `=bindings.${storedName.id}`;
+    } else if (entry.name === "folderPath" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+      entry.default = storedFolder.default;
+      entry.value = `=bindings.${storedFolder.id}`;
+    }
+  }
+}
+function ensureProcessBindings(workflow, logger) {
+  const nodes = workflow.nodes ?? [];
+  const definitions = workflow.definitions ?? [];
+  let bindingsCreated = 0;
+  for (const node of nodes) {
+    if (!isProcessNode(node.type))
+      continue;
+    const nodeModel = node.model;
+    const defModel = definitions.find((d) => d.nodeType === node.type)?.model;
+    const hasUnresolved = [nodeModel, defModel].some((m) => m?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
+    if (!hasUnresolved)
+      continue;
+    const definition = definitions.find((d) => d.nodeType === node.type);
+    if (!definition)
+      continue;
+    let nameBinding;
+    let folderBinding;
+    try {
+      ({ nameBinding, folderBinding } = createProcessBindings(definition));
+    } catch (err) {
+      logger.warn(`Skipping binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`);
+      continue;
+    }
+    const beforeCount = workflow.bindings?.length ?? 0;
+    addBinding(workflow, nameBinding);
+    addBinding(workflow, folderBinding);
+    const storedBindings = workflow.bindings;
+    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+    resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
+    resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+    const added = (workflow.bindings?.length ?? 0) - beforeCount;
+    bindingsCreated += added;
+    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
+  }
+  if (bindingsCreated > 0) {
+    logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
+  }
+  return bindingsCreated;
+}
+
+// src/flow-io.ts
+import { getFileSystem } from "@uipath/filesystem";
+import { resolveAndConvertWorkflow } from "@uipath/flow-schema";
+async function readFlowWorkflow(filePath, options = {}) {
+  const fs = options.fs ?? getFileSystem();
+  const logger = options.logger;
+  const raw = JSON.parse(await readUtf8(fs, filePath));
+  const resolver = async (refPath, baseUri) => {
+    const resolvedPath = fs.path.resolve(fs.path.dirname(baseUri), refPath);
+    const refContent = await readUtf8OrNull(fs, resolvedPath);
+    if (refContent === null) {
+      logger?.warn(`Failed to resolve $ref "${refPath}": file not found at ${resolvedPath}`);
+      return null;
+    }
+    return JSON.parse(refContent);
+  };
+  const { workflow } = await resolveAndConvertWorkflow(raw, resolver, {
+    baseUri: filePath
+  });
+  return workflow;
+}
+async function readUtf8(fs, filePath) {
+  const content = await readUtf8OrNull(fs, filePath);
+  if (content === null) {
+    throw new Error(`Could not read flow file: ${filePath}`);
+  }
+  return content;
+}
+async function readUtf8OrNull(fs, filePath) {
+  const buffer = await fs.readFile(filePath);
+  if (buffer === null)
+    return null;
+  return typeof buffer === "string" ? buffer : new TextDecoder().decode(buffer);
+}
+
+// src/inline-agent-utils.ts
+var INLINE_AGENT_DEF_TYPES = [
+  "uipath.agent.autonomous",
+  "uipath.agent.conversational"
+];
+function setPublishIntentOnInlineAgents(fileFormat) {
+  const ff = fileFormat;
+  for (const def of ff.definitions ?? []) {
+    const d = def;
+    if (INLINE_AGENT_DEF_TYPES.includes(d.nodeType)) {
+      const model = d.model ?? {};
+      model.__packageIntent = "Publish";
+      d.model = model;
+    }
+  }
+}
+
 // src/flow-tool.ts
 var FlowConstants = {
   EntryPointsFileName: "entry-points.json",
@@ -121,6 +278,8 @@ class FlowTool extends ProjectTool {
       await this.copyProjectFiles(options.projectPath, contentFolder);
       this.logger.progress("Processing agents...");
       await processAgents(this.fileSystem, this.logger, options.projectPath, contentFolder);
+      this.logger.progress("Resolving process bindings...");
+      await this.resolveProcessBindings(contentFolder);
       this.logger.progress("Generating packaging artifacts from .flow...");
       await this.generateFlowPackagingArtifacts(contentFolder, options.projectStorageId ?? "");
       this.logger.progress("Creating operate.json file...");
@@ -164,6 +323,27 @@ class FlowTool extends ProjectTool {
       await this._temporaryStorage.cleanup();
     } catch {}
   }
+  async resolveProcessBindings(contentFolder) {
+    const entries = await this.fileSystem.readdir(contentFolder);
+    const flowFile = entries.find((e) => e.endsWith(".flow"));
+    if (!flowFile)
+      return;
+    const flowPath = Path3.join(contentFolder, flowFile);
+    const flowBuffer = await this.fileSystem.readFile(flowPath);
+    if (!flowBuffer)
+      return;
+    const flowJson = typeof flowBuffer === "string" ? flowBuffer : new TextDecoder().decode(flowBuffer);
+    let workflow;
+    try {
+      workflow = JSON.parse(flowJson);
+    } catch {
+      return;
+    }
+    const count = ensureProcessBindings(workflow, this.logger);
+    if (count > 0) {
+      await this.fileSystem.writeFile(flowPath, JSON.stringify(workflow, null, 4));
+    }
+  }
   async generateFlowPackagingArtifacts(contentFolder, projectId) {
     const entries = await this.fileSystem.readdir(contentFolder);
     const flowFile = entries.find((e) => e.endsWith(".flow"));
@@ -171,50 +351,111 @@ class FlowTool extends ProjectTool {
       this.logger.warn("No .flow file found in content folder — skipping artifact generation");
       return;
     }
-    const flowJsonBuffer = await this.fileSystem.readFile(Path3.join(contentFolder, flowFile));
-    if (!flowJsonBuffer) {
-      this.logger.warn(`Could not read ${flowFile} — skipping artifact generation`);
-      return;
-    }
-    const flowJson = typeof flowJsonBuffer === "string" ? flowJsonBuffer : new TextDecoder().decode(flowJsonBuffer);
-    let flowData;
+    const flowFilePath = Path3.join(contentFolder, flowFile);
+    let workflow;
     try {
-      flowData = JSON.parse(flowJson);
-    } catch {
-      this.logger.warn(`Could not parse ${flowFile} as JSON — skipping artifact generation`);
+      workflow = await readFlowWorkflow(flowFilePath, {
+        fs: this.fileSystem,
+        logger: this.logger
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`Could not load ${flowFile} as a workflow — skipping artifact generation: ${message}`);
       return;
     }
     const bpmnFileName = flowFile.replace(/\.flow$/, ".bpmn");
     const bpmnPath = Path3.join(contentFolder, bpmnFileName);
-    const { bpmn } = await convertFlowToBpmn(flowJson);
+    const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+    setPublishIntentOnInlineAgents(fileFormat);
+    const resolvedFlowJson = JSON.stringify(fileFormat);
+    const { bpmn } = await convertFlowToBpmn(resolvedFlowJson);
     await this.fileSystem.writeFile(bpmnPath, bpmn);
-    const packagingNodes = (flowData.nodes ?? []).map((node) => ({
+    const packagingNodes = (workflow.nodes ?? []).map((node) => ({
       id: node.id,
       type: node.type,
-      data: {
-        type: node.type,
-        typeVersion: node.typeVersion ?? "1.0.0",
-        display: node.display,
-        inputs: node.inputs,
-        outputs: node.outputs,
-        model: node.model
-      }
+      typeVersion: node.typeVersion ?? "1.0",
+      display: node.display,
+      inputs: node.inputs,
+      outputs: node.outputs
     }));
-    const variables = flowData.variables ?? {};
-    const bindings = flowData.bindings ?? [];
+    const variables = workflow.variables ?? {};
+    const bindings = workflow.bindings ?? [];
+    const definitions = workflow.definitions ?? [];
     const entryPointsPath = Path3.join(contentFolder, FlowConstants.EntryPointsFileName);
-    const entryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, ProjectType.Flow);
-    await this.fileSystem.writeFile(entryPointsPath, `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}
+    const entryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
+    const INLINE_AGENT_TYPES = [
+      "uipath.agent.autonomous",
+      "uipath.agent.conversational"
+    ];
+    const readSource = (n) => {
+      const inputs = n.inputs;
+      const model = n.model;
+      const candidates = [
+        inputs?.source,
+        model?.source,
+        inputs?.agentProjectId,
+        model?.agentProjectId
+      ];
+      for (const c of candidates) {
+        if (typeof c === "string" && c.length > 0)
+          return c;
+      }
+      return;
+    };
+    const agentEntryPoints = [];
+    const seenSources = new Set;
+    for (const node of workflow.nodes ?? []) {
+      const n = node;
+      if (!INLINE_AGENT_TYPES.includes(n.type))
+        continue;
+      const source = readSource(n);
+      if (!source)
+        continue;
+      if (seenSources.has(source))
+        continue;
+      seenSources.add(source);
+      const agentJsonPath = Path3.join(contentFolder, source, "agent.json");
+      if (!await this.fileSystem.exists(agentJsonPath))
+        continue;
+      let agent = {};
+      try {
+        const raw = await this.fileSystem.readFile(agentJsonPath);
+        if (raw) {
+          const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+          agent = JSON.parse(text);
+        }
+      } catch {
+        continue;
+      }
+      const inputSchema = agent.inputSchema ?? {
+        type: "object",
+        properties: {}
+      };
+      const outputSchema = agent.outputSchema ?? {
+        type: "object",
+        properties: {}
+      };
+      agentEntryPoints.push({
+        filePath: `content/${source}/agent.json`,
+        uniqueId: agent.projectId ?? source,
+        type: "agent",
+        input: inputSchema,
+        output: outputSchema,
+        displayName: agent.name ?? "Agent"
+      });
+    }
+    const allEntryPoints = [...entryPoints, ...agentEntryPoints];
+    await this.fileSystem.writeFile(entryPointsPath, `${JSON.stringify(generateEntryPointsJson(allEntryPoints), null, 2)}
 `);
     const bindingsPath = Path3.join(contentFolder, FlowConstants.BindingsV2FileName);
-    const bindingResources = getBindingResources(packagingNodes, bindings);
+    const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
     await this.fileSystem.writeFile(bindingsPath, `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
 `);
     const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
     const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
     const startEventId = startEventMatch?.[1] ?? "start";
     const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
-    await this.fileSystem.writeFile(operatePath, `${JSON.stringify(generateOperateJson(projectId || flowData.id || "", mainEntryPoint), null, 2)}
+    await this.fileSystem.writeFile(operatePath, `${JSON.stringify(generateOperateJson(projectId || workflow.id || "", mainEntryPoint), null, 2)}
 `);
   }
   async copyProjectFiles(projectPath, contentFolder) {
@@ -322,6 +563,8 @@ class FlowToolFactory {
 // src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
 export {
+  setPublishIntentOnInlineAgents,
+  readFlowWorkflow,
   FlowToolFactory,
   FlowTool
 };

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

@@ -0,0 +1,8 @@
+/**
+ * Set `__packageIntent = "Publish"` on inline agent definitions in a
+ * file-format workflow so the BPMN converter emits "content/" prefixed
+ * entry points.
+ *
+ * Mutates `fileFormat` in place.
+ */
+export declare function setPublishIntentOnInlineAgents(fileFormat: unknown): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
@@ -18,23 +18,6 @@
         "registry": "https://registry.npmjs.org/"
     },
     "types": "./dist/index.d.ts",
-    "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-converter --external @uipath/flow-schema && tsc --emitDeclarationOnly --outDir dist",
-        "dev": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-converter --external @uipath/flow-schema --watch",
-        "test": "vitest run",
-        "test:browser": "vitest run --config=vitest.browser.config.ts",
-        "test:coverage": "vitest run --coverage",
-        "test:browser:coverage": "vitest run --config=vitest.browser.config.ts --coverage",
-        "test:all": "bun run test && bun run test:browser",
-        "test:all:coverage": "bun run test:coverage && bun run test:browser:coverage",
-        "prepack": "bun run build",
-        "publish:dry": "bun publish --dry-run",
-        "publish:gh": "bun publish",
-        "version:patch": "bun version patch --no-git-tag-version",
-        "version:minor": "bun version minor --no-git-tag-version",
-        "version:major": "bun version major --no-git-tag-version",
-        "lint": "biome check ."
-    },
     "files": [
         "dist",
         "!dist/**/*.map",
@@ -43,21 +26,25 @@
     "author": "",
     "license": "ISC",
     "peerDependencies": {
-        "@uipath/flow-converter": "^0.1.6",
-        "@uipath/flow-schema": "^0.2.141",
+        "@uipath/filesystem": "1.195.0",
+        "@uipath/flow-converter": "^0.1.273",
+        "@uipath/flow-core": "^0.2.376",
+        "@uipath/flow-schema": "^0.2.495",
         "@uipath/solutionpackager-tool-core": "0.0.33",
-        "@uipath/tool-agent": "^1.0.1"
+        "@uipath/tool-agent": "^1.2.4"
     },
     "devDependencies": {
-        "@types/node": "^25.5.0",
+        "@types/node": "^25.5.2",
+        "@uipath/filesystem": "1.195.0",
+        "@uipath/flow-core": "^0.2.376",
         "@uipath/solutionpackager-tool-core": "0.0.33",
-        "@uipath/tool-agent": "^1.0.1",
-        "@vitest/browser": "^4.0.14",
-        "@vitest/browser-playwright": "^4.0.14",
-        "@vitest/coverage-v8": "^4.0.14",
+        "@uipath/tool-agent": "^1.2.4",
+        "@vitest/browser": "^4.1.6",
+        "@vitest/browser-playwright": "^4.1.6",
+        "@vitest/coverage-v8": "^4.1.6",
         "playwright": "^1.57.0",
-        "typescript": "^5.9.3",
-        "vitest": "^4.0.14"
+        "typescript": "^6.0.2",
+        "vitest": "^4.1.6"
     },
-    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
+    "gitHead": "ca8e2977762f231364386b40d976c61ca9ce87ca"
 }

package/src/ensure-process-bindings.ts

@@ -0,0 +1,213 @@
+import type { Binding, NodeInstance, Workflow } from "@uipath/flow-core";
+import { addBinding, createBinding } from "@uipath/flow-core";
+import type { IToolLogger } from "@uipath/solutionpackager-tool-core";
+
+/**
+ * Node type prefixes that use process-style bindings (GUID as resourceKey).
+ * Covers RPA workflows, agent process tools, and agent nodes.
+ */
+const PROCESS_NODE_PREFIXES = [
+    "uipath.core.rpa-workflow.",
+    "uipath.agent.resource.tool.process.",
+    "uipath.core.agent.",
+    "uipath.core.api-workflow.",
+];
+
+const UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+
+function isProcessNode(nodeType: string): boolean {
+    return PROCESS_NODE_PREFIXES.some((prefix) => nodeType?.startsWith(prefix));
+}
+
+function extractProcessGuid(nodeType: string): string {
+    const match = nodeType.match(
+        /^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i,
+    );
+    if (!match) {
+        throw new Error(
+            `Invalid process node type: "${nodeType}". ` +
+                "Expected a known prefix followed by a process GUID.",
+        );
+    }
+    return match[1];
+}
+
+function createProcessBindings(manifest: {
+    nodeType: string;
+    model?: Record<string, unknown>;
+}): { nameBinding: Binding; folderBinding: Binding } {
+    const processGuid = extractProcessGuid(manifest.nodeType);
+    const model = manifest.model as
+        | {
+              bindings?: {
+                  resourceSubType?: string;
+                  resourceKey?: string;
+                  values?: { name?: string; folderPath?: string };
+              };
+          }
+        | undefined;
+    const processName = model?.bindings?.values?.name ?? "";
+    const folderPath = model?.bindings?.values?.folderPath;
+    if (folderPath == null) {
+        throw new Error(
+            "Manifest is missing model.bindings.values.folderPath. " +
+                "Cannot create process bindings without a folder path.",
+        );
+    }
+    const subType = model?.bindings?.resourceSubType ?? "Process";
+    const resourceKey = model?.bindings?.resourceKey ?? processGuid;
+
+    const nameBinding = createBinding({
+        name: "name",
+        value: processName,
+        resource: "process",
+        resourceKey,
+        propertyAttribute: "name",
+        resourceSubType: subType,
+    });
+    const folderBinding = createBinding({
+        name: "folderPath",
+        value: folderPath,
+        resource: "process",
+        resourceKey,
+        propertyAttribute: "folderPath",
+        resourceSubType: subType,
+    });
+    if (folderPath === "" && folderBinding.default === undefined) {
+        folderBinding.default = "";
+    }
+
+    return { nameBinding, folderBinding };
+}
+
+function resolveContextPlaceholders(
+    context: Array<Record<string, unknown>> | undefined,
+    storedName: Binding,
+    storedFolder: Binding,
+): void {
+    if (!context) return;
+    for (const entry of context) {
+        if (
+            entry.name === "name" &&
+            typeof entry.value === "string" &&
+            UNRESOLVED_BINDING_PATTERN.test(entry.value)
+        ) {
+            entry.default = storedName.default;
+            entry.value = `=bindings.${storedName.id}`;
+        } else if (
+            entry.name === "folderPath" &&
+            typeof entry.value === "string" &&
+            UNRESOLVED_BINDING_PATTERN.test(entry.value)
+        ) {
+            entry.default = storedFolder.default;
+            entry.value = `=bindings.${storedFolder.id}`;
+        }
+    }
+}
+
+/**
+ * Safety net: ensure every process/agent node in the workflow has corresponding
+ * entries in the workflow `bindings` array and that `<bindings.*>` placeholders
+ * in model.context are resolved to `=bindings.<id>` references.
+ *
+ * This handles flows authored outside the CLI (e.g. direct file edits or
+ * skill-generated files) where `addNodeToFlow` was never called, so the
+ * binding creation / resolution step was skipped.
+ *
+ * Mutates the workflow in place. Safe to call multiple times — already-resolved
+ * nodes are skipped.
+ */
+export function ensureProcessBindings(
+    workflow: Workflow,
+    logger: IToolLogger,
+): number {
+    const nodes = (workflow.nodes ?? []) as NodeInstance[];
+    const definitions = (workflow.definitions ?? []) as Array<{
+        nodeType: string;
+        model?: Record<string, unknown>;
+    }>;
+
+    let bindingsCreated = 0;
+
+    for (const node of nodes) {
+        if (!isProcessNode(node.type)) continue;
+
+        const nodeModel = node.model as
+            | { context?: Array<Record<string, unknown>> }
+            | undefined;
+        const defModel = definitions.find((d) => d.nodeType === node.type)
+            ?.model as { context?: Array<Record<string, unknown>> } | undefined;
+
+        // Check both node and definition contexts for unresolved placeholders
+        const hasUnresolved = [nodeModel, defModel].some((m) =>
+            m?.context?.some(
+                (entry) =>
+                    typeof entry.value === "string" &&
+                    UNRESOLVED_BINDING_PATTERN.test(entry.value),
+            ),
+        );
+        if (!hasUnresolved) continue;
+
+        const definition = definitions.find((d) => d.nodeType === node.type);
+        if (!definition) continue;
+
+        let nameBinding: Binding;
+        let folderBinding: Binding;
+        try {
+            ({ nameBinding, folderBinding } =
+                createProcessBindings(definition));
+        } catch (err: unknown) {
+            logger.warn(
+                `Skipping binding resolution for node "${node.id}": ${err instanceof Error ? err.message : String(err)}`,
+            );
+            continue;
+        }
+
+        const beforeCount =
+            (workflow.bindings as Binding[] | undefined)?.length ?? 0;
+        addBinding(workflow, nameBinding);
+        addBinding(workflow, folderBinding);
+
+        // Resolve against stored bindings (addBinding deduplicates)
+        const storedBindings = workflow.bindings as Binding[];
+        const storedName =
+            storedBindings.find(
+                (b) =>
+                    b.resourceKey === nameBinding.resourceKey &&
+                    b.propertyAttribute === nameBinding.propertyAttribute,
+            ) ?? nameBinding;
+        const storedFolder =
+            storedBindings.find(
+                (b) =>
+                    b.resourceKey === folderBinding.resourceKey &&
+                    b.propertyAttribute === folderBinding.propertyAttribute,
+            ) ?? folderBinding;
+
+        // Resolve placeholders in node model.context
+        resolveContextPlaceholders(
+            nodeModel?.context,
+            storedName,
+            storedFolder,
+        );
+
+        // Resolve in definition model.context for BPMN converter
+        resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+
+        const added =
+            ((workflow.bindings as Binding[] | undefined)?.length ?? 0) -
+            beforeCount;
+        bindingsCreated += added;
+
+        logger.info(
+            `Resolved process bindings for node "${node.id}" (${node.type})`,
+        );
+    }
+
+    if (bindingsCreated > 0) {
+        logger.info(
+            `ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`,
+        );
+    }
+
+    return bindingsCreated;
+}

package/src/flow-io.ts

@@ -0,0 +1,73 @@
+import { getFileSystem, type IFileSystem } from "@uipath/filesystem";
+import { resolveAndConvertWorkflow, type Workflow } from "@uipath/flow-schema";
+
+export type FlowIoLogger = {
+    warn: (message: string) => void;
+};
+
+export interface ReadFlowWorkflowOptions {
+    /** Filesystem to read from. Defaults to `getFileSystem()`. */
+    fs?: IFileSystem;
+    /** Logger for non-fatal `$ref` resolution failures. */
+    logger?: FlowIoLogger;
+}
+
+/**
+ * Read a `.flow` file, resolve any `$ref` chunk references, and convert
+ * to an in-memory Workflow.
+ *
+ * Flow files may be split across sibling chunk files (layout.json,
+ * shared-vars.json, subflows/) via JSON `$ref` objects. These must be
+ * resolved before calling the schema validator, since unknown keys
+ * (including `$ref`) are stripped at parse time. Missing ref targets
+ * log a warning (fail-soft) and resolve to `null`; the resulting
+ * workflow may be partial.
+ *
+ * Pass `options.fs` when calling from an environment that injects its
+ * own filesystem (e.g., a packaging tool bundled for the browser);
+ * otherwise the process-wide `getFileSystem()` is used.
+ */
+export async function readFlowWorkflow(
+    filePath: string,
+    options: ReadFlowWorkflowOptions = {},
+): Promise<Workflow> {
+    const fs = options.fs ?? getFileSystem();
+    const logger = options.logger;
+    const raw = JSON.parse(await readUtf8(fs, filePath));
+
+    const resolver = async (refPath: string, baseUri: string) => {
+        const resolvedPath = fs.path.resolve(fs.path.dirname(baseUri), refPath);
+        const refContent = await readUtf8OrNull(fs, resolvedPath);
+        if (refContent === null) {
+            logger?.warn(
+                `Failed to resolve $ref "${refPath}": file not found at ${resolvedPath}`,
+            );
+            return null;
+        }
+        return JSON.parse(refContent);
+    };
+
+    const { workflow } = await resolveAndConvertWorkflow(raw, resolver, {
+        baseUri: filePath,
+    });
+    return workflow;
+}
+
+async function readUtf8(fs: IFileSystem, filePath: string): Promise<string> {
+    const content = await readUtf8OrNull(fs, filePath);
+    if (content === null) {
+        throw new Error(`Could not read flow file: ${filePath}`);
+    }
+    return content;
+}
+
+async function readUtf8OrNull(
+    fs: IFileSystem,
+    filePath: string,
+): Promise<string | null> {
+    const buffer = await fs.readFile(filePath);
+    if (buffer === null) return null;
+    return typeof buffer === "string"
+        ? buffer
+        : new TextDecoder().decode(buffer);
+}

package/src/flow-tool.ts

@@ -1,14 +1,18 @@
 import { convertFlowToBpmn } from "@uipath/flow-converter";
 import {
+    type EntryPoint,
     generateBindingsJson,
     generateEntryPointsJson,
     generateOperateJson,
     getBindingResources,
     getEntryPoints,
+    inMemoryWorkflowToFileFormat,
     type PackagingBinding,
     type PackagingNode,
+    type PackagingNodeManifest,
     type PackagingWorkflowVariables,
     ProjectType,
+    type Workflow,
 } from "@uipath/flow-schema";
 import type {
     EntryPointsFileModel,
@@ -30,6 +34,9 @@ import {
     ToolResult,
 } from "@uipath/solutionpackager-tool-core";
 import { processAgents } from "./agents.js";
+import { ensureProcessBindings } from "./ensure-process-bindings.js";
+import { readFlowWorkflow } from "./flow-io.js";
+import { setPublishIntentOnInlineAgents } from "./inline-agent-utils.js";
 
 const FlowConstants = {
     EntryPointsFileName: "entry-points.json",
@@ -91,6 +98,9 @@ export class FlowTool extends ProjectTool {
                 contentFolder,
             );
 
+            this.logger.progress("Resolving process bindings...");
+            await this.resolveProcessBindings(contentFolder);
+
             this.logger.progress(
                 "Generating packaging artifacts from .flow...",
             );
@@ -169,6 +179,43 @@ export class FlowTool extends ProjectTool {
         }
     }
 
+    /**
+     * Read the .flow file from the content folder, resolve any unresolved
+     * process bindings, and write the updated workflow back.
+     *
+     * This is the solution pack safety net — flows authored outside the CLI
+     * may have `<bindings.*>` placeholders that need resolving before packaging.
+     */
+    private async resolveProcessBindings(contentFolder: string): Promise<void> {
+        const entries = await this.fileSystem.readdir(contentFolder);
+        const flowFile = entries.find((e: string) => e.endsWith(".flow"));
+        if (!flowFile) return;
+
+        const flowPath = Path.join(contentFolder, flowFile);
+        const flowBuffer = await this.fileSystem.readFile(flowPath);
+        if (!flowBuffer) return;
+
+        const flowJson =
+            typeof flowBuffer === "string"
+                ? flowBuffer
+                : new TextDecoder().decode(flowBuffer);
+
+        let workflow: Workflow;
+        try {
+            workflow = JSON.parse(flowJson) as Workflow;
+        } catch {
+            return;
+        }
+
+        const count = ensureProcessBindings(workflow, this.logger);
+        if (count > 0) {
+            await this.fileSystem.writeFile(
+                flowPath,
+                JSON.stringify(workflow, null, 4),
+            );
+        }
+    }
+
     /**
      * Read the .flow file from the content folder, convert to BPMN, and
      * generate entry-points.json, bindings_v2.json, and the BPMN file.
@@ -191,70 +238,52 @@ export class FlowTool extends ProjectTool {
             return;
         }
 
-        // Read the .flow JSON
-        const flowJsonBuffer = await this.fileSystem.readFile(
-            Path.join(contentFolder, flowFile),
-        );
-        if (!flowJsonBuffer) {
-            this.logger.warn(
-                `Could not read ${flowFile} — skipping artifact generation`,
-            );
-            return;
-        }
-        const flowJson =
-            typeof flowJsonBuffer === "string"
-                ? flowJsonBuffer
-                : new TextDecoder().decode(flowJsonBuffer);
-
-        let flowData: {
-            id?: string;
-            nodes?: Array<{
-                id: string;
-                type: string;
-                typeVersion?: string;
-                display?: Record<string, unknown>;
-                inputs?: Record<string, unknown>;
-                outputs?: Record<string, unknown>;
-                model?: Record<string, unknown>;
-            }>;
-            bindings?: PackagingBinding[];
-            variables?: PackagingWorkflowVariables;
-        };
-
+        const flowFilePath = Path.join(contentFolder, flowFile);
+        let workflow: Workflow;
         try {
-            flowData = JSON.parse(flowJson);
-        } catch {
+            workflow = await readFlowWorkflow(flowFilePath, {
+                fs: this.fileSystem,
+                logger: this.logger,
+            });
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
             this.logger.warn(
-                `Could not parse ${flowFile} as JSON — skipping artifact generation`,
+                `Could not load ${flowFile} as a workflow — skipping artifact generation: ${message}`,
             );
             return;
         }
 
-        // Convert .flow to BPMN (always regenerate from .flow source)
+        // Convert .flow to BPMN from the resolved file format, so any $ref
+        // content is inlined before the converter sees it.
+        // For pack/publish, set __packageIntent = "Publish" on inline agent
+        // definitions so the converter emits "content/" prefixed entry points.
         const bpmnFileName = flowFile.replace(/\.flow$/, ".bpmn");
         const bpmnPath = Path.join(contentFolder, bpmnFileName);
-        const { bpmn } = await convertFlowToBpmn(flowJson);
+        const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+        setPublishIntentOnInlineAgents(fileFormat);
+        const resolvedFlowJson = JSON.stringify(fileFormat);
+        const { bpmn } = await convertFlowToBpmn(resolvedFlowJson);
         await this.fileSystem.writeFile(bpmnPath, bpmn);
 
-        // Build PackagingNode[] from the .flow nodes
-        const packagingNodes: PackagingNode[] = (flowData.nodes ?? []).map(
-            (node) => ({
-                id: node.id,
-                type: node.type,
-                data: {
-                    type: node.type,
-                    typeVersion: node.typeVersion ?? "1.0.0",
-                    display: node.display,
-                    inputs: node.inputs,
-                    outputs: node.outputs,
-                    model: node.model,
-                },
+        // Map file-format nodes to flat PackagingNode shape so
+        // getEntryPoints can read inputs.entryPointId and display.label.
+        const packagingNodes: PackagingNode[] = (workflow.nodes ?? []).map(
+            (node: Record<string, unknown>) => ({
+                id: node.id as string,
+                type: node.type as string,
+                typeVersion: (node.typeVersion as string) ?? "1.0",
+                display: node.display as PackagingNode["display"],
+                inputs: node.inputs as Record<string, unknown>,
+                outputs: node.outputs as Record<string, unknown>,
             }),
         );
 
         const variables =
-            (flowData.variables as PackagingWorkflowVariables) ?? {};
-        const bindings = (flowData.bindings ?? []) as PackagingBinding[];
+            (workflow.variables as PackagingWorkflowVariables) ?? {};
+        const bindings = (workflow.bindings ?? []) as PackagingBinding[];
+        // definitions required: without it getBindingResources silently drops process/queue/app bindings from bindings_v2.json
+        const definitions = (workflow.definitions ??
+            []) as PackagingNodeManifest[];
 
         // Generate entry-points.json (always regenerate from .flow source)
         const entryPointsPath = Path.join(
@@ -265,11 +294,94 @@ export class FlowTool extends ProjectTool {
             bpmnFileName,
             packagingNodes,
             variables,
+            definitions,
             ProjectType.Flow,
         );
+
+        // Scan for inline agent nodes and add their entry points.
+        // The source UUID lives at `inputs.source` (canonical post
+        // flow-core 0.2.50) or `model.source` (legacy). Validation
+        // accepts both, so packaging must too — otherwise legacy flows
+        // produce a .nupkg whose entry-points.json silently omits the
+        // agent, and runtime returns 404 for `StartInlineAgentJob`.
+        //
+        // Canonical copy of this resolution rule lives at
+        // `flow-tool/src/services/packaging-utils.ts:readInlineAgentSource`.
+        // It's duplicated here (rather than imported) because `flow-tool`
+        // already depends on this package, so the reverse import would
+        // be a cycle. Keep both in sync; longer-term the helper should
+        // move to `@uipath/flow-schema` (an external dep both can share).
+        const INLINE_AGENT_TYPES = [
+            "uipath.agent.autonomous",
+            "uipath.agent.conversational",
+        ];
+        const readSource = (n: Record<string, unknown>): string | undefined => {
+            const inputs = n.inputs as Record<string, unknown> | undefined;
+            const model = n.model as Record<string, unknown> | undefined;
+            const candidates: unknown[] = [
+                inputs?.source,
+                model?.source,
+                inputs?.agentProjectId,
+                model?.agentProjectId,
+            ];
+            for (const c of candidates) {
+                if (typeof c === "string" && c.length > 0) return c;
+            }
+            return undefined;
+        };
+        const agentEntryPoints: EntryPoint[] = [];
+        const seenSources = new Set<string>();
+        for (const node of workflow.nodes ?? []) {
+            const n = node as Record<string, unknown>;
+            if (!INLINE_AGENT_TYPES.includes(n.type as string)) continue;
+            const source = readSource(n);
+            if (!source) continue;
+            if (seenSources.has(source)) continue;
+            seenSources.add(source);
+
+            const agentJsonPath = Path.join(
+                contentFolder,
+                source,
+                "agent.json",
+            );
+            if (!(await this.fileSystem.exists(agentJsonPath))) continue;
+
+            let agent: Record<string, unknown> = {};
+            try {
+                const raw = await this.fileSystem.readFile(agentJsonPath);
+                if (raw) {
+                    const text =
+                        typeof raw === "string"
+                            ? raw
+                            : new TextDecoder().decode(raw);
+                    agent = JSON.parse(text) as Record<string, unknown>;
+                }
+            } catch {
+                continue;
+            }
+
+            const inputSchema = (agent.inputSchema ?? {
+                type: "object",
+                properties: {},
+            }) as EntryPoint["input"];
+            const outputSchema = (agent.outputSchema ?? {
+                type: "object",
+                properties: {},
+            }) as EntryPoint["output"];
+            agentEntryPoints.push({
+                filePath: `content/${source}/agent.json`,
+                uniqueId: (agent.projectId as string) ?? source,
+                type: "agent" as EntryPoint["type"],
+                input: inputSchema,
+                output: outputSchema,
+                displayName: (agent.name as string) ?? "Agent",
+            });
+        }
+
+        const allEntryPoints = [...entryPoints, ...agentEntryPoints];
         await this.fileSystem.writeFile(
             entryPointsPath,
-            `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}\n`,
+            `${JSON.stringify(generateEntryPointsJson(allEntryPoints), null, 2)}\n`,
         );
 
         // Generate bindings_v2.json (always regenerate from .flow source)
@@ -277,7 +389,11 @@ export class FlowTool extends ProjectTool {
             contentFolder,
             FlowConstants.BindingsV2FileName,
         );
-        const bindingResources = getBindingResources(packagingNodes, bindings);
+        const bindingResources = getBindingResources(
+            packagingNodes,
+            bindings,
+            definitions,
+        );
         await this.fileSystem.writeFile(
             bindingsPath,
             `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}\n`,
@@ -293,7 +409,7 @@ export class FlowTool extends ProjectTool {
         const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
         await this.fileSystem.writeFile(
             operatePath,
-            `${JSON.stringify(generateOperateJson(projectId || flowData.id || "", mainEntryPoint), null, 2)}\n`,
+            `${JSON.stringify(generateOperateJson(projectId || workflow.id || "", mainEntryPoint), null, 2)}\n`,
         );
     }
 

package/src/index.ts

@@ -2,7 +2,9 @@
 import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
 import { FlowToolFactory } from "./flow-tool-factory.js";
 
+export { type FlowIoLogger, readFlowWorkflow } from "./flow-io.js";
 export { FlowTool } from "./flow-tool.js";
 export { FlowToolFactory } from "./flow-tool-factory.js";
+export { setPublishIntentOnInlineAgents } from "./inline-agent-utils.js";
 
 toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory());

package/src/inline-agent-utils.ts

@@ -0,0 +1,23 @@
+const INLINE_AGENT_DEF_TYPES = [
+    "uipath.agent.autonomous",
+    "uipath.agent.conversational",
+];
+
+/**
+ * Set `__packageIntent = "Publish"` on inline agent definitions in a
+ * file-format workflow so the BPMN converter emits "content/" prefixed
+ * entry points.
+ *
+ * Mutates `fileFormat` in place.
+ */
+export function setPublishIntentOnInlineAgents(fileFormat: unknown): void {
+    const ff = fileFormat as Record<string, unknown[]>;
+    for (const def of ff.definitions ?? []) {
+        const d = def as Record<string, unknown>;
+        if (INLINE_AGENT_DEF_TYPES.includes(d.nodeType as string)) {
+            const model = (d.model ?? {}) as Record<string, unknown>;
+            model.__packageIntent = "Publish";
+            d.model = model;
+        }
+    }
+}