@covibes/zeroshot 5.3.0 → 5.4.0

package/src/providers/index.js

@@ -1,12 +1,14 @@
 const AnthropicProvider = require('./anthropic');
 const OpenAIProvider = require('./openai');
 const GoogleProvider = require('./google');
+const OpencodeProvider = require('./opencode');
 const { normalizeProviderName } = require('../../lib/provider-names');
 
 const PROVIDERS = {
   claude: AnthropicProvider,
   codex: OpenAIProvider,
   gemini: GoogleProvider,
+  opencode: OpencodeProvider,
 };
 
 function getProvider(name) {
@@ -35,10 +37,24 @@ function listProviders() {
 
 function stripTimestampPrefix(line) {
   if (!line || typeof line !== 'string') return '';
-  const trimmed = line.trim().replace(/\r$/, '');
+  let trimmed = line.trim().replace(/\r$/, '');
   if (!trimmed) return '';
-  const match = trimmed.match(/^\[(\d{13})\](.*)$/);
-  return match ? match[2] : trimmed;
+
+  const tsMatch = trimmed.match(/^\[(\d{13})\](.*)$/);
+  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
+
+  // In cluster logs, lines are often prefixed like:
+  // "validator       | {json...}"
+  // Strip the "<agent> | " prefix so provider parsers can JSON.parse the event.
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+    const pipeMatch = trimmed.match(/^[^|]{1,40}\|\s*(.*)$/);
+    if (pipeMatch) {
+      const afterPipe = (pipeMatch[1] || '').trimStart();
+      if (afterPipe.startsWith('{') || afterPipe.startsWith('[')) return afterPipe;
+    }
+  }
+
+  return trimmed;
 }
 
 function parseChunkWithProvider(provider, chunk) {

package/src/providers/openai/cli-builder.js

@@ -3,10 +3,12 @@ const path = require('path');
 const os = require('os');
 
 /**
- * Codex structured outputs require additionalProperties: false on ALL object schemas.
- * This function recursively adds that constraint to ensure schema validation passes.
+ * OpenAI structured outputs have strict schema requirements:
+ * 1. additionalProperties: false on ALL object schemas
+ * 2. 'required' must include ALL keys in 'properties'
+ * This function recursively enforces both constraints.
  * @param {Object} schema - JSON Schema object
- * @returns {Object} - Modified schema with additionalProperties: false on all objects
+ * @returns {Object} - Modified schema compliant with OpenAI structured output requirements
  */
 function enforceStrictSchema(schema) {
   if (!schema || typeof schema !== 'object') return schema;
@@ -14,8 +16,12 @@ function enforceStrictSchema(schema) {
   const result = { ...schema };
 
   // Add additionalProperties: false to object types
+  // OpenAI also requires 'required' to include ALL property keys
   if (result.type === 'object') {
     result.additionalProperties = false;
+    if (result.properties) {
+      result.required = Object.keys(result.properties);
+    }
   }
 
   // Recurse into properties
@@ -72,6 +78,11 @@ function buildCommand(context, options = {}) {
     args.push('--dangerously-bypass-approvals-and-sandbox');
   }
 
+  // Always skip git repo check - zeroshot runs non-interactively and may run in any directory
+  if (cliFeatures.supportsSkipGitRepoCheck !== false) {
+    args.push('--skip-git-repo-check');
+  }
+
   // Augment context with schema if CLI doesn't support native --output-schema
   let finalContext = context;
   if (jsonSchema && cliFeatures.supportsOutputSchema) {

package/src/providers/openai/index.js

@@ -54,6 +54,7 @@ class OpenAIProvider extends BaseProvider {
       supportsCwd: unknown ? true : /\s-C\b/.test(help) || /--cwd\b/.test(help),
       supportsConfigOverride: unknown ? true : /--config\b/.test(help),
       supportsModel: unknown ? true : /\s-m\b/.test(help) || /--model\b/.test(help),
+      supportsSkipGitRepoCheck: unknown ? true : /--skip-git-repo-check\b/.test(help),
       unknown,
     };
 

package/src/providers/openai/output-parser.js

@@ -6,24 +6,53 @@ function safeJsonParse(value, fallback) {
   }
 }
 
+function parseAssistantMessage(item) {
+  const events = [];
+  const content = Array.isArray(item.content)
+    ? item.content
+    : [{ type: 'text', text: item.content }];
+  const text = content
+    .filter((c) => c.type === 'text')
+    .map((c) => c.text)
+    .join('');
+  const thinking = content
+    .filter((c) => c.type === 'thinking' || c.type === 'reasoning')
+    .map((c) => c.text)
+    .join('');
+  if (text) events.push({ type: 'text', text });
+  if (thinking) events.push({ type: 'thinking', text: thinking });
+  return events;
+}
+
+function parseFunctionCall(item) {
+  const toolId = item.call_id || item.id || item.tool_call_id || item.tool_id;
+  const args =
+    typeof item.arguments === 'string' ? safeJsonParse(item.arguments, {}) : item.arguments || {};
+  return {
+    type: 'tool_call',
+    toolName: item.name,
+    toolId,
+    input: args,
+  };
+}
+
+function parseFunctionCallOutput(item) {
+  const toolId = item.call_id || item.id || item.tool_call_id || item.tool_id;
+  const content = item.output ?? item.result ?? item.content ?? '';
+  return {
+    type: 'tool_result',
+    toolId,
+    content,
+    isError: !!item.error,
+  };
+}
+
 function parseItem(item) {
   const events = [];
 
   // Handle assistant messages (Claude-style: type=message, role=assistant)
   if (item.type === 'message' && item.role === 'assistant') {
-    const content = Array.isArray(item.content)
-      ? item.content
-      : [{ type: 'text', text: item.content }];
-    const text = content
-      .filter((c) => c.type === 'text')
-      .map((c) => c.text)
-      .join('');
-    const thinking = content
-      .filter((c) => c.type === 'thinking' || c.type === 'reasoning')
-      .map((c) => c.text)
-      .join('');
-    if (text) events.push({ type: 'text', text });
-    if (thinking) events.push({ type: 'thinking', text: thinking });
+    events.push(...parseAssistantMessage(item));
   }
 
   // Handle agent messages (Codex-style: type=agent_message, text=string)
@@ -32,26 +61,11 @@ function parseItem(item) {
   }
 
   if (item.type === 'function_call') {
-    const toolId = item.call_id || item.id || item.tool_call_id || item.tool_id;
-    const args =
-      typeof item.arguments === 'string' ? safeJsonParse(item.arguments, {}) : item.arguments || {};
-    events.push({
-      type: 'tool_call',
-      toolName: item.name,
-      toolId,
-      input: args,
-    });
+    events.push(parseFunctionCall(item));
   }
 
   if (item.type === 'function_call_output') {
-    const toolId = item.call_id || item.id || item.tool_call_id || item.tool_id;
-    const content = item.output ?? item.result ?? item.content ?? '';
-    events.push({
-      type: 'tool_result',
-      toolId,
-      content,
-      isError: !!item.error,
-    });
+    events.push(parseFunctionCallOutput(item));
   }
 
   if (events.length === 1) return events[0];

package/src/providers/opencode/cli-builder.js

@@ -0,0 +1,42 @@
+function buildCommand(context, options = {}) {
+  const { modelSpec, outputFormat, jsonSchema, cwd, cliFeatures = {} } = options;
+
+  let finalContext = context;
+  if (jsonSchema) {
+    const schemaStr =
+      typeof jsonSchema === 'string' ? jsonSchema : JSON.stringify(jsonSchema, null, 2);
+    finalContext =
+      context +
+      `\n\n## OUTPUT FORMAT (CRITICAL - REQUIRED)\n\nYou MUST respond with a JSON object that exactly matches this schema. NO markdown, NO explanation, NO code blocks. ONLY the raw JSON object.\n\nSchema:\n\`\`\`json\n${schemaStr}\n\`\`\`\n\nYour response must be ONLY valid JSON. Start with { and end with }. Nothing else.`;
+  }
+
+  const args = ['run'];
+
+  if ((outputFormat === 'stream-json' || outputFormat === 'json') && cliFeatures.supportsJson) {
+    args.push('--format', 'json');
+  }
+
+  if (modelSpec?.model) {
+    args.push('--model', modelSpec.model);
+  }
+
+  if (modelSpec?.reasoningEffort && cliFeatures.supportsVariant) {
+    args.push('--variant', modelSpec.reasoningEffort);
+  }
+
+  if (cwd && cliFeatures.supportsCwd) {
+    args.push('--cwd', cwd);
+  }
+
+  args.push(finalContext);
+
+  return {
+    binary: 'opencode',
+    args,
+    env: {},
+  };
+}
+
+module.exports = {
+  buildCommand,
+};

package/src/providers/opencode/index.js

@@ -0,0 +1,103 @@
+const BaseProvider = require('../base-provider');
+const { commandExists, getCommandPath, getHelpOutput } = require('../../../lib/provider-detection');
+const { buildCommand } = require('./cli-builder');
+const { parseEvent } = require('./output-parser');
+const {
+  MODEL_CATALOG,
+  LEVEL_MAPPING,
+  DEFAULT_LEVEL,
+  DEFAULT_MAX_LEVEL,
+  DEFAULT_MIN_LEVEL,
+} = require('./models');
+
+const warned = new Set();
+
+class OpencodeProvider extends BaseProvider {
+  constructor() {
+    super({ name: 'opencode', displayName: 'Opencode', cliCommand: 'opencode' });
+    this._cliFeatures = null;
+  }
+
+  isAvailable() {
+    return commandExists(this.cliCommand);
+  }
+
+  getCliPath() {
+    return getCommandPath(this.cliCommand) || this.cliCommand;
+  }
+
+  getInstallInstructions() {
+    return 'See https://opencode.ai for installation instructions.';
+  }
+
+  getAuthInstructions() {
+    return 'opencode auth login';
+  }
+
+  getCliFeatures() {
+    if (this._cliFeatures) return this._cliFeatures;
+    const help = getHelpOutput(this.cliCommand, ['run']);
+    const unknown = !help;
+
+    const features = {
+      supportsJson: unknown ? true : /--format\b/.test(help),
+      supportsModel: unknown ? true : /--model\b/.test(help),
+      supportsVariant: unknown ? true : /--variant\b/.test(help),
+      supportsCwd: unknown ? false : /--cwd\b/.test(help),
+      supportsAutoApprove: false,
+      unknown,
+    };
+
+    this._cliFeatures = features;
+    return features;
+  }
+
+  getCredentialPaths() {
+    return ['~/.local/share/opencode'];
+  }
+
+  buildCommand(context, options) {
+    const cliFeatures = options.cliFeatures || {};
+
+    if (options.modelSpec?.reasoningEffort && cliFeatures.supportsVariant === false) {
+      this._warnOnce(
+        'opencode-variant',
+        'Opencode CLI does not support --variant; skipping reasoningEffort.'
+      );
+    }
+
+    return buildCommand(context, { ...options, cliFeatures });
+  }
+
+  parseEvent(line) {
+    return parseEvent(line);
+  }
+
+  getModelCatalog() {
+    return MODEL_CATALOG;
+  }
+
+  getLevelMapping() {
+    return LEVEL_MAPPING;
+  }
+
+  getDefaultLevel() {
+    return DEFAULT_LEVEL;
+  }
+
+  getDefaultMaxLevel() {
+    return DEFAULT_MAX_LEVEL;
+  }
+
+  getDefaultMinLevel() {
+    return DEFAULT_MIN_LEVEL;
+  }
+
+  _warnOnce(key, message) {
+    if (warned.has(key)) return;
+    warned.add(key);
+    console.warn(`⚠️ ${message}`);
+  }
+}
+
+module.exports = OpencodeProvider;

package/src/providers/opencode/models.js

@@ -0,0 +1,55 @@
+const MODEL_CATALOG = {
+  'opencode/big-pickle': { rank: 1 },
+  'opencode/glm-4.7-free': { rank: 1 },
+  'opencode/gpt-5-nano': { rank: 1 },
+  'opencode/grok-code': { rank: 1 },
+  'opencode/minimax-m2.1-free': { rank: 1 },
+  'google/gemini-1.5-flash': { rank: 1 },
+  'google/gemini-1.5-flash-8b': { rank: 1 },
+  'google/gemini-1.5-pro': { rank: 1 },
+  'google/gemini-2.0-flash': { rank: 1 },
+  'google/gemini-2.0-flash-lite': { rank: 1 },
+  'google/gemini-2.5-flash': { rank: 1 },
+  'google/gemini-2.5-flash-image': { rank: 1 },
+  'google/gemini-2.5-flash-image-preview': { rank: 1 },
+  'google/gemini-2.5-flash-lite': { rank: 1 },
+  'google/gemini-2.5-flash-lite-preview-06-17': { rank: 1 },
+  'google/gemini-2.5-flash-lite-preview-09-2025': { rank: 1 },
+  'google/gemini-2.5-flash-preview-04-17': { rank: 1 },
+  'google/gemini-2.5-flash-preview-05-20': { rank: 1 },
+  'google/gemini-2.5-flash-preview-09-2025': { rank: 1 },
+  'google/gemini-2.5-flash-preview-tts': { rank: 1 },
+  'google/gemini-2.5-pro': { rank: 1 },
+  'google/gemini-2.5-pro-preview-05-06': { rank: 1 },
+  'google/gemini-2.5-pro-preview-06-05': { rank: 1 },
+  'google/gemini-2.5-pro-preview-tts': { rank: 1 },
+  'google/gemini-3-flash-preview': { rank: 1 },
+  'google/gemini-3-pro-preview': { rank: 1 },
+  'google/gemini-embedding-001': { rank: 1 },
+  'google/gemini-flash-latest': { rank: 1 },
+  'google/gemini-flash-lite-latest': { rank: 1 },
+  'google/gemini-live-2.5-flash': { rank: 1 },
+  'google/gemini-live-2.5-flash-preview-native-audio': { rank: 1 },
+  'openai/gpt-5.1-codex-max': { rank: 1 },
+  'openai/gpt-5.1-codex-mini': { rank: 1 },
+  'openai/gpt-5.2': { rank: 1 },
+  'openai/gpt-5.2-codex': { rank: 1 },
+};
+
+const LEVEL_MAPPING = {
+  level1: { rank: 1, model: null, reasoningEffort: 'low' },
+  level2: { rank: 2, model: null, reasoningEffort: 'medium' },
+  level3: { rank: 3, model: null, reasoningEffort: 'high' },
+};
+
+const DEFAULT_LEVEL = 'level2';
+const DEFAULT_MAX_LEVEL = 'level3';
+const DEFAULT_MIN_LEVEL = 'level1';
+
+module.exports = {
+  MODEL_CATALOG,
+  LEVEL_MAPPING,
+  DEFAULT_LEVEL,
+  DEFAULT_MAX_LEVEL,
+  DEFAULT_MIN_LEVEL,
+};

package/src/providers/opencode/output-parser.js

@@ -0,0 +1,122 @@
+function parseToolPart(part) {
+  const state = part.state || {};
+
+  if (state.status === 'pending' || state.status === 'running') {
+    return {
+      type: 'tool_call',
+      toolName: part.tool,
+      toolId: part.callID,
+      input: state.input || {},
+    };
+  }
+
+  if (state.status === 'completed') {
+    return {
+      type: 'tool_result',
+      toolId: part.callID,
+      content: state.output || '',
+      isError: false,
+    };
+  }
+
+  if (state.status === 'error') {
+    return {
+      type: 'tool_result',
+      toolId: part.callID,
+      content: state.error || '',
+      isError: true,
+    };
+  }
+
+  return null;
+}
+
+function parseStepFinish(part) {
+  const tokens = part.tokens || {};
+  return {
+    type: 'result',
+    success: true,
+    inputTokens: tokens.input || 0,
+    outputTokens: tokens.output || 0,
+  };
+}
+
+function parsePart(part) {
+  if (!part || typeof part !== 'object') return null;
+
+  if (part.type === 'text' && part.text) {
+    return { type: 'text', text: part.text };
+  }
+
+  if (part.type === 'reasoning' && part.text) {
+    return { type: 'thinking', text: part.text };
+  }
+
+  if (part.type === 'tool') {
+    return parseToolPart(part);
+  }
+
+  if (part.type === 'step-finish') {
+    return parseStepFinish(part);
+  }
+
+  return null;
+}
+
+function parseErrorEvent(event) {
+  const error = event.error || {};
+  return {
+    type: 'result',
+    success: false,
+    error: error.data?.message || error.message || error.name || 'Unknown error',
+  };
+}
+
+function parseEvent(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return null;
+  }
+
+  if (!event || typeof event !== 'object') return null;
+
+  if (event.type === 'error') {
+    return parseErrorEvent(event);
+  }
+
+  if (event.type === 'text' || event.type === 'step_start' || event.type === 'step_finish') {
+    return parsePart(event.part || event);
+  }
+
+  if (event.type === 'message.part.updated') {
+    return parsePart(event.properties?.part);
+  }
+
+  return null;
+}
+
+function parseChunk(chunk) {
+  const events = [];
+  const lines = chunk.split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const event = parseEvent(line);
+    if (!event) continue;
+    if (Array.isArray(event)) {
+      events.push(...event);
+    } else {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+module.exports = {
+  parseEvent,
+  parseChunk,
+  parsePart,
+};

package/src/schemas/sub-cluster.js

@@ -30,16 +30,18 @@
  * @param {Number} depth - Current nesting depth (for recursion limit)
  * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
  */
+const MAX_SUBCLUSTER_DEPTH = 5;
+
 function validateSubCluster(agentConfig, depth = 0) {
   const errors = [];
   const warnings = [];
 
   // Max nesting depth to prevent infinite recursion
-  const MAX_DEPTH = 5;
-
-  if (depth > MAX_DEPTH) {
-    errors.push(`Sub-cluster '${agentConfig.id}' exceeds max nesting depth (${MAX_DEPTH})`);
-    return { valid: false, errors, warnings };
+  if (depth > MAX_SUBCLUSTER_DEPTH) {
+    errors.push(
+      `Sub-cluster '${agentConfig.id}' exceeds max nesting depth (${MAX_SUBCLUSTER_DEPTH})`
+    );
+    return buildValidationResult(errors, warnings);
   }
 
   // Validate required fields
@@ -47,19 +49,44 @@ function validateSubCluster(agentConfig, depth = 0) {
     errors.push(`Agent '${agentConfig.id}' must have type: 'subcluster'`);
   }
 
+  if (!validateSubClusterConfig(agentConfig, depth, errors, warnings)) {
+    return buildValidationResult(errors, warnings);
+  }
+
+  // Validate triggers (sub-cluster must have triggers to activate)
+  validateSubClusterTriggers(agentConfig, errors);
+
+  // Validate hooks structure
+  validateSubClusterHooks(agentConfig, errors);
+
+  // Check for context bridging configuration
+  validateContextStrategy(agentConfig, errors);
+
+  return buildValidationResult(errors, warnings);
+}
+
+function buildValidationResult(errors, warnings) {
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+function validateSubClusterConfig(agentConfig, depth, errors, warnings) {
   if (!agentConfig.config) {
     errors.push(`Sub-cluster '${agentConfig.id}' missing config field`);
-    return { valid: false, errors, warnings };
+    return false;
   }
 
   if (!agentConfig.config.agents || !Array.isArray(agentConfig.config.agents)) {
     errors.push(`Sub-cluster '${agentConfig.id}' config.agents must be an array`);
-    return { valid: false, errors, warnings };
+    return false;
   }
 
   if (agentConfig.config.agents.length === 0) {
     errors.push(`Sub-cluster '${agentConfig.id}' config.agents cannot be empty`);
-    return { valid: false, errors, warnings };
+    return false;
   }
 
   // Recursively validate nested cluster config
@@ -71,46 +98,48 @@ function validateSubCluster(agentConfig, depth = 0) {
   }
 
   warnings.push(...childValidation.warnings.map((w) => `Sub-cluster '${agentConfig.id}': ${w}`));
+  return true;
+}
 
-  // Validate triggers (sub-cluster must have triggers to activate)
+function validateSubClusterTriggers(agentConfig, errors) {
   if (!agentConfig.triggers || agentConfig.triggers.length === 0) {
     errors.push(`Sub-cluster '${agentConfig.id}' must have triggers to activate`);
   }
+}
 
-  // Validate hooks structure
-  if (agentConfig.hooks) {
-    if (agentConfig.hooks.onComplete) {
-      const hook = agentConfig.hooks.onComplete;
-      if (!hook.action) {
-        errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing action`);
-      }
-      if (hook.action === 'publish_message' && !hook.config?.topic) {
-        errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing config.topic`);
-      }
-    }
+function validateSubClusterHooks(agentConfig, errors) {
+  if (!agentConfig.hooks?.onComplete) {
+    return;
   }
 
-  // Check for context bridging configuration
-  if (agentConfig.contextStrategy?.parentTopics) {
-    if (!Array.isArray(agentConfig.contextStrategy.parentTopics)) {
-      errors.push(`Sub-cluster '${agentConfig.id}' contextStrategy.parentTopics must be an array`);
-    } else {
-      // Validate each parent topic is a string
-      for (const topic of agentConfig.contextStrategy.parentTopics) {
-        if (typeof topic !== 'string') {
-          errors.push(
-            `Sub-cluster '${agentConfig.id}' parentTopics must contain strings, got ${typeof topic}`
-          );
-        }
-      }
-    }
+  const hook = agentConfig.hooks.onComplete;
+  if (!hook.action) {
+    errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing action`);
+  }
+  if (hook.action === 'publish_message' && !hook.config?.topic) {
+    errors.push(`Sub-cluster '${agentConfig.id}' onComplete hook missing config.topic`);
   }
+}
 
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-  };
+function validateContextStrategy(agentConfig, errors) {
+  const parentTopics = agentConfig.contextStrategy?.parentTopics;
+  if (!parentTopics) {
+    return;
+  }
+
+  if (!Array.isArray(parentTopics)) {
+    errors.push(`Sub-cluster '${agentConfig.id}' contextStrategy.parentTopics must be an array`);
+    return;
+  }
+
+  // Validate each parent topic is a string
+  for (const topic of parentTopics) {
+    if (typeof topic !== 'string') {
+      errors.push(
+        `Sub-cluster '${agentConfig.id}' parentTopics must contain strings, got ${typeof topic}`
+      );
+    }
+  }
 }
 
 /**