@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/packager-tool-4g87fbz6.js

@@ -0,0 +1,273 @@
+import {
+  CONNECTOR_NODE_PREFIX2
+} from "./packager-tool-fzgfb0jt.js";
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-33XQ5K6D.js
+var ARRAY_WILDCARD_RE = /\[\*\]/g;
+function stripWildcard(name) {
+  return name.replace(ARRAY_WILDCARD_RE, "");
+}
+function hasWildcardKey(record) {
+  return record ? Object.keys(record).some((key) => key.includes("[*]")) : false;
+}
+function hasWildcard(schema) {
+  return hasWildcardKey(schema.properties) || hasWildcardKey(schema.definitions) || hasWildcardKey(schema.$defs);
+}
+function rewriteKeyedSchemas(record) {
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[stripWildcard(key)] = sanitizeNode(value);
+  }
+  return result;
+}
+function sanitizeNode(node) {
+  const result = { ...node };
+  if (typeof result.$ref === "string" && result.$ref.includes("[*]")) {
+    result.$ref = stripWildcard(result.$ref);
+  }
+  if (node.properties) {
+    result.properties = rewriteKeyedSchemas(node.properties);
+  }
+  if (node.items && !Array.isArray(node.items)) {
+    result.items = sanitizeNode(node.items);
+  }
+  for (const combinator of ["oneOf", "anyOf", "allOf"]) {
+    if (node[combinator]) {
+      result[combinator] = node[combinator].map(sanitizeNode);
+    }
+  }
+  return result;
+}
+function sanitizeConnectorSchema(schema) {
+  if (!schema || !hasWildcard(schema))
+    return schema;
+  const result = sanitizeNode(schema);
+  if (schema.definitions)
+    result.definitions = rewriteKeyedSchemas(schema.definitions);
+  if (schema.$defs)
+    result.$defs = rewriteKeyedSchemas(schema.$defs);
+  return result;
+}
+var JSON_STRING_PREFIX = "=jsonString:";
+var JIT_OBJECT_INPUT_MODE = "jitObject";
+function flattenSplitConfiguration(config) {
+  if ("essentialConfiguration" in config || "optionalConfiguration" in config) {
+    return {
+      ...config.optionalConfiguration,
+      ...config.essentialConfiguration
+    };
+  }
+  return config;
+}
+function normalizeTransientProperties(config) {
+  const result = { ...config };
+  const fc = result.fieldsContainer;
+  const inputMode = result.savedInputMode ?? fc?.inputMode;
+  const jitFieldName = result.savedJitInputFieldId ?? fc?.jitInputField?.name;
+  if (inputMode === JIT_OBJECT_INPUT_MODE || jitFieldName === "body") {
+    result.isJitObjectInputMode = true;
+  }
+  return result;
+}
+function parseConfigurationJson2(configuration) {
+  if (!configuration)
+    return null;
+  try {
+    if (typeof configuration === "object") {
+      return normalizeTransientProperties(flattenSplitConfiguration(configuration));
+    }
+    let str = configuration;
+    if (str.startsWith(JSON_STRING_PREFIX))
+      str = str.substring(JSON_STRING_PREFIX.length);
+    const parsed = JSON.parse(str);
+    return typeof parsed === "object" && parsed !== null ? normalizeTransientProperties(flattenSplitConfiguration(parsed)) : null;
+  } catch {
+    return null;
+  }
+}
+function resolveJsonSchema(schema, options = {}) {
+  const { maxDepth = 25 } = options;
+  const definitions = schema.definitions || schema.$defs || {};
+  function resolveRef(ref) {
+    const match = ref.match(/^#\/(?:definitions|\$defs)\/(.+)$/);
+    if (!match)
+      return {};
+    return definitions[match[1]] || {};
+  }
+  function resolve(node, visited, depth) {
+    if (depth > maxDepth)
+      return node;
+    if (node.$ref) {
+      if (visited.has(node.$ref))
+        return { type: "any" };
+      visited.add(node.$ref);
+      return resolve(resolveRef(node.$ref), visited, depth + 1);
+    }
+    const result = { ...node };
+    if (node.properties) {
+      result.properties = {};
+      for (const [key, prop] of Object.entries(node.properties)) {
+        result.properties[key] = resolve(prop, new Set(visited), depth + 1);
+      }
+    }
+    if (node.items && !Array.isArray(node.items)) {
+      result.items = resolve(node.items, new Set(visited), depth + 1);
+    }
+    for (const combinator of ["oneOf", "anyOf", "allOf"]) {
+      if (node[combinator]) {
+        result[combinator] = node[combinator].map((s) => resolve(s, new Set(visited), depth + 1));
+      }
+    }
+    return result;
+  }
+  const isArray = schema.type === "array";
+  let rootSchema = schema;
+  if (isArray && schema.items && !Array.isArray(schema.items)) {
+    rootSchema = schema.items;
+  }
+  return {
+    schema: resolve(rootSchema, /* @__PURE__ */ new Set, 0),
+    isArray
+  };
+}
+function resolveLocalRef(root, node) {
+  if (!node || typeof node.$ref !== "string")
+    return node;
+  const match = node.$ref.match(/^#\/(definitions|\$defs)\/(.+)$/);
+  if (!match)
+    return node;
+  const bucket = root[match[1]];
+  return bucket?.[match[2]] ?? node;
+}
+function resolveConnectorOutputSchema(rawOutputJsonSchema, fieldsContainer) {
+  if (!rawOutputJsonSchema || typeof rawOutputJsonSchema !== "object")
+    return;
+  const schema = sanitizeConnectorSchema(rawOutputJsonSchema);
+  if (!schema.type && !schema.properties && !schema.$ref && !schema.definitions && !schema.$defs)
+    return;
+  const jsonSchemaType = typeof schema.type === "string" ? schema.type : "object";
+  const formatFields = fieldsContainer ? collectResponseFieldFormats(fieldsContainer) : [];
+  if (formatFields.length > 0) {
+    const stamped = structuredClone(schema);
+    for (const field of formatFields) {
+      const target = findSchemaNodeByFieldPath(stamped, field.name.split("."));
+      if (target)
+        applyStringFormat(target, field.format);
+    }
+    return { jsonSchemaType, schema: markOutputSchemaOpen(stamped, jsonSchemaType) };
+  }
+  return { jsonSchemaType, schema: markOutputSchemaOpen(schema, jsonSchemaType) };
+}
+function markOutputSchemaOpen(schema, jsonSchemaType) {
+  if (jsonSchemaType !== "object" || schema.additionalProperties !== undefined)
+    return schema;
+  return { ...schema, additionalProperties: true };
+}
+function resolveConnectorOutputTypeSchema(inputsDetail) {
+  if (!inputsDetail || typeof inputsDetail !== "object")
+    return;
+  const configuration = parseConfigurationJson2(inputsDetail.configuration);
+  const fieldsContainer = configuration?.fieldsContainer;
+  return resolveConnectorOutputSchema(fieldsContainer?.outputJsonSchema, fieldsContainer);
+}
+function collectResponseFieldFormats(fieldsContainer) {
+  const raw = [
+    ...Array.isArray(fieldsContainer.inputFields) ? fieldsContainer.inputFields : [],
+    ...Array.isArray(fieldsContainer.outputFields) ? fieldsContainer.outputFields : []
+  ];
+  const fields = [];
+  for (const field of raw) {
+    if (typeof field?.name !== "string" || !field.name)
+      continue;
+    if (typeof field.format !== "string" || !field.format)
+      continue;
+    if (field.response !== true)
+      continue;
+    fields.push({ name: field.name, format: field.format });
+  }
+  return fields;
+}
+function applyStringFormat(node, format) {
+  if (node.format)
+    return;
+  if (node.type === "string" || Array.isArray(node.type) && node.type.includes("string")) {
+    node.format = format;
+  } else if (node.type === "array" && node.items && !Array.isArray(node.items)) {
+    applyStringFormat(node.items, format);
+  }
+}
+function findSchemaNodeByFieldPath(root, segments) {
+  let node = root;
+  for (const segment of segments) {
+    node = resolveLocalRef(root, node);
+    const properties = node?.properties;
+    node = properties?.[segment];
+    if (!node)
+      return;
+  }
+  return resolveLocalRef(root, node);
+}
+function resolveNodeOutputTypeSchema(nodeType, inputsDetail, outputKey) {
+  if (outputKey !== "output")
+    return;
+  if (nodeType.startsWith(CONNECTOR_NODE_PREFIX2)) {
+    return resolveConnectorOutputTypeSchema(inputsDetail);
+  }
+  return;
+}
+function createWorkflowVariable2(options) {
+  return {
+    id: options.id,
+    direction: options.direction,
+    type: options.type ?? "string",
+    ...options.subType && { subType: options.subType },
+    ...options.schema && { schema: options.schema },
+    ...options.defaultValue !== undefined && { defaultValue: options.defaultValue },
+    ...options.description && { description: options.description }
+  };
+}
+function createNodeVariable(options) {
+  return {
+    id: `${options.nodeId}.${options.outputId}`,
+    type: options.type ?? "string",
+    ...options.subType && { subType: options.subType },
+    ...options.description && { description: options.description },
+    ...options.schema && { schema: options.schema },
+    binding: {
+      nodeId: options.nodeId,
+      outputId: options.outputId
+    }
+  };
+}
+function generateNodeVariables3(nodes, definitions) {
+  const generatedVariables = [];
+  const definitionOutputs = /* @__PURE__ */ new Map;
+  for (const def of definitions) {
+    if (def.outputDefinition && Object.keys(def.outputDefinition).length > 0) {
+      definitionOutputs.set(def.nodeType, def.outputDefinition);
+    }
+  }
+  for (const node of nodes) {
+    const nodeOutputs = node.outputs ?? {};
+    const outputs = Object.keys(nodeOutputs).length > 0 ? nodeOutputs : definitionOutputs.get(node.type) ?? {};
+    for (const [outputKey, outputDef] of Object.entries(outputs)) {
+      if (outputDef && typeof outputDef === "object") {
+        const def = outputDef;
+        const resolved = resolveNodeOutputTypeSchema(node.type, node.inputs?.detail, outputKey);
+        generatedVariables.push(createNodeVariable({
+          nodeId: node.id,
+          outputId: outputKey,
+          type: resolved?.jsonSchemaType ?? def.type,
+          subType: def.subType,
+          description: def.description,
+          schema: def.schema
+        }));
+      }
+    }
+  }
+  return generatedVariables;
+}
+
+export { parseConfigurationJson2, resolveJsonSchema, resolveConnectorOutputSchema, createWorkflowVariable2, generateNodeVariables3 };
+
+//# debugId=0C7340D80B7E33DA64756E2164756E21

package/dist/packager-tool-4zt1s51a.js

@@ -0,0 +1,53 @@
+import {
+  extractErrorDetails,
+  createHiddenDeprecatedTenantOption,
+  parseBoundedInt
+} from "./packager-tool-8ed52y5r.js";
+// ../maestro-sdk/src/shared-utils.ts
+var VALID_PROJECT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+var VALID_PACKAGE_NAME_REGEX = /^[a-zA-Z0-9._-]+$/;
+function formatTraceStatus(status) {
+  if (status === "Completed")
+    return "✓";
+  if (status === "Failed" || status === "Faulted")
+    return "✗";
+  if (status === "Running" || status === "InProgress")
+    return "⏳";
+  return "•";
+}
+function formatTraceLine(trace) {
+  const time = new Date(trace.timestamp).toLocaleTimeString();
+  const statusIcon = formatTraceStatus(trace.status);
+  const duration = trace.duration ? ` ${trace.duration}ms` : "";
+  const label = trace.name ?? "(unnamed span)";
+  const name = label.length > 60 ? `${label.substring(0, 57)}...` : label;
+  return `[${time}] ${statusIcon} ${name} (${trace.status})${duration}`;
+}
+var backendFailure = async (error, instructions) => {
+  const details = await extractErrorDetails(error);
+  return {
+    Result: details.result,
+    ErrorCode: details.errorCode,
+    Message: details.message,
+    Instructions: instructions,
+    Retry: details.retry,
+    ...details.context ? { Context: details.context } : {}
+  };
+};
+function genericObjectDiscoveryCommands(connectorKey, connectionId, operation) {
+  const op = operation === undefined ? "" : ` --operation ${operation}`;
+  return [
+    `uip is resources list ${connectorKey}${op} --connection-id ${connectionId}`,
+    `uip is resources describe ${connectorKey} <object-name>${op} --connection-id ${connectionId}`
+  ];
+}
+function addJobTracesOptions(command, folderDescription = "Folder key (GUID from run command, defaults to authenticated folder)") {
+  return command.addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--folder-key <key>", folderDescription).option("--poll-interval <ms>", "Polling interval in milliseconds", "2000").option("--traces-service <name>", "Traces service name (default: llmopstenant_)", "llmopstenant_").option("--pretty", "Show traces in human-readable format instead of raw JSON").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", (raw) => parseBoundedInt(raw, "--login-validity", {
+    min: 0,
+    max: 60 * 24 * 365
+  }), 10);
+}
+
+export { VALID_PROJECT_NAME_REGEX, VALID_PACKAGE_NAME_REGEX, formatTraceLine, backendFailure, genericObjectDiscoveryCommands, addJobTracesOptions };
+
+//# debugId=2B9CF5AE99F4ED2C64756E2164756E21

package/dist/{packager-tool-frjt46rb.js → packager-tool-508ka40b.js}

@@ -1,9 +1,9 @@
 import {
   logger
-} from "./packager-tool-apawc11t.js";
+} from "./packager-tool-8ed52y5r.js";
 
 // ../maestro-sdk/src/debug-http-client.ts
