@covibes/zeroshot 5.2.1 → 5.4.0

package/src/agent/agent-config.js

@@ -9,7 +9,9 @@
  * - maxModel ceiling enforcement at config time
  */
 
-const { loadSettings, validateModelAgainstMax } = require('../../lib/settings');
+const { loadSettings, validateModelAgainstMax, VALID_MODELS } = require('../../lib/settings');
+
+const VALID_LEVELS = ['level1', 'level2', 'level3'];
 
 // Default max iterations (high limit - let the user decide when to give up)
 const DEFAULT_MAX_ITERATIONS = 100;
@@ -25,21 +27,13 @@ const DEFAULT_TIMEOUT = 0;
 const DEFAULT_STALE_DURATION_MS = 30 * 60 * 1000; // 30 minutes before triggering analysis
 const DEFAULT_LIVENESS_CHECK_ENABLED = true; // Safe with multi-indicator detection
 
-/**
- * Validate and normalize agent configuration
- * @param {Object} config - Raw agent configuration
- * @param {Object} options - Agent wrapper options
- * @returns {Object} Normalized configuration
- */
-function validateAgentConfig(config, options = {}) {
+function applyOutputDefaults(config) {
   // CRITICAL: Enforce JSON schema output by default to prevent parse failures and crashes
-  // Agents MUST return structured output so hooks can safely use {{result.*}} templates
   if (!config.outputFormat) {
     config.outputFormat = 'json';
   }
 
   // If outputFormat is json but no schema defined, use a minimal default schema
-  // This prevents uncaught exceptions when parsing agent output
   if (config.outputFormat === 'json' && !config.jsonSchema) {
     config.jsonSchema = {
       type: 'object',
@@ -56,99 +50,135 @@ function validateAgentConfig(config, options = {}) {
       required: ['summary', 'result'],
     };
   }
+}
 
-  // Model configuration: support both static model and dynamic rules
-  // If no model specified, model is null - _selectModel() will use maxModel as default
-  let modelConfig;
+function buildModelConfig(config) {
   if (config.modelRules) {
-    modelConfig = { type: 'rules', rules: config.modelRules };
-  } else {
-    modelConfig = { type: 'static', model: config.model || null };
+    return { type: 'rules', rules: config.modelRules };
   }
+  return {
+    type: 'static',
+    model: config.model || null,
+    modelLevel: config.modelLevel || null,
+  };
+}
 
-  // COST CEILING ENFORCEMENT: Validate model(s) against maxModel at config time
-  // Catches violations EARLY (config load) instead of at runtime (iteration N)
-  const settings = loadSettings();
-  const maxModel = settings.maxModel || 'sonnet';
+function applyStrictSchemaDefault(config, settings) {
+  if (config.strictSchema === undefined) {
+    config.strictSchema = settings.strictSchema !== false; // Default true if not set
+  }
+}
 
-  if (modelConfig.type === 'static' && modelConfig.model) {
-    // Static model: validate once
+function validateStaticModelConfig(configId, modelConfig, maxModel, minModel) {
+  if (modelConfig.model && VALID_MODELS.includes(modelConfig.model)) {
     try {
-      validateModelAgainstMax(modelConfig.model, maxModel);
+      validateModelAgainstMax(modelConfig.model, maxModel, minModel);
     } catch (error) {
-      throw new Error(`Agent "${config.id}": ${error.message}`);
+      throw new Error(`Agent "${configId}": ${error.message}`);
+    }
+  }
+
+  if (modelConfig.modelLevel && !VALID_LEVELS.includes(modelConfig.modelLevel)) {
+    throw new Error(
+      `Agent "${configId}": invalid modelLevel "${modelConfig.modelLevel}". ` +
+        `Valid: ${VALID_LEVELS.join(', ')}`
+    );
+  }
+}
+
+function validateModelRule(configId, rule, maxModel, minModel) {
+  if (rule.model && VALID_MODELS.includes(rule.model)) {
+    try {
+      validateModelAgainstMax(rule.model, maxModel, minModel);
+    } catch {
+      throw new Error(
+        `Agent "${configId}": modelRule "${rule.iterations}" requests "${rule.model}" ` +
+          `but maxModel is "${maxModel}"${minModel ? ` and minModel is "${minModel}"` : ''}. ` +
+          `Either adjust the rule's model or change maxModel/minModel settings.`
+      );
     }
-  } else if (modelConfig.type === 'rules') {
-    // Dynamic rules: validate ALL rules upfront (don't wait until iteration N)
+  }
+
+  if (rule.modelLevel && !VALID_LEVELS.includes(rule.modelLevel)) {
+    throw new Error(
+      `Agent "${configId}": modelRule "${rule.iterations}" has invalid modelLevel ` +
+        `"${rule.modelLevel}". Valid: ${VALID_LEVELS.join(', ')}`
+    );
+  }
+}
+
+function validateModelConfig(config, modelConfig, maxModel, minModel) {
+  if (modelConfig.type === 'static') {
+    validateStaticModelConfig(config.id, modelConfig, maxModel, minModel);
+    return;
+  }
+
+  if (modelConfig.type === 'rules') {
     for (const rule of modelConfig.rules) {
-      if (rule.model) {
-        try {
-          validateModelAgainstMax(rule.model, maxModel);
-        } catch {
-          throw new Error(
-            `Agent "${config.id}": modelRule "${rule.iterations}" requests "${rule.model}" ` +
-              `but maxModel is "${maxModel}". Either lower the rule's model or raise maxModel.`
-          );
-        }
-      }
+      validateModelRule(config.id, rule, maxModel, minModel);
     }
   }
+}
 
-  // Prompt configuration: support static prompt OR iteration-based rules
-  // Formats:
-  //   prompt: "string"                              -> static
-  //   prompt: { system: "string" }                  -> static
-  //   prompt: { initial: "...", subsequent: "..." } -> iteration 1 vs 2+
-  //   prompt: { iterations: [...] }                 -> full control
-  let promptConfig = null;
+function buildPromptConfig(config) {
   if (config.prompt?.iterations) {
-    promptConfig = { type: 'rules', rules: config.prompt.iterations };
-  } else if (config.prompt?.initial || config.prompt?.subsequent) {
+    return { type: 'rules', rules: config.prompt.iterations };
+  }
+
+  if (config.prompt?.initial || config.prompt?.subsequent) {
     const rules = [];
     if (config.prompt.initial) rules.push({ match: '1', system: config.prompt.initial });
     if (config.prompt.subsequent) rules.push({ match: '2+', system: config.prompt.subsequent });
-    promptConfig = { type: 'rules', rules };
-  } else if (typeof config.prompt === 'string') {
-    promptConfig = { type: 'static', system: config.prompt };
-  } else if (config.prompt?.system) {
-    promptConfig = { type: 'static', system: config.prompt.system };
-  } else if (config.prompt) {
+    return { type: 'rules', rules };
+  }
+
+  if (typeof config.prompt === 'string') {
+    return { type: 'static', system: config.prompt };
+  }
+
+  if (config.prompt?.system) {
+    return { type: 'static', system: config.prompt.system };
+  }
+
+  if (config.prompt) {
     throw new Error(`Agent "${config.id}": invalid prompt format`);
   }
 
-  // Default timeout to 0 (no timeout) if not specified
-  // Use positive number for timeout in milliseconds
-  // ROBUST: Handle undefined, null, AND string values from template resolution
+  return null;
+}
+
+function normalizeTimeout(config) {
   if (config.timeout === undefined || config.timeout === null || config.timeout === '') {
     config.timeout = DEFAULT_TIMEOUT;
   } else {
-    // Coerce to number (handles string "0" from template resolution)
     config.timeout = Number(config.timeout);
   }
+
   if (!Number.isFinite(config.timeout) || config.timeout < 0) {
     throw new Error(
       `Agent "${config.id}": timeout must be a non-negative number (got ${config.timeout}).`
     );
   }
 
-  // Build normalized config
-  const normalizedConfig = {
+  return config.timeout;
+}
+
+function buildNormalizedConfig(config, modelConfig, promptConfig) {
+  return {
     ...config,
     modelConfig,
     promptConfig,
     maxIterations: config.maxIterations || DEFAULT_MAX_ITERATIONS,
-    timeout: config.timeout, // Defaults to 0 (no timeout) if not specified
+    timeout: config.timeout,
     staleDuration: config.staleDuration || DEFAULT_STALE_DURATION_MS,
-    enableLivenessCheck: config.enableLivenessCheck ?? DEFAULT_LIVENESS_CHECK_ENABLED, // On by default, opt-out with false
+    enableLivenessCheck: config.enableLivenessCheck ?? DEFAULT_LIVENESS_CHECK_ENABLED,
   };
+}
 
-  // SAFETY: In test mode, verify mock is provided for agents that execute tasks
-  // Check if this agent executes tasks (vs orchestrator agents that only publish messages)
+function assertTestModeSafety(config, options) {
   const executesTask = config.triggers?.some(
     (trigger) => !trigger.action || trigger.action === 'execute_task'
   );
-
-  // Accept either mockSpawnFn OR taskRunner as valid mock sources
   const hasMock = options.mockSpawnFn || options.taskRunner;
 
   if (options.testMode && !hasMock && executesTask) {
@@ -157,6 +187,53 @@ function validateAgentConfig(config, options = {}) {
         `This would cause real Claude API calls. ABORTING.`
     );
   }
+}
+
+/**
+ * Validate and normalize agent configuration
+ * @param {Object} config - Raw agent configuration
+ * @param {Object} options - Agent wrapper options
+ * @returns {Object} Normalized configuration
+ */
+function validateAgentConfig(config, options = {}) {
+  applyOutputDefaults(config);
+
+  // Model configuration: support both static model and dynamic rules
+  // If no model specified, model is null - _selectModel() will use provider defaults
+  const modelConfig = buildModelConfig(config);
+
+  // COST CEILING/FLOOR ENFORCEMENT: Validate model(s) against maxModel and minModel at config time
+  // Catches violations EARLY (config load) instead of at runtime (iteration N)
+  const settings = loadSettings();
+  const maxModel = settings.maxModel || 'sonnet';
+  const minModel = settings.minModel || null;
+
+  // STRICT SCHEMA PROPAGATION: Issue #52 fix
+  // If agent config doesn't explicitly set strictSchema, inherit from global settings
+  // This allows `zeroshot settings set strictSchema false` to actually affect agents
+  // Default behavior: strictSchema=true (reliable JSON output, no streaming)
+  applyStrictSchemaDefault(config, settings);
+  validateModelConfig(config, modelConfig, maxModel, minModel);
+
+  // Prompt configuration: support static prompt OR iteration-based rules
+  // Formats:
+  //   prompt: "string"                              -> static
+  //   prompt: { system: "string" }                  -> static
+  //   prompt: { initial: "...", subsequent: "..." } -> iteration 1 vs 2+
+  //   prompt: { iterations: [...] }                 -> full control
+  const promptConfig = buildPromptConfig(config);
+
+  // Default timeout to 0 (no timeout) if not specified
+  // Use positive number for timeout in milliseconds
+  // ROBUST: Handle undefined, null, AND string values from template resolution
+  normalizeTimeout(config);
+
+  // Build normalized config
+  const normalizedConfig = buildNormalizedConfig(config, modelConfig, promptConfig);
+
+  // SAFETY: In test mode, verify mock is provided for agents that execute tasks
+  // Check if this agent executes tasks (vs orchestrator agents that only publish messages)
+  assertTestModeSafety(config, options);
 
   return normalizedConfig;
 }