@the-open-engine/zeroshot 6.9.0 → 6.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.9.0",
+  "version": "6.9.1",
   "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
   "main": "src/orchestrator.js",
   "bin": {

package/src/agent/agent-lifecycle.js

@@ -574,6 +574,7 @@ async function runTaskAttempt(agent, triggeringMessage) {
     const error = new Error(result.error || 'Task execution failed');
     error.code = result.code || result.errorType || null;
     error.taskId = result.taskId || null;
+    error.vertexModelError = result.vertexModelError || null;
     throw error;
   }
 
@@ -604,6 +605,20 @@ ${'='.repeat(80)}`);
   console.error(`🔴 TASK EXECUTION FAILED - AGENT: ${agent.id} (Attempt ${attempt}/${maxRetries})`);
   console.error(`${'='.repeat(80)}`);
   console.error(`Error: ${error.message}`);
+
+  const vertexError = error.vertexModelError;
+  if (vertexError) {
+    const model = vertexError.model ? `"${vertexError.model}" is` : 'Selected model is';
+    console.error(`
+⚠️  ${model} not available on your Vertex AI deployment.
+    Fix: set explicit model IDs that are enabled on your deployment:
+
+    zeroshot settings set providerSettings.claude.levelOverrides '{"level1": {"model": "claude-sonnet-4-6"}, "level2": {"model": "claude-sonnet-4-6"}, "level3": {"model": "claude-sonnet-4-6"}}'
+
+    Replace "claude-sonnet-4-6" with whichever Claude model your deployment has enabled.
+    You can test a model with: claude --dangerously-skip-permissions -p "hi" --model <model-id>
+`);
+  }
 }
 
 async function handleLockContention() {
@@ -692,6 +707,22 @@ ${'='.repeat(80)}`);
     });
   }
 