-function parseBackendErrorBody(body) {
+function parseBackendErrorBody2(body) {
   if (!body)
     return {};
   let parsed;
@@ -28,7 +28,7 @@ function parseBackendErrorBody(body) {
   return result;
 }
 
-class MaestroHttpError extends Error {
+class MaestroHttpError2 extends Error {
   service;
   method;
   endpoint;
@@ -44,7 +44,7 @@ class MaestroHttpError extends Error {
   attempts;
   traceIds;
   constructor(details) {
-    super(MaestroHttpError.formatMessage(details));
+    super(MaestroHttpError2.formatMessage(details));
     this.name = "MaestroHttpError";
     this.service = details.service;
     this.method = details.method;
@@ -79,7 +79,7 @@ async function buildHttpErrorDetails(response, init) {
   try {
     body = await response.text();
   } catch {}
-  const parsed = parseBackendErrorBody(body);
+  const parsed = parseBackendErrorBody2(body);
   return {
     service: init.service,
     method: init.method,
@@ -120,7 +120,7 @@ function buildPimsUrl(config, path) {
 function buildAutomationSolutionsUrl(config, path) {
   return `${config.baseUrl}/${config.organizationId}/${config.tenantId}/automationsolutions_${path}`;
 }
-async function automationSolutionsGet(config, path, stage, signal) {
+async function automationSolutionsGet2(config, path, stage, signal) {
   const url = buildAutomationSolutionsUrl(config, path);
   const headers = buildCommonHeaders(config, { includeContentType: false });
   if (config.tenantId) {
@@ -131,7 +131,7 @@ async function automationSolutionsGet(config, path, stage, signal) {
   }
   const response = await fetch(url, { method: "GET", headers, signal });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "automation-solutions",
       method: "GET",
       endpoint: path,
@@ -141,7 +141,7 @@ async function automationSolutionsGet(config, path, stage, signal) {
   }
   return response.json();
 }
-async function orchestratorGet(config, path, stage) {
+async function orchestratorGet2(config, path, stage) {
   const url = buildOrchestratorUrl(config, path);
   const headers = buildCommonHeaders(config);
   if (typeof process !== "undefined" && process.env?.DEBUG) {
@@ -149,7 +149,7 @@ async function orchestratorGet(config, path, stage) {
   }
   const response = await fetch(url, { method: "GET", headers });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "orchestrator",
       method: "GET",
       endpoint: path,
@@ -159,7 +159,7 @@ async function orchestratorGet(config, path, stage) {
   }
   return response.json();
 }
-async function orchestratorPost(config, path, body, stage) {
+async function orchestratorPost2(config, path, body, stage) {
   const url = buildOrchestratorUrl(config, path);
   const headers = buildCommonHeaders(config);
   if (typeof process !== "undefined" && process.env?.DEBUG) {
@@ -171,7 +171,7 @@ async function orchestratorPost(config, path, body, stage) {
     body: JSON.stringify(body)
   });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "orchestrator",
       method: "POST",
       endpoint: path,
@@ -181,7 +181,7 @@ async function orchestratorPost(config, path, body, stage) {
   }
   return response.json();
 }
-async function debugPimsGet(config, path, stage, options) {
+async function debugPimsGet2(config, path, stage, options) {
   const url = buildPimsUrl(config, path);
   const headers = buildCommonHeaders(config, { includeContentType: false });
   if (typeof process !== "undefined" && process.env?.DEBUG) {
@@ -193,7 +193,7 @@ async function debugPimsGet(config, path, stage, options) {
     ...options?.signal ? { signal: options.signal } : {}
   });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "pims",
       method: "GET",
       endpoint: path,
@@ -219,7 +219,7 @@ async function debugPimsWrite(config, path, body, method, stage) {
     body: JSON.stringify(body)
   });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "pims",
       method,
       endpoint: path,
@@ -229,16 +229,16 @@ async function debugPimsWrite(config, path, body, method, stage) {
   }
   return readOptionalJsonResponse(response);
 }
-async function debugPimsPost(config, path, body, stage) {
+async function debugPimsPost2(config, path, body, stage) {
   return debugPimsWrite(config, path, body, "POST", stage);
 }
-async function debugPimsPut(config, path, body, stage) {
+async function debugPimsPut2(config, path, body, stage) {
   return debugPimsWrite(config, path, body, "PUT", stage);
 }
-async function debugPimsPatch(config, path, body, stage) {
+async function debugPimsPatch2(config, path, body, stage) {
   return debugPimsWrite(config, path, body, "PATCH", stage);
 }
-async function studioWebPost(config, organizationName, path, body, extraHeaders, stage) {
+async function studioWebPost2(config, organizationName, path, body, extraHeaders, stage) {
   const url = `${config.baseUrl}/${organizationName}/studio_/backend/api${path}`;
   const headers = {
     Authorization: `Bearer ${config.authToken}`,
@@ -254,7 +254,7 @@ async function studioWebPost(config, organizationName, path, body, extraHeaders,
     body: isFormData ? body : JSON.stringify(body)
   });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "studio-web",
       method: "POST",
       endpoint: path,
@@ -264,7 +264,7 @@ async function studioWebPost(config, organizationName, path, body, extraHeaders,
   }
   return response.json();
 }
-async function studioWebDelete(config, organizationName, path, stage) {
+async function studioWebDelete2(config, organizationName, path, stage) {
   const url = `${config.baseUrl}/${organizationName}/studio_/backend/api${path}`;
   const headers = {
     Authorization: `Bearer ${config.authToken}`
@@ -274,7 +274,7 @@ async function studioWebDelete(config, organizationName, path, stage) {
   }
   const response = await fetch(url, { method: "DELETE", headers });
   if (!response.ok) {
-    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+    throw new MaestroHttpError2(await buildHttpErrorDetails(response, {
       service: "studio-web",
       method: "DELETE",
       endpoint: path,
@@ -284,6 +284,6 @@ async function studioWebDelete(config, organizationName, path, stage) {
   }
 }
 
-export { parseBackendErrorBody, MaestroHttpError, automationSolutionsGet, orchestratorGet, orchestratorPost, debugPimsGet, debugPimsPost, debugPimsPut, debugPimsPatch, studioWebPost, studioWebDelete };
+export { parseBackendErrorBody2, MaestroHttpError2, automationSolutionsGet2, orchestratorGet2, orchestratorPost2, debugPimsGet2, debugPimsPost2, debugPimsPut2, debugPimsPatch2, studioWebPost2, studioWebDelete2 };
 
-//# debugId=4C72C920A6F1BEF764756E2164756E21
+//# debugId=6562C3EF5322147D64756E2164756E21

package/dist/{packager-tool-gbv6f0ac.js → packager-tool-5104bnpv.js}

@@ -1,17 +1,18 @@
 import {
-  isRecord
-} from "./packager-tool-xk78j7dz.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
   collectAgentInputLeaves,
+  isBareProjectIdSource,
   isInlineAgentNodeType
-} from "./packager-tool-7ja1b5hh.js";
+} from "./packager-tool-mdf7bws6.js";
 import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+  isRecord
+} from "./packager-tool-ac6rvny7.js";
 
 // src/services/flow-eval-node-target.ts
-function findFlowNode(flowContent, nodeId) {
-  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+function findFlowNode2(flowContent, nodeId) {
+  const [parseError, parsed] = catchError2(() => JSON.parse(flowContent));
   if (parseError || !isRecord(parsed)) {
     return { flowParsed: false };
   }
@@ -30,7 +31,7 @@ function readAgentSourceId(node) {
   const normalized = source.trim();
   return normalized.length > 0 ? normalized : undefined;
 }
-function isNodeEvalTarget(node) {
+function isNodeEvalTarget2(node) {
   const type = typeof node.type === "string" ? node.type.toLowerCase() : undefined;
   return isInlineAgentNodeType(type) && readAgentSourceId(node) !== undefined;
 }
@@ -38,11 +39,11 @@ var DOCUMENT_EVAL_NODE_TYPES = new Set([
   "uipath.ixp.extract-document-builder",
   "uipath.document.classify"
 ]);
-function isDocumentEvalNode(node) {
+function isDocumentEvalNode2(node) {
   const type = typeof node.type === "string" ? node.type.toLowerCase() : "";
   return DOCUMENT_EVAL_NODE_TYPES.has(type);
 }
-function readNodeTargetId(set) {
+function readNodeTargetId2(set) {
   if (set.target) {
     return set.target.kind === "agentNode" ? set.target.nodeId : undefined;
   }
@@ -57,7 +58,7 @@ var NO_AGENT = {
   outputs: new Set
 };
 
-class FlowAgentNodeSchemaReader {
+class FlowAgentNodeSchemaReader2 {
   fs;
   pathResolver;
   constructor(fs, pathResolver) {
@@ -66,28 +67,28 @@ class FlowAgentNodeSchemaReader {
   }
   async read(projectPath, nodeId) {
     const root = await this.pathResolver.resolveProjectPath(projectPath);
-    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    const [flowError, flowFilePath] = await catchError2(this.pathResolver.findFlowFile(root));
     if (flowError || !flowFilePath) {
       return NO_AGENT;
     }
-    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    const [readError, flowContent] = await catchError2(this.fs.readFile(flowFilePath, "utf-8"));
     if (readError) {
       return NO_AGENT;
     }
-    const lookup = findFlowNode(String(flowContent), nodeId);
+    const lookup = findFlowNode2(String(flowContent), nodeId);
     if (!lookup.node) {
       return NO_AGENT;
     }
     const sourceId = readAgentSourceId(lookup.node);
-    if (sourceId === undefined || /[/\\.]/.test(sourceId)) {
+    if (sourceId === undefined || !isBareProjectIdSource(sourceId)) {
       return NO_AGENT;
     }
     const agentJsonPath = this.fs.path.join(this.fs.path.dirname(flowFilePath), sourceId, "agent.json");
-    const [agentReadError, raw] = await catchError(this.fs.readFile(agentJsonPath, "utf-8"));
+    const [agentReadError, raw] = await catchError2(this.fs.readFile(agentJsonPath, "utf-8"));
     if (agentReadError) {
       return NO_AGENT;
     }
-    const [parseError, agent] = catchError(() => JSON.parse(String(raw)));
+    const [parseError, agent] = catchError2(() => JSON.parse(String(raw)));
     if (parseError || !isRecord(agent)) {
       return NO_AGENT;
     }
@@ -105,8 +106,8 @@ function readOutputKeys(outputSchema) {
   }
   return new Set(Object.keys(outputSchema.properties));
 }
-function readEvalSetScope(set) {
-  if (readNodeTargetId(set) !== undefined) {
+function readEvalSetScope2(set) {
+  if (readNodeTargetId2(set) !== undefined) {
     return "node";
   }
   const kind = set.target?.kind ?? set.targetKind;
@@ -116,6 +117,6 @@ function readEvalSetScope(set) {
   return "flow";
 }
 
-export { findFlowNode, readAgentSourceId, isNodeEvalTarget, isDocumentEvalNode, readNodeTargetId, FlowAgentNodeSchemaReader, readEvalSetScope };
+export { findFlowNode2, isNodeEvalTarget2, isDocumentEvalNode2, readNodeTargetId2, FlowAgentNodeSchemaReader2, readEvalSetScope2 };
 
-//# debugId=EEBFB069B393613D64756E2164756E21
+//# debugId=852D6ABBC9CB2A4864756E2164756E21