@uipath/flow-tool 1.202.2 → 1.203.0-preview.180

package/dist/ro-BWR3ONRR-vzx3hy8a.js

@@ -0,0 +1,173 @@
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/ro-BWR3ONRR.js
+var agentDuplicateToolNames_duplicateName_message = "Numele instrumentului „{{name}}” este utilizat de mai multe instrumente pe acest agent. Fiecare instrument trebuie să aibă un nume unic.";
+var agentEmptyVar_unwrittenVariable_message = 'Agentul folosește "$vars.{{root}}", dar niciun nod nu atribuie o valoare lui "{{root}}", astfel încât va fi gol în timpul execuției. Asociați-l cu un output al unui nod (de exemplu, output-ul "<node>.output" al unui conector) sau oferiți-i o sursă de valoare.';
+var agentInputRefs_ambiguousUnderscoreRoot_message = "Referința promptului este „$vars.{{ref}}”, dar numele „{{rootSegment}}” conține „__”, care este rezervat ca separator de codificare pentru input-ul agentului și nu poate fi convertit dus-întors. Redenumiți-l pentru a elimina caracterul de subliniere dublu.";
+var agentInputRefs_reservedMetadataRoot_message = 'Referințele din prompt la "$vars.{{ref}}" există, dar o variabilă sau un nod numit "metadata" intră în conflict cu spațiul de nume "$metadata" după ce este serializat pentru agent și nu poate fi reconvertit fără pierderi. Redenumiți-l cu un nume diferit de "metadata".';
+var agentInputRefs_reservedNamespace_message = '"$agent.{{ref}}" este un spațiu de nume intern al runtime-ului agentului din Flow și nu poate fi utilizat direct în prompturi. Faceți referire în schimb la variabila de flux prin "$vars.{{ref}}" sau "$metadata.{{ref}}".';
+var agentInputRefs_unresolvedRef_message = 'Promptul face referire la "$vars.{{ref}}", dar nu există nicio variabilă workflow sau niciun nod „{{rootSegment}}”. Adăugați variabila/nodul în flux sau eliminați referința.';
+var conditionExpression_decisionWrapped_message = "Condiție nevalidă pentru „{{nodeLabel}}”: {{error}}";
+var conditionExpression_incomplete_message = "Expresie incompletă";
+var conditionExpression_invalid_message = "Expresie invalidă";
+var conditionExpression_required_message = "Adăugați o condiție";
+var conversationalVoiceEndCall_callContextInvalid_message = "{{label}}: Contextul apelului trebuie asociat cu un obiect de context al apelului";
+var conversationalVoice_callContextInvalid_message = "{{label}}: Contextul apelului trebuie asociat cu un obiect de context al apelului";
+var conversationalVoice_callContextRequired_message = "{{label}}: Contextul apelului este necesar când vocea este activată";
+var dataTransform_customScriptMissing_message = "Operațiunea de script personalizat „{{nodeLabel}}” nu are niciun script";
+var dataTransform_filterMissingField_message = "Condiției de filtrare „{{nodeLabel}}” îi lipsește un câmp";
+var dataTransform_filterNoConditions_message = "Operațiunea de filtrare „{{nodeLabel}}” nu are condiții";
+var dataTransform_groupByAggMissingField_message = "Agregării de grupare „{{nodeLabel}}” îi lipsește un câmp";
+var dataTransform_groupByAggMissingOutputName_message = "Agregării „group by” pentru „{{nodeLabel}}” îi lipsește un nume de ieșire";
+var dataTransform_groupByMissingField_message = "Operației „grupare după” pentru „{{nodeLabel}}” îi lipsește câmpul de grupare";
+var dataTransform_mapMissingField_message = "În maparea câmpurilor pentru „{{nodeLabel}}” lipsește un câmp";
+var dataTransform_mapNoMappings_message = "Operațiunea de mapare „{{nodeLabel}}” necesită cel puțin o mapare a câmpurilor atunci când câmpurile originale nu sunt păstrate";
+var dataTransform_missingCollection_message = "„{{nodeLabel}}” nu are o variabilă de colecție";
+var dataTransform_noOperations_message = '"{{nodeLabel}}" nu are nicio operațiune configurată';
+var doWhile_limitOutOfRange_message = "Setați numărul maxim de iterații între {{min}} și {{max}}";
+var entityQuery_emptyFilterExpression_message = "Scrieți o expresie pentru fiecare filtru sau eliminați filtrul";
+var entityQuery_emptyFilterValueList_message = "Adăugați cel puțin o valoare la filtru sau eliminați filtrul";
+var entityQuery_uncarryableExpression_message = "Stocați această expresie într-o variabilă sau scrieți-o fără spații, ghilimele sau bare oblice inverse";
+var escalation_appRequired_message = "Selectează o aplicație de acțiune";
+var escalation_memoryArgumentRequired_message = "{{label}}: Adăugați cel puțin un argument pentru memoria agentului sau dezactivați memoria agentului";
+var escalation_nameRequired_message = "{{label}}: Numele escaladării este obligatoriu";
+var escalation_quickFormDuplicateFieldLabel_message = "{{label}}: Mai multe câmpuri sunt etichetate „{{fieldLabel}}” — sarcina de escaladare ar păstra doar unul dintre ele. Faceți etichetele câmpurilor unice";
+var escalation_recipientRequired_message = "{{label}}: Destinatarul escaladării este obligatoriu";
+var governance_hitlRequired_message = "Agentul trebuie să aibă cel puțin o resursă de escaladare sau un guardrail cu acțiune HITL. Regula este impusă de politica de guvernanță: {{policyName}}";
+var governance_maxIterationsExceeded_message = "Numărul maxim de iterații depășește {{maxIterations}}. Regula este impusă de politica de guvernanță: {{policyName}}";
+var governance_maxTokensExceeded_message = "Numărul maxim de tokenuri per răspuns depășește {{maxTokens}}. Regula este aplicată de politica de guvernanță: {{policyName}}";
+var governance_modelNotAvailable_message = "{{model}} model nu este permis, impus de politica de guvernanță: {{policyName}}";
+var governance_noAllowedModel_message = "Nu este selectat niciun model permis, impus de politica de guvernanță: {{policyName}}";
+var governance_temperatureExceeded_message = "Temperatura depășește {{maxTemperature}}. Regula este aplicată prin politica de guvernanță: {{policyName}}";
+var hitlQuickForm_emptySchema_message = "Adăugați cel puțin un câmp";
+var hitlQuickForm_fieldLabelRequired_message = "Eticheta câmpului este obligatorie";
+var ixpSchemaDraft_invalidWithDetail_message = 'Schema nu este validă pentru "{{nodeLabel}}": {{detail}}';
+var ixpSchemaDraft_invalid_message = "Schema nu este validă pentru „{{nodeLabel}}”.";
+var outputMapping_missing_message = '"{{nodeLabel}}" nu are mapare de ieșire pentru "{{varId}}"';
+var schemaValidator_genericKeyword_message = '"{{fieldName}}" pe "{{nodeLabel}}": {{detail}}';
+var schemaValidator_invalidEnum_message = '"{{fieldName}}" din "{{nodeLabel}}" trebuie să fie una dintre valorile permise';
+var schemaValidator_invalidField_message = '"{{fieldName}}" din "{{nodeLabel}}" este nevalid';
+var schemaValidator_invalidPattern_message = '"{{fieldName}}" din "{{nodeLabel}}" are un format nevalid';
+var schemaValidator_outOfRange_message = '"{{fieldName}}" pe "{{nodeLabel}}" {{detail}}';
+var schemaValidator_required_message = '"{{fieldName}}" este obligatoriu în "{{nodeLabel}}"';
+var schemaValidator_typeMismatch_message = "„{{fieldName}}” din „{{nodeLabel}}” așteaptă {{type}}";
+var schemaValidator_validation_genericError = "Eroare de validare";
+var scriptBody_mustache_message = "Faceți referire direct la variabile fără acolade duble";
+var singleConversationTrigger_message = "Este permis un singur declanșator de conversație pentru fiecare proces. Eliminați declanșatorul suplimentar.";
+var triggerRequired_message = "Procesul trebuie să aibă cel puțin un nod de declanșare";
+var ro_default = {
+  agentDuplicateToolNames_duplicateName_message,
+  agentEmptyVar_unwrittenVariable_message,
+  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentInputRefs_reservedMetadataRoot_message,
+  agentInputRefs_reservedNamespace_message,
+  agentInputRefs_unresolvedRef_message,
+  conditionExpression_decisionWrapped_message,
+  conditionExpression_incomplete_message,
+  conditionExpression_invalid_message,
+  conditionExpression_required_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoice_callContextRequired_message,
+  dataTransform_customScriptMissing_message,
+  dataTransform_filterMissingField_message,
+  dataTransform_filterNoConditions_message,
+  dataTransform_groupByAggMissingField_message,
+  dataTransform_groupByAggMissingOutputName_message,
+  dataTransform_groupByMissingField_message,
+  dataTransform_mapMissingField_message,
+  dataTransform_mapNoMappings_message,
+  dataTransform_missingCollection_message,
+  dataTransform_noOperations_message,
+  doWhile_limitOutOfRange_message,
+  entityQuery_emptyFilterExpression_message,
+  entityQuery_emptyFilterValueList_message,
+  entityQuery_uncarryableExpression_message,
+  escalation_appRequired_message,
+  escalation_memoryArgumentRequired_message,
+  escalation_nameRequired_message,
+  escalation_quickFormDuplicateFieldLabel_message,
+  escalation_recipientRequired_message,
+  governance_hitlRequired_message,
+  governance_maxIterationsExceeded_message,
+  governance_maxTokensExceeded_message,
+  governance_modelNotAvailable_message,
+  governance_noAllowedModel_message,
+  governance_temperatureExceeded_message,
+  hitlQuickForm_emptySchema_message,
+  hitlQuickForm_fieldLabelRequired_message,
+  ixpSchemaDraft_invalidWithDetail_message,
+  ixpSchemaDraft_invalid_message,
+  outputMapping_missing_message,
+  schemaValidator_genericKeyword_message,
+  schemaValidator_invalidEnum_message,
+  schemaValidator_invalidField_message,
+  schemaValidator_invalidPattern_message,
+  schemaValidator_outOfRange_message,
+  schemaValidator_required_message,
+  schemaValidator_typeMismatch_message,
+  schemaValidator_validation_genericError,
+  scriptBody_mustache_message,
+  singleConversationTrigger_message,
+  triggerRequired_message
+};
+export {
+  agentDuplicateToolNames_duplicateName_message,
+  agentEmptyVar_unwrittenVariable_message,
+  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentInputRefs_reservedMetadataRoot_message,
+  agentInputRefs_reservedNamespace_message,
+  agentInputRefs_unresolvedRef_message,
+  conditionExpression_decisionWrapped_message,
+  conditionExpression_incomplete_message,
+  conditionExpression_invalid_message,
+  conditionExpression_required_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoice_callContextRequired_message,
+  dataTransform_customScriptMissing_message,
+  dataTransform_filterMissingField_message,
+  dataTransform_filterNoConditions_message,
+  dataTransform_groupByAggMissingField_message,
+  dataTransform_groupByAggMissingOutputName_message,
+  dataTransform_groupByMissingField_message,
+  dataTransform_mapMissingField_message,
+  dataTransform_mapNoMappings_message,
+  dataTransform_missingCollection_message,
+  dataTransform_noOperations_message,
+  ro_default as default,
+  doWhile_limitOutOfRange_message,
+  entityQuery_emptyFilterExpression_message,
+  entityQuery_emptyFilterValueList_message,
+  entityQuery_uncarryableExpression_message,
+  escalation_appRequired_message,
+  escalation_memoryArgumentRequired_message,
+  escalation_nameRequired_message,
+  escalation_quickFormDuplicateFieldLabel_message,
+  escalation_recipientRequired_message,
+  governance_hitlRequired_message,
+  governance_maxIterationsExceeded_message,
+  governance_maxTokensExceeded_message,
+  governance_modelNotAvailable_message,
+  governance_noAllowedModel_message,
+  governance_temperatureExceeded_message,
+  hitlQuickForm_emptySchema_message,
+  hitlQuickForm_fieldLabelRequired_message,
+  ixpSchemaDraft_invalidWithDetail_message,
+  ixpSchemaDraft_invalid_message,
+  outputMapping_missing_message,
+  schemaValidator_genericKeyword_message,
+  schemaValidator_invalidEnum_message,
+  schemaValidator_invalidField_message,
+  schemaValidator_invalidPattern_message,
+  schemaValidator_outOfRange_message,
+  schemaValidator_required_message,
+  schemaValidator_typeMismatch_message,
+  schemaValidator_validation_genericError,
+  scriptBody_mustache_message,
+  singleConversationTrigger_message,
+  triggerRequired_message
+};
+
+//# debugId=148C0693C9BEE5AE64756E2164756E21

