@the-open-engine/zeroshot 6.15.0 → 6.16.0

package/src/agent-cli-provider/types.ts

@@ -89,6 +89,7 @@ export interface ResolvedGatewayBuildOptions {
 export interface BaseCliFeatures {
   readonly provider?: ProviderId;
   readonly unknown?: boolean;
+  readonly supportsWebSearch?: boolean;
 }
 
 export interface ClaudeCliFeatures extends BaseCliFeatures {
@@ -116,6 +117,7 @@ export interface CodexCliFeatures extends BaseCliFeatures {
   readonly supportsModel: boolean;
   readonly supportsSkipGitRepoCheck: boolean;
   readonly supportsResume: boolean;
+  readonly supportsWebSearch: boolean;
 }
 
 export interface GeminiCliFeatures extends BaseCliFeatures {
@@ -134,6 +136,8 @@ export interface OpencodeCliFeatures extends BaseCliFeatures {
   readonly supportsDir: boolean;
   readonly supportsCwd: boolean;
   readonly supportsAutoApprove: false;
+  readonly supportsResume: boolean;
+  readonly supportsWebSearch: boolean;
 }
 
 export interface PiCliFeatures extends BaseCliFeatures {
@@ -218,6 +222,7 @@ export interface CliFeatureOverrides {
   readonly supportsAddDir?: boolean;
   readonly supportsMcpConfig?: boolean;
   readonly supportsResume?: boolean;
+  readonly supportsWebSearch?: boolean;
   readonly supportsBundledRunner?: boolean;
   readonly supportsAcpStdio?: boolean;
   readonly supportsPromptImages?: boolean;
@@ -252,6 +257,11 @@ export interface RedactionMetadata {
   readonly source?: string;
 }
 
+export interface WebSearchAttestation {
+  readonly requested: boolean;
+  readonly effective: boolean;
+}
+
 export interface CommandSpec {
   readonly binary: string;
   readonly args: readonly string[];
@@ -272,6 +282,7 @@ export interface BuildProviderCommandOptions {
   readonly autoApprove?: boolean;
   readonly resumeSessionId?: string;
   readonly continueSession?: boolean;
+  readonly webSearch?: boolean;
   readonly claudeSettingsFile?: string;
   readonly cliFeatures?: CliFeatureOverrides;
   readonly authEnv?: Readonly<Record<string, string>>;
@@ -373,7 +384,7 @@ export interface ProviderAdapter {
   readonly defaultLevel: ModelLevel;
   readonly defaultMaxLevel: ModelLevel;
   readonly defaultMinLevel: ModelLevel;
-  detectCliFeatures(helpText?: string | null): ProviderCliFeatures;
+  detectCliFeatures(helpText?: string | null, versionText?: string | null): ProviderCliFeatures;
   buildCommand(context: string, options?: BuildProviderCommandOptions): CommandSpec;
   extractSessionId?(line: string): string | null;
   parseEvent(line: string, state: ProviderParserState): ProviderParseResult;

package/src/claude-task-runner.js

@@ -34,6 +34,7 @@ const {
   appendTaskRunModelArgs,
   wrapTaskRunWithIsolatedSettings,
 } = require('./task-run-model-args');
+const { parseTaskStartupError } = require('./task-startup-error');
 
 function rejectCallerSuppliedModelProvenance(options) {
   if (Object.prototype.hasOwnProperty.call(options, 'modelSpecSource')) {
@@ -98,6 +99,7 @@ function runCommand(command, args, options = {}, callback = null) {
 }
 
 const TASK_TERMINAL_STATUSES = new Set(['completed', 'failed', 'killed', 'stale', 'cancelled']);
+const TASK_STARTUP_STDERR_MAX_CHARS = 500;
 
 async function cleanupPersistedTaskAfterLaunchFailure(ctPath, taskId) {
   let lastError = null;
@@ -808,6 +810,7 @@ class ClaudeTaskRunner extends TaskRunner {
     return new Promise((resolve, reject) => {
       let output = '';
       let resolved = false;
+      let stderr = '';
 
       const proc = manager.spawnInContainer(clusterId, command, {
         env: {
@@ -828,6 +831,7 @@ class ClaudeTaskRunner extends TaskRunner {
 
       proc.stderr.on('data', (/** @type {Buffer} */ data) => {
         const chunk = data.toString();
+        stderr = `${stderr}${chunk}`.slice(-TASK_STARTUP_STDERR_MAX_CHARS);
         if (!this.quiet) {
           console.error(`[${agentId}] stderr:`, chunk);
         }
@@ -836,6 +840,13 @@ class ClaudeTaskRunner extends TaskRunner {
       proc.on('close', (/** @type {number|null} */ code) => {
         if (resolved) return;
         resolved = true;
+        if (code !== 0) {
+          const startupError = parseTaskStartupError(stderr);
+          if (startupError) {
+            reject(startupError);
+            return;
+          }
+        }
 
         resolve({
           success: code === 0,

package/src/orchestrator.js

@@ -2716,12 +2716,17 @@ class Orchestrator {
     });
 
     for (const error of errors) {
+      const errorData = error.content?.data || {};
       const failureInfo = {
         agentId: error.sender,
-        taskId: error.content?.data?.taskId || null,
-        iteration: error.content?.data?.iteration || 0,
-        error: error.content?.data?.error || error.content?.text,
+        taskId: errorData.taskId || null,
+        iteration: errorData.iteration || 0,
+        error: errorData.error || error.content?.text,
         timestamp: error.timestamp,
+        ...(errorData.code !== undefined ? { code: errorData.code } : {}),
+        ...(errorData.permanent !== undefined ? { permanent: errorData.permanent } : {}),
+        ...(errorData.provider !== undefined ? { provider: errorData.provider } : {}),
+        ...(errorData.capability !== undefined ? { capability: errorData.capability } : {}),
       };
       if (this._hasDurableProgressAfterFailure(cluster, clusterId, failureInfo)) {
         this._log(

package/src/providers/index.js

@@ -159,6 +159,12 @@ class RuntimeProvider extends BaseProvider {
   validateSettings(settings) {
     const baseError = super.validateSettings(settings);
     if (baseError) return baseError;
+    if (
+      Object.prototype.hasOwnProperty.call(settings, 'webSearch') &&
+      !this._metadata.settingsFields.includes('webSearch')
+    ) {
+      return `Unknown provider setting: providerSettings.${this.name}.webSearch`;
+    }
     if (this._metadata.settingsValidator) {
       const providerError = this._metadata.settingsValidator(settings);
       if (providerError) return providerError;

package/src/task-run-model-args.js

@@ -1,3 +1,5 @@
+const { providerSupportsCapability } = require('../lib/provider-names');
+
 /**
  * Append a resolved model selection to a nested `zeroshot task run` invocation.
  *
@@ -61,9 +63,9 @@ try {
 
 /**
  * Wrap an isolated task command with a Docker-only, temporary settings-file
- * bootstrap. The snapshot is a closed projection containing only the selected
- * OpenCode level and its model. It never contains arbitrary provider settings,
- * credentials, or caller-owned keys.
+ * bootstrap. The snapshot is a closed projection containing only an enabled
+ * native-search control and, when needed, the selected OpenCode level/model.
+ * It never contains credentials or caller-owned keys.
  *
  * @param {string[]} command
  * @param {{providerName: string, settings: Object, modelSpecSource: 'direct'|'provider-level', modelSpec: Object|null|undefined}} context
@@ -71,57 +73,73 @@ try {
  */
 function wrapTaskRunWithIsolatedSettings(command, context) {
   const { providerName, settings, modelSpecSource, modelSpec } = context;
-  if (providerName !== 'opencode' || modelSpecSource !== 'provider-level') return command;
-  const snapshot = buildIsolatedSettingsSnapshot(settings, modelSpec);
+  if (!providerSupportsCapability(providerName, 'webSearch')) return command;
+  const includesOpencodeModel =
+    providerName === 'opencode' && modelSpecSource === 'provider-level';
+  const snapshot = buildIsolatedSettingsSnapshot(
+    settings,
+    providerName,
+    includesOpencodeModel ? modelSpec : null
+  );
   if (snapshot === null) return command;
   return ['node', '-e', SETTINGS_BOOTSTRAP_SCRIPT, snapshot, ...command];
 }
 
-function buildIsolatedSettingsSnapshot(settings, modelSpec) {
-  const level = modelSpec?.level;
-  if (!['level1', 'level2', 'level3'].includes(level)) {
-    throw permanentError(
-      'Provider-level isolated OpenCode selections require a valid model level.'
-    );
-  }
-
+function buildIsolatedSettingsSnapshot(settings, providerName, opencodeModelSpec) {
   const providerSettings = ownRecordValue(settings, 'providerSettings', 'settings') ?? {};
-  const opencodeSettings = ownRecordValue(
+  const selectedSettings = ownRecordValue(
     providerSettings,
-    'opencode',
+    providerName,
     'settings.providerSettings'
   );
-  const levelOverrides = ownRecordValue(
-    opencodeSettings,
-    'levelOverrides',
-    'settings.providerSettings.opencode'
-  );
-  const levelOverride = ownRecordValue(
-    levelOverrides,
-    level,
-    'settings.providerSettings.opencode.levelOverrides'
-  );
-  const configuredModel =
-    levelOverride && Object.prototype.hasOwnProperty.call(levelOverride, 'model')
-      ? levelOverride.model
-      : null;
-  if (configuredModel !== null && typeof configuredModel !== 'string') {
-    throw permanentError(`Configured isolated OpenCode ${level} model must be a string or null.`);
+  const webSearch = selectedSettings?.webSearch;
+  if (webSearch !== undefined && typeof webSearch !== 'boolean') {
+    throw permanentError(`settings.providerSettings.${providerName}.webSearch must be a boolean.`);
   }
-  if (modelSpec?.model !== configuredModel) {
-    throw permanentError(
-      `Provider-level model "${modelSpec?.model}" does not match the effective isolated ${modelSpec?.level} model "${configuredModel}".`
+
+  const snapshot = {};
+  if (webSearch === true) snapshot.webSearch = true;
+  if (opencodeModelSpec !== null) {
+    const level = opencodeModelSpec?.level;
+    if (!['level1', 'level2', 'level3'].includes(level)) {
+      throw permanentError(
+        'Provider-level isolated OpenCode selections require a valid model level.'
+      );
+    }
+
+    const levelOverrides = ownRecordValue(
+      selectedSettings,
+      'levelOverrides',
+      'settings.providerSettings.opencode'
+    );
+    const levelOverride = ownRecordValue(
+      levelOverrides,
+      level,
+      'settings.providerSettings.opencode.levelOverrides'
     );
+    const configuredModel =
+      levelOverride && Object.prototype.hasOwnProperty.call(levelOverride, 'model')
+        ? levelOverride.model
+        : null;
+    if (configuredModel !== null && typeof configuredModel !== 'string') {
+      throw permanentError(`Configured isolated OpenCode ${level} model must be a string or null.`);
+    }
+    if (opencodeModelSpec.model !== configuredModel) {
+      throw permanentError(
+        `Provider-level model "${opencodeModelSpec.model}" does not match the effective isolated ${level} model "${configuredModel}".`
+      );
+    }
+    if (configuredModel !== null) {
+      snapshot.levelOverrides = {
+        [level]: { model: configuredModel },
+      };
+    }
   }
-  if (configuredModel === null) return null;
 
+  if (Object.keys(snapshot).length === 0) return null;
   return JSON.stringify({
     providerSettings: {
-      opencode: {
-        levelOverrides: {
-          [level]: { model: configuredModel },
-        },
-      },
+      [providerName]: snapshot,
     },
   });
 }

package/src/task-spawn-cleanup-ownership.js

@@ -1,4 +1,5 @@
 const { randomUUID } = require('node:crypto');
+const { parseTaskStartupError } = require('./task-startup-error');
 
 const TASK_SPAWN_OWNERSHIP_TOKEN_ENV = 'ZEROSHOT_TASK_SPAWN_OWNERSHIP_TOKEN';
 
@@ -38,6 +39,8 @@ function requireTaskIdFromWrapperResult({
   persistedTaskId = null,
 }) {
   if (code !== 0) {
+    const startupError = parseTaskStartupError(stderr);
+    if (startupError) throw startupError;
     throw new Error(`zeroshot task run failed with code ${code}: ${stderr}`);
   }
   if (!persistedTaskId) {

package/src/task-startup-error.js

@@ -0,0 +1,68 @@
+const TASK_STARTUP_ERROR_PREFIX = 'ZEROSHOT_TASK_STARTUP_ERROR:';
+const SUPPORTED_STARTUP_ERROR_CODES = new Set(['unsupported-capability']);
+
+function createUnsupportedProviderCapabilityError(provider, capability, message) {
+  const error = new Error(message);
+  error.name = 'UnsupportedProviderCapabilityError';
+  error.code = 'unsupported-capability';
+  error.permanent = true;
+  error.provider = provider;
+  error.capability = capability;
+  return error;
+}
+
+function serializeTaskStartupError(error) {
+  if (
+    !SUPPORTED_STARTUP_ERROR_CODES.has(error?.code) ||
+    error?.permanent !== true
+  ) {
+    return null;
+  }
+  const payload = {
+    version: 1,
+    code: error.code,
+    permanent: true,
+    message: String(error.message || error.code),
+  };
+  if (typeof error.provider === 'string') payload.provider = error.provider;
+  if (typeof error.capability === 'string') payload.capability = error.capability;
+  return `${TASK_STARTUP_ERROR_PREFIX}${JSON.stringify(payload)}`;
+}
+
+function parseTaskStartupError(stderr) {
+  const lines = String(stderr || '').split(/\r?\n/);
+  let line = lines.pop();
+  while (line === '' && lines.length > 0) line = lines.pop();
+  if (!line?.startsWith(TASK_STARTUP_ERROR_PREFIX)) return null;
+
+  let parsed;
+  try {
+    parsed = JSON.parse(line.slice(TASK_STARTUP_ERROR_PREFIX.length));
+  } catch {
+    return null;
+  }
+  if (
+    parsed?.version !== 1 ||
+    !SUPPORTED_STARTUP_ERROR_CODES.has(parsed.code) ||
+    parsed.permanent !== true ||
+    typeof parsed.message !== 'string' ||
+    parsed.message.length === 0 ||
+    (parsed.provider !== undefined && typeof parsed.provider !== 'string') ||
+    (parsed.capability !== undefined && typeof parsed.capability !== 'string')
+  ) {
+    return null;
+  }
+  const error = new Error(parsed.message);
+  error.code = parsed.code;
+  error.permanent = true;
+  if (parsed.provider !== undefined) error.provider = parsed.provider;
+  if (parsed.capability !== undefined) error.capability = parsed.capability;
+  return error;
+}
+
+module.exports = {
+  TASK_STARTUP_ERROR_PREFIX,
+  createUnsupportedProviderCapabilityError,
+  parseTaskStartupError,
+  serializeTaskStartupError,
+};