@the-open-engine/zeroshot 6.4.0 → 6.6.0

package/src/providers/index.js

@@ -1,61 +1,16 @@
 const BaseProvider = require('./base-provider');
-const { getClaudeCommand } = require('../../lib/settings');
-const { normalizeProviderName } = require('../../lib/provider-names');
+const {
+  getProviderMetadata,
+  normalizeProviderName,
+  resolveProviderCommand,
+} = require('../../lib/provider-names');
 const { commandExists, getCommandPath } = require('../../lib/provider-detection');
 const helper = require('../../lib/agent-cli-provider');
 
-const PROVIDER_METADATA = {
-  claude: {
-    displayName: 'Claude',
-    cliCommand: 'claude',
-    helpArgs: () => getClaudeCommand().args,
-    commandParts: () => getClaudeCommand(),
-    installInstructions:
-      'npm install -g @anthropic-ai/claude-code\nOr (macOS): brew install claude',
-    authInstructions: 'claude login',
-    credentialPaths: ['~/.claude'],
-    settingsFields: ['anthropicApiKey', 'bedrockApiKey', 'bedrockRegion'],
-  },
-  codex: {
-    displayName: 'Codex',
-    cliCommand: 'codex',
-    helpArgs: () => ['exec'],
-    commandParts: () => ({ command: 'codex', args: [] }),
-    installInstructions: 'npm install -g @openai/codex',
-    authInstructions: 'codex login',
-    credentialPaths: ['~/.config/codex', '~/.codex'],
-    settingsFields: [],
-  },
-  gemini: {
-    displayName: 'Gemini',
-    cliCommand: 'gemini',
-    helpArgs: () => [],
-    commandParts: () => ({ command: 'gemini', args: [] }),
-    installInstructions: 'npm install -g @google/gemini-cli',
-    authInstructions: 'gemini auth login',
-    credentialPaths: ['~/.config/gcloud', '~/.config/gemini', '~/.gemini'],
-    settingsFields: [],
-  },
-  opencode: {
-    displayName: 'Opencode',
-    cliCommand: 'opencode',
-    helpArgs: () => ['run'],
-    commandParts: () => ({ command: 'opencode', args: [] }),
-    installInstructions: 'See https://opencode.ai for installation instructions.',
-    authInstructions: 'opencode auth login',
-    credentialPaths: ['~/.local/share/opencode'],
-    settingsFields: [],
-  },
-};
-
 const warned = new Set();
 
 function metadataForProvider(name) {
-  const metadata = PROVIDER_METADATA[name];
-  if (!metadata) {
-    throw new Error(`Unknown provider: ${name}. Valid: ${listProviders().join(', ')}`);
-  }
-  return metadata;
+  return getProviderMetadata(name);
 }
 
 class RuntimeProvider extends BaseProvider {
@@ -65,7 +20,7 @@ class RuntimeProvider extends BaseProvider {
     super({
       name: normalized,
       displayName: metadata.displayName,
-      cliCommand: metadata.cliCommand,
+      cliCommand: metadata.binary,
     });
     this._metadata = metadata;
     this._adapter = helper.getProviderAdapter(normalized);
@@ -78,12 +33,19 @@ class RuntimeProvider extends BaseProvider {
   }
 
   isAvailable() {
-    const { command } = this._metadata.commandParts();
-    return commandExists(command);
+    if (this._usesBundledRunner()) {
+      return helper.probeRuntimeProviderCli(this.name).available;
+    }
+    const { command } = resolveProviderCommand(this.name);
+    if (!commandExists(command)) return false;
+    return helper.probeRuntimeProviderCli(this.name).available;
   }
 
   getCliPath() {
-    const { command } = this._metadata.commandParts();
+    if (this._usesBundledRunner()) {
+      return this._adapter.binary || process.execPath;
+    }
+    const { command } = resolveProviderCommand(this.name);
     return getCommandPath(command) || command;
   }
 
@@ -105,6 +67,10 @@ class RuntimeProvider extends BaseProvider {
     return this._metadata.credentialPaths;
   }
 
+  _usesBundledRunner() {
+    return this._adapter.detectCliFeatures('').supportsBundledRunner === true;
+  }
+
   buildCommand(context, options = {}) {
     const prepared = helper.prepareSingleAgentProviderCommand({
       provider: this.name,
@@ -169,30 +135,42 @@ class RuntimeProvider extends BaseProvider {
 
   getDefaultSettings() {
     const settings = super.getDefaultSettings();
-    if (this.name !== 'claude') return settings;
-    return {
-      ...settings,
-      anthropicApiKey: null,
-      bedrockApiKey: null,
-      bedrockRegion: null,
-    };
+    if (this._metadata.settingsDefaults) {
+      return {
+        ...settings,
+        ...this._metadata.settingsDefaults,
+      };
+    }
+    if (this._metadata.settingsFields.length === 0) return settings;
+    return this._metadata.settingsFields.reduce(
+      (result, field) => ({
+        ...result,
+        [field]: null,
+      }),
+      { ...settings }
+    );
   }
 
   validateSettings(settings) {
     const baseError = super.validateSettings(settings);
     if (baseError) return baseError;
+    if (this._metadata.settingsValidator) {
+      const providerError = this._metadata.settingsValidator(settings);
+      if (providerError) return providerError;
+    } else {
+      for (const field of this._metadata.settingsFields) {
+        if (
+          settings[field] !== undefined &&
+          settings[field] !== null &&
+          typeof settings[field] !== 'string'
+        ) {
+          return `providerSettings.${this.name}.${field} must be a string or null`;
+        }
+      }
+    }
     if (this.name !== 'claude') return null;
 
     const { isValidAnthropicKey, ANTHROPIC_KEY_PREFIX } = require('../../lib/settings/claude-auth');
-    for (const field of this._metadata.settingsFields) {
-      if (
-        settings[field] !== undefined &&
-        settings[field] !== null &&
-        typeof settings[field] !== 'string'
-      ) {
-        return `providerSettings.claude.${field} must be a string or null`;
-      }
-    }
     if (settings.anthropicApiKey && !isValidAnthropicKey(settings.anthropicApiKey)) {
       return `providerSettings.claude.anthropicApiKey must start with ${ANTHROPIC_KEY_PREFIX}`;
     }
@@ -206,7 +184,9 @@ class RuntimeProvider extends BaseProvider {
 
 function getProvider(name) {
   const normalized = normalizeProviderName(name || '');
-  if (!PROVIDER_METADATA[normalized]) {
+  try {
+    metadataForProvider(normalized);
+  } catch {
     throw new Error(`Unknown provider: ${name}. Valid: ${listProviders().join(', ')}`);
   }
   return new RuntimeProvider(normalized);

package/src/worktree-claude-config.js

@@ -119,6 +119,23 @@ function prepareClaudeConfigDir(options = {}) {
   return overlayDir;
 }
 
+/**
+ * Resolve the repo's `.mcp.json` path (the same MCP-server source Claude consumes via
+ * prepareClaudeConfigDir) for a given worktree/cwd, or null if none exists. Reused by providers
+ * that consume MCP servers through a CLI flag instead of the Claude config-dir overlay (e.g.
+ * Copilot's `--additional-mcp-config`), so both providers share one MCP config surface.
+ */
+function resolveRepoMcpConfigPath(options = {}) {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  if (!worktreeRoot) {
+    return null;
+  }
+
+  const mcpPath = path.join(worktreeRoot, CLAUDE_DIRNAME, MCP_BASENAME);
+  return fs.existsSync(mcpPath) ? mcpPath : null;
+}
+
 module.exports = {
   prepareClaudeConfigDir,
+  resolveRepoMcpConfigPath,
 };

package/task-lib/commands/run.js

@@ -38,6 +38,7 @@ export async function runTask(prompt, options = {}) {
     continue: options.continue,
     outputFormat,
     jsonSchema,
+    mcpConfig: options.mcpConfig,
     silentJsonOutput,
   });
 

package/task-lib/provider-helper-runtime.js

@@ -19,11 +19,22 @@ export const {
   classifyProviderError,
   detectProviderFatalError,
   detectProviderStreamingModeError,
+  findProviderRegistryEntry,
   getProviderAdapter,
+  getProviderRegistryEntry,
+  knownProviderNames,
   listProviderAdapters,
+  listProviderRegistryEntries,
+  normalizeProviderName,
   parseProviderChunk,
   prepareSingleAgentProviderCommand,
   recoverProviderStructuredOutput,
+  resolveProviderCommand,
   resolveModelSpec,
+  supportsProviderCapability,
+  providerAliasMap,
+  providerAliases,
+  providerIds,
+  providerRegistry,
   supportsProviderStructuredOutputRecovery,
 } = helper;

package/task-lib/runner.js

@@ -80,11 +80,18 @@ function buildProviderOptions(options, outputFormat, jsonSchema, cwd) {
     cwd,
     autoApprove: true,
     ...modelSpecOption(options),
+    ...mcpConfigOption(options),
     ...(options.resume ? { resumeSessionId: options.resume } : {}),
     ...(options.continue ? { continueSession: true } : {}),
   };
 }
 
+function mcpConfigOption(options) {
+  const entries = options.mcpConfig;
+  if (!Array.isArray(entries) || entries.length === 0) return {};
+  return { mcpConfig: entries };
+}
+
 function modelSpecOption(options) {
   const modelSpec = resolveRequestedModelSpec(options);
   return modelSpec === undefined ? {} : { modelSpec };