@agentv/core 4.32.0-next.1 → 4.33.0-next.1

package/dist/evaluation/validation/index.cjs

@@ -1306,7 +1306,8 @@ var DEPRECATED_TARGET_CAMEL_CASE_FIELDS = /* @__PURE__ */ new Map([
   ["retryInitialDelayMs", "retry_initial_delay_ms"],
   ["retryMaxDelayMs", "retry_max_delay_ms"],
   ["retryBackoffFactor", "retry_backoff_factor"],
-  ["retryStatusCodes", "retry_status_codes"]
+  ["retryStatusCodes", "retry_status_codes"],
+  ["modelReasoningEffort", "model_reasoning_effort"]
 ]);
 var DEPRECATED_HEALTHCHECK_CAMEL_CASE_FIELDS = /* @__PURE__ */ new Map([
   ["timeoutSeconds", "timeout_seconds"]
@@ -1415,6 +1416,9 @@ var PROVIDER_ALIASES = [
 function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
 var COMMON_SETTINGS = new Set(COMMON_TARGET_SETTINGS);
 var RETRY_SETTINGS = /* @__PURE__ */ new Set([
   "max_retries",
@@ -1483,6 +1487,7 @@ var GEMINI_SETTINGS = /* @__PURE__ */ new Set([
 var CODEX_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
   "model",
+  "model_reasoning_effort",
   "executable",
   "command",
   "binary",
@@ -1492,8 +1497,7 @@ var CODEX_SETTINGS = /* @__PURE__ */ new Set([
   "timeout_seconds",
   "log_dir",
   "log_directory",
-  "log_format",
-  "log_output_format",
+  "stream_log",
   "system_prompt"
 ]);
 var COPILOT_SDK_SETTINGS = /* @__PURE__ */ new Set([
@@ -1618,6 +1622,26 @@ function validateUnknownSettings(target, provider, absolutePath, location, error
         "api_format",
         "The 'api_format' field is no longer supported on Azure targets. AgentV always uses Azure's Responses API (`/openai/v1/responses`). If your deployment only exposes /chat/completions, use 'provider: openai' with a deployment-scoped 'base_url' instead."
       ]
+    ]),
+    codex: /* @__PURE__ */ new Map([
+      [
+        "log_format",
+        "The 'log_format' field is no longer supported on Codex targets. Use 'stream_log: raw' for per-event logs or 'stream_log: summary' for consolidated logs."
+      ],
+      [
+        "log_output_format",
+        "The 'log_output_format' field is no longer supported on Codex targets. Use 'stream_log: raw' for per-event logs or 'stream_log: summary' for consolidated logs."
+      ]
+    ]),
+    "codex-cli": /* @__PURE__ */ new Map([
+      [
+        "log_format",
+        "The 'log_format' field is no longer supported on Codex targets. Use 'stream_log: raw' for per-event logs or 'stream_log: summary' for consolidated logs."
+      ],
+      [
+        "log_output_format",
+        "The 'log_output_format' field is no longer supported on Codex targets. Use 'stream_log: raw' for per-event logs or 'stream_log: summary' for consolidated logs."
+      ]
     ])
   };
   const removedForProvider = removedPerProvider[provider];
@@ -1654,9 +1678,11 @@ async function validateTargetsFile(filePath) {
   const errors = [];
   const absolutePath = import_node_path6.default.resolve(filePath);
   let parsed;
+  let rawParsed;
   try {
     const content = await (0, import_promises5.readFile)(absolutePath, "utf8");
-    parsed = interpolateEnv(parseYamlValue(content), process.env);
+    rawParsed = parseYamlValue(content);
+    parsed = interpolateEnv(rawParsed, process.env);
   } catch (error) {
     errors.push({
       severity: "error",
@@ -1777,6 +1803,7 @@ async function validateTargetsFile(filePath) {
     };
   }
   const targets = parsed.targets;
+  const rawTargets = isObject3(rawParsed) && Array.isArray(rawParsed.targets) ? rawParsed.targets : [];
   if (!Array.isArray(targets)) {
     errors.push({
       severity: "error",
@@ -1826,7 +1853,9 @@ async function validateTargetsFile(filePath) {
       });
     }
     const provider = target.provider;
-    const hasUseTarget = typeof target.use_target === "string" && target.use_target.trim().length > 0;
+    const rawTarget = rawTargets[i];
+    const rawUseTarget = isObject3(rawTarget) ? rawTarget.use_target : void 0;
+    const hasUseTarget = isNonEmptyString(target.use_target) || isNonEmptyString(rawUseTarget);
     const providerValue = typeof provider === "string" ? provider.trim().toLowerCase() : void 0;
     const isTemplated = typeof provider === "string" && /^\$\{\{.+\}\}$/.test(provider.trim());
     if (!hasUseTarget && (typeof provider !== "string" || provider.trim().length === 0)) {
@@ -1870,8 +1899,24 @@ async function validateTargetsFile(filePath) {
 
 // src/evaluation/validation/config-validator.ts
 var import_promises6 = require("fs/promises");
-async function validateConfigFile(filePath) {
+var import_node_path8 = __toESM(require("path"), 1);
+
+// src/paths.ts
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+function readEnvPath(name) {
+  const value = process.env[name];
+  if (!value || value === "undefined") return void 0;
+  return value;
+}
+function getAgentvConfigDir() {
+  return readEnvPath("AGENTV_HOME") ?? import_node_path7.default.join(import_node_os2.default.homedir(), ".agentv");
+}
+
+// src/evaluation/validation/config-validator.ts
+async function validateConfigFile(filePath, options = {}) {
   const errors = [];
+  const scope = options.scope ?? inferConfigScope(filePath);
   try {
     const content = await (0, import_promises6.readFile)(filePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
@@ -1920,78 +1965,43 @@ async function validateConfigFile(filePath) {
         });
       }
     }
-    const results = config.results;
-    if (results !== void 0) {
-      if (typeof results !== "object" || results === null || Array.isArray(results)) {
+    validateResultsConfig(errors, filePath, config.results, "results");
+    const projects = config.projects;
+    if (projects !== void 0) {
+      if (scope === "project") {
+        errors.push({
+          severity: "warning",
+          filePath,
+          location: "projects",
+          message: "Field 'projects' is only valid in $AGENTV_HOME/config.yaml. Ignoring project registry entries in project-local .agentv/config.yaml."
+        });
+      } else if (!Array.isArray(projects)) {
         errors.push({
           severity: "error",
           filePath,
-          location: "results",
-          message: "Field 'results' must be an object"
+          location: "projects",
+          message: "Field 'projects' must be an array"
         });
       } else {
-        const resultsRecord = results;
-        if (resultsRecord.mode !== "github") {
-          errors.push({
-            severity: "error",
-            filePath,
-            location: "results.mode",
-            message: "Field 'results.mode' must be 'github'"
-          });
-        }
-        if (typeof resultsRecord.repo !== "string" || resultsRecord.repo.trim().length === 0) {
-          errors.push({
-            severity: "error",
-            filePath,
-            location: "results.repo",
-            message: "Field 'results.repo' must be a non-empty string"
-          });
-        }
-        if (resultsRecord.path !== void 0) {
-          if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
-            errors.push({
-              severity: "error",
-              filePath,
-              location: "results.path",
-              message: "Field 'results.path' must be a non-empty string"
-            });
-          } else {
-            const p = resultsRecord.path.trim();
-            const isFilesystemPath = p.startsWith("/") || p.startsWith("~/") || p.startsWith("~\\") || p === "~" || /^[A-Za-z]:[/\\]/.test(p);
-            if (!isFilesystemPath) {
-              errors.push({
-                severity: "error",
-                filePath,
-                location: "results.path",
-                message: `'results.path' must be an absolute or home-relative filesystem path (e.g., ~/data/agentv-results). Found: '${p}'. Remove 'path' to use the default.`
-              });
-            }
-          }
-        }
-        if (resultsRecord.auto_push !== void 0 && typeof resultsRecord.auto_push !== "boolean") {
-          errors.push({
-            severity: "error",
-            filePath,
-            location: "results.auto_push",
-            message: "Field 'results.auto_push' must be a boolean"
-          });
-        }
-        if (resultsRecord.branch_prefix !== void 0 && (typeof resultsRecord.branch_prefix !== "string" || resultsRecord.branch_prefix.trim().length === 0)) {
-          errors.push({
-            severity: "error",
-            filePath,
-            location: "results.branch_prefix",
-            message: "Field 'results.branch_prefix' must be a non-empty string"
-          });
-        }
+        validateProjects(errors, filePath, projects);
       }
     }
+    if (config.results_by_project !== void 0) {
+      errors.push({
+        severity: "warning",
+        filePath,
+        location: "results_by_project",
+        message: "Field 'results_by_project' is deprecated. Put per-project result repo settings under projects[].results in $AGENTV_HOME/config.yaml."
+      });
+    }
     const allowedFields = /* @__PURE__ */ new Set([
       "$schema",
       "eval_patterns",
       "required_version",
       "execution",
       "results",
+      "projects",
+      "results_by_project",
       "dashboard",
       "studio"
     ]);
@@ -2018,15 +2028,114 @@ async function validateConfigFile(filePath) {
     return { valid: false, filePath, fileType: "config", errors };
   }
 }
+function inferConfigScope(filePath) {
+  const globalConfigPath = import_node_path8.default.resolve(getAgentvConfigDir(), "config.yaml");
+  if (import_node_path8.default.resolve(filePath) === globalConfigPath) {
+    return "global";
+  }
+  return filePath.split(/[\\/]/).includes(".agentv") ? "project" : "global";
+}
+function validateProjects(errors, filePath, projects) {
+  projects.forEach((project, index) => {
+    const location = `projects[${index}]`;
+    if (typeof project !== "object" || project === null || Array.isArray(project)) {
+      errors.push({
+        severity: "error",
+        filePath,
+        location,
+        message: `Field '${location}' must be an object`
+      });
+      return;
+    }
+    const projectRecord = project;
+    validateRequiredString(errors, filePath, projectRecord.id, `${location}.id`);
+    validateRequiredString(errors, filePath, projectRecord.name, `${location}.name`);
+    validateRequiredString(errors, filePath, projectRecord.path, `${location}.path`);
+    validateResultsConfig(errors, filePath, projectRecord.results, `${location}.results`);
+  });
+}
+function validateRequiredString(errors, filePath, value, location) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location,
+      message: `Field '${location}' must be a non-empty string`
+    });
+  }
+}
+function validateResultsConfig(errors, filePath, rawResults, location) {
+  if (rawResults === void 0) {
+    return;
+  }
+  if (typeof rawResults !== "object" || rawResults === null || Array.isArray(rawResults)) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location,
+      message: `Field '${location}' must be an object`
+    });
+    return;
+  }
+  const resultsRecord = rawResults;
+  if (resultsRecord.mode !== "github") {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.mode`,
+      message: `Field '${location}.mode' must be 'github'`
+    });
+  }
+  validateRequiredString(errors, filePath, resultsRecord.repo, `${location}.repo`);
+  if (resultsRecord.path !== void 0) {
+    if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
+      errors.push({
+        severity: "error",
+        filePath,
+        location: `${location}.path`,
+        message: `Field '${location}.path' must be a non-empty string`
+      });
+    } else {
+      const p = resultsRecord.path.trim();
+      if (!isFilesystemPath(p)) {
+        errors.push({
+          severity: "error",
+          filePath,
+          location: `${location}.path`,
+          message: `'${location}.path' must be an absolute or home-relative filesystem path (e.g., ~/data/agentv-results). Found: '${p}'. Remove 'path' to use the default.`
+        });
+      }
+    }
+  }
+  if (resultsRecord.auto_push !== void 0 && typeof resultsRecord.auto_push !== "boolean") {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.auto_push`,
+      message: `Field '${location}.auto_push' must be a boolean`
+    });
+  }
+  if (resultsRecord.branch_prefix !== void 0 && (typeof resultsRecord.branch_prefix !== "string" || resultsRecord.branch_prefix.trim().length === 0)) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.branch_prefix`,
+      message: `Field '${location}.branch_prefix' must be a non-empty string`
+    });
+  }
+}
+function isFilesystemPath(p) {
+  return p.startsWith("/") || p.startsWith("~/") || p.startsWith("~\\") || p === "~" || /^[A-Za-z]:[/\\]/.test(p);
+}
 
 // src/evaluation/validation/file-reference-validator.ts
 var import_promises8 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 
 // src/evaluation/file-utils.ts
 var import_node_fs2 = require("fs");
 var import_promises7 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 async function fileExists(filePath) {
   try {
     await (0, import_promises7.access)(filePath, import_node_fs2.constants.F_OK);
@@ -2036,14 +2145,14 @@ async function fileExists(filePath) {
   }
 }
 async function findGitRoot(startPath) {
-  let currentDir = import_node_path7.default.dirname(import_node_path7.default.resolve(startPath));
-  const root = import_node_path7.default.parse(currentDir).root;
+  let currentDir = import_node_path9.default.dirname(import_node_path9.default.resolve(startPath));
+  const root = import_node_path9.default.parse(currentDir).root;
   while (currentDir !== root) {
-    const gitPath = import_node_path7.default.join(currentDir, ".git");
+    const gitPath = import_node_path9.default.join(currentDir, ".git");
     if (await fileExists(gitPath)) {
       return currentDir;
     }
-    const parentDir = import_node_path7.default.dirname(currentDir);
+    const parentDir = import_node_path9.default.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -2054,16 +2163,16 @@ async function findGitRoot(startPath) {
 function buildSearchRoots(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = import_node_path7.default.resolve(root);
+    const normalized = import_node_path9.default.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = import_node_path7.default.dirname(evalPath);
+  let currentDir = import_node_path9.default.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = import_node_path7.default.dirname(currentDir);
+    const parentDir = import_node_path9.default.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -2081,16 +2190,16 @@ function trimLeadingSeparators(value) {
 async function resolveFileReference(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators(rawValue);
   const potentialPaths = [];
-  if (import_node_path7.default.isAbsolute(rawValue)) {
-    potentialPaths.push(import_node_path7.default.normalize(rawValue));
+  if (import_node_path9.default.isAbsolute(rawValue)) {
+    potentialPaths.push(import_node_path9.default.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(import_node_path7.default.resolve(base, displayPath));
+    potentialPaths.push(import_node_path9.default.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = import_node_path7.default.resolve(candidate);
+    const absoluteCandidate = import_node_path9.default.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -2109,7 +2218,7 @@ function isObject4(value) {
 }
 async function validateFileReferences(evalFilePath) {
   const errors = [];
-  const absolutePath = import_node_path8.default.resolve(evalFilePath);
+  const absolutePath = import_node_path10.default.resolve(evalFilePath);
   const gitRoot = await findGitRoot(absolutePath);
   if (!gitRoot) {
     errors.push({
@@ -2234,14 +2343,14 @@ async function validateMessagesFileRefs(messages, location, searchRoots, filePat
 
 // src/evaluation/validation/workspace-path-validator.ts
 var import_promises9 = require("fs/promises");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 function isObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function validateWorkspacePaths(evalFilePath) {
   const errors = [];
-  const absolutePath = import_node_path9.default.resolve(evalFilePath);
-  const evalDir = import_node_path9.default.dirname(absolutePath);
+  const absolutePath = import_node_path11.default.resolve(evalFilePath);
+  const evalDir = import_node_path11.default.dirname(absolutePath);
   let parsed;
   try {
     const content = await (0, import_promises9.readFile)(absolutePath, "utf8");
@@ -2253,12 +2362,12 @@ async function validateWorkspacePaths(evalFilePath) {
   const workspaceRaw = parsed.workspace;
   if (workspaceRaw === void 0 || workspaceRaw === null) return errors;
   if (typeof workspaceRaw === "string") {
-    const workspaceFilePath = import_node_path9.default.resolve(evalDir, workspaceRaw);
+    const workspaceFilePath = import_node_path11.default.resolve(evalDir, workspaceRaw);
     try {
       const wsContent = await (0, import_promises9.readFile)(workspaceFilePath, "utf8");
       const wsParsed = parseYamlValue(wsContent);
       if (isObject5(wsParsed)) {
-        const wsDir = import_node_path9.default.dirname(workspaceFilePath);
+        const wsDir = import_node_path11.default.dirname(workspaceFilePath);
         await validateWorkspaceObject(wsParsed, wsDir, absolutePath, "workspace", errors);
       }
     } catch {
@@ -2271,7 +2380,7 @@ async function validateWorkspacePaths(evalFilePath) {
 async function validateWorkspaceObject(obj, baseDir, evalFilePath, location, errors) {
   const template = obj.template;
   if (typeof template === "string") {
-    const templatePath = import_node_path9.default.isAbsolute(template) ? template : import_node_path9.default.resolve(baseDir, template);
+    const templatePath = import_node_path11.default.isAbsolute(template) ? template : import_node_path11.default.resolve(baseDir, template);
     if (!await fileExists2(templatePath)) {
       errors.push({
         severity: "error",
@@ -2287,14 +2396,14 @@ async function validateWorkspaceObject(obj, baseDir, evalFilePath, location, err
     const hook = hooks[hookName];
     if (!isObject5(hook)) continue;
     const hookCwdRaw = typeof hook.cwd === "string" ? hook.cwd : void 0;
-    const hookCwd = hookCwdRaw ? import_node_path9.default.isAbsolute(hookCwdRaw) ? hookCwdRaw : import_node_path9.default.resolve(baseDir, hookCwdRaw) : baseDir;
+    const hookCwd = hookCwdRaw ? import_node_path11.default.isAbsolute(hookCwdRaw) ? hookCwdRaw : import_node_path11.default.resolve(baseDir, hookCwdRaw) : baseDir;
     const command = hook.command ?? hook.script;
     if (!Array.isArray(command)) continue;
     for (let i = 0; i < command.length; i++) {
       const arg = command[i];
       if (typeof arg !== "string") continue;
       if (!looksLikeFilePath(arg)) continue;
-      const resolved = import_node_path9.default.isAbsolute(arg) ? arg : import_node_path9.default.resolve(hookCwd, arg);
+      const resolved = import_node_path11.default.isAbsolute(arg) ? arg : import_node_path11.default.resolve(hookCwd, arg);
       if (!await fileExists2(resolved)) {
         errors.push({
           severity: "error",