Merge remote-tracking branch 'origin/main' into prepare-pr811-fixes

# Conflicts:
#	src/agent/agent-task-executor.js

Author: tomdps

CONTRIBUTING.md

@@ -22,7 +22,9 @@ Thank you for your interest in contributing to Zeroshot! This guide covers every
 - **Node.js 18+** (check: `node --version`)
 - **npm** (bundled with Node)
 - **Docker** (optional, for isolation mode tests)
-- **Claude Code CLI** - `npm i -g @anthropic-ai/claude-code && claude auth login`
+- **AI provider** - Configure the bundled Gateway provider or install at least one supported provider
+  CLI: Claude Code, Codex, Gemini, Opencode, Pi, Kiro, or Copilot (see
+  [provider setup and installation instructions](./docs/providers.md))
 - **GitHub CLI** - Required for PR creation features ([install guide](https://cli.github.com/))
 
 ### Installation

docs/providers.md

@@ -3,8 +3,8 @@
 Zeroshot supports two provider shapes:
 
 - CLI-backed providers that shell out to a full agent CLI
-- One bundled `gateway` provider that wraps OpenAI-compatible model APIs with a
-  Zeroshot-owned tool runner
+- One bundled `gateway` provider that wraps OpenAI-compatible or Anthropic-compatible
+  model APIs with a Zeroshot-owned tool runner
 
 ## Supported Providers
 
@@ -29,16 +29,17 @@ Zeroshot supports two provider shapes:
 
 ## Gateway Provider
 
-Use `gateway` for OpenAI-compatible model endpoints such as OpenRouter,
-Ollama, vLLM, or self-hosted gateways. These stay model configs behind one
-provider engine; do not add them as standalone provider ids.
+Use `gateway` for OpenAI-compatible or Anthropic-compatible model endpoints.
+These stay model configs behind one provider engine; do not add them as
+standalone provider ids.
 
 Required settings:
 
 ```json
 {
   "providerSettings": {
     "gateway": {
+      "protocol": "openai",
       "baseUrl": "http://127.0.0.1:11434",
       "apiKey": "gateway-key",
       "model": "openrouter/meta-llama/test-model",
@@ -53,10 +54,49 @@ Required settings:
 
 Notes:
 
+- `protocol` defaults to `openai`; set it to `anthropic` for Messages API endpoints.
+- Anthropic-compatible configurations require a positive `maxTokens` value.
 - `toolPolicy` is required. There is no default file or shell access.
 - `headers` is optional for extra gateway-specific request headers.
 - `model` may be any non-empty provider-specific model id.
 
+### MiniMax
+
+The gateway model catalog includes `MiniMax-M3` and `MiniMax-M2.7`. Choose the
+region and protocol with the matching base URL:
+
+| Region | Protocol    | Base URL                             |
+| ------ | ----------- | ------------------------------------ |
+| Global | `openai`    | `https://api.minimax.io/v1`          |
+| Global | `anthropic` | `https://api.minimax.io/anthropic`   |
+| China  | `openai`    | `https://api.minimaxi.com/v1`        |
+| China  | `anthropic` | `https://api.minimaxi.com/anthropic` |
+
+Example Anthropic-compatible settings:
+
+```json
+{
+  "providerSettings": {
+    "gateway": {
+      "protocol": "anthropic",
+      "baseUrl": "https://api.minimax.io/anthropic",
+      "apiKey": "your-api-key",
+      "model": "MiniMax-M3",
+      "maxTokens": 8192,
+      "toolPolicy": {
+        "roots": ["/absolute/path/to/worktree"],
+        "commands": ["node"]
+      }
+    }
+  }
+}
+```
+
+Pass the Anthropic base URL exactly as shown. The bundled client appends
+`/v1/messages` for each request. For OpenAI-compatible settings, use
+`"protocol": "openai"` and omit `maxTokens` unless the endpoint needs a custom
+limit.
+
 ## Model Levels
 
 Zeroshot uses provider-agnostic levels:

scripts/assert-release-published.js

@@ -179,28 +179,74 @@ function sleep(ms) {
   });
 }
 
