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

package/dist/packager-tool-xk78j7dz.js

@@ -0,0 +1,1256 @@
+import {
+  catchError
+} from "./packager-tool-t7ahhaer.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../eval-sdk/src/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}}
+`;
+
+// ../eval-sdk/src/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"
+};
+function strictModeConfigField(description) {
+  return {
+    key: "strict",
+    label: "Strict Mode",
+    type: "boolean",
+    required: false,
+    default: false,
+    description
+  };
+}
+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);
+
+// ../eval-sdk/src/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" } }
+    }
+  }
+};
+
+// ../eval-sdk/src/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"
+      }
+    }
+  }
+};
+
+// ../eval-sdk/src/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: [
+      strictModeConfigField("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: [
+      strictModeConfigField("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: [
+      strictModeConfigField("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: [
+      strictModeConfigField("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"
+      }
+    ]
+  }
+};
+
+// ../eval-sdk/src/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"
+};
+
+// ../eval-sdk/src/eval-schema/helpers.ts
+function evaluatorTypeAliases() {
+  return Object.keys(EVALUATOR_TYPE_ALIASES);
+}
+function isEvaluatorTypeId(value) {
+  return Object.hasOwn(EVALUATOR_TYPE_REGISTRY, value);
+}
+function getEvaluatorTypeDefinition(typeId) {
+  if (!isEvaluatorTypeId(typeId)) {
+    return null;
+  }
+  return EVALUATOR_TYPE_REGISTRY[typeId];
+}
+function resolveEvaluatorType(type) {
+  const alias = Object.hasOwn(EVALUATOR_TYPE_ALIASES, type) ? EVALUATOR_TYPE_ALIASES[type] : undefined;
+  const resolved = alias ?? 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;
+}
+// ../eval-sdk/src/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;
+}
+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;
+}
+
+// ../eval-sdk/src/eval-selectors.ts
+function findEvaluator(evaluators, idOrName) {
+  return evaluators.find((ev) => ev.id === idOrName || ev.name === idOrName || getEvaluatorRef(ev) === idOrName) ?? null;
+}
+function findEvalSet(sets, idOrName) {
+  return sets.find((set) => set.id === idOrName || set.name === idOrName || stripJsonExt(set.fileName ?? "") === idOrName) ?? null;
+}
+function getLinkedEvaluators(allEvaluators, evalSet) {
+  const refs = new Set(evalSet.evaluatorRefs.map(stripJsonExt));
+  return allEvaluators.filter((evaluator) => {
+    const candidates = [
+      evaluator.id,
+      evaluator.fileName,
+      getEvaluatorRef(evaluator)
+    ].filter((value) => value !== undefined);
+    return candidates.some((candidate) => refs.has(stripJsonExt(candidate)));
+  });
+}
+function removeEvaluatorRefFromSet(evalSet, evaluator) {
+  const removedRefs = new Set([
+    evaluator.id,
+    getEvaluatorRef(evaluator),
+    evaluator.fileName
+  ]);
+  const before = evalSet.evaluatorRefs.length;
+  evalSet.evaluatorRefs = evalSet.evaluatorRefs.filter((ref) => !removedRefs.has(ref));
+  return evalSet.evaluatorRefs.length !== before;
+}
+
+// ../eval-sdk/src/eval-evaluation-crud.ts
+class EvaluationCrud {
+  fs;
+  store;
+  pathResolver;
+  constructor(fs, store, pathResolver) {
+    this.fs = fs;
+    this.store = store;
+    this.pathResolver = pathResolver;
+  }
+  async add(projectPath, setIdOrName, options) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluators = getLinkedEvaluators(await this.listEvaluators(root), evalSet);
+    const now = new Date().toISOString();
+    const evaluation = {
+      id: crypto.randomUUID(),
+      name: options.name,
+      inputs: options.inputs,
+      expectedOutput: options.expectedOutput,
+      evaluationCriterias: options.criteria ?? buildDefaultCriteria(evaluators, options.expectedOutput, options.searchText),
+      createdAt: now,
+      updatedAt: now
+    };
+    evalSet.evaluations.push(evaluation);
+    evalSet.updatedAt = now;
+    await this.writeEvalSet(root, evalSet);
+    return evaluation;
+  }
+  async list(projectPath, setIdOrName) {
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    return evalSet.evaluations;
+  }
+  async addSimulation(projectPath, setIdOrName, evaluationIdOrName, simulation) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    if (!evaluation.simulations) {
+      evaluation.simulations = [];
+    }
+    const existing = evaluation.simulations.findIndex((s) => s.componentId === simulation.componentId);
+    const now = new Date().toISOString();
+    if (existing !== -1) {
+      evaluation.simulations[existing] = simulation;
+    } else {
+      evaluation.simulations.push(simulation);
+    }
+    evaluation.updatedAt = now;
+    evalSet.updatedAt = now;
+    await this.writeEvalSet(root, evalSet);
+    return simulation;
+  }
+  async listSimulations(projectPath, setIdOrName, evaluationIdOrName) {
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    return evaluation.simulations ?? [];
+  }
+  async addChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childSimulation) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    if (!evaluation.simulations) {
+      evaluation.simulations = [];
+    }
+    let parent = evaluation.simulations.find((s) => s.componentId === parentComponentId);
+    if (!parent) {
+      parent = {
+        componentId: parentComponentId,
+        componentType: "agent",
+        simulationStrategy: "Llm",
+        childSimulations: []
+      };
+      evaluation.simulations.push(parent);
+    }
+    if (!parent.childSimulations) {
+      parent.childSimulations = [];
+    }
+    const existing = parent.childSimulations.findIndex((s) => s.componentId === childSimulation.componentId);
+    const now = new Date().toISOString();
+    if (existing !== -1) {
+      parent.childSimulations[existing] = childSimulation;
+    } else {
+      parent.childSimulations.push(childSimulation);
+    }
+    evaluation.updatedAt = now;
+    evalSet.updatedAt = now;
+    await this.writeEvalSet(root, evalSet);
+    return childSimulation;
+  }
+  listChildSimulations(evaluation, parentComponentId) {
+    const parent = (evaluation.simulations ?? []).find((s) => s.componentId === parentComponentId);
+    if (!parent) {
+      throw new Error(`Simulation for component "${parentComponentId}" not found`);
+    }
+    return parent.childSimulations ?? [];
+  }
+  async removeChildSimulation(projectPath, setIdOrName, evaluationIdOrName, parentComponentId, childComponentId) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    const parent = (evaluation.simulations ?? []).find((s) => s.componentId === parentComponentId);
+    if (!parent) {
+      throw new Error(`Simulation for component "${parentComponentId}" not found`);
+    }
+    const index = (parent.childSimulations ?? []).findIndex((s) => s.componentId === childComponentId);
+    if (index === -1) {
+      return false;
+    }
+    parent.childSimulations?.splice(index, 1);
+    evalSet.updatedAt = new Date().toISOString();
+    await this.writeEvalSet(root, evalSet);
+    return true;
+  }
+  async removeSimulation(projectPath, setIdOrName, evaluationIdOrName, componentId) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const evaluation = evalSet.evaluations.find((e) => e.id === evaluationIdOrName || e.name === evaluationIdOrName);
+    if (!evaluation) {
+      throw new Error(`Data point "${evaluationIdOrName}" not found`);
+    }
+    const index = (evaluation.simulations ?? []).findIndex((s) => s.componentId === componentId);
+    if (index === -1) {
+      return false;
+    }
+    evaluation.simulations?.splice(index, 1);
+    evalSet.updatedAt = new Date().toISOString();
+    await this.writeEvalSet(root, evalSet);
+    return true;
+  }
+  async remove(projectPath, setIdOrName, evaluationIdOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evalSet = await this.requireEvalSet(projectPath, setIdOrName);
+    const index = evalSet.evaluations.findIndex((evaluation) => evaluation.id === evaluationIdOrName || evaluation.name === evaluationIdOrName);
+    if (index === -1) {
+      return false;
+    }
+    evalSet.evaluations.splice(index, 1);
+    evalSet.updatedAt = new Date().toISOString();
+    await this.writeEvalSet(root, evalSet);
+    return true;
+  }
+  async requireEvalSet(projectPath, idOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    const evalSet = root ? findEvalSet(await this.listEvalSets(root), idOrName) : null;
+    if (!evalSet) {
+      throw new Error(`Evaluation set "${idOrName}" not found`);
+    }
+    return evalSet;
+  }
+  async listEvalSets(root) {
+    return this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
+  }
+  async listEvaluators(root) {
+    return this.store.readJsonFiles(this.fs.path.join(root, "evaluators"));
+  }
+  async writeEvalSet(root, evalSet) {
+    await this.store.writeJsonFile(this.fs.path.join(root, "eval-sets", evalSet.fileName ?? `${evalSet.id}.json`), evalSet);
+  }
+}
+
+// ../eval-sdk/src/eval-evaluator-crud.ts
+class EvaluatorCrud {
+  fs;
+  store;
+  pathResolver;
+  constructor(fs, store, pathResolver) {
+    this.fs = fs;
+    this.store = store;
+    this.pathResolver = pathResolver;
+  }
+  async list(projectPath) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return [];
+    }
+    return this.store.readJsonFiles(this.fs.path.join(root, "evaluators"));
+  }
+  async add(projectPath, options) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const typeId = resolveEvaluatorType(options.type);
+    const id = `${slugify(options.name)}-${crypto.randomUUID().slice(0, 8)}`;
+    const now = new Date().toISOString();
+    const fileName = `${id}.json`;
+    const evaluator = {
+      version: "1.0",
+      id,
+      name: options.name,
+      description: options.description ?? `${options.name} evaluator`,
+      evaluatorTypeId: typeId,
+      evaluatorConfig: buildEvaluatorConfig(typeId, options),
+      fileName,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.store.writeJsonFile(this.fs.path.join(root, "evaluators", fileName), evaluator);
+    return evaluator;
+  }
+  async remove(projectPath, idOrName) {
+    const root = await this.pathResolver.resolveEvalRoot(projectPath, false);
+    if (!root) {
+      return false;
+    }
+    const evaluator = findEvaluator(await this.list(projectPath), idOrName);
+    if (!evaluator?.fileName) {
+      return false;
+    }
+    await this.store.remove(this.fs.path.join(root, "evaluators", evaluator.fileName));
+    await this.removeEvaluatorRefs(root, evaluator);
+    return true;
+  }
+  async removeEvaluatorRefs(root, evaluator) {
+    const sets = await this.store.readJsonFiles(this.fs.path.join(root, "eval-sets"));
+    for (const set of sets) {
+      if (removeEvaluatorRefFromSet(set, evaluator) && set.fileName) {
+        await this.writeEvalSet(root, set);
+      }
+    }
+  }
+  async writeEvalSet(root, evalSet) {
+    await this.store.writeJsonFile(this.fs.path.join(root, "eval-sets", evalSet.fileName ?? `${evalSet.id}.json`), evalSet);
+  }
+}
+
+// ../eval-sdk/src/eval-file-store.ts
+async function ensureDirectory(fs, path) {
+  if (await fs.exists(path)) {
+    return;
+  }
+  const parent = fs.path.dirname(path);
+  if (parent && parent !== path && !await fs.exists(parent)) {
+    await ensureDirectory(fs, parent);
+  }
+  const [error] = await catchError(fs.mkdir(path));
+  if (error && !await fs.exists(path)) {
+    throw error;
+  }
+}
+
+class EvalFileStore {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  async readJsonFiles(dir) {
+    const [readDirError, files] = await catchError(this.fs.readdir(dir));
+    if (readDirError) {
+      return [];
+    }
+    const items = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      const filePath = this.fs.path.join(dir, file);
+      const [readError, raw] = await catchError(this.fs.readFile(filePath, "utf-8"));
+      if (readError) {
+        throw new Error(`Failed to read JSON file "${filePath}": ${readError.message}`);
+      }
+      if (raw === null) {
+        continue;
+      }
+      const [parseError, data] = catchError(() => JSON.parse(String(raw)));
+      if (parseError) {
+        throw new Error(`Invalid JSON in "${filePath}": ${parseError.message}`);
+      }
+      data.fileName = file;
+      items.push(data);
+    }
+    return items;
+  }
+  async writeJsonFile(path, value) {
+    await ensureDirectory(this.fs, this.fs.path.dirname(path));
+    await this.fs.writeFile(path, `${JSON.stringify(value, null, 2)}
+`);
+  }
+  async remove(path) {
+    await this.fs.rm(path);
+  }
+}
+
+// ../eval-sdk/src/eval-files.ts
+import { randomUUID } from "node:crypto";
+var EVAL_FILES_DIR = "eval-files";
+var TOKEN_LENGTH = 12;
+var EVALUATION_BINARY_PREFIX = "BINARY_FILE:";
+var EVALUATION_BINARY_DELIMITER = `
+---BASE64---
+`;
+var TEXT_EXTENSIONS = new Set([
+  ".json",
+  ".csv",
+  ".tsv",
+  ".txt",
+  ".md",
+  ".log",
+  ".xml",
+  ".html",
+  ".htm",
+  ".yaml",
+  ".yml"
+]);
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".webp": "image/webp",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".csv": "text/csv",
+  ".tsv": "text/tab-separated-values",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".log": "text/plain",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".yaml": "application/yaml",
+  ".yml": "application/yaml"
+};
+
+class EvalFiles {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async materialize(projectPath, sourcePath) {
+    const projectRoot = await this.pathResolver.resolveProjectPath(projectPath);
+    const sourceAbsolute = this.fs.path.resolve(sourcePath);
+    if (!await this.fs.exists(sourceAbsolute)) {
+      throw new Error(`Input file not found: ${sourcePath}`);
+    }
+    const content = await this.fs.readFile(sourceAbsolute);
+    if (content === null) {
+      throw new Error(`Could not read input file: ${sourcePath}`);
+    }
+    const fullName = this.fs.path.basename(sourceAbsolute);
+    const evalRoot = await this.pathResolver.resolveEvalRoot(projectPath, true);
+    const dir = this.fs.path.join(evalRoot, EVAL_FILES_DIR);
+    await this.fs.mkdir(dir);
+    const targetName = await this.resolveTargetName(dir, fullName);
+    const targetPath = this.fs.path.join(dir, targetName);
+    const mimeType = mimeFromExt(extOf(fullName));
+    if (TEXT_EXTENSIONS.has(extOf(fullName))) {
+      await this.fs.writeFile(targetPath, content);
+    } else {
+      await this.fs.writeFile(targetPath, encodeBinaryEnvelope(content, mimeType));
+    }
+    const relative = this.fs.path.relative(projectRoot, targetPath).replaceAll("\\", "/");
+    return {
+      ID: `/${relative}`,
+      FullName: fullName,
+      MimeType: mimeType
+    };
+  }
+  async resolveTargetName(dir, fullName) {
+    if (!await this.fs.exists(this.fs.path.join(dir, fullName))) {
+      return fullName;
+    }
+    const ext = extOf(fullName);
+    const stem = ext ? fullName.slice(0, -ext.length) : fullName;
+    const token = randomUUID().replaceAll("-", "").slice(0, TOKEN_LENGTH);
+    return `${stem}_${token}${ext}`;
+  }
+}
+function encodeBinaryEnvelope(content, mimeType) {
+  const base64Content = Buffer.from(content).toString("base64");
+  return `${EVALUATION_BINARY_PREFIX}${mimeType}:${content.byteLength}${EVALUATION_BINARY_DELIMITER}${base64Content}`;
+}
+function extOf(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) {
+    return "";
+  }
+  return name.slice(dot).toLowerCase();
+}
+function mimeFromExt(ext) {
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+
+// ../eval-sdk/src/eval-inject-workload-id.ts
+var SIMULATION_STRATEGY_WIRE_VALUES = {
+  Llm: 0,
+  Static: 2
+};
+function injectWorkloadId(simulation, defaultWorkloadId) {
+  const { childSimulations: rawChildSimulations, ...rest } = simulation;
+  const workloadId = typeof simulation.workloadId === "string" ? simulation.workloadId : defaultWorkloadId;
+  const childSimulations = Array.isArray(rawChildSimulations) ? rawChildSimulations.map((child) => injectWorkloadId(child, workloadId)) : undefined;
+  const wireStrategy = SIMULATION_STRATEGY_WIRE_VALUES[simulation.simulationStrategy];
+  if (wireStrategy === undefined) {
+    throw new Error(`Unknown simulationStrategy "${String(simulation.simulationStrategy)}" on component "${simulation.componentId}". Supported values: ${Object.keys(SIMULATION_STRATEGY_WIRE_VALUES).join(", ")}.`);
+  }
+  return {
+    ...rest,
+    workloadId,
+    simulationStrategy: wireStrategy,
+    ...childSimulations ? { childSimulations } : {}
+  };
+}
+
+// ../eval-sdk/src/eval-run-readers.ts
+function asRecordArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} response must be an array`);
+  }
+  return value.map((item, index) => {
+    if (!isRecord(item)) {
+      throw new Error(`${label} response item ${index} must be an object`);
+    }
+    return item;
+  });
+}
+function readRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
+function readRecordArray(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  return value.filter(isRecord);
+}
+function optionalNumber(value) {
+  return typeof value === "number" ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : "";
+}
+function statusString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    const statusByCode = {
+      0: "Pending",
+      1: "Running",
+      2: "Completed",
+      3: "PartiallyCompleted",
+      4: "Failed"
+    };
+    return statusByCode[value] ?? String(value);
+  }
+  return "";
+}
+function readEvaluatorScores(value) {
+  const records = readRecordArray(value);
+  if (!records) {
+    return null;
+  }
+  return records.flatMap((score) => {
+    const evaluatorId = score.evaluatorId;
+    const scoreValue = score.value;
+    if (typeof evaluatorId !== "string" || typeof scoreValue !== "number") {
+      return [];
+    }
+    return [{ evaluatorId, value: scoreValue }];
+  });
+}
+function readRemoteEvalSetRun(record) {
+  return {
+    id: optionalString(record.id),
+    workloadId: optionalString(record.workloadId),
+    evalSetId: typeof record.evalSetId === "string" ? record.evalSetId : null,
+    status: statusString(record.status),
+    score: optionalNumber(record.score),
+    evaluatorScores: readEvaluatorScores(record.evaluatorScores),
+    config: readRecord(record.config) ?? {},
+    numberOfEvalsExecuted: optionalNumber(record.numberOfEvalsExecuted),
+    durationMilliseconds: optionalNumber(record.durationMilliseconds),
+    createdAt: optionalString(record.createdAt),
+    updatedAt: optionalString(record.updatedAt)
+  };
+}
+function readRemoteEvalRun(record) {
+  const snapshot = readRecord(record.evalSnapshot);
+  const result = readRecord(record.result);
+  return {
+    id: optionalString(record.id),
+    evalSetRunId: optionalString(record.evalSetRunId),
+    evalSnapshot: snapshot ? {
+      id: typeof snapshot.id === "string" ? snapshot.id : undefined,
+      name: typeof snapshot.name === "string" ? snapshot.name : undefined,
+      inputs: readRecord(snapshot.inputs),
+      evaluationCriterias: readRecord(snapshot.evaluationCriterias),
+      expectedOutput: readRecord(snapshot.expectedOutput) ?? (snapshot.expectedOutput === null ? null : undefined)
+    } : undefined,
+    status: statusString(record.status),
+    result: result ? {
+      output: readRecord(result.output),
+      scores: readEvaluatorScores(result.scores) ?? undefined,
+      score: readRecord(result.score)
+    } : null,
+    completionMetrics: readRecord(record.completionMetrics),
+    evaluatorRuns: readRecordArray(record.evaluatorRuns)?.flatMap((evaluatorRun) => {
+      const evaluatorId = evaluatorRun.evaluatorId;
+      if (typeof evaluatorId !== "string") {
+        return [];
+      }
+      const evaluatorResult = readRecord(evaluatorRun.result);
+      return [
+        {
+          evaluatorId,
+          evaluatorSnapshot: evaluatorRun.evaluatorSnapshot,
+          status: typeof evaluatorRun.status === "string" ? evaluatorRun.status : undefined,
+          result: evaluatorResult ? {
+            output: readRecord(evaluatorResult.output),
+            score: readRecord(evaluatorResult.score)
+          } : null,
+          completionMetrics: readRecord(evaluatorRun.completionMetrics)
+        }
+      ];
+    }),
+    error: typeof record.error === "string" || isRecord(record.error) ? record.error : null,
+    errorMessage: typeof record.errorMessage === "string" ? record.errorMessage : null,
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : undefined,
+    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : undefined
+  };
+}
+
+// ../eval-sdk/src/eval-run-api.ts
+var METADATA_FETCH_TIMEOUT_MS = 30000;
+var MAX_ERROR_BODY_LENGTH = 400;
+
+class EvalRunApi {
+  workloadType;
+  constructor(workloadType) {
+    this.workloadType = workloadType;
+  }
+  async executeAndEvaluate(config, payload) {
+    return this.requestJson(config, "/unifiedEvals/workloads/executeAndEvaluate", {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+  }
+  async listEvalSetRuns(config, workloadId) {
+    const response = await this.requestJson(config, `/unifiedEvals/workloads/${encodeURIComponent(workloadId)}/evalSetRuns?workloadType=${encodeURIComponent(this.workloadType)}`, { method: "GET" });
+    return asRecordArray(response, "Eval set runs").map(readRemoteEvalSetRun);
+  }
+  async getEvalSetRun(config, workloadId, evalSetRunId) {
+    const response = await this.requestJson(config, `/unifiedEvals/workloads/${encodeURIComponent(workloadId)}/evalSetRuns/${encodeURIComponent(evalSetRunId)}?workloadType=${encodeURIComponent(this.workloadType)}`, { method: "GET" });
+    if (!isRecord(response)) {
+      throw new Error("Eval set run response must be an object");
+    }
+    return readRemoteEvalSetRun(response);
+  }
+  async getEvalRuns(config, workloadId, evalSetRunId) {
+    const response = await this.requestJson(config, `/unifiedEvals/workloads/${encodeURIComponent(workloadId)}/evalSetRuns/${encodeURIComponent(evalSetRunId)}/evalRuns?workloadType=${encodeURIComponent(this.workloadType)}`, { method: "GET" });
+    return asRecordArray(response, "Eval runs").map(readRemoteEvalRun);
+  }
+  async getSimulatableComponents(config, processKey, processVersion) {
+    const params = new URLSearchParams({ workloadType: "Agents" });
+    if (processVersion) {
+      params.set("processVersion", processVersion);
+    }
+    const data = await this.requestJson(config, `/unifiedEvals/processes/${encodeURIComponent(processKey)}/simulatableComponents?${params.toString()}`, { method: "GET" }, METADATA_FETCH_TIMEOUT_MS);
+    const components = Array.isArray(data.components) ? data.components : [];
+    return components.filter((c) => isRecord(c) && typeof c.id === "string" && typeof c.name === "string" && c.isEnabled === true);
+  }
+  apiBase(config) {
+    return `${config.baseUrl}/${encodeURIComponent(config.organizationId)}/${encodeURIComponent(config.tenantName)}/agentsruntime_/api`;
+  }
+  headers(config) {
+    return {
+      Authorization: `Bearer ${config.authToken}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "X-UiPath-Internal-TenantId": config.tenantId,
+      "X-UiPath-Internal-AccountId": config.organizationId
+    };
+  }
+  async requestJson(config, path, request, timeoutMs) {
+    let response;
+    let text;
+    try {
+      response = await fetch(`${this.apiBase(config)}${path}`, {
+        method: request.method,
+        headers: {
+          ...this.headers(config),
+          ...request.headers
+        },
+        body: request.body,
+        ...timeoutMs !== undefined ? { signal: AbortSignal.timeout(timeoutMs) } : {}
+      });
+      text = await response.text();
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "TimeoutError") {
+        throw new Error(`Unified eval API request timed out after ${timeoutMs}ms (${request.method} ${path})`);
+      }
+      throw new Error(`Unified eval API request failed (${request.method} ${path}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!response.ok) {
+      const body = text.length > MAX_ERROR_BODY_LENGTH ? `${text.slice(0, MAX_ERROR_BODY_LENGTH)}… (truncated)` : text;
+      throw new Error(`Unified eval API returned ${response.status}: ${body}`);
+    }
+    if (!text) {
+      throw new Error(`Unified eval API returned ${response.status} with empty body`);
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      const preview = text.length > MAX_ERROR_BODY_LENGTH ? `${text.slice(0, MAX_ERROR_BODY_LENGTH)}… (truncated)` : text;
+      throw new Error(`Unified eval API returned ${response.status} with non-JSON body (${request.method} ${path}): ${preview}`);
+    }
+  }
+}
+// ../eval-sdk/src/eval-login.ts
+async function validateLoginFields() {
+  const { getLoginStatusAsync } = await import("./index-sqhbn7ew.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
+  };
+}
+// ../eval-sdk/src/eval-run-format.ts
+function formatDuration(durationMs) {
+  if (durationMs === null || durationMs === undefined) {
+    return "-";
+  }
+  return `${(durationMs / 1000).toFixed(1)}s`;
+}
+function formatEvaluatorScores(scores, evaluators) {
+  if (!scores || scores.length === 0) {
+    return "-";
+  }
+  return scores.map((score) => {
+    const evaluator = evaluators.find((item) => item.id === score.evaluatorId);
+    return `${evaluator?.name ?? score.evaluatorId}: ${score.value}`;
+  }).join(", ");
+}
+function evaluatorSnapshotName(snapshot) {
+  if (typeof snapshot === "object" && snapshot !== null && !Array.isArray(snapshot) && typeof snapshot.name === "string") {
+    return snapshot.name;
+  }
+  return;
+}
+function remoteEvaluatorName(evaluatorId, evaluatorSnapshot, evaluators) {
+  return evaluators.find((item) => item.id === evaluatorId)?.name ?? evaluatorSnapshotName(evaluatorSnapshot) ?? evaluatorId;
+}
+function remoteRunScore(run) {
+  if (run.result?.scores && run.result.scores.length > 0) {
+    const sum = run.result.scores.reduce((total, score) => total + score.value, 0);
+    return Number((sum / run.result.scores.length).toFixed(4));
+  }
+  const value = run.result?.score?.value;
+  return typeof value === "number" || typeof value === "boolean" ? value : "-";
+}
+function formatRemoteEvalRunRow(run, evaluators, verbose = false) {
+  let evaluatorScores = "-";
+  let justifications = "-";
+  if (run.evaluatorRuns && run.evaluatorRuns.length > 0) {
+    evaluatorScores = run.evaluatorRuns.map((evaluatorRun) => {
+      const name = remoteEvaluatorName(evaluatorRun.evaluatorId, evaluatorRun.evaluatorSnapshot, evaluators);
+      const score = evaluatorRun.result?.score;
+      if (score?.type === "error") {
+        return `${name}: Error`;
+      }
+      return `${name}: ${score?.value ?? "-"}`;
+    }).join(", ");
+    const justificationParts = run.evaluatorRuns.filter((evaluatorRun) => evaluatorRun.result?.score?.justification).map((evaluatorRun) => {
+      const name = remoteEvaluatorName(evaluatorRun.evaluatorId, evaluatorRun.evaluatorSnapshot, evaluators);
+      return `[${name}] ${evaluatorRun.result?.score?.justification}`;
+    });
+    if (justificationParts.length > 0) {
+      justifications = justificationParts.join(" | ");
+    }
+  } else if (run.result?.scores && run.result.scores.length > 0) {
+    evaluatorScores = formatEvaluatorScores(run.result.scores, evaluators);
+  }
+  const tokens = run.completionMetrics?.tokens;
+  const duration = run.completionMetrics?.duration;
+  const error = run.errorMessage ?? (typeof run.error === "string" ? run.error : run.error?.message) ?? "-";
+  const row = {
+    DataPoint: run.evalSnapshot?.name ?? run.id,
+    Status: run.status,
+    Score: remoteRunScore(run),
+    EvaluatorScores: evaluatorScores,
+    Tokens: typeof tokens === "number" && tokens > 0 ? tokens : "-",
+    Duration: typeof duration === "number" ? formatDuration(duration) : "-",
+    Error: error
+  };
+  if (verbose) {
+    row.Justifications = justifications;
+  }
+  return row;
+}
+function isFailedRemoteRun(run) {
+  const status = run.status.toLowerCase();
+  if (status === "failed" || status === "workloadfailed" || run.errorMessage || run.error) {
+    return true;
+  }
+  if (run.result?.score?.type === "error") {
+    return true;
+  }
+  return run.evaluatorRuns?.some((evaluatorRun) => evaluatorRun.result?.score?.type === "error" || evaluatorRun.result?.score?.value === false) ?? false;
+}
+function isTerminalRemoteStatus(status) {
+  return ["completed", "partiallycompleted", "failed"].includes(status.toLowerCase());
+}
+function formatEvalSetRunRow(run, evaluators) {
+  return {
+    EvalSetRunId: run.id,
+    Status: run.status,
+    Score: run.score ?? "-",
+    DataPoints: run.numberOfEvalsExecuted ?? "-",
+    Duration: formatDuration(run.durationMilliseconds),
+    EvaluatorScores: formatEvaluatorScores(run.evaluatorScores, evaluators),
+    CreatedAt: run.createdAt
+  };
+}
+export { evaluatorTypeAliases, isRecord, isUUID, slugify, findEvalSet, getLinkedEvaluators, EvaluationCrud, EvaluatorCrud, ensureDirectory, EvalFileStore, EvalFiles, injectWorkloadId, resolveLoginConfig, resolveEvalApiConfig, EvalRunApi, formatDuration, formatEvaluatorScores, remoteRunScore, formatRemoteEvalRunRow, isFailedRemoteRun, isTerminalRemoteStatus, formatEvalSetRunRow };
+
+//# debugId=BBF99570DB2BC04964756E2164756E21