@the-open-engine/zeroshot 6.29.0 → 6.30.0

package/protocol/openengine-cluster/v1/worker.schema.json

@@ -246,15 +246,32 @@
             "null"
           ]
         },
+        "modelLevel": {
+          "enum": [
+            "level1",
+            "level2",
+            "level3"
+          ]
+        },
         "prompt": {
           "type": [
             "string",
             "null"
           ]
         },
+        "provider": {
+          "minLength": 1,
+          "pattern": "\\S",
+          "type": "string"
+        },
         "providerProfile": {
           "$ref": "#/$defs/CredentialHandle"
         },
+        "repository": {
+          "minLength": 1,
+          "pattern": "\\S",
+          "type": "string"
+        },
         "source": {
           "enum": [
             "issue",
@@ -267,13 +284,89 @@
         "source",
         "artifacts",
         "isolationProfile",
-        "providerProfile"
+        "providerProfile",
+        "repository",
+        "provider",
+        "modelLevel"
       ],
       "title": "LegacyShipRequest",
       "type": "object"
     },
     "LegacyShipResult": {
       "additionalProperties": false,
+      "oneOf": [
+        {
+          "properties": {
+            "branch": {
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "headRevision": {
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "pullRequestUrl": {
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "repository": {
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "status": {
+              "const": "succeeded"
+            }
+          },
+          "required": [
+            "repository",
+            "branch",
+            "headRevision",
+            "pullRequestUrl"
+          ]
+        },
+        {
+          "properties": {
+            "branch": {
+              "type": "null"
+            },
+            "headRevision": {
+              "type": "null"
+            },
+            "pullRequestUrl": {
+              "type": "null"
+            },
+            "repository": {
+              "type": "null"
+            },
+            "status": {
+              "const": "succeeded"
+            }
+          }
+        },
+        {
+          "properties": {
+            "branch": {
+              "type": "null"
+            },
+            "headRevision": {
+              "type": "null"
+            },
+            "pullRequestUrl": {
+              "type": "null"
+            },
+            "repository": {
+              "type": "null"
+            },
+            "status": {
+              "const": "failed"
+            }
+          }
+        }
+      ],
       "properties": {
         "artifacts": {
           "items": {
@@ -281,10 +374,39 @@
           },
           "type": "array"
         },
+        "branch": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "headRevision": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "pullRequestUrl": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "repository": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
         "status": {
-          "$ref": "#/$defs/LegacyShipStatus"
+          "enum": [
+            "succeeded",
+            "failed"
+          ]
         },
         "summary": {
+          "minLength": 1,
+          "pattern": "\\S",
           "type": "string"
         }
       },
@@ -296,13 +418,6 @@
       "title": "LegacyShipResult",
       "type": "object"
     },
-    "LegacyShipStatus": {
-      "enum": [
-        "succeeded",
-        "failed"
-      ],
-      "type": "string"
-    },
     "PayloadType": {
       "oneOf": [
         {
@@ -985,18 +1100,41 @@
                           "kind": "string"
                         }
                       },
+                      "modelLevel": {
+                        "required": true,
+                        "type": {
+                          "kind": "enum",
+                          "values": [
+                            "level1",
+                            "level2",
+                            "level3"
+                          ]
+                        }
+                      },
                       "prompt": {
                         "required": false,
                         "type": {
                           "kind": "string"
                         }
                       },
+                      "provider": {
+                        "required": true,
+                        "type": {
+                          "kind": "string"
+                        }
+                      },
                       "providerProfile": {
                         "required": true,
                         "type": {
                           "kind": "string"
                         }
                       },
+                      "repository": {
+                        "required": true,
+                        "type": {
+                          "kind": "string"
+                        }
+                      },
                       "source": {
                         "required": true,
                         "type": {
@@ -1114,6 +1252,30 @@
                           "kind": "array"
                         }
                       },
+                      "branch": {
+                        "required": false,
+                        "type": {
+                          "kind": "string"
+                        }
+                      },
+                      "headRevision": {
+                        "required": false,
+                        "type": {
+                          "kind": "string"
+                        }
+                      },
+                      "pullRequestUrl": {
+                        "required": false,
+                        "type": {
+                          "kind": "string"
+                        }
+                      },
+                      "repository": {
+                        "required": false,
+                        "type": {
+                          "kind": "string"
+                        }
+                      },
                       "status": {
                         "required": true,
                         "type": {

package/scripts/build-cluster.js

@@ -6,8 +6,11 @@ const path = require('node:path');
 const root = path.resolve(__dirname, '..');
 const clusterBuildRoot = path.join(root, '.cluster-build');
 const hostedSessionBuildRoot = path.join(root, '.hosted-session-build');
+const hostedTargetBuildRoot = path.join(root, '.hosted-target-build');
 const clusterOutputRoot = path.join(root, 'lib/cluster');
 const hostedSessionOutputRoot = path.join(root, 'lib/hosted-session');
+const hostedTargetOutputRoot = path.join(root, 'lib/hosted-target');
+const targetOutputRoot = path.join(root, 'lib/target');
 
 function filesBelow(directory) {
   const entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -17,6 +20,15 @@ function filesBelow(directory) {
   });
 }
 
+function declarationContent(source, localExtension) {
+  return fs
+    .readFileSync(source, 'utf8')
+    .replace(/(["'])(\.\.?\/[^"']+)\.ts\1/g, (_match, quote, specifier) => {
+      const extension = specifier.startsWith('../target/') ? '.js' : localExtension;
+      return `${quote}${specifier}${extension}${quote}`;
+    });
+}
+
 function copyBuild(sourceRoot, outputRoot, mode) {
   for (const source of filesBelow(sourceRoot)) {
     const relative = path.relative(sourceRoot, source);
@@ -32,15 +44,18 @@ function copyBuild(sourceRoot, outputRoot, mode) {
       fs.mkdirSync(path.dirname(target), { recursive: true });
       fs.writeFileSync(target, content);
     } else if (mode === 'cjs' && extension === '.ts' && relative.endsWith('.d.ts')) {
-      const target = path.join(outputRoot, relative);
-      fs.mkdirSync(path.dirname(target), { recursive: true });
-      fs.copyFileSync(source, target);
+      const base = path.join(outputRoot, relative.slice(0, -5));
+      fs.mkdirSync(path.dirname(base), { recursive: true });
+      fs.writeFileSync(`${base}.d.ts`, declarationContent(source, '.js'));
+      fs.writeFileSync(`${base}.d.cts`, declarationContent(source, '.cjs'));
+      fs.writeFileSync(`${base}.d.mts`, declarationContent(source, '.mjs'));
     }
   }
 }
 
 fs.rmSync(clusterOutputRoot, { recursive: true, force: true });
 fs.rmSync(hostedSessionOutputRoot, { recursive: true, force: true });
+fs.rmSync(hostedTargetOutputRoot, { recursive: true, force: true });
 copyBuild(path.join(clusterBuildRoot, 'cjs'), clusterOutputRoot, 'cjs');
 copyBuild(path.join(clusterBuildRoot, 'esm'), clusterOutputRoot, 'esm');
 copyBuild(
@@ -53,5 +68,10 @@ copyBuild(
   hostedSessionOutputRoot,
   'esm'
 );
+copyBuild(path.join(hostedTargetBuildRoot, 'cjs', 'hosted-target'), hostedTargetOutputRoot, 'cjs');
+copyBuild(path.join(hostedTargetBuildRoot, 'esm', 'hosted-target'), hostedTargetOutputRoot, 'esm');
+copyBuild(path.join(hostedTargetBuildRoot, 'cjs', 'target'), targetOutputRoot, 'cjs');
+copyBuild(path.join(hostedTargetBuildRoot, 'esm', 'target'), targetOutputRoot, 'esm');
 fs.rmSync(clusterBuildRoot, { recursive: true, force: true });
 fs.rmSync(hostedSessionBuildRoot, { recursive: true, force: true });
+fs.rmSync(hostedTargetBuildRoot, { recursive: true, force: true });

package/scripts/opcore-introduced-check.js

@@ -197,8 +197,6 @@ function createRequest(repo, baseline, changes, options) {
   for (const change of changes) {
     normalizeBaselineRename(baseline, change);
     if (change.kind === 'D') {
-      overlays.push({ action: 'delete', path: change.path });
-      files.push(change.path);
       continue;
     }
     const content = readAfter(repo, change, options.staged);

package/src/agent-cli-provider/adapters/codex.ts

@@ -28,7 +28,6 @@ import { parseCodexEvent } from './codex-parser';
 
 const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
   'gpt-5.4': { rank: 2 },
-  'openai/gpt-5.4': { rank: 2 },
   'gpt-5.5': { rank: 3 },
   'gpt-5.6': { rank: 3 },
   'gpt-5.6-sol': { rank: 3 },

package/src/agent-cli-provider/contract-actions.ts

@@ -21,8 +21,11 @@ import { getString, isRecord, unknownToMessage } from './json';
 import type { ErrorClassification } from './types';
 import type { ProcessRunner } from './process-runner';
 
-function runBuildCommand(request: RequestData): ContractEnvelope {
-  const { adapter, commandSpec, options } = buildCommandSpec(request);
+function runBuildCommand(
+  request: RequestData,
+  runtimeSettings?: Record<string, unknown>
+): ContractEnvelope {
+  const { adapter, commandSpec, options } = buildCommandSpec(request, runtimeSettings);
   const webSearch = {
     requested: options.webSearch === true,
     effective: options.webSearch === true && options.cliFeatures?.supportsWebSearch === true,
@@ -134,19 +137,20 @@ function runClassifyError(request: RequestData): ContractEnvelope {
 
 export function dispatchRequest(
   request: RequestData,
-  runner: ProcessRunner
+  runner: ProcessRunner,
+  runtimeSettings?: Record<string, unknown>
 ): ContractEnvelope | Promise<ContractEnvelope> {
   switch (request.command) {
     case 'probe':
       return runProbe(request);
     case 'build-command':
-      return runBuildCommand(request);
+      return runBuildCommand(request, runtimeSettings);
     case 'parse-output':
       return runParseOutput(request);
     case 'classify-error':
       return runClassifyError(request);
     case 'invoke':
-      return runInvoke(request, runner);
+      return runInvoke(request, runner, runtimeSettings);
     default:
       throw contractError({
         code: 'unknown-command',

package/src/agent-cli-provider/contract-invoke.ts

@@ -120,9 +120,10 @@ async function runOmpRpcContractPrompt(
 
 export async function runInvoke(
   request: RequestData,
-  runner: ProcessRunner
+  runner: ProcessRunner,
+  runtimeSettings?: Record<string, unknown>
 ): Promise<ContractEnvelope> {
-  const { adapter, commandSpec, context, options } = buildCommandSpec(request);
+  const { adapter, commandSpec, context, options } = buildCommandSpec(request, runtimeSettings);
   const timeoutMs = optionalNumber(request.raw, 'timeoutMs');
   const runnerOptions = timeoutMs === undefined ? {} : { timeoutMs };
   const invokeSpec = getProviderRegistryEntry(adapter.id).invoke;

package/src/agent-cli-provider/contract-support.ts

@@ -94,7 +94,10 @@ function buildOptions(request: RequestData): BuildProviderCommandOptions {
   return { ...options, cwd };
 }
 
-export function buildCommandSpec(request: RequestData): {
+export function buildCommandSpec(
+  request: RequestData,
+  runtimeSettings?: Record<string, unknown>
+): {
   readonly adapter: ProviderAdapter;
   readonly commandSpec: CommandSpec;
   readonly options: BuildProviderCommandOptions;
@@ -103,11 +106,14 @@ export function buildCommandSpec(request: RequestData): {
   const adapter = adapterForProvider(request.provider);
   const context = requiredString(request.raw, 'context');
   const options = buildOptions(request);
-  const prepared = prepareSingleAgentProviderCommand({
-    provider: adapter.id,
-    context,
-    options,
-  });
+  const prepared = prepareSingleAgentProviderCommand(
+    {
+      provider: adapter.id,
+      context,
+      options,
+    },
+    runtimeSettings
+  );
   return {
     adapter: prepared.adapter,
     context,

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

@@ -32,6 +32,7 @@ export interface ProviderExecutableResponse {
 
 export interface ProviderExecutableOptions {
   readonly runner?: ProcessRunner;
+  readonly runtimeSettings?: Record<string, unknown>;
 }
 
 export async function runProviderExecutable(
@@ -41,7 +42,11 @@ export async function runProviderExecutable(
   const fallback = requestEnvelopeData(input);
   try {
     const request = validateRequest(input, providerExecutableSchemaVersion);
-    const envelope = await dispatchRequest(request, options.runner ?? spawnProcessRunner());
+    const envelope = await dispatchRequest(
+      request,
+      options.runner ?? spawnProcessRunner(),
+      options.runtimeSettings
+    );
     return {
       envelope: finalizeEnvelope(envelope, request.env),
       exitCode: 0,

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

@@ -55,6 +55,7 @@ export {
   type SingleAgentProviderCommandInput,
 } from './single-agent-runtime';
 export {
+  credentialEnvKeysForProvider,
   findProviderRegistryEntry,
   getProviderRegistryEntry,
   knownProviderNames,

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

@@ -715,6 +715,10 @@ export function getProviderRegistryEntry(name: string): ProviderRegistryEntry {
   throw new Error(`Unknown provider: ${name}. Valid: ${providerIds.join(', ')}`);
 }
 
+export function credentialEnvKeysForProvider(providerId: string): readonly string[] {
+  return getProviderRegistryEntry(providerId).credentialEnvKeys;
+}
+
 export function resolveProviderCommand(name: string): {
   readonly command: string;
   readonly args: readonly string[];

package/src/agent-cli-provider/single-agent-runtime.ts

@@ -86,23 +86,19 @@ type MutableModelSpec = {
 const MODEL_LEVELS: readonly ModelLevel[] = ['level1', 'level2', 'level3'];
 const REASONING_EFFORTS: readonly ReasoningEffort[] = ['low', 'medium', 'high', 'xhigh', 'max'];
 const LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV = 'ZEROSHOT_ISOLATED_PROVIDER_SETTINGS_JSON';
-const settingsModule: unknown = require('../../lib/settings');
 const providerDetectionModule: unknown = require('../../lib/provider-detection');
-const claudeAuthModule: unknown = require('../../lib/settings/claude-auth');
 
-const loadSettingsFn = moduleFunction(settingsModule, 'loadSettings');
-const getClaudeCommandFn = moduleFunction(settingsModule, 'getClaudeCommand');
 const commandExistsFn = moduleFunction(providerDetectionModule, 'commandExists');
 const getHelpOutputFn = moduleFunction(providerDetectionModule, 'getHelpOutput');
 const getVersionOutputFn = moduleFunction(providerDetectionModule, 'getVersionOutput');
-const resolveClaudeAuthFn = moduleFunction(claudeAuthModule, 'resolveClaudeAuth');
 
 export function prepareSingleAgentProviderCommand(
-  input: SingleAgentProviderCommandInput
+  input: SingleAgentProviderCommandInput,
+  runtimeSettings?: Record<string, unknown>
 ): PreparedSingleAgentProviderCommand {
   rejectCallerSuppliedModelProvenance(input);
   const baseOptions = input.options ?? {};
-  const settings = loadRuntimeSettings();
+  const settings = runtimeSettings ?? loadRuntimeSettings();
   const adapter = adapterForRuntimeInput(input.provider, settings);
   const providerSettings = runtimeProviderSettings(
     settings,
@@ -116,7 +112,8 @@ export function prepareSingleAgentProviderCommand(
   const cliFeatures = resolveRuntimeCliFeatures(
     adapter.id,
     baseOptions.cliFeatures,
-    requestedWebSearch === true
+    requestedWebSearch === true,
+    settings
   );
   const authEnv = baseOptions.authEnv ?? resolveRuntimeAuthEnv(adapter.id, settings);
   const options = buildRuntimeOptions(baseOptions, adapter, providerSettings, {
@@ -161,17 +158,21 @@ function buildRuntimeCommand(
   return recoveryAdapter.buildStructuredOutputRecoveryCommand(context, options);
 }
 
-export function detectRuntimeProviderCliFeatures(provider: string): ProviderCliFeatures {
-  return probeRuntimeProviderCli(provider).capabilities;
+export function detectRuntimeProviderCliFeatures(
+  provider: string,
+  runtimeSettings?: Record<string, unknown>
+): ProviderCliFeatures {
+  return probeRuntimeProviderCli(provider, undefined, runtimeSettings).capabilities;
 }
 
 function resolveRuntimeCliFeatures(
   provider: ProviderId,
   overrides: CliFeatureOverrides | undefined,
-  webSearchRequested: boolean
+  webSearchRequested: boolean,
+  runtimeSettings: Record<string, unknown>
 ): CliFeatureOverrides {
   if (provider === 'gateway') {
-    const detected = detectRuntimeProviderCliFeatures(provider);
+    const detected = detectRuntimeProviderCliFeatures(provider, runtimeSettings);
     return {
       ...detected,
       ...overrides,
@@ -180,13 +181,13 @@ function resolveRuntimeCliFeatures(
     };
   }
   if (getProviderRegistryEntry(provider).invoke.lane === 'acp-stdio') {
-    const detected = detectRuntimeProviderCliFeatures(provider);
+    const detected = detectRuntimeProviderCliFeatures(provider, runtimeSettings);
     if (overrides === undefined) return detected;
     return mergeAcpFailClosedCliFeatures(detected, overrides);
   }
-  if (overrides === undefined) return detectRuntimeProviderCliFeatures(provider);
+  if (overrides === undefined) return detectRuntimeProviderCliFeatures(provider, runtimeSettings);
   if (!webSearchRequested) return overrides;
-  const detected = detectRuntimeProviderCliFeatures(provider);
+  const detected = detectRuntimeProviderCliFeatures(provider, runtimeSettings);
   return {
     ...overrides,
     supportsResume:
@@ -225,14 +226,16 @@ function mergeAcpFailClosedCliFeatures(
 
 export function probeRuntimeProviderCli(
   provider: string,
-  evidence?: RuntimeProbeEvidence
+  evidence?: RuntimeProbeEvidence,
+  runtimeSettings?: Record<string, unknown>
 ): RuntimeProviderProbe {
   const adapter = getProviderAdapter(provider);
   if (adapter.id === 'gateway') {
-    return probeGatewayProvider(adapter);
+    return probeGatewayProvider(adapter, runtimeSettings);
   }
   const requested = getProviderRegistryEntry(adapter.id).settingsFields.includes('webSearch')
-    ? runtimeProviderSettings(loadRuntimeSettings(), adapter.id, process.cwd()).webSearch === true
+    ? runtimeProviderSettings(runtimeSettings ?? loadRuntimeSettings(), adapter.id, process.cwd())
+        .webSearch === true
     : false;
   const helpCommand = runtimeHelpCommand(adapter.id);
   const commandAvailable =
@@ -406,7 +409,9 @@ function resolveRuntimeAuthEnv(
   settings: Record<string, unknown>
 ): Readonly<Record<string, string>> {
   if (provider !== 'claude') return {};
-  return stringRecordFromUnknown(resolveClaudeAuthFn(settings), 'resolveClaudeAuth');
+  const claudeAuthModule: unknown = require('../../lib/settings/claude-auth');
+  const resolveClaudeAuth = moduleFunction(claudeAuthModule, 'resolveClaudeAuth');
+  return stringRecordFromUnknown(resolveClaudeAuth(settings), 'resolveClaudeAuth');
 }
 
 function adapterForRuntimeInput(
@@ -452,16 +457,16 @@ function runtimeProviderSettings(
 }
 
 function runtimeHelpCommand(provider: ProviderId): CommandParts {
-  if (provider === 'claude') {
-    return commandPartsFromUnknown(getClaudeCommandFn(), 'getClaudeCommand');
-  }
   return resolveProviderCommand(provider);
 }
 
-function probeGatewayProvider(adapter: ProviderAdapter): RuntimeProviderProbe {
+function probeGatewayProvider(
+  adapter: ProviderAdapter,
+  runtimeSettings?: Record<string, unknown>
+): RuntimeProviderProbe {
   const capabilities = attestedCliFeatures(adapter, '', '');
   try {
-    const settings = loadRuntimeSettings();
+    const settings = runtimeSettings ?? loadRuntimeSettings();
     const providerSettings = runtimeProviderSettings(settings, 'gateway', process.cwd());
     resolveGatewayConfiguration(
       providerSettings.gateway,
@@ -532,7 +537,9 @@ function loadRuntimeSettings(): Record<string, unknown> {
       `${LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV} is not a trusted settings channel; use the settings file.`
     );
   }
-  return requiredRecord(loadSettingsFn(), 'loadSettings');
+  const settingsModule: unknown = require('../../lib/settings');
+  const loadSettings = moduleFunction(settingsModule, 'loadSettings');
+  return requiredRecord(loadSettings(), 'loadSettings');
 }
 
 function rejectCallerSuppliedModelProvenance(input: SingleAgentProviderCommandInput): void {
@@ -554,13 +561,6 @@ function isUnknownFunction(value: unknown): value is UnknownFunction {
   return typeof value === 'function';
 }
 
-function commandPartsFromUnknown(value: unknown, field: string): CommandParts {
-  const record = requiredRecord(value, field);
-  return {
-    command: requiredStringValue(record.command, `${field}.command`),
-    args: stringArray(record.args, `${field}.args`),
-  };
-}
 
 function levelOverridesFromUnknown(value: unknown, field: string): LevelOverrides {
   if (value === undefined) return {};
@@ -632,10 +632,6 @@ function optionalString(value: unknown, field: string): string | undefined {
   throw new Error(`${field} must be a string.`);
 }
 
-function requiredStringValue(value: unknown, field: string): string {
-  if (typeof value === 'string' && value.length > 0) return value;
-  throw new Error(`${field} must be a non-empty string.`);
-}
 
 function optionalRecord(
   value: unknown,
@@ -661,15 +657,6 @@ function stringRecordFromUnknown(value: unknown, field: string): Readonly<Record
   return result;
 }
 
-function stringArray(value: unknown, field: string): readonly string[] {
-  if (!Array.isArray(value)) throw new Error(`${field} must be an array.`);
-  const result: string[] = [];
-  for (const item of value) {
-    if (typeof item !== 'string') throw new Error(`${field} entries must be strings.`);
-    result.push(item);
-  }
-  return result;
-}
 
 function stringResult(value: unknown): string {
   if (typeof value === 'string') return value;