@uipath/flow-tool 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/packager-tool-t3ysatjd.js

@@ -1,521 +0,0 @@
-import {
-  findNodeDefinition
-} from "./packager-tool-w5a1hhyj.js";
-import {
-  catchError
-} from "./packager-tool-02f63a08.js";
-import {
-  __require
-} from "./packager-tool-1yh8g550.js";
-
-// src/services/flow-eval-schema/prompts.ts
-var DEFAULT_EVALUATOR_PROMPT = `As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
-----
-ExpectedOutput:
-{{ExpectedOutput}}
-----
-ActualOutput:
-{{ActualOutput}}
-`;
-var DEFAULT_TRAJECTORY_EVALUATOR_PROMPT = `As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
-----
-UserOrSyntheticInputGivenToAgent:
-{{UserOrSyntheticInput}}
-----
-SimulationInstructions:
-{{SimulationInstructions}}
-----
-ExpectedAgentBehavior:
-{{ExpectedAgentBehavior}}
-----
-AgentRunHistory:
-{{AgentRunHistory}}
-`;
-
-// src/services/flow-eval-schema/evaluator-fields.ts
-var targetOutputKeyConfigField = {
-  key: "targetOutputKey",
-  label: "Target Output Key",
-  type: "targetOutputKey",
-  required: false,
-  description: "The key in the output to evaluate"
-};
-var caseSensitiveConfigField = {
-  key: "caseSensitive",
-  label: "Case Sensitive",
-  type: "boolean",
-  required: false,
-  default: false,
-  description: "If true, the comparison is case-sensitive"
-};
-var negatedConfigField = {
-  key: "negated",
-  label: "Negated",
-  type: "boolean",
-  required: false,
-  default: false,
-  description: "If true, the evaluation passes when the match is not found"
-};
-var expectedOutputCriteriaField = {
-  key: "expectedOutput",
-  label: "Expected Output",
-  type: "object",
-  required: false,
-  description: "The expected output value for this evaluator"
-};
-var llmBaseConfigFields = [
-  {
-    key: "model",
-    label: "Model",
-    type: "llmModel",
-    required: true,
-    description: "The LLM model to use for judging"
-  },
-  {
-    key: "prompt",
-    label: "Evaluation Prompt",
-    type: "string",
-    required: true,
-    default: DEFAULT_EVALUATOR_PROMPT,
-    description: "Custom prompt template for the LLM judge"
-  },
-  {
-    key: "temperature",
-    label: "Temperature",
-    type: "number",
-    required: true,
-    default: 0,
-    min: 0,
-    max: 2,
-    step: 0.1,
-    description: "Temperature for LLM generation"
-  },
-  {
-    key: "maxTokens",
-    label: "Max Tokens",
-    type: "number",
-    required: true,
-    default: 8192,
-    min: 0,
-    max: 16384,
-    step: 256,
-    description: "Maximum tokens for LLM response"
-  }
-];
-var llmTrajectoryBaseConfigFields = llmBaseConfigFields.map((field) => field.key === "prompt" ? { ...field, default: DEFAULT_TRAJECTORY_EVALUATOR_PROMPT } : field);
-
-// src/services/flow-eval-schema/deterministic-evaluators.ts
-var DETERMINISTIC_EVALUATOR_TYPES = {
-  "uipath-contains": {
-    name: "Contains Text",
-    description: "Check if output contains specific text",
-    category: "deterministic",
-    shortDescription: "Passes when output contains given text",
-    configFields: [
-      targetOutputKeyConfigField,
-      caseSensitiveConfigField,
-      {
-        ...negatedConfigField,
-        label: "Negated (should NOT contain)"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "searchText",
-        label: "Search Text",
-        type: "string",
-        required: false,
-        minLength: 1,
-        description: "The text to search for in the output"
-      }
-    ],
-    examples: {
-      criteria: { searchText: "loan approved" }
-    }
-  },
-  "uipath-exact-match": {
-    name: "Exact Match",
-    description: "Check if output exactly matches expected value",
-    category: "deterministic",
-    shortDescription: "Passes when output is an exact match",
-    configFields: [
-      targetOutputKeyConfigField,
-      caseSensitiveConfigField,
-      negatedConfigField
-    ],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      criteria: { expectedOutput: { value: "Application approved" } }
-    }
-  },
-  "uipath-json-similarity": {
-    name: "JSON Similarity",
-    description: "Compare JSON output similarity",
-    category: "deterministic",
-    shortDescription: "Passes when JSON structures are similar",
-    configFields: [targetOutputKeyConfigField],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      criteria: { expectedOutput: { status: "ok" } }
-    }
-  }
-};
-
-// src/services/flow-eval-schema/llm-judge-evaluators.ts
-var LLM_JUDGE_EVALUATOR_TYPES = {
-  "uipath-llm-judge-output-semantic-similarity": {
-    name: "LLM Judge Output",
-    description: "Use LLM to judge semantic similarity of outputs",
-    category: "llm-judge",
-    shortDescription: "AI judges if output semantically matches expected",
-    configFields: [...llmBaseConfigFields, targetOutputKeyConfigField],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      config: { model: "gpt-4o", temperature: 0 },
-      criteria: {
-        expectedOutput: {
-          text: "The loan has been approved for the requested amount."
-        }
-      }
-    }
-  },
-  "uipath-llm-judge-output-strict-json-similarity": {
-    name: "LLM Judge Strict JSON",
-    description: "Use LLM to judge strict JSON similarity",
-    category: "llm-judge",
-    shortDescription: "AI judges strict JSON structural match",
-    configFields: [...llmBaseConfigFields, targetOutputKeyConfigField],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      config: { model: "gpt-4o", temperature: 0 },
-      criteria: { expectedOutput: { result: "success" } }
-    }
-  },
-  "uipath-llm-judge-trajectory-similarity": {
-    name: "LLM Judge Trajectory",
-    description: "Use LLM to judge agent trajectory and behavior",
-    category: "llm-judge",
-    shortDescription: "AI judges if agent followed expected behavior",
-    configFields: llmTrajectoryBaseConfigFields,
-    criteriaFields: [
-      {
-        key: "expectedAgentBehavior",
-        label: "Expected Agent Behavior",
-        type: "string",
-        required: false,
-        description: "Description of expected agent behavior and actions"
-      }
-    ],
-    examples: {
-      config: { model: "gpt-4o" },
-      criteria: {
-        expectedAgentBehavior: "Agent checks eligibility, then calls approval API"
-      }
-    }
-  },
-  "uipath-llm-judge-trajectory-simulation": {
-    name: "LLM Judge Simulation",
-    description: "Use LLM to judge simulation trajectory",
-    category: "llm-judge",
-    shortDescription: "AI judges simulated agent execution path",
-    configFields: llmTrajectoryBaseConfigFields,
-    criteriaFields: [
-      {
-        key: "expectedAgentBehavior",
-        label: "Expected Agent Behavior",
-        type: "string",
-        required: false,
-        description: "Description of expected agent behavior during simulation"
-      }
-    ],
-    examples: {
-      config: { model: "gpt-4o" },
-      criteria: {
-        expectedAgentBehavior: "Agent simulates the user journey through checkout flow"
-      }
-    }
-  }
-};
-
-// src/services/flow-eval-schema/tool-call-evaluators.ts
-var TOOL_CALL_EVALUATOR_TYPES = {
-  "uipath-tool-call-args": {
-    name: "Tool Call Arguments",
-    description: "Verify tool call arguments match expected values",
-    category: "tool-call",
-    shortDescription: "Checks that tools were called with correct arguments",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact match of all tool call arguments"
-      },
-      {
-        key: "subset",
-        label: "Subset Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, allows actual tool calls to be a subset of expected"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolCalls",
-        label: "Tool Calls",
-        type: "toolCallArgs",
-        required: false,
-        description: "Expected tool calls with names and arguments"
-      }
-    ]
-  },
-  "uipath-tool-call-count": {
-    name: "Tool Call Count",
-    description: "Verify tool call counts match expected values",
-    category: "tool-call",
-    shortDescription: "Checks number of times each tool was called",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact count match"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolCallsCount",
-        label: "Tool Calls Count",
-        type: "toolCallCount",
-        required: false,
-        description: "Expected tool call counts with comparison operators"
-      }
-    ]
-  },
-  "uipath-tool-call-order": {
-    name: "Tool Call Order",
-    description: "Verify tool calls occur in expected order",
-    category: "tool-call",
-    shortDescription: "Checks that tools were called in the right sequence",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact order match"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolCallsOrder",
-        label: "Tool Calls Order",
-        type: "toolCallOrder",
-        required: false,
-        description: "Tool names in expected execution order"
-      }
-    ]
-  },
-  "uipath-tool-call-output": {
-    name: "Tool Call Output",
-    description: "Verify tool call outputs match expected values",
-    category: "tool-call",
-    shortDescription: "Checks that tool outputs match expected values",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact output match"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolOutputs",
-        label: "Tool Outputs",
-        type: "toolCallOutput",
-        required: false,
-        description: "Expected tool outputs with names and output values"
-      }
-    ]
-  }
-};
-
-// src/services/flow-eval-schema/registry.ts
-var EVALUATOR_TYPE_REGISTRY = {
-  ...DETERMINISTIC_EVALUATOR_TYPES,
-  ...LLM_JUDGE_EVALUATOR_TYPES,
-  ...TOOL_CALL_EVALUATOR_TYPES
-};
-var EVALUATOR_TYPE_ALIASES = {
-  "exact-match": "uipath-exact-match",
-  "json-similarity": "uipath-json-similarity",
-  contains: "uipath-contains",
-  "llm-judge-output": "uipath-llm-judge-output-semantic-similarity",
-  "llm-judge-strict-json": "uipath-llm-judge-output-strict-json-similarity",
-  "llm-judge-trajectory": "uipath-llm-judge-trajectory-similarity",
-  "llm-judge-trajectory-simulation": "uipath-llm-judge-trajectory-simulation"
-};
-
-// src/services/flow-eval-schema/helpers.ts
-function evaluatorTypeAliases() {
-  return Object.keys(EVALUATOR_TYPE_ALIASES);
-}
-function isEvaluatorTypeId(value) {
-  return value in EVALUATOR_TYPE_REGISTRY;
-}
-function getEvaluatorTypeDefinition(typeId) {
-  if (!isEvaluatorTypeId(typeId)) {
-    return null;
-  }
-  return EVALUATOR_TYPE_REGISTRY[typeId];
-}
-function resolveEvaluatorType(type) {
-  const resolved = EVALUATOR_TYPE_ALIASES[type] ?? type;
-  if (!isEvaluatorTypeId(resolved)) {
-    throw new Error(`Unknown evaluator type "${type}". Valid types: ${evaluatorTypeAliases().join(", ")}`);
-  }
-  return resolved;
-}
-function getDefaultConfigForEvaluatorType(typeId) {
-  return collectFieldDefaults(EVALUATOR_TYPE_REGISTRY[typeId].configFields);
-}
-function collectFieldDefaults(fields) {
-  const defaults = {};
-  for (const field of fields) {
-    if (field.default !== undefined) {
-      defaults[field.key] = field.default;
-    }
-  }
-  return defaults;
-}
-function evaluatorTypeHasConfigField(typeId, fieldKey) {
-  return getEvaluatorTypeDefinition(typeId)?.configFields.some((field) => field.key === fieldKey) ?? false;
-}
-function evaluatorCanUseSharedExpectedOutput(typeId) {
-  return getEvaluatorTypeDefinition(typeId)?.criteriaFields.some((field) => field.key === "expectedOutput" && field.type === "object") ?? false;
-}
-// src/services/flow-eval-utils.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isUUID(value) {
-  return UUID_RE.test(value);
-}
-function stripJsonExt(name) {
-  return name.endsWith(".json") ? name.slice(0, -".json".length) : name;
-}
-function slugify(text) {
-  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return slug || "untitled";
-}
-function getEvaluatorRef(evaluator) {
-  return stripJsonExt(evaluator.fileName ?? `${evaluator.id}.json`);
-}
-function buildEvaluatorConfig(typeId, options) {
-  const evaluatorConfig = {
-    name: options.name,
-    ...getDefaultConfigForEvaluatorType(typeId)
-  };
-  if (evaluatorTypeHasConfigField(typeId, "targetOutputKey")) {
-    evaluatorConfig.targetOutputKey = options.targetOutputKey ?? "*";
-  }
-  if (options.model !== undefined) {
-    evaluatorConfig.model = options.model;
-  }
-  if (options.prompt !== undefined) {
-    evaluatorConfig.prompt = options.prompt;
-  }
-  return evaluatorConfig;
-}
-async function validateLoginFields() {
-  const { getLoginStatusAsync } = await import("./index-2s8rmmw6.js");
-  const [loginError, login] = await catchError(getLoginStatusAsync());
-  if (loginError) {
-    throw new Error(loginError.message);
-  }
-  if (login.loginStatus !== "Logged in" || !login.baseUrl) {
-    throw new Error("Not logged in. Run 'uip login' first.");
-  }
-  if (!login.organizationId) {
-    throw new Error("Organization ID not available from login.");
-  }
-  if (!login.tenantId) {
-    throw new Error("Tenant ID not available from login.");
-  }
-  if (!login.tenantName) {
-    throw new Error("Tenant name not available from login.");
-  }
-  if (!login.accessToken) {
-    throw new Error("Access token not available from login.");
-  }
-  return {
-    baseUrl: login.baseUrl,
-    organizationId: login.organizationId,
-    tenantId: login.tenantId,
-    tenantName: login.tenantName,
-    accessToken: login.accessToken,
-    organizationName: login.organizationName || undefined
-  };
-}
-async function resolveLoginConfig() {
-  const fields = await validateLoginFields();
-  if (!fields.organizationName) {
-    throw new Error("Organization name not available from login. Required for Studio Web evaluation.");
-  }
-  return {
-    baseUrl: fields.baseUrl,
-    organizationId: fields.organizationId,
-    tenantId: fields.tenantId,
-    tenantName: fields.tenantName,
-    authToken: fields.accessToken,
-    organizationName: fields.organizationName
-  };
-}
-async function resolveEvalApiConfig() {
-  const fields = await validateLoginFields();
-  return {
-    baseUrl: fields.baseUrl,
-    organizationId: fields.organizationId,
-    tenantName: fields.tenantName,
-    tenantId: fields.tenantId,
-    authToken: fields.accessToken
-  };
-}
-function findMatchingDefinition(nodeType, typeVersion, definitions) {
-  const strict = findNodeDefinition(definitions, {
-    type: nodeType,
-    typeVersion
-  });
-  if (strict)
-    return strict;
-  return definitions.find((d) => d.nodeType === nodeType);
-}
-function buildDefaultCriteria(evaluators, expectedOutput, searchText) {
-  const criterias = {};
-  for (const evaluator of evaluators) {
-    const key = evaluator.id;
-    if (expectedOutput !== undefined && evaluatorCanUseSharedExpectedOutput(evaluator.evaluatorTypeId)) {
-      criterias[key] = { expectedOutput };
-    } else if (searchText !== undefined && evaluator.evaluatorTypeId === "uipath-contains") {
-      criterias[key] = { searchText };
-    } else {
-      const defaultCriteria = evaluator.evaluatorConfig.defaultEvaluationCriteria;
-      criterias[key] = isRecord(defaultCriteria) ? defaultCriteria : null;
-    }
-  }
-  return criterias;
-}
-
-export { evaluatorTypeAliases, resolveEvaluatorType, isRecord, isUUID, stripJsonExt, slugify, getEvaluatorRef, buildEvaluatorConfig, resolveLoginConfig, resolveEvalApiConfig, findMatchingDefinition, buildDefaultCriteria };
-
-//# debugId=6033C3040704269E64756E2164756E21