+function nextRetryDelay(attempt, attempts, delayMs, options) {
+  if (attempt >= attempts) return null;
+  if (options.deadline === undefined) return delayMs;
+
+  const now = options.now || Date.now;
+  const remainingMs = options.deadline - now();
+  if (remainingMs <= 0) return null;
+  return Math.min(delayMs, remainingMs);
+}
+
 async function waitForNpmLatest(name, expectedVersion, options = {}) {
   const attempts =
     options.attempts || Number(process.env.RELEASE_ASSERT_ATTEMPTS || DEFAULT_ATTEMPTS);
   const delayMs =
     options.delayMs || Number(process.env.RELEASE_ASSERT_DELAY_MS || DEFAULT_DELAY_MS);
+  const wait = options.sleep || sleep;
 
   let latest = null;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     latest = npmLatest(name);
     if (latest === expectedVersion) return latest;
 
-    if (attempt < attempts) {
+    const retryDelay = nextRetryDelay(attempt, attempts, delayMs, options);
+    if (retryDelay !== null) {
       console.log(
         `npm latest for ${name} is ${latest}; waiting for ${expectedVersion} (${attempt}/${attempts})`
       );
-      await sleep(delayMs);
+      await wait(retryDelay);
+    } else {
+      break;
     }
   }
 
   throw new Error(`expected npm latest for ${name} to be ${expectedVersion}, got ${latest}`);
 }
 