package/dist/ru-GSCT4ARZ-jrxwev63.js

@@ -0,0 +1,10 @@
+import"./packager-tool-j78fwwhq.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-expression-model/node_modules/@uipath/flow-core/dist/ru-GSCT4ARZ.js
+var ru_default = {};
+export {
+  ru_default as default
+};
+
+//# debugId=7DB3A9EB33FD392364756E2164756E21

package/dist/ru-WBLQ5B2U-s4em88p0.js

@@ -0,0 +1,10 @@
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/ru-WBLQ5B2U.js
+var ru_default = {};
+export {
+  ru_default as default
+};
+
+//# debugId=B7EA616BDBCEA40B64756E2164756E21

package/dist/{serialization-BXU6AKAN-n5b0v0kd.js → serialization-BXU6AKAN-z0vcrhpz.js}

@@ -3,7 +3,7 @@ import {
   IDP_PROCESSOR_BINDING_RESOURCE,
   isContainerNodeManifest,
   readIdpProcessorKey
-} from "./packager-tool-9y5am147.js";
+} from "./packager-tool-z185rq2a.js";
 import {
   require_lib
 } from "./packager-tool-zfrp8ecz.js";
@@ -45,7 +45,7 @@ import {
   transformExpression,
   transformNodeExpressions,
   unwrapScriptBody
-} from "./packager-tool-aa481g36.js";
+} from "./packager-tool-gpwec9sp.js";
 import {
   FIRE_AND_FORGET_INPUT,
   IN_FILTER_OPERATOR,
@@ -77,14 +77,7 @@ import {
   stripVarsPrefix,
   toEngineRefPath,
   toFilterModel
-} from "./packager-tool-yr3bws42.js";
-import"./packager-tool-z83pga0z.js";
-import {
-  init_esm_shims
-} from "./packager-tool-6ejqwbw9.js";
-import {
-  __glob
-} from "./packager-tool-mcaf4ewf.js";
+} from "./packager-tool-vqcnvaae.js";
 import"./packager-tool-gbgfwx8f.js";
 import {
   BINDINGS_PATH_PREFIX,
@@ -130,10 +123,18 @@ import {
   resolveDoWhileLimit,
   supportsVariableUpdates,
   validateRelatedPaths
-} from "./packager-tool-e8td7b01.js";
+} from "./packager-tool-fvm2dddf.js";
 import {
   createI18nRegistrar
 } from "./packager-tool-p79yh9ww.js";
