@covibes/zeroshot 5.2.1 → 5.4.0

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

@@ -0,0 +1,133 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * 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 compliant with OpenAI structured output requirements
+ */
+function enforceStrictSchema(schema) {
+  if (!schema || typeof schema !== 'object') return 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
+  if (result.properties) {
+    result.properties = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+      result.properties[key] = enforceStrictSchema(value);
+    }
+  }
+
+  // Recurse into items (arrays)
+  if (result.items) {
+    result.items = enforceStrictSchema(schema.items);
+  }
+
+  // Recurse into anyOf/oneOf/allOf
+  for (const key of ['anyOf', 'oneOf', 'allOf']) {
+    if (Array.isArray(result[key])) {
+      result[key] = result[key].map(enforceStrictSchema);
+    }
+  }
+
+  // Recurse into additionalProperties if it's a schema
+  if (result.additionalProperties && typeof result.additionalProperties === 'object') {
+    result.additionalProperties = enforceStrictSchema(result.additionalProperties);
+  }
+
+  return result;
+}
+
+function buildCommand(context, options = {}) {
+  const { modelSpec, outputFormat, jsonSchema, cwd, autoApprove, cliFeatures = {} } = options;
+
+  const args = ['exec'];
+  const cleanup = []; // Files to cleanup after command completes
+
+  if ((outputFormat === 'stream-json' || outputFormat === 'json') && cliFeatures.supportsJson) {
+    args.push('--json');
+  }
+
+  if (modelSpec?.model) {
+    args.push('-m', modelSpec.model);
+  }
+
+  if (modelSpec?.reasoningEffort && cliFeatures.supportsConfigOverride) {
+    args.push('--config', `model_reasoning_effort="${modelSpec.reasoningEffort}"`);
+  }
+
+  if (cwd && cliFeatures.supportsCwd) {
+    args.push('-C', cwd);
+  }
+
+  if (autoApprove && cliFeatures.supportsAutoApprove) {
+    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) {
+    // CRITICAL: Codex --output-schema takes a FILE PATH, not a JSON string
+    // Write schema to temp file and pass the path
+    // Codex requires additionalProperties: false on all object schemas
+    const parsedSchema = typeof jsonSchema === 'string' ? JSON.parse(jsonSchema) : jsonSchema;
+    const strictSchema = enforceStrictSchema(parsedSchema);
+    const schemaStr = JSON.stringify(strictSchema, null, 2);
+    const schemaFile = path.join(
+      os.tmpdir(),
+      `zeroshot-schema-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
+    );
+    fs.writeFileSync(schemaFile, schemaStr);
+    cleanup.push(schemaFile);
+    args.push('--output-schema', schemaFile);
+  } else if (jsonSchema) {
+    // CRITICAL: Inject schema into prompt when CLI doesn't support --output-schema
+    // Without this, model outputs free-form text instead of JSON
+    const schemaStr =
+      typeof jsonSchema === 'string' ? jsonSchema : JSON.stringify(jsonSchema, null, 2);
+    finalContext =
+      context +
+      `\n\n## OUTPUT FORMAT (CRITICAL - REQUIRED)
+
+You MUST respond with a JSON object that exactly matches this schema. NO markdown, NO explanation, NO code blocks. ONLY the raw JSON object.
+
+Schema:
+\`\`\`json
+${schemaStr}
+\`\`\`
+
+Your response must be ONLY valid JSON. Start with { and end with }. Nothing else.`;
+  }
+
+  args.push(finalContext);
+
+  return {
+    binary: 'codex',
+    args,
+    env: {},
+    cleanup, // Temp files to delete after command completes
+  };
+}
+
+module.exports = {
+  buildCommand,
+};

package/src/providers/openai/index.js

@@ -0,0 +1,136 @@
+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 OpenAIProvider extends BaseProvider {
+  constructor() {
+    super({ name: 'codex', displayName: 'Codex', cliCommand: 'codex' });
+    this._cliFeatures = null;
+    this._unknownEventCounts = new Map();
+  }
+
+  // SDK not implemented - uses CLI only
+  // See BaseProvider for SDK extension point documentation
+
+  isAvailable() {
+    return commandExists(this.cliCommand);
+  }
+
+  getCliPath() {
+    return getCommandPath(this.cliCommand) || this.cliCommand;
+  }
+
+  getInstallInstructions() {
+    return 'npm install -g @openai/codex';
+  }
+
+  getAuthInstructions() {
+    return 'codex login';
+  }
+
+  getCliFeatures() {
+    if (this._cliFeatures) return this._cliFeatures;
+    // CRITICAL: Check 'codex exec --help' not 'codex --help'
+    // The --output-schema flag is on the exec subcommand, not the main command
+    const help = getHelpOutput(this.cliCommand, ['exec']);
+    const unknown = !help;
+
+    const features = {
+      supportsJson: unknown ? true : /--json\b/.test(help),
+      supportsOutputSchema: unknown ? true : /--output-schema\b/.test(help),
+      supportsAutoApprove: unknown
+        ? true
+        : /--dangerously-bypass-approvals-and-sandbox\b/.test(help),
+      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,
+    };
+
+    this._cliFeatures = features;
+    return features;
+  }
+
+  getCredentialPaths() {
+    return ['~/.config/codex', '~/.codex'];
+  }
+
+  buildCommand(context, options) {
+    const cliFeatures = options.cliFeatures || {};
+
+    if (options.autoApprove && cliFeatures.supportsAutoApprove === false) {
+      this._warnOnce(
+        'codex-auto-approve',
+        'Codex CLI does not support auto-approve; continuing without bypass flag.'
+      );
+    }
+
+    if (options.jsonSchema && cliFeatures.supportsOutputSchema === false) {
+      this._warnOnce(
+        'codex-jsonschema',
+        'Codex CLI does not support --output-schema; skipping schema flag.'
+      );
+    }
+
+    if (options.modelSpec?.reasoningEffort && cliFeatures.supportsConfigOverride === false) {
+      this._warnOnce(
+        'codex-reasoning',
+        'Codex CLI does not support --config overrides; skipping reasoningEffort.'
+      );
+    }
+
+    return buildCommand(context, { ...options, cliFeatures });
+  }
+
+  parseEvent(line) {
+    return parseEvent(line, {
+      onUnknown: (type) => this._logUnknown(type),
+    });
+  }
+
+  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}`);
+  }
+
+  _logUnknown(type) {
+    const current = this._unknownEventCounts.get(type) || 0;
+    if (current >= 5) return;
+    this._unknownEventCounts.set(type, current + 1);
+    console.debug(`[codex] Unknown event type: ${type}`);
+  }
+}
+
+module.exports = OpenAIProvider;

package/src/providers/openai/models.js

@@ -0,0 +1,21 @@
+// Codex CLI - use null to let CLI pick its default model
+// Levels vary by reasoning effort only
+const MODEL_CATALOG = {};
+
+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/openai/output-parser.js

@@ -0,0 +1,143 @@
+function safeJsonParse(value, fallback) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return 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') {
+    events.push(...parseAssistantMessage(item));
+  }
+
+  // Handle agent messages (Codex-style: type=agent_message, text=string)
+  if (item.type === 'agent_message' && item.text) {
+    events.push({ type: 'text', text: item.text });
+  }
+
+  if (item.type === 'function_call') {
+    events.push(parseFunctionCall(item));
+  }
+
+  if (item.type === 'function_call_output') {
+    events.push(parseFunctionCallOutput(item));
+  }
+
+  if (events.length === 1) return events[0];
+  if (events.length > 1) return events;
+  return null;
+}
+
+function parseEvent(line, options = {}) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return null;
+  }
+
+  switch (event.type) {
+    case 'thread.started':
+    case 'turn.started':
+      return null;
+
+    case 'item.created':
+    case 'item.completed':
+      return parseItem(event.item);
+
+    case 'turn.completed': {
+      const usage = event.usage || event.response?.usage || {};
+      return {
+        type: 'result',
+        success: true,
+        inputTokens: usage.input_tokens || 0,
+        outputTokens: usage.output_tokens || 0,
+      };
+    }
+
+    case 'turn.failed':
+      return {
+        type: 'result',
+        success: false,
+        error: event.error?.message || event.error || 'Turn failed',
+      };
+
+    default:
+      // Only log warnings for actual unknown string types, not malformed events
+      // (undefined/object types are just noise from non-standard CLI output)
+      if (options.onUnknown && typeof event.type === 'string') {
+        options.onUnknown(event.type, event);
+      }
+      return null;
+  }
+}
+
+function parseChunk(chunk, options = {}) {
+  const events = [];
+  const lines = chunk.split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const event = parseEvent(line, options);
+    if (!event) continue;
+    if (Array.isArray(event)) {
+      events.push(...event);
+    } else {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+module.exports = {
+  parseEvent,
+  parseChunk,
+  parseItem,
+  safeJsonParse,
+};

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,
+};