+async function waitForPublishedArtifact(label, check, options = {}) {
+  const attempts =
+    options.attempts || Number(process.env.RELEASE_ASSERT_ATTEMPTS || DEFAULT_ATTEMPTS);
+  const delayMs =
+    options.delayMs || Number(process.env.RELEASE_ASSERT_DELAY_MS || DEFAULT_DELAY_MS);
+  const wait = options.sleep || sleep;
+  let lastError = null;
+  let attemptsMade = 0;
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    attemptsMade = attempt;
+    try {
+      return await check();
+    } catch (error) {
+      lastError = error;
+      const retryDelay = nextRetryDelay(attempt, attempts, delayMs, options);
+      if (retryDelay !== null) {
+        console.log(
+          `${label} is not ready: ${error.message}; retrying (${attempt}/${attempts})`
+        );
+        await wait(retryDelay);
+      } else {
+        break;
+      }
+    }
+  }
+
+  throw new Error(
+    `${label} did not become ready after ${attemptsMade} attempts: ${lastError?.message || 'unknown error'}`
+  );
+}
+
 async function main() {
   const name = packageName();
   const headTags = tagsPointingAtHead();
@@ -218,30 +264,62 @@ async function main() {
 
   console.log(`tags on HEAD: ${headTags.join(', ') || '(none)'}`);
   const expectedVersion = expectedTag.slice(1);
-  const latest = await waitForNpmLatest(name, expectedVersion);
+  const retryAttempts = Number(process.env.RELEASE_ASSERT_ATTEMPTS || DEFAULT_ATTEMPTS);
+  const retryDelayMs = Number(process.env.RELEASE_ASSERT_DELAY_MS || DEFAULT_DELAY_MS);
+  const retryOptions = {
+    attempts: retryAttempts,
+    delayMs: retryDelayMs,
+    deadline: Date.now() + retryAttempts * retryDelayMs,
+  };
+  const latest = await waitForNpmLatest(name, expectedVersion, retryOptions);
 
   console.log(`npm latest for ${name}: ${latest}`);
 
   const expectedCommit = run('git', ['rev-parse', 'HEAD']);
-  const metadata = npmReleaseMetadata(name, expectedVersion);
-  if (metadata.version !== expectedVersion) {
-    throw new Error(`npm metadata returned ${metadata.version}; expected ${expectedVersion}`);
-  }
-  if (metadata.gitHead !== expectedCommit) {
-    throw new Error(`npm gitHead ${metadata.gitHead || '(missing)'} does not match HEAD`);
-  }
+  const metadata = await waitForPublishedArtifact(
+    'npm release metadata',
+    () => {
+      const result = npmReleaseMetadata(name, expectedVersion);
+      if (result.version !== expectedVersion) {
+        throw new Error(`npm metadata returned ${result.version}; expected ${expectedVersion}`);
+      }
+      if (result.gitHead !== expectedCommit) {
+        throw new Error(`npm gitHead ${result.gitHead || '(missing)'} does not match HEAD`);
+      }
+      if (!result['dist.attestations']?.url) {
+        throw new Error('npm attestation URL is missing');
+      }
+      return result;
+    },
+    retryOptions
+  );
 
-  const attestationUrl = metadata['dist.attestations']?.url;
-  if (!attestationUrl) throw new Error('npm attestation URL is missing');
-  const attestations = await httpsJson(attestationUrl);
-  verifyProvenance(provenanceStatement(attestations), expectedCommit);
+  await waitForPublishedArtifact(
+    'npm provenance',
+    async () => {
+      const attestations = await httpsJson(metadata['dist.attestations'].url);
+      verifyProvenance(provenanceStatement(attestations), expectedCommit);
+    },
+    retryOptions
+  );
 
-  const release = githubRelease(expectedTag);
-  if (release.tagName !== expectedTag) {
-    throw new Error(`GitHub Release tag ${release.tagName} does not match ${expectedTag}`);
-  }
-  verifyCuratedNotes(expectedTag, release);
-  verifyInstalledCli(name, expectedVersion);
+  await waitForPublishedArtifact(
+    'GitHub Release',
+    () => {
+      const release = githubRelease(expectedTag);
+      if (release.tagName !== expectedTag) {
+        throw new Error(`GitHub Release tag ${release.tagName} does not match ${expectedTag}`);
+      }
+      verifyCuratedNotes(expectedTag, release);
+    },
+    retryOptions
+  );
+
+  await waitForPublishedArtifact(
+    'installed CLI',
+    () => verifyInstalledCli(name, expectedVersion),
+    retryOptions
+  );
 
   console.log(`Release publication verified: ${name}@${latest}`);
 }
@@ -263,4 +341,5 @@ module.exports = {
   verifyInstalledCli,
   verifyProvenance,
   waitForNpmLatest,
+  waitForPublishedArtifact,
 };

src/agent-cli-provider/adapters/claude.ts

@@ -40,6 +40,7 @@ const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
   'claude-opus-4-6': { rank: 3 },
   'claude-opus-4-7': { rank: 3 },
   'claude-opus-4-8': { rank: 3 },
+  'claude-opus-5': { rank: 3 },
   fable: { rank: 3 },
   'claude-fable-5': { rank: 3 },
   'claude-mythos-5': { rank: 3 },

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

@@ -29,8 +29,11 @@ const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
   'gpt-5.5': { rank: 3 },
   'gpt-5.6': { rank: 3 },
   'gpt-5.6-sol': { rank: 3 },
+  'openai.gpt-5.6-sol': { rank: 3 },
   'gpt-5.6-terra': { rank: 2 },
+  'openai.gpt-5.6-terra': { rank: 2 },
   'gpt-5.6-luna': { rank: 1 },
+  'openai.gpt-5.6-luna': { rank: 1 },
 };
 
 const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {

src/agent-cli-provider/adapters/gateway.ts

@@ -18,7 +18,10 @@ import { classifyBaseProviderError, commandSpec, createParserState, envRedaction
 import { resolveGatewayConfiguration, validateGatewaySettings } from '../gateway-tools';
 import { getBoolean, getString, isRecord, tryParseJson } from '../json';
 
-const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {};
+const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
+  'MiniMax-M3': { rank: 3 },
+  'MiniMax-M2.7': { rank: 2 },
+};
 
 const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
   level1: { rank: 1, model: null },
@@ -27,10 +30,12 @@ const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
 };
 
 export const gatewaySettingsDefaults: Readonly<Record<string, unknown>> = Object.freeze({
+  protocol: 'openai',
   baseUrl: null,
   apiKey: null,
   headers: null,
   model: null,
+  maxTokens: null,
   toolPolicy: null,
 });
 
@@ -52,8 +57,10 @@ function buildCommand(context: string, options: BuildProviderCommandOptions = {}
     context,
     cwd,
     gateway: {
+      protocol: gateway.protocol,
       baseUrl: gateway.baseUrl,
       model: gateway.model,
+      ...(gateway.maxTokens === undefined ? {} : { maxTokens: gateway.maxTokens }),
       toolPolicy: gateway.toolPolicy,
     },
     ...(Object.keys(headerEnv.mapping).length === 0 ? {} : { gatewayHeaderEnv: headerEnv.mapping }),
@@ -160,7 +167,7 @@ function classifyError(error: unknown): ErrorClassification {
       /\bmust be a valid url\b/i,
       /\btoolpolicy\b/i,
       /\bnon-empty model identifier\b/i,
-      /\bgateway\.(?:baseUrl|apiKey|model|toolPolicy)\b/i,
+      /\bgateway\.(?:protocol|baseUrl|apiKey|model|maxTokens|toolPolicy)\b/i,
     ]
   );
 }