+import"./packager-tool-vdc8r21p.js";
+import"./packager-tool-z83pga0z.js";
+import {
+  init_esm_shims
+} from "./packager-tool-6ejqwbw9.js";
+import {
+  __glob
+} from "./packager-tool-mcaf4ewf.js";
 import"./packager-tool-4mna26cc.js";
 import"./packager-tool-c23zrhj8.js";
 import {
@@ -37586,4 +37587,4 @@ export {
   walkAncestorCollectionLoops
 };
 
-//# debugId=A7F983B55FF9F91464756E2164756E21
+//# debugId=B6DA3DCF029B982664756E2164756E21

package/dist/services/connector-binding-validator.d.ts

@@ -31,6 +31,7 @@ export declare const MANAGED_HTTP_NODE_TYPE = "core.action.http.v2";
 export interface ConnectorBindingNode {
     id: string;
     type: string;
+    typeVersion?: unknown;
     name?: unknown;
     display?: {
         label?: unknown;
@@ -43,6 +44,13 @@ export interface ConnectorBindingWorkflow {
     subflows?: Record<string, {
         nodes?: ConnectorBindingNode[];
     }>;
+    /**
+     * The flow's `definitions[]` list. Read only to skip the MCP check on a
+     * node whose definition already marks `toolName` required (the shared
+     * `schema-validation` rule reports that one — avoid a second, softer
+     * report for the same defect).
+     */
+    definitions?: unknown[];
 }
 export interface ConnectorBindingValidationOptions {
     /**
@@ -88,7 +96,8 @@ export interface ConnectorCatalog {
 export declare function loadConnectorCatalog(): Promise<ConnectorCatalog>;
 /**
  * Walk every node in the flow + every subflow and emit one issue per
- * unbound, connector-shaped Managed HTTP node. Scope mirrors
+ * unbound, connector-shaped Managed HTTP node — plus one per MCP "Run a Tool"
+ * node with no selected tool (UV-15018). Scope mirrors
  * `validateResourceBindings` so the new check stays consistent with the
  * §A4 binding-integrity pass already in `FlowValidateService`.
  */

package/dist/services/definitions-lookup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The one lookup for a node's `definitions[]` entry, shared by every site
+ * that resolves a definition to WRITE to it or to act on its content
+ * (`patchOutputType` / `patchRequiredInputs` in connector-service, the
+ * toolName-required suppression in connector-binding-validator).
+ *
+ * `definitions[]` can legitimately hold two versions of one `nodeType`
+ * (schema-validation keys manifests by `nodeType:version`), so an unversioned
+ * lookup can resolve the wrong version's entry. The rules:
+ *
+ * - A node that carries a `typeVersion` resolves ONLY the entry with that
+ *   exact `version`. A node whose version has no entry resolves nothing —
+ *   it does not validate against any of the present entries either
+ *   (`validateDefinitionsPresent` reports it), and patching a different
+ *   version's entry would stamp this node's truth onto other nodes' schema.
+ * - A node with NO `typeVersion` (hand-authored flows, unit fixtures) falls
+ *   back to a SOLE `nodeType` match — never one of several versions picked
+ *   arbitrarily.
+ *
+ * Read-only display paths that prefer a best guess over nothing wrap this
+ * with a first-entry fallback (`findMatchingDefinition` in flow-eval-utils);
+ * write paths must not.
+ */
+export declare function findNodeDefinition(definitions: ReadonlyArray<unknown> | undefined, node: {
+    type?: string;
+    typeVersion?: unknown;
+}): Record<string, unknown> | undefined;

package/dist/services/flow-debug-service.d.ts

@@ -0,0 +1,290 @@
+/**
+ * Service for debugging Flow files.
+ *
+ * Converts a .flow file to BPMN XML, generates the required project files,
+ * begins a debug session in Orchestrator, creates a debug instance in PIMS,
+ * and polls for execution status.
+ */
+import type { Workflow } from "@uipath/flow-core";
+import type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, DebugVariablesResponse, ElementExecution, StudioWebDebugConfig } from "@uipath/maestro-sdk";
+import { RuntimeProfile } from "@uipath/packager-tool-flow";
+import { type SolutionImportResponse } from "@uipath/solution-sdk";
+export type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, DebugVariablesResponse, ElementExecution, SolutionImportResponse, StudioWebDebugConfig, };
+/**
+ * Canonical user-facing message + instructions surfaced when `flow debug`
+ * is run against a standalone Flow project (no enclosing `.uipx`).
+ *
+ * Exported so the command layer (and tests) can assert the exact envelope
+ * shape required by UiPath/cli#2023 without re-stringifying it.
+ */
+export declare const FLOW_DEBUG_MISSING_SOLUTION_MESSAGE = "Flow debug requires this Flow to be inside a solution.";
+export declare const FLOW_DEBUG_MISSING_SOLUTION_INSTRUCTIONS = "Create a solution wrapper and import this Flow before debugging: `uip solution init <name>` then `uip solution projects import <flow-dir>` from inside the solution directory, then re-run `uip maestro flow debug`.";
+/**
+ * Canonical user-facing message surfaced when the Flow project's directory
+ * is not listed in the enclosing solution's `.uipx` Projects[] manifest.
+ *
+ * Without this preflight, Studio Web rejects the upload with an opaque
+ *   `Import failed (400): The solution archive does not contain any valid projects.`
+ * (MST-10004). Failing locally with the project path + solution path is
+ * far more actionable.
+ */
+export declare const FLOW_DEBUG_UNREGISTERED_PROJECT_MESSAGE = "Flow project is not registered in the enclosing solution.";
+export declare const buildFlowDebugUnregisteredProjectInstructions: (projectDir: string, solutionFile: string) => string;
+/**
+ * Thrown by {@link FlowDebugService.executeProjectViaStudioWeb} when the
+ * Flow project is not enclosed by a `.uipx` solution wrapper.
+ *
+ * The command layer translates this into a `ValidationError` envelope
+ * (exit code 3) so users get an actionable, locally-generated diagnostic
+ * before any upload is attempted — fixing the opaque server-side 400
+ * tracked in UiPath/cli#2023.
+ */
+export declare class MissingSolutionWrapperError extends Error {
+    readonly instructions: string;
+    constructor(message?: string, instructions?: string);
+}
+/**
+ * Thrown by {@link FlowDebugService.executeProjectViaStudioWeb} when an
+ * enclosing `.uipx` solution wrapper exists but does not list the Flow
+ * project directory in its `Projects[]` manifest.
+ *
+ * The command layer translates this into a `ValidationError` envelope
+ * (exit code 3). This replaces the opaque server-side
+ *   `Import failed (400): The solution archive does not contain any valid projects.`
+ * surfaced from Studio Web (MST-10004) with a typed, locally-detected
+ * diagnostic that names the exact repair command.
+ */
+export declare class UnregisteredProjectError extends Error {
+    readonly instructions: string;
+    readonly projectDir: string;
+    readonly solutionFile: string;
+    constructor(projectDir: string, solutionFile: string);
+}
+/**
+ * What an upload-only run returns: the solution is on Studio Web and the
+ * designer URL is known, but no debug session or instance was created.
+ */
+export interface StudioWebUploadResult {
+    uploadedOnly: true;
+    solutionId: string;
+    studioWebUrl: string;
+}
+export declare const FLOW_DEBUG_INBOUND_VOICE_MESSAGE = "Inbound voice flows cannot be debugged from the CLI.";
+export declare const buildFlowDebugInboundVoiceInstructions: (triggerLabel: string) => string;
+/**
+ * Thrown when the flow starts from an incoming-call trigger. Only a real call
+ * to a published flow can raise one, so the run would never advance.
+ */
+export declare class InboundVoiceDebugError extends Error {
+    readonly instructions: string;
+    constructor(triggerLabel: string);
+}
+/**
+ * Reject a flow that starts from an incoming-call trigger. Keyed on the
+ * trigger, not on voice nodes: an outbound flow carries the same nodes.
+ */
+export declare function assertNotInboundVoiceFlow(workflow: {
+    nodes?: readonly unknown[];
+}): void;
+export declare class FlowDebugService {
+    private readonly fs;
+    constructor();
+    /**
+     * Pre-flight check: confirm the Flow project lives inside a `.uipx`
+     * solution wrapper by walking ancestor directories.
+     *
+     * Throws {@link MissingSolutionWrapperError} if no `.uipx` is found.
+     * Reuses {@link findNearestParentUipxFile} from `@uipath/solution-sdk`
+     * to share the ancestor-walk semantics with `uip solution projects import`.
+     *
+     * Returns the absolute path of the `.uipx` file when present so callers
+     * can log it without re-walking.
+     */
+    assertEnclosingSolution(projectPath: string): Promise<string>;
+    /**
+     * Pre-flight check: confirm the Flow project's directory is actually
+     * listed in the enclosing solution's `.uipx` `Projects[]` manifest.
+     *
+     * Throws {@link UnregisteredProjectError} when the manifest does not
+     * include the project. Comparison is canonicalized via `realpath()`
+     * so case-insensitive filesystems and symlinks don't yield false
+     * negatives.
+     *
+     * This is the local guard for MST-10004: without it, Studio Web
+     * silently accepts the upload and then rejects the import with an
+     * opaque `code:20001 / "The solution archive does not contain any
+     * valid projects."` HTTP 400. By failing locally, the agent (or
+     * human) gets the exact repair command (`uip solution projects add`)
+     * before any network I/O.
+     */
+    assertProjectRegisteredInSolution(projectPath: string, solutionFile: string): Promise<void>;
+    /**
+     * Read and parse a .flow file.
+     */
+    readFlowFile(flowFilePath: string): Promise<Workflow>;
+    /**
+     * Read a .bpmn file and return the raw XML string.
+     */
+    readBpmnFile(bpmnFilePath: string): Promise<string>;
+    /**
+     * Convert a Workflow to BPMN XML using @uipath/flow-converter.
+     *
+     * The inline-agent `Orchestrator.StartInlineAgentJob` activity's
+     * `entryPoint` must stay BARE (`<projectId>/agent.json`, no `content/`
+     * prefix). At debug time Orchestrator's debug-flow detector resolves the
+     * agent by matching the activity `entryPoint` against the
+     * `FpsProperties.debug.master.processes[].entryPointPath` entry, and that
+     * entry uses the bare path. A `content/`-prefixed activity entryPoint never
+     * matches, so the agent faults with `[170007]` "the job's associated
+     * process could not be found" (verified byte-for-byte against a working
+     * Studio Web debug capture, which also emits the bare path).
+     *
+     * We therefore do NOT call `setPublishIntentOnInlineAgents` here — that
+     * marks agents `__packageIntent = "Publish"`, which makes the converter
+     * emit the `content/`-prefixed form used by real publish/deploy. That form
+     * is wrong for a debug session.
+     */
+    convertToBpmn(workflow: Workflow, projectDir?: string): Promise<string>;
+    /**
+     * Reconstruct inline-agent `agentInputVariables` from each agent's
+     * `agent.json` `inputSchema` when the flow node leaves them empty.
+     *
+     * Studio Web keeps the input binding in the agent's `inputSchema` and rebuilds
+     * the node's `agentInputVariables` from it on load; the `.flow` it writes
+     * carries an empty `agentInputVariables`. The CLI converter derives the
+     * agent's `JobArguments` from `agentInputVariables` (it never reads
+     * `agent.json`), so an SW-authored flow would otherwise convert to an agent
+     * with empty input — works in SW, fails on `uip maestro flow debug`.
+     *
+     * We mirror SW: for each inline-agent node, read `<projectDir>/<source>/agent.json`
+     * and **reconcile** the node's `agentInputVariables` against the agent's
+     * `inputSchema.properties` — the contract the runtime actually binds. We
+     * *add* a derived entry for every schema input LEAF the node is missing and
+     * *preserve* every entry the node already declares, so a custom/divergent
+     * binding is never clobbered. Leaves are enumerated encoding-agnostically
+     * (MST-12020): a flat key (`<node>__output__<field>`) is one leaf; a NESTED
+     * schema's `x-uipath-container` trees are descended to their leaves — so an
+     * agent.json authored by a nested-flag canvas still reconciles per-field
+     * bindings instead of one un-navigable whole-container binding. Either way
+     * the derived id is the FLAT spelling (matching the packager's flat-healed
+     * prompt tokens), the binding is `=$vars.<node>.output.<field>`
+     * (`metadata`-rooted paths → `$metadata`), and "already declares" is
+     * checked on the CANONICAL dotted path so a flat and a nested spelling of
+     * the same input never produce a duplicate JobArgument.
+     *
+     * Reconciling (rather than only filling an empty list) also catches drift: an
+     * `agent.json` that gained an input the `.flow` node never re-wired would
+     * otherwise silently drop that input at debug. We therefore always read the
+     * agent.json. Best-effort — a missing/unreadable `agent.json` or absent
+     * `inputSchema` leaves the node as-is, and a node that already covers every
+     * schema key is left untouched (no spurious mutation).
+     */
+    private hydrateInlineAgentInputs;
+    /**
+     * Generate project files (operate.json, entry-points.json, bindings_v2.json,
+     * package-descriptor.json) into a temporary directory alongside the BPMN and .flow file.
+     */
+    generateProjectFiles(flowData: Workflow, bpmnXml: string, flowFileContent?: string, startEventId?: string, profile?: RuntimeProfile): Promise<string>;
+    /**
+     * Build a .uis solution package from the generated project files.
+     * Creates a solution wrapper, zips it into .uis format.
+     */
+    buildSolutionPackage(projectDir: string, projectName: string): Promise<string>;
+    private writeSingleProjectSolutionMetadata;
+    /**
+     * Build the `debug.master.processes` descriptors for every in-solution
+     * project so a flow-as-node callee's `Orchestrator.StartAgenticProcess`
+     * resolves the child — the same FpsProperties registry inline agents use,
+     * so no Orchestrator provisioning or deployed release is needed.
+     *
+     * Each descriptor pairs the Studio Web-minted `projectId` (from the upload
+     * result, matched by folder name) and the uploaded `solutionId` with the
+     * project's type + per-project entry point read from the staged solution.
+     * The lead Flow being debugged gets the exact BPMN + start node the session
+     * launches from; standalone Agent projects are skipped (inline agents are
+     * registered separately via `inlineAgents`).
+     */
+    private buildSolutionProjectDescriptors;
+    /**
+     * Compile a sibling flow project's `.flow` to BPMN + packaging artifacts
+     * in place inside its staged directory. Sibling flow projects are copied
+     * from the solution with only their `.flow` source; a flow-as-node call
+     * needs the compiled `.bpmn` (and bindings/manifests) in the package or the
+     * child job faults with 180003 (FileMissingInProjectArchive). Mirrors the
+     * artifact generation the lead flow already gets.
+     */
+    private generateSiblingFlowPackage;
+    /**
+     * Write a flow project's debug-package artifacts (`.flow`, compiled
+     * `.bpmn`, packaging manifests, resolved flow) into `projectDir`. Shared by
+     * the lead flow being debugged and each sibling flow-as-node callee so the
+     * conversion/packaging pipeline lives in one place. Returns the values the
+     * lead path needs downstream (entry points, start node, bpmn file name).
+     */
+    private writeFlowProjectPackage;
+    /** Map a raw `.uiproj` ProjectType to the BeginSession wire vocabulary. */
+    private toWireProjectType;
+    /**
+     * Normalize an entry point to the `debug.master` form: no leading slash,
+     * no `content/` prefix (e.g. `/Flow.bpmn#start` or
+     * `content/new.bpmn#manualTrigger1` → `Flow.bpmn#start` / `new.bpmn#manualTrigger1`).
+     */
+    private normalizeEntryPoint;
+    /** Read the first `entry-points.json` filePath in a project dir, or "". */
+    private readFirstEntryPointPath;
+    /**
+     * Derive an entry point from a project's compiled `.bpmn` start event,
+     * for projects whose `entry-points.json` is empty (ProcessOrchestration).
+     * Matches Studio Web's `/{bpmn}#{startEvent}` form (leading slash kept).
+     * Returns "" when no `.bpmn` is present.
+     */
+    private deriveEntryPointFromBpmn;
+    /** Read a project's `.uiproj` `ProjectType`, or undefined if unavailable. */
+    private readProjectTypeRaw;
+    /**
+     * Build a name→type map from the `.uipx` Projects array so
+     * {@link buildSolutionProjectDescriptors} can resolve the type for
+     * projects that have no `project.uiproj` (JS/TS Functions).
+     */
+    static buildProjectTypeMap(projects?: Array<{
+        ProjectRelativePath: string;
+        Type?: unknown;
+    }>): Map<string, string>;
+    /**
+     * Full Studio Web debug flow from a flow project directory:
+     * 1. Validate project directory has required files
+     * 2. Read .flow file + generate packaging artifacts on the fly
+     * 3. Build .uis solution package containing ALL projects in the solution
+     * 5. Upload/overwrite to Studio Web → get projectId + solutionId
+     * 6. Begin debug session in Orchestrator → get jobKey
+     * 7. Create debug instance in PIMS with solutionId + projectId
+     * 8. Poll PIMS debug-instances for completion
+     */
+    executeProjectViaStudioWeb(projectPath: string, config: StudioWebDebugConfig, callbacks?: DebugCallbacks, pollInterval?: number, options?: {
+        inputs?: Record<string, unknown>;
+        maxPolls?: number;
+        /**
+         * Upload the solution and stop. For a flow only a chat UI can drive,
+         * a debug instance would sit unused — and its message subscription
+         * would block the next run — so the CLI hands the user the designer
+         * URL instead of starting a session nobody can advance.
+         */
+        uploadOnly?: boolean;
+    }): Promise<DebugResult | StudioWebUploadResult>;
+    /**
+     * Full Studio Web debug flow:
+     * 1. Read .flow/.bpmn file
+     * 2. Convert to BPMN (if .flow)
+     * 3. Generate project files
+     * 4. Build .uis solution package
+     * 5. Upload to Studio Web → get projectId + solutionId
+     * 6. Begin debug session in Orchestrator → get jobKey
+     * 7. Create debug instance in PIMS with solutionId + projectId
+     * 8. Poll PIMS debug-instances for completion
+     */
+    executeViaStudioWeb(filePath: string, config: StudioWebDebugConfig, callbacks?: DebugCallbacks, pollInterval?: number, options?: {
+        inputs?: Record<string, unknown>;
+        keep?: boolean;
+        maxPolls?: number;
+    }): Promise<DebugResult>;
+}

package/dist/services/flow-eval-types.d.ts

@@ -1,6 +1,6 @@
-import type { Evaluation, EvaluationSet, Evaluator, EvaluationCriteria as SchemaEvaluationCriteria, Simulation } from "./flow-eval-schema/index.js";
+import type { Evaluation, EvaluationSet, Evaluator, EvaluationCriteria as SchemaEvaluationCriteria, Simulation, SimulationStrategy } from "./flow-eval-schema/index.js";
 export type EvaluationCriteria = SchemaEvaluationCriteria;
 export type FlowEvaluator = Evaluator;
 export type FlowEvaluation = Evaluation;
 export type FlowEvaluationSet = EvaluationSet;
-export type { Simulation };
+export type { Simulation, SimulationStrategy };

package/dist/services/flow-eval-utils.d.ts

@@ -1,3 +1,4 @@
+import type { StudioWebDebugConfig } from "./flow-debug-service.js";
 import { type EvaluatorTypeId } from "./flow-eval-schema/index.js";
 import type { EvaluationCriteria, FlowEvaluator } from "./flow-eval-types.js";
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
@@ -11,4 +12,32 @@ export declare function buildEvaluatorConfig(typeId: EvaluatorTypeId, options: {
     model?: string;
     prompt?: string;
 }): Record<string, unknown>;
+/**
+ * Resolves the current login status into a {@link StudioWebDebugConfig}.
+ * Throws if the login is missing any required field, including organizationName.
+ */
+export declare function resolveLoginConfig(): Promise<StudioWebDebugConfig>;
+/**
+ * Resolves the login fields needed by {@link FlowEvalRunApi} metadata calls.
+ * Does not require organizationName — only the base URL, org/tenant IDs,
+ * and auth token.
+ */
+export declare function resolveEvalApiConfig(): Promise<{
+    baseUrl: string;
+    organizationId: string;
+    tenantName: string;
+    tenantId: string;
+    authToken: string;
+}>;
+/**
+ * Finds the definition entry matching a node's type (and optionally version)
+ * from the flow's definitions array. Pure logic, no I/O.
+ *
+ * BEST-EFFORT read variant of `findNodeDefinition` (definitions-lookup.ts):
+ * when the strict lookup resolves nothing (several versions, none matching),
+ * this falls back to the first same-type entry — display/read paths prefer a
+ * best guess over nothing. Paths that WRITE to the definition (or suppress
+ * diagnostics based on it) must use the strict helper directly.
+ */
+export declare function findMatchingDefinition(nodeType: string, typeVersion: string | undefined, definitions: Array<Record<string, unknown>>): Record<string, unknown> | undefined;
 export declare function buildDefaultCriteria(evaluators: FlowEvaluator[], expectedOutput: Record<string, unknown> | undefined, searchText: string | undefined): Record<string, EvaluationCriteria | null | undefined>;