@covibes/zeroshot 5.2.1 → 5.4.0

package/src/claude-task-runner.js

@@ -1,14 +1,17 @@
 /**
  * ClaudeTaskRunner - Production implementation of TaskRunner
  *
- * Executes Claude tasks by spawning the `zeroshot task run` CLI command,
+ * Executes provider tasks by spawning the `zeroshot task run` CLI command,
  * following logs, and assembling results.
  */
 
-const { spawn, exec, execSync } = require('child_process');
+const { spawn } = require('child_process');
+const { exec, execSync } = require('./lib/safe-exec'); // Enforces timeouts
 const fs = require('fs');
 const TaskRunner = require('./task-runner');
-const { getClaudeCommand } = require('../lib/settings');
+const { loadSettings } = require('../lib/settings');
+const { normalizeProviderName } = require('../lib/provider-names');
+const { getProvider } = require('./providers');
 
 class ClaudeTaskRunner extends TaskRunner {
   /**
@@ -36,7 +39,7 @@ class ClaudeTaskRunner extends TaskRunner {
   }
 
   /**
-   * Execute a Claude task via zeroshot CLI
+   * Execute a task via zeroshot CLI
    *
    * @param {string} context - Full prompt/context
    * @param {{agentId?: string, model?: string, outputFormat?: string, jsonSchema?: any, strictSchema?: boolean, cwd?: string, isolation?: any}} options - Execution options
@@ -45,7 +48,11 @@ class ClaudeTaskRunner extends TaskRunner {
   async run(context, options = {}) {
     const {
       agentId = 'unknown',
-      model = 'sonnet',
+      provider,
+      model = null,
+      modelLevel = null,
+      modelSpec: explicitModelSpec = null,
+      reasoningEffort = null,
       outputFormat = 'stream-json',
       jsonSchema = null,
       strictSchema = false, // false = live streaming (default), true = CLI schema enforcement (no streaming)
@@ -53,23 +60,110 @@ class ClaudeTaskRunner extends TaskRunner {
       isolation = null,
     } = options;
 
+    const settings = loadSettings();
+    const providerName = normalizeProviderName(provider || settings.defaultProvider || 'claude');
+    const { providerModule, providerSettings, levelOverrides } = this._getProviderContext(
+      providerName,
+      settings
+    );
+    const resolvedModelSpec = this._resolveModelSpec({
+      explicitModelSpec,
+      model,
+      reasoningEffort,
+      modelLevel,
+      providerModule,
+      providerSettings,
+      levelOverrides,
+    });
+
     // Isolation mode delegates to separate method
     if (isolation?.enabled) {
-      return this._runIsolated(context, options);
+      return this._runIsolated(context, {
+        ...options,
+        provider: providerName,
+        modelSpec: resolvedModelSpec,
+      });
     }
 
     const ctPath = 'zeroshot';
 
-    // Build args.
+    const runOutputFormat = this._resolveOutputFormat({
+      outputFormat,
+      jsonSchema,
+      strictSchema,
+    });
+    const args = this._buildRunArgs({
+      context,
+      providerName,
+      runOutputFormat,
+      resolvedModelSpec,
+      jsonSchema,
+    });
+
+    // Spawn and get task ID
+    const spawnEnv = this._buildSpawnEnv(providerName, resolvedModelSpec);
+
+    const taskId = await this._spawnAndGetTaskId(ctPath, args, cwd, spawnEnv, agentId);
+
+    this._log(`📋 [${agentId}]: Following zeroshot logs for ${taskId}`);
+
+    // Wait for task registration
+    await this._waitForTaskReady(ctPath, taskId);
+
+    // Follow logs until completion
+    return this._followLogs(ctPath, taskId, agentId);
+  }
+
+  _getProviderContext(providerName, settings) {
+    const providerModule = getProvider(providerName);
+    const providerSettings = settings.providerSettings?.[providerName] || {};
+    const levelOverrides = providerSettings.levelOverrides || {};
+    return { providerModule, providerSettings, levelOverrides };
+  }
+
+  _resolveModelSpec({
+    explicitModelSpec,
+    model,
+    reasoningEffort,
+    modelLevel,
+    providerModule,
+    providerSettings,
+    levelOverrides,
+  }) {
+    if (explicitModelSpec) {
+      return explicitModelSpec;
+    }
+
+    if (model) {
+      return { model, reasoningEffort };
+    }
+
+    const level = modelLevel || providerSettings.defaultLevel || providerModule.getDefaultLevel();
+    let resolvedModelSpec = providerModule.resolveModelSpec(level, levelOverrides);
+    if (reasoningEffort) {
+      resolvedModelSpec = { ...resolvedModelSpec, reasoningEffort };
+    }
+
+    return resolvedModelSpec;
+  }
+
+  _resolveOutputFormat({ outputFormat, jsonSchema, strictSchema }) {
     // json output does not stream; if a jsonSchema is configured we run stream-json
     // for live logs and validate/parse JSON after completion.
     // Set strictSchema=true to disable live streaming and use CLI's native schema enforcement.
-    const desiredOutputFormat = outputFormat;
-    const runOutputFormat =
-      jsonSchema && desiredOutputFormat === 'json' && !strictSchema
-        ? 'stream-json'
-        : desiredOutputFormat;
-    const args = ['task', 'run', '--output-format', runOutputFormat];
+    return jsonSchema && outputFormat === 'json' && !strictSchema ? 'stream-json' : outputFormat;
+  }
+
+  _buildRunArgs({ context, providerName, runOutputFormat, resolvedModelSpec, jsonSchema }) {
+    const args = ['task', 'run', '--output-format', runOutputFormat, '--provider', providerName];
+
+    if (resolvedModelSpec?.model) {
+      args.push('--model', resolvedModelSpec.model);
+    }
+
+    if (resolvedModelSpec?.reasoningEffort) {
+      args.push('--reasoning-effort', resolvedModelSpec.reasoningEffort);
+    }
 
     // Pass schema to CLI only when using json output (strictSchema=true or no conflict)
     if (jsonSchema && runOutputFormat === 'json') {
@@ -78,35 +172,34 @@ class ClaudeTaskRunner extends TaskRunner {
 
     args.push(context);
 
-    // Spawn and get task ID
-    const taskId = await this._spawnAndGetTaskId(ctPath, args, cwd, model, agentId);
-
-    this._log(`📋 [${agentId}]: Following zeroshot logs for ${taskId}`);
+    return args;
+  }
 
-    // Wait for task registration
-    await this._waitForTaskReady(ctPath, taskId);
+  _buildSpawnEnv(providerName, resolvedModelSpec) {
+    const spawnEnv = {
+      ...process.env,
+    };
+    if (providerName === 'claude' && resolvedModelSpec?.model) {
+      spawnEnv.ANTHROPIC_MODEL = resolvedModelSpec.model;
+    }
 
-    // Follow logs until completion
-    return this._followLogs(ctPath, taskId, agentId);
+    return spawnEnv;
   }
 
   /**
    * @param {string} ctPath
    * @param {string[]} args
    * @param {string} cwd
-   * @param {string} model
+   * @param {Object} spawnEnv
    * @param {string} _agentId
    * @returns {Promise<string>}
    */
-  _spawnAndGetTaskId(ctPath, args, cwd, model, _agentId) {
+  _spawnAndGetTaskId(ctPath, args, cwd, spawnEnv, _agentId) {
     return new Promise((resolve, reject) => {
       const proc = spawn(ctPath, args, {
         cwd,
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: {
-          ...process.env,
-          ANTHROPIC_MODEL: model,
-        },
+        env: spawnEnv,
       });
 
       let stdout = '';
@@ -367,7 +460,8 @@ class ClaudeTaskRunner extends TaskRunner {
   _runIsolated(context, options) {
     const {
       agentId = 'unknown',
-      model = 'sonnet',
+      provider = 'claude',
+      modelSpec = null,
       outputFormat = 'stream-json',
       jsonSchema = null,
       strictSchema = false,
@@ -377,47 +471,54 @@ class ClaudeTaskRunner extends TaskRunner {
 
     this._log(`📦 [${agentId}]: Running task in isolated container...`);
 
-    // Determine output format: stream-json for live logs unless strictSchema=true
     const desiredOutputFormat = outputFormat;
     const runOutputFormat =
       jsonSchema && desiredOutputFormat === 'json' && !strictSchema
         ? 'stream-json'
         : desiredOutputFormat;
 
-    // Get configured Claude command (supports custom commands like 'ccr code')
-    const { command: claudeCmd, args: claudeExtraArgs } = getClaudeCommand();
-
     const command = [
-      claudeCmd,
-      ...claudeExtraArgs,
-      '--print',
-      '--dangerously-skip-permissions',
+      'zeroshot',
+      'task',
+      'run',
       '--output-format',
       runOutputFormat,
+      '--provider',
+      provider,
     ];
 
-    if (runOutputFormat === 'stream-json') {
-      command.push('--verbose');
-      command.push('--include-partial-messages');
+    if (modelSpec?.model) {
+      command.push('--model', modelSpec.model);
+    }
+
+    if (modelSpec?.reasoningEffort) {
+      command.push('--reasoning-effort', modelSpec.reasoningEffort);
     }
 
-    // Pass schema to CLI only when using json output (strictSchema=true or no conflict)
     if (jsonSchema && runOutputFormat === 'json') {
       command.push('--json-schema', JSON.stringify(jsonSchema));
     }
 
-    if (model) {
-      command.push('--model', model);
+    let finalContext = context;
+    if (jsonSchema && desiredOutputFormat === 'json' && runOutputFormat === 'stream-json') {
+      finalContext += `\n\n## Output Format (REQUIRED)\n\nReturn a JSON object that matches this schema exactly.\n\nSchema:\n\`\`\`json\n${JSON.stringify(
+        jsonSchema,
+        null,
+        2
+      )}\n\`\`\`\n`;
     }
 
-    command.push(context);
+    command.push(finalContext);
 
     return new Promise((resolve, reject) => {
       let output = '';
       let resolved = false;
 
       const proc = manager.spawnInContainer(clusterId, command, {
-        env: { ANTHROPIC_MODEL: model },
+        env:
+          provider === 'claude' && modelSpec?.model
+            ? { ANTHROPIC_MODEL: modelSpec.model, ZEROSHOT_BLOCK_ASK_USER: '1' }
+            : {},
       });
 
       proc.stdout.on('data', (/** @type {Buffer} */ data) => {

package/src/config-router.js

@@ -27,10 +27,10 @@ function getConfig(complexity, taskType) {
     return 'full-workflow';
   };
 
-  const getModel = (role) => {
-    if (complexity === 'CRITICAL' && role === 'planner') return 'opus';
-    if (complexity === 'TRIVIAL') return 'haiku';
-    return 'sonnet';
+  const getLevel = (role) => {
+    if (complexity === 'CRITICAL' && role === 'planner') return 'level3';
+    if (complexity === 'TRIVIAL') return 'level1';
+    return 'level2';
   };
 
   const getValidatorCount = () => {
@@ -59,18 +59,18 @@ function getConfig(complexity, taskType) {
   };
 
   if (base === 'single-worker') {
-    params.worker_model = getModel('worker');
+    params.worker_level = getLevel('worker');
   } else if (base === 'worker-validator') {
-    params.worker_model = getModel('worker');
-    params.validator_model = getModel('validator');
+    params.worker_level = getLevel('worker');
+    params.validator_level = getLevel('validator');
   } else if (base === 'debug-workflow') {
-    params.investigator_model = getModel('planner');
-    params.fixer_model = getModel('worker');
-    params.tester_model = getModel('validator');
+    params.investigator_level = getLevel('planner');
+    params.fixer_level = getLevel('worker');
+    params.tester_level = getLevel('validator');
   } else if (base === 'full-workflow') {
-    params.planner_model = getModel('planner');
-    params.worker_model = getModel('worker');
-    params.validator_model = getModel('validator');
+    params.planner_level = getLevel('planner');
+    params.worker_level = getLevel('worker');
+    params.validator_level = getLevel('validator');
     params.validator_count = getValidatorCount();
   }