@uipath/codedagent-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/tool-qbah9hhz.js

@@ -0,0 +1,1030 @@
+import {
+  COMMAND_RULES,
+  CommandDimensions,
+  OutputFormatter,
+  RESULTS,
+  ShipDimensions,
+  WHITELISTED_COMMANDS,
+  catchError,
+  codedAgentCommandPreflight,
+  createExecuteCommand,
+  createSetupCommand,
+  extractErrorMessageSync,
+  getFileSystem,
+  getLoginStatusAsync,
+  parseJWT,
+  processContext,
+  trackShipSucceeded
+} from "./tool-fy5pvax7.js";
+// package.json
+var package_default = {
+  name: "@uipath/codedagent-tool",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.204.0-preview.211",
+  description: "Build, run, deploy, and manage AI Agents.",
+  keywords: [
+    "cli-tool",
+    "codedagents",
+    "wrapper"
+  ],
+  type: "module",
+  main: "./dist/tool.js",
+  exports: {
+    ".": "./dist/tool.js",
+    "./init": {
+      types: "./dist/init.d.ts",
+      default: "./dist/init.js"
+    }
+  },
+  private: false,
+  bin: {
+    "codedagent-tool": "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/codedagent-tool"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  scripts: {
+    build: "bun ../../tools/build-tool.ts && tsc -p tsconfig.build.json --noCheck",
+    package: "bun run build && bun pm pack",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    lint: "biome check .",
+    "lint:fix": "biome check --write ."
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.2",
+    "@uipath/agent-reviewer-sdk": "workspace:*",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/llmgw-sdk": "workspace:*",
+    "@uipath/uipath-python-bridge": "workspace:*",
+    commander: "^14.0.3",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../agent-reviewer-sdk/src/types.ts
+var KNOWN_CATEGORIES = [
+  "evals",
+  "schema",
+  "tools",
+  "guardrails",
+  "code",
+  "general"
+];
+
+// ../agent-reviewer-sdk/src/categories.ts
+function listCategories() {
+  return [...KNOWN_CATEGORIES];
+}
+// ../agent-reviewer-sdk/src/project-context.ts
+async function loadFile(fs, path) {
+  const raw = await fs.readFile(path, "utf-8");
+  if (raw === null) {
+    return { present: false };
+  }
+  return { present: true, raw };
+}
+function parseJsonObject(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return null;
+}
+function resolveEntryPyPath(langgraphJson) {
+  if (langgraphJson.present) {
+    const graphs = parseJsonObject(langgraphJson.raw)?.graphs;
+    const graphsObj = typeof graphs === "object" && graphs !== null && !Array.isArray(graphs) ? graphs : undefined;
+    for (const spec of Object.values(graphsObj ?? {})) {
+      if (typeof spec === "string") {
+        const filePart = spec.split(":")[0]?.replace(/^\.\//, "").trim();
+        if (filePart?.endsWith(".py")) {
+          return filePart;
+        }
+      }
+    }
+  }
+  return "main.py";
+}
+async function loadCodedProjectContext(projectPath, fs) {
+  const uipathJsonPath = fs.path.join(projectPath, "uipath.json");
+  const pyprojectPath = fs.path.join(projectPath, "pyproject.toml");
+  const entryPointsPath = fs.path.join(projectPath, "entry-points.json");
+  const mainPyPath = fs.path.join(projectPath, "main.py");
+  const langgraphJsonPath = fs.path.join(projectPath, "langgraph.json");
+  const [uipathJson, pyproject, entryPoints, mainPyExists, langgraphJson] = await Promise.all([
+    loadFile(fs, uipathJsonPath),
+    loadFile(fs, pyprojectPath),
+    loadFile(fs, entryPointsPath),
+    fs.exists(mainPyPath),
+    loadFile(fs, langgraphJsonPath)
+  ]);
+  const entrySourcePath = resolveEntryPyPath(langgraphJson);
+  const entrySource = await loadFile(fs, fs.path.join(projectPath, entrySourcePath));
+  return {
+    projectPath,
+    kind: "coded",
+    uipathJson,
+    pyproject,
+    entryPoints,
+    mainPy: { present: mainPyExists },
+    langgraphJson,
+    entrySource,
+    entrySourcePath
+  };
+}
+
+// ../agent-reviewer-sdk/src/scoring.ts
+var PENALTY_PER_ERROR = 15;
+var PENALTY_PER_WARNING = 4;
+var PENALTY_PER_INFO = 1;
+var BONUS_PER_STRENGTH = 1;
+var BONUS_CAP = 5;
+var PASS_FAIL_THRESHOLD = 50;
+var FAIL_GRADE_CAP = "C+";
+var GRADE_CHART = [
+  [100, "A+"],
+  [90, "A"],
+  [85, "A-"],
+  [80, "B+"],
+  [70, "B"],
+  [65, "B-"],
+  [60, "C+"],
+  [50, "C"],
+  [45, "C-"],
+  [40, "D+"],
+  [30, "D"],
+  [25, "D-"],
+  [0, "F"]
+];
+var GRADE_RANK = new Map(GRADE_CHART.map(([, grade], index) => [grade, index]));
+var ZERO_CATEGORY_COUNTS = () => ({
+  evals: 0,
+  schema: 0,
+  tools: 0,
+  guardrails: 0,
+  code: 0,
+  general: 0
+});
+function lookupGrade(score) {
+  for (const [threshold, grade] of GRADE_CHART) {
+    if (score >= threshold) {
+      return grade;
+    }
+  }
+  return "F";
+}
+function rankOf(grade) {
+  return GRADE_RANK.get(grade) ?? GRADE_CHART.length - 1;
+}
+function clamp(value, lo, hi) {
+  return Math.max(lo, Math.min(hi, value));
+}
+function assertExhaustive(value) {
+  throw new Error(`Unhandled severity: ${String(value)}`);
+}
+function buildStats(issues) {
+  const byCategory = ZERO_CATEGORY_COUNTS();
+  let errors = 0;
+  let warnings = 0;
+  let infos = 0;
+  for (const issue of issues) {
+    byCategory[issue.category] += 1;
+    const severity = issue.severity;
+    switch (severity) {
+      case "error":
+        errors += 1;
+        break;
+      case "warning":
+        warnings += 1;
+        break;
+      case "info":
+        infos += 1;
+        break;
+      default:
+        assertExhaustive(severity);
+    }
+  }
+  return { errors, warnings, infos, byCategory };
+}
+function computeReviewResult(issues, strengths) {
+  const stats = buildStats(issues);
+  const penalty = PENALTY_PER_ERROR * stats.errors + PENALTY_PER_WARNING * stats.warnings + PENALTY_PER_INFO * stats.infos;
+  const bonus = stats.errors === 0 ? Math.min(BONUS_CAP, BONUS_PER_STRENGTH * strengths.length) : 0;
+  const score = clamp(100 - penalty + bonus, 0, 100);
+  const verdict = stats.errors > 0 || score < PASS_FAIL_THRESHOLD ? "FAIL" : "PASS";
+  let grade = lookupGrade(score);
+  if (verdict === "FAIL" && rankOf(grade) < rankOf(FAIL_GRADE_CAP)) {
+    grade = FAIL_GRADE_CAP;
+  }
+  return {
+    verdict,
+    score,
+    grade,
+    issues,
+    strengths,
+    stats
+  };
+}
+
+// ../agent-reviewer-sdk/src/runner.ts
+async function runRules(rules, context, fs, options) {
+  let selected = rules;
+  if (options.categories !== undefined) {
+    const known = new Set(KNOWN_CATEGORIES);
+    const unknown = options.categories.filter((c) => !known.has(c));
+    if (unknown.length > 0) {
+      return { ok: false, error: "UNKNOWN_CATEGORIES", unknown };
+    }
+    const filter = new Set(options.categories);
+    selected = rules.filter((rule) => filter.has(rule.category));
+  }
+  const issues = [];
+  for (const rule of selected) {
+    let ruleIssues;
+    try {
+      ruleIssues = await rule.run(context, fs);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      issues.push({
+        ruleId: "RULE_RUNTIME_ERROR",
+        category: "general",
+        severity: "error",
+        description: `Rule '${rule.id}' threw an unhandled error: ${message}`,
+        element: rule.id
+      });
+      continue;
+    }
+    for (const ruleIssue of ruleIssues) {
+      issues.push({
+        ruleId: rule.id,
+        category: rule.category,
+        severity: rule.severity,
+        ...ruleIssue
+      });
+    }
+  }
+  return { ok: true, result: computeReviewResult(issues, []) };
+}
+
+// ../agent-reviewer-sdk/src/shared/rules/index.ts
+var SHARED_RULES = [];
+
+// ../agent-reviewer-sdk/src/coded/rules/code/pyproject-missing.ts
+var codedPyprojectMissing = {
+  id: "PYPROJECT_TOML_MISSING",
+  category: "code",
+  severity: "error",
+  run: async (ctx) => {
+    if (ctx.pyproject.present) {
+      return [];
+    }
+    return [
+      {
+        description: "Coded agent project is missing `pyproject.toml`.",
+        file: "pyproject.toml",
+        suggestedFix: "Add a `pyproject.toml` declaring the project's Python dependencies and metadata."
+      }
+    ];
+  }
+};
+
+// ../agent-reviewer-sdk/src/coded/guardrail-extract.ts
+var SCOPE_MAP = {
+  AGENT: "Agent",
+  LLM: "Llm",
+  TOOL: "Tool"
+};
+function balancedArgs(source, openParen) {
+  let depth = 0;
+  let quote = null;
+  for (let i = openParen;i < source.length; i++) {
+    const ch = source[i];
+    if (quote !== null) {
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        return source.slice(openParen + 1, i);
+      }
+    }
+  }
+  return "";
+}
+function nameArg(args) {
+  const m = /\bname\s*=\s*["']([^"']*)["']/.exec(args);
+  return m?.[1] && m[1].length > 0 ? m[1] : "<unnamed>";
+}
+function stringKwarg(args, key) {
+  return new RegExp(`\\b${key}\\s*=\\s*["']([^"']*)["']`).exec(args)?.[1];
+}
+function actionClassArg(args) {
+  return /\baction\s*=\s*([A-Za-z_]\w*)\s*\(/.exec(args)?.[1];
+}
+function scopeArgs(args) {
+  const m = /\bscopes\s*=\s*\[([^\]]*)\]/.exec(args);
+  if (!m?.[1]) {
+    return [];
+  }
+  const out = [];
+  for (const sm of m[1].matchAll(/GuardrailScope\.([A-Z_]+)/g)) {
+    const mapped = SCOPE_MAP[sm[1]];
+    if (mapped !== undefined && !out.includes(mapped)) {
+      out.push(mapped);
+    }
+  }
+  return out;
+}
+function findCalls(source, classRe) {
+  const out = [];
+  for (const m of source.matchAll(classRe)) {
+    const className = m[1];
+    const openParen = m.index + m[0].length - 1;
+    out.push({ className, args: balancedArgs(source, openParen) });
+  }
+  return out;
+}
+function resolveValidatorClass(validatorExpr, source) {
+  const inline = /^\s*([A-Z]\w*)\s*\(/.exec(validatorExpr);
+  if (inline?.[1]) {
+    return inline[1];
+  }
+  const ident = /^\s*([A-Za-z_]\w*)\s*$/.exec(validatorExpr)?.[1];
+  if (ident !== undefined) {
+    const assign = new RegExp(`\\b${ident}\\s*=\\s*([A-Z]\\w*)\\s*\\(`).exec(source);
+    return assign?.[1];
+  }
+  return;
+}
+function collectLocalClasses(source) {
+  const out = new Map;
+  for (const m of source.matchAll(/^\s*class\s+([A-Za-z_]\w*)\s*(?:\(([^)]*)\))?\s*:/gm)) {
+    const name = m[1];
+    const bases = (m[2] ?? "").split(",").filter((b) => !b.includes("=") && !b.includes("*")).map((b) => b.trim().replace(/\[.*$/, "").split(".").pop()).filter((b) => b.length > 0);
+    out.set(name, bases);
+  }
+  return out;
+}
+function extractCodedGuardrails(entrySource, pyprojectRaw) {
+  const source = entrySource ?? "";
+  const guardrails = [];
+  for (const { className, args } of findCalls(source, /\b(UiPath[A-Za-z]*Middleware)\s*\(/g)) {
+    guardrails.push({
+      label: nameArg(args),
+      style: "middleware",
+      className,
+      actionClass: actionClassArg(args),
+      scopes: scopeArgs(args),
+      hasTools: /\btools\s*=\s*\[/.test(args),
+      model: stringKwarg(args, "model")
+    });
+  }
+  for (const m of source.matchAll(/@guardrail\s*\(/g)) {
+    const args = balancedArgs(source, m.index + m[0].length - 1);
+    const validatorExpr = /\bvalidator\s*=\s*([\s\S]*?)(?:,\s*(?:action|stage|name)\s*=|$)/.exec(args)?.[1];
+    const className = validatorExpr !== undefined ? resolveValidatorClass(validatorExpr, source) ?? "<unknown>" : "<unknown>";
+    guardrails.push({
+      label: nameArg(args),
+      style: "decorator",
+      className,
+      actionClass: actionClassArg(args),
+      scopes: [],
+      hasTools: /\btools\s*=\s*\[/.test(args),
+      model: stringKwarg(args, "model")
+    });
+  }
+  const isLangChain = /\bfrom\s+langchain[\w.]*\s+import\b|\bfrom\s+langgraph[\w.]*\s+import\b|\bimport\s+langgraph\b/.test(source) || /uipath[-_]langchain/.test(pyprojectRaw ?? "");
+  return {
+    guardrails,
+    isLangChain,
+    importsGuardrailFromPlatform: /(?:from|import)\s+uipath\.platform\.guardrails\b/.test(source),
+    importsGuardrailFromLangchain: /(?:from|import)\s+uipath_langchain\.guardrails\b/.test(source),
+    localClasses: collectLocalClasses(source)
+  };
+}
+
+// ../agent-reviewer-sdk/src/coded/agent-data.ts
+var extractionCache = new WeakMap;
+function codedGuardrailExtraction(ctx) {
+  const cached = extractionCache.get(ctx);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const extraction = extractCodedGuardrails(ctx.entrySource.present ? ctx.entrySource.raw : undefined, ctx.pyproject.present ? ctx.pyproject.raw : undefined);
+  extractionCache.set(ctx, extraction);
+  return extraction;
+}
+function subclassesAny(className, targets, localClasses, seen = new Set) {
+  if (seen.has(className)) {
+    return false;
+  }
+  seen.add(className);
+  const bases = localClasses.get(className);
+  if (bases === undefined) {
+    return false;
+  }
+  return bases.some((b) => targets.includes(b) || subclassesAny(b, targets, localClasses, seen));
+}
+
+// ../agent-reviewer-sdk/src/coded/rules/guardrails/invalid-contract.ts
+var VALIDATOR_BASES = [
+  "GuardrailValidatorBase",
+  "BuiltInGuardrailValidator",
+  "CustomGuardrailValidator"
+];
+var codedGuardrailInvalidContract = {
+  id: "CODED_GUARDRAIL_INVALID_CONTRACT",
+  category: "guardrails",
+  severity: "error",
+  run: async (ctx) => {
+    const { guardrails, localClasses } = codedGuardrailExtraction(ctx);
+    return guardrails.flatMap((g) => {
+      const issues = [];
+      if (g.actionClass !== undefined && localClasses.has(g.actionClass) && !subclassesAny(g.actionClass, ["GuardrailAction"], localClasses)) {
+        issues.push({
+          description: `Guardrail \`${g.label}\` uses action class \`${g.actionClass}\`, which does not subclass \`GuardrailAction\` — a custom action must extend it and implement \`handle_validation_result\`, or it fails at runtime.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          suggestedFix: "Make the action class subclass `GuardrailAction` from the guardrails SDK and implement `handle_validation_result`."
+        });
+      }
+      if (g.style === "decorator" && localClasses.has(g.className) && !subclassesAny(g.className, VALIDATOR_BASES, localClasses)) {
+        issues.push({
+          description: `Guardrail \`${g.label}\` uses validator class \`${g.className}\`, which does not subclass a guardrail validator base — use \`CustomValidator(...)\` or subclass \`GuardrailValidatorBase\` / \`CustomGuardrailValidator\`, or it fails at runtime.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          suggestedFix: "Use `CustomValidator(...)` for an in-process rule, or subclass `BuiltInGuardrailValidator` / `CustomGuardrailValidator`."
+        });
+      }
+      return issues;
+    });
+  }
+};
+
+// ../agent-reviewer-sdk/src/coded/rules/guardrails/llm-judge-model-invalid.ts
+var codedGuardrailLlmJudgeModelInvalid = {
+  id: "CODED_GUARDRAIL_LLM_JUDGE_MODEL_INVALID",
+  category: "guardrails",
+  severity: "error",
+  run: async (ctx) => {
+    if (ctx.llmJudgeModels === undefined) {
+      return [];
+    }
+    const allowed = new Set(ctx.llmJudgeModels);
+    const available = [...allowed].sort((a, b) => a.localeCompare(b));
+    const evidence = available.length > 0 ? `Available models: ${available.join(", ")}` : "No models are available for the LLM-as-judge guardrail on this tenant.";
+    return codedGuardrailExtraction(ctx).guardrails.flatMap((g) => {
+      const value = g.model;
+      if (value === undefined || value.length === 0) {
+        return [];
+      }
+      if (allowed.has(value)) {
+        return [];
+      }
+      return [
+        {
+          description: `LLM-as-judge guardrail \`${g.label}\` uses model \`${value}\`, which is not available for this tenant's LLM Gateway.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          evidences: [evidence],
+          suggestedFix: "Set the `model=` argument to a ModelId listed by `uip agent guardrails llm-as-judge-models`."
+        }
+      ];
+    });
+  }
+};
+
+// ../agent-reviewer-sdk/src/coded/rules/guardrails/tool-scope-no-tools.ts
+var codedGuardrailToolScopeNoTools = {
+  id: "CODED_GUARDRAIL_TOOL_SCOPE_NO_TOOLS",
+  category: "guardrails",
+  severity: "warning",
+  run: async (ctx) => {
+    return codedGuardrailExtraction(ctx).guardrails.flatMap((g) => {
+      if (g.style !== "middleware" || !g.scopes.includes("Tool") || g.hasTools) {
+        return [];
+      }
+      return [
+        {
+          description: `Tool-scoped guardrail \`${g.label}\` passes no \`tools=[...]\`, so it has no tool to attach to and will not fire.`,
+          element: g.label,
+          file: ctx.entrySourcePath,
+          suggestedFix: "Pass the `@tool` objects this guardrail should guard via `tools=[my_tool, …]`."
+        }
+      ];
+    });
+  }
+};
+
+// ../agent-reviewer-sdk/src/coded/rules/guardrails/wrong-import.ts
+var codedGuardrailWrongImport = {
+  id: "CODED_GUARDRAIL_WRONG_IMPORT",
+  category: "guardrails",
+  severity: "error",
+  run: async (ctx) => {
+    const extraction = codedGuardrailExtraction(ctx);
+    if (!extraction.isLangChain || !extraction.importsGuardrailFromPlatform || extraction.importsGuardrailFromLangchain) {
+      return [];
+    }
+    return [
+      {
+        description: "This LangChain agent imports guardrail symbols from `uipath.platform.guardrails`. " + "The LangChain adapter is only registered by importing from `uipath_langchain.guardrails`, " + "so as written the guardrails never wrap the LLM/tool/agent and silently do nothing at runtime.",
+        file: ctx.entrySourcePath,
+        evidences: ["from uipath.platform.guardrails import …"],
+        suggestedFix: "Import guardrail symbols from `uipath_langchain.guardrails` (not `uipath.platform.guardrails`) " + "so the LangChain adapter wraps the decorated/middleware objects."
+      }
+    ];
+  }
+};
+
+// ../agent-reviewer-sdk/src/coded/rules/index.ts
+var CODED_RULES = [
+  codedPyprojectMissing,
+  codedGuardrailWrongImport,
+  codedGuardrailToolScopeNoTools,
+  codedGuardrailInvalidContract,
+  codedGuardrailLlmJudgeModelInvalid
+];
+
+// ../agent-reviewer-sdk/src/coded/index.ts
+async function reviewCodedAgent(projectPath, options, fs) {
+  const loaded = await loadCodedProjectContext(projectPath, fs);
+  const context = {
+    ...loaded,
+    llmJudgeModels: options.llmJudgeModels
+  };
+  return runRules([...SHARED_RULES, ...CODED_RULES], context, fs, options);
+}
+// ../agent-reviewer-sdk/src/low-code/agent-data.ts
+var CLASSIFIER_FIELD_NAMES = new Set([
+  "class",
+  "classification",
+  "label",
+  "category",
+  "intent"
+]);
+var TOOL_LIKE_RESOURCE_TYPES = new Set([
+  "tool",
+  "escalation",
+  "context",
+  "mcp"
+]);
+
+// ../agent-reviewer-sdk/src/low-code/rules/guardrails/custom-rule-spec.ts
+var CUSTOM_RULE_TYPES = new Set([
+  "word",
+  "number",
+  "boolean",
+  "always"
+]);
+var SELECTOR_TYPES = new Set(["all", "specific"]);
+var WORD_OPERATORS = new Set([
+  "contains",
+  "equals",
+  "startsWith",
+  "endsWith",
+  "matchesRegex",
+  "doesNotContain",
+  "doesNotEqual",
+  "doesNotStartWith",
+  "doesNotEndWith",
+  "isEmpty",
+  "isNotEmpty"
+]);
+var WORD_VALUELESS_OPERATORS = new Set([
+  "isEmpty",
+  "isNotEmpty"
+]);
+var NUMBER_OPERATORS = new Set([
+  "equals",
+  "doesNotEqual",
+  "greaterThan",
+  "greaterThanOrEqual",
+  "lessThan",
+  "lessThanOrEqual"
+]);
+var BOOLEAN_OPERATORS = new Set(["equals"]);
+// ../admin/llmgw-sdk/src/client-factory.ts
+var SERVICE_PATH = {
+  "llm-gateway": "llmgateway_"
+};
+var REQUESTING_PRODUCT = "uipath-cli";
+async function resolveStatus(options) {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options?.loginValidity
+  });
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
+    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+  }
+  if (!status.organizationId) {
+    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+  }
+  return {
+    status,
+    bearerToken: options?.s2sToken ?? status.accessToken
+  };
+}
+function stripTrailingSlash(s) {
+  let end = s.length;
+  while (end > 0 && s.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === s.length ? s : s.slice(0, end);
+}
+function buildUrl(baseUrl, path, query) {
+  const trimmed = stripTrailingSlash(baseUrl);
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  if (!query)
+    return `${trimmed}${suffix}`;
+  const search = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined)
+      continue;
+    search.append(key, String(value));
+  }
+  const qs = search.toString();
+  return qs ? `${trimmed}${suffix}?${qs}` : `${trimmed}${suffix}`;
+}
+async function readErrorBody(response) {
+  const text = await response.text().catch(() => "");
+  if (!text)
+    return `${response.status} ${response.statusText}`;
+  return `${response.status} ${response.statusText}: ${text.slice(0, 1000)}`;
+}
+async function createAiHttpContext(service, options) {
+  const { status, bearerToken } = await resolveStatus(options);
+  const explicitTenantOverride = options?.tenantName !== undefined;
+  const tenantName = options?.tenantName ?? status.tenantName;
+  const tenantSegment = explicitTenantOverride ? options?.tenantName : status.tenantId ?? status.tenantName;
+  const segments = [
+    status.baseUrl ? stripTrailingSlash(status.baseUrl) : undefined,
+    status.organizationId ? encodeURIComponent(status.organizationId) : undefined
+  ];
+  if (tenantSegment) {
+    segments.push(encodeURIComponent(tenantSegment));
+  }
+  segments.push(SERVICE_PATH[service]);
+  const baseUrl = segments.filter(Boolean).join("/");
+  const baseHeaders = {
+    Authorization: `Bearer ${bearerToken}`,
+    Accept: "application/json"
+  };
+  if (status.organizationId) {
+    baseHeaders["x-uipath-internal-accountid"] = status.organizationId;
+  }
+  if (!explicitTenantOverride && status.tenantId) {
+    baseHeaders["x-uipath-internal-tenantid"] = status.tenantId;
+  }
+  baseHeaders["x-uipath-requestingproduct"] = REQUESTING_PRODUCT;
+  baseHeaders["X-UiPath-LLMGateway-AllowFull4xxResponse"] = "true";
+  const fetchJson = async (req) => {
+    const url = buildUrl(baseUrl, req.path, req.query);
+    const headers = {
+      ...baseHeaders,
+      ...req.extraHeaders ?? {}
+    };
+    if (req.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+      method: req.method,
+      headers,
+      body: req.body !== undefined ? JSON.stringify(req.body) : undefined
+    });
+    if (!response.ok) {
+      throw new Error(await readErrorBody(response));
+    }
+    if (response.status === 204) {
+      return;
+    }
+    const text = await response.text();
+    if (!text)
+      return;
+    return JSON.parse(text);
+  };
+  const fetchVoid = async (req) => {
+    const url = buildUrl(baseUrl, req.path, req.query);
+    const headers = {
+      ...baseHeaders,
+      ...req.extraHeaders ?? {}
+    };
+    if (req.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+      method: req.method,
+      headers,
+      body: req.body !== undefined ? JSON.stringify(req.body) : undefined
+    });
+    if (!response.ok) {
+      throw new Error(await readErrorBody(response));
+    }
+  };
+  return {
+    baseUrl,
+    organizationId: status.organizationId,
+    tenantId: explicitTenantOverride ? undefined : status.tenantId,
+    tenantName,
+    requestingProduct: REQUESTING_PRODUCT,
+    fetchJson,
+    fetchVoid
+  };
+}
+// ../admin/llmgw-sdk/src/discovery.ts
+async function getDiscoveryModels(options) {
+  const context = await createAiHttpContext("llm-gateway", options);
+  const extraHeaders = {
+    "X-UiPath-LlmGateway-RequestingProduct": options.product,
+    "X-UiPath-LlmGateway-RequestingFeature": options.feature
+  };
+  if (options.operationCode) {
+    extraHeaders["X-UiPath-LlmGateway-OperationCode"] = options.operationCode;
+  }
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options.loginValidity
+  });
+  if (status.accessToken) {
+    try {
+      const claims = parseJWT(status.accessToken);
+      if (typeof claims.sub === "string") {
+        extraHeaders["X-UiPath-LlmGateway-UserId"] = claims.sub;
+      }
+    } catch {}
+  }
+  return context.fetchJson({
+    method: "GET",
+    path: "/api/discovery",
+    extraHeaders
+  });
+}
+var LLM_AS_JUDGE_DISCOVERY = {
+  product: "guardrails",
+  feature: "llm-as-judge-validator",
+  operationCode: "Guardrails.LlmAsJudge.Debug"
+};
+async function getLlmJudgeModelIds(options) {
+  const models = await getDiscoveryModels({
+    ...options,
+    ...LLM_AS_JUDGE_DISCOVERY
+  });
+  return models.filter((m) => !m.isBlockedByPolicy).map((m) => m.modelId);
+}
+// src/services/llm-judge-models-service.ts
+var JUDGE_MIDDLEWARE = "UiPathLLMAsJudgeMiddleware";
+async function loadLlmJudgeModels(fs, projectPath) {
+  const source = await readEntrySource(fs, projectPath);
+  if (source === undefined || !source.includes(JUDGE_MIDDLEWARE)) {
+    return;
+  }
+  const [err, models] = await catchError(getLlmJudgeModelIds());
+  if (err || models === undefined) {
+    return;
+  }
+  return models;
+}
+async function readEntrySource(fs, projectPath) {
+  const entryPath = await resolveEntryPyPath2(fs, projectPath);
+  const [err, raw] = await catchError(fs.readFile(fs.path.join(projectPath, entryPath), "utf-8"));
+  return err || raw == null ? undefined : raw;
+}
+async function resolveEntryPyPath2(fs, projectPath) {
+  const [, raw] = await catchError(fs.readFile(fs.path.join(projectPath, "langgraph.json"), "utf-8"));
+  if (raw != null) {
+    const [, parsed] = await catchError(Promise.resolve().then(() => JSON.parse(raw)));
+    const config = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+    const graphs = config?.graphs;
+    if (typeof graphs === "object" && graphs !== null) {
+      for (const spec of Object.values(graphs)) {
+        if (typeof spec === "string") {
+          const filePart = spec.split(":")[0]?.replace(/^\.\//, "").trim();
+          if (filePart?.endsWith(".py")) {
+            return filePart;
+          }
+        }
+      }
+    }
+  }
+  return "main.py";
+}
+
+// src/commands/review.ts
+var CODES = {
+  success: "CodedAgentReview",
+  invalidChecks: "CodedAgentReviewInvalidChecks",
+  failed: "CodedAgentReviewFailed"
+};
+var ZERO_BY_CATEGORY = {
+  evals: 0,
+  schema: 0,
+  tools: 0,
+  guardrails: 0,
+  code: 0,
+  general: 0
+};
+var REVIEW_EXAMPLES = [
+  {
+    Description: "Review a project at a specific path",
+    Command: "uip codedagent review ./my-coded-agent",
+    Output: {
+      Code: CODES.success,
+      Data: {
+        ProjectDir: "./my-coded-agent",
+        Verdict: "PASS",
+        Score: 100,
+        Grade: "A+",
+        Issues: [],
+        Strengths: [],
+        Stats: {
+          errors: 0,
+          warnings: 0,
+          infos: 0,
+          byCategory: { ...ZERO_BY_CATEGORY }
+        }
+      }
+    }
+  },
+  {
+    Description: "Run only the rules in specific categories (comma-separated)",
+    Command: "uip codedagent review --checks code",
+    Output: {
+      Code: CODES.success,
+      Data: {
+        ProjectDir: ".",
+        Verdict: "PASS",
+        Score: 100,
+        Grade: "A+",
+        Issues: [],
+        Strengths: [],
+        Stats: {
+          errors: 0,
+          warnings: 0,
+          infos: 0,
+          byCategory: { ...ZERO_BY_CATEGORY }
+        }
+      }
+    }
+  }
+];
+var registerReviewCommand = (program) => {
+  program.command("review").description("Review a coded agent project against the deterministic rule set. " + "Returns a verdict (PASS/FAIL), score (0-100), grade (A+...F), and a list of issues.").argument("[path]", "Agent project directory", ".").option("--checks <categories>", `Comma-separated rule categories to run (default: all). Known categories: ${listCategories().join(", ")}.`).examples(REVIEW_EXAMPLES).trackedAction(processContext, async (targetPath, options) => {
+    const fs = getFileSystem();
+    const projectPath = targetPath;
+    let categories;
+    if (options.checks !== undefined) {
+      const parts = options.checks.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      if (parts.length === 0) {
+        const knownCategories = listCategories().join(", ");
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Code: CODES.invalidChecks,
+          Message: "`--checks` requires at least one category.",
+          Instructions: `Known categories: ${knownCategories}. Omit --checks to run all rules.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      categories = parts;
+    }
+    const llmJudgeModels = await loadLlmJudgeModels(fs, projectPath);
+    const [err, outcome] = await catchError(reviewCodedAgent(projectPath, { categories, llmJudgeModels }, fs));
+    if (err) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES.failed,
+        Message: `Review failed: ${extractErrorMessageSync(err)}`,
+        Instructions: "Verify the project path exists and is a readable agent project. " + "Run `uip codedagent review --help` for usage."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!outcome.ok) {
+      const knownCategories = listCategories().join(", ");
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES.invalidChecks,
+        Message: `Unknown category value(s): ${outcome.unknown.join(", ")}.`,
+        Instructions: `Known categories: ${knownCategories}.`
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { result } = outcome;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: CODES.success,
+      Data: {
+        ProjectDir: projectPath,
+        Verdict: result.verdict,
+        Score: result.score,
+        Grade: result.grade,
+        Issues: result.issues,
+        Strengths: result.strengths,
+        Stats: result.stats
+      }
+    });
+  });
+};
+
+// src/tool.ts
+var PROJECT_ID_ENV_NAME = "UIPATH_PROJECT_ID";
+var PROJECT_ID_INSTRUCTIONS = [
+  "Create or open a Coded Agent project in Studio Web, copy its project ID, then set it before pushing:",
+  `  echo "${PROJECT_ID_ENV_NAME}=<id>" >> .env`,
+  "  uip codedagent push"
+].join(`
+`);
+var metadata = {
+  name: "codedagent-tool",
+  version: package_default.version,
+  description: "Build, run, deploy, and manage AI Agents.",
+  commandPrefix: "codedagent"
+};
+var { executeCommand } = createExecuteCommand({
+  commandRules: COMMAND_RULES,
+  pinNewType: "agent",
+  commandPreflight: codedAgentCommandPreflight,
+  requiredEnvironmentVariables: [
+    {
+      name: PROJECT_ID_ENV_NAME,
+      commands: ["push"],
+      instructions: PROJECT_ID_INSTRUCTIONS,
+      skipWhenHelp: true
+    }
+  ]
+});
+var registerSetupCommand = createSetupCommand({
+  successCode: "CodedAgentsSetup",
+  toolName: "codedagent"
+});
+function isHelpRequest(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function isCodedAgentShipCommand(name) {
+  return name === "deploy" || name === "publish";
+}
+function hasFlag(args, ...flags) {
+  return args.some((arg) => flags.includes(arg));
+}
+function getCodedAgentShipTarget(name, args) {
+  const suffix = name === "publish" ? "feed" : "deployment";
+  if (hasFlag(args, "--my-workspace", "-w")) {
+    return `personal_workspace_coded_agent_${suffix}`;
+  }
+  if (hasFlag(args, "--tenant")) {
+    return `tenant_coded_agent_${suffix}`;
+  }
+  return `coded_agent_${suffix}`;
+}
+var registerWhitelistedCommand = (program, name, description) => {
+  program.command(name, { hidden: false }).description(description).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).argument("[args...]").trackedAction(processContext, async (args = []) => {
+    const result = await executeCommand(["_", "_", "exec", name, ...args], {});
+    if (result.ok && isCodedAgentShipCommand(name) && !isHelpRequest(args)) {
+      trackShipSucceeded({
+        [ShipDimensions.ShipKind]: name,
+        [ShipDimensions.Target]: getCodedAgentShipTarget(name, args),
+        [ShipDimensions.ProjectType]: "coded_agent",
+        [CommandDimensions.CommandName]: `uip codedagent ${name}`,
+        [ShipDimensions.ArtifactCorrelationKey]: process.env[PROJECT_ID_ENV_NAME]
+      });
+    }
+  });
+};
+var registerCommands = async (program) => {
+  registerSetupCommand(program);
+  registerReviewCommand(program);
+  for (const { name, description } of WHITELISTED_COMMANDS) {
+    registerWhitelistedCommand(program, name, description);
+  }
+  program.showHelpAfterError(false);
+};
+
+export { metadata, registerCommands };
+
+//# debugId=6572BB4711783B1E64756E2164756E21