+  if (error?.vertexModelError) {
+    agent._publish({
+      topic: 'CLUSTER_FAILED',
+      receiver: 'broadcast',
+      content: {
+        text: `Cluster failed: Claude model is unavailable on Vertex for ${agent.id}`,
+        data: {
+          reason: 'vertex_model_unavailable',
+          agentId: agent.id,
+          role: agent.role,
+          model: error.vertexModelError.model,
+        },
+      },
+    });
+  }
+
   if (error?.terminationExhausted) {
     agent._publish({
       topic: 'CLUSTER_FAILED',
@@ -985,6 +1016,20 @@ async function executeTask(agent, triggeringMessage) {
         await handleFinalFailure(agent, triggeringMessage, error, 1);
         return;
       }
+      if (error.vertexModelError) {
+        agent._publishLifecycle('TASK_FAILED', {
+          iteration: agent.iteration,
+          taskId: error.taskId || agent.currentTaskId,
+          error: error.message,
+          code: error.code || null,
+          attempt,
+        });
+        clearTransientTaskState(agent);
+        logTaskAttemptFailure(agent, attempt, maxRetries, error);
+        // Model unavailability on Vertex is deterministic — retrying wastes nothing but time.
+        await handleFinalFailure(agent, triggeringMessage, error, attempt);
+        return;
+      }
       agent._publishLifecycle('TASK_FAILED', {
         iteration: agent.iteration,
         taskId: error.taskId || agent.currentTaskId,

package/src/agent/agent-task-executor.js

@@ -28,6 +28,7 @@ const {
   wrapTaskRunWithIsolatedSettings,
 } = require('../task-run-model-args.js');
 const { buildRawLogOnlyMetadata } = require('./context-replay-policy');
+const { extractClaudeVertexModelError } = require('./output-extraction');
 
 function runCommandWithTimeout(command, args, options = {}, callback = null) {
   const timeout = options.timeout ?? 30000;
@@ -1213,6 +1214,15 @@ function buildFailureContext({ agent, taskId, providerName, state, stdout }) {
 
 async function buildCompletionResult({ agent, taskId, providerName, state, stdout, success }) {
   const classified = await evaluateStructuredSuccess({ agent, taskId, state, success });
+  const vertexModelError =
+    providerName === 'claude'
+      ? extractClaudeVertexModelError(state.output, {
+          useVertex: process.env.CLAUDE_CODE_USE_VERTEX === '1',
+        })
+      : null;
+  if (vertexModelError) {
+    classified.success = false;
+  }
   let errorContext = classified.error;
   if (!errorContext && !classified.success) {
     errorContext = buildFailureContext({ agent, taskId, providerName, state, stdout });
@@ -1223,6 +1233,7 @@ async function buildCompletionResult({ agent, taskId, providerName, state, stdou
     output: state.output,
     error: errorContext,
     tokenUsage: extractTokenUsage(state.output, providerName),
+    vertexModelError,
   };
 }
 
@@ -1797,7 +1808,13 @@ function settleIsolatedTerminalStatus({
       }
     }
 
-    const success = status === 'completed';
+    const vertexModelError =
+      providerName === 'claude'
+        ? extractClaudeVertexModelError(state.fullOutput, {
+            useVertex: process.env.CLAUDE_CODE_USE_VERTEX === '1',
+          })
+        : null;
+    const success = status === 'completed' && !vertexModelError;
     const errorContext = !success
       ? extractErrorContext({
           output: state.fullOutput,
@@ -1816,7 +1833,7 @@ function settleIsolatedTerminalStatus({
           },
         })
       : null;
-    const parsedResult = await agent._parseResultOutput(state.fullOutput);
+    const parsedResult = vertexModelError ? null : await agent._parseResultOutput(state.fullOutput);
 
     settleIsolatedFollower({
       agent,
@@ -1830,6 +1847,7 @@ function settleIsolatedTerminalStatus({
         result: parsedResult,
         error: errorContext,
         tokenUsage: extractTokenUsage(state.fullOutput, providerName),
+        vertexModelError,
       },
     });
   })().catch((error) => {

package/src/agent/output-extraction.js

@@ -234,6 +234,45 @@ function extractDirectJson(text) {
   return null;
 }
 
+/**
+ * Extract deterministic Claude Vertex model-unavailability metadata from the raw CLI envelope.
+ *
+ * @param {string} output - Raw Claude CLI output
+ * @param {{useVertex?: boolean}} [options] - Whether the Claude task was configured for Vertex
+ * @returns {{model: string}|null} Vertex model metadata or null
+ */
+function extractClaudeVertexModelError(output, { useVertex = false } = {}) {
+  if (!output || typeof output !== 'string') return null;
+
+  for (const line of output.split('\n')) {
+    const content = stripTimestamp(line);
+    if (!content.startsWith('{')) continue;
+
+    try {
+      const parsed = JSON.parse(content);
+      if (
+        parsed.type !== 'result' ||
+        parsed.is_error !== true ||
+        parsed.api_error_status !== 404 ||
+        typeof parsed.result !== 'string'
+      ) {
+        continue;
+      }
+      const modelMatch = parsed.result.match(/model\s+\(([^)]+)\)/);
+      const hasExplicitVertexSignal = parsed.result.includes('vertex deployment');
+      const isVertexFallback =
+        useVertex && parsed.result.includes('may not exist or you may not have access');
+      if (!modelMatch || (!hasExplicitVertexSignal && !isVertexFallback)) continue;
+
+      return { model: modelMatch[1] };
+    } catch {
+      // Not a JSON result envelope.
+    }
+  }
+
+  return null;
+}
+
 /**
  * Extract CLI error from provider output (all providers).
  * Returns the error message if the CLI reported an error, null otherwise.
@@ -358,6 +397,7 @@ function extractJsonFromOutput(output, providerName = 'claude') {
 module.exports = {
   extractJsonFromOutput,
   extractCliError,
+  extractClaudeVertexModelError,
   extractFromResultWrapper,
   extractFromTextEvents,
   extractFromMarkdown,