@the-open-engine/zeroshot 6.34.1 → 6.34.3

package/src/agent/output-extraction.js

@@ -16,8 +16,51 @@
  * 4. Direct JSON parse of entire output
  */
 
+const { createHash } = require('node:crypto');
 const { parseProviderChunk } = require('../providers');
 
+const MAX_CLI_ERROR_BYTES = 4096;
+const CLI_ERROR_TRUNCATION_SUFFIX = '… [truncated]';
+
+function truncateUtf8(text, maxBytes = MAX_CLI_ERROR_BYTES) {
+  if (Buffer.byteLength(text) <= maxBytes) return text;
+
+  const suffixBytes = Buffer.byteLength(CLI_ERROR_TRUNCATION_SUFFIX);
+  const contentBudget = Math.max(0, maxBytes - suffixBytes);
+  let bytes = 0;
+  let truncated = '';
+  for (const character of text) {
+    const characterBytes = Buffer.byteLength(character);
+    if (bytes + characterBytes > contentBudget) break;
+    truncated += character;
+    bytes += characterBytes;
+  }
+  return `${truncated}${CLI_ERROR_TRUNCATION_SUFFIX}`;
+}
+
+function primitiveErrorText(value) {
+  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+    ? String(value)
+    : '';
+}
+
+function cliErrorDetail(value, fallback) {
+  const candidate = Array.isArray(value)
+    ? value
+        .map(primitiveErrorText)
+        .filter((message) => message.trim())
+        .join('; ')
+    : primitiveErrorText(value);
+  const raw = candidate.trim() ? candidate : fallback;
+  return {
+    error: truncateUtf8(raw.trim()),
+    diagnostic: {
+      byteLength: Buffer.byteLength(raw),
+      sha256: createHash('sha256').update(raw).digest('hex'),
+    },
+  };
+}
+
 /**
  * Strip timestamp prefix from log lines.
  * Format: [epochMs]content or [epochMs]{json...}
@@ -308,60 +351,87 @@ function extractClaudeVertexModelError(output, { useVertex = false } = {}) {
  * @param {string} providerName - Active provider whose terminal errors may be inspected
  * @returns {{error: string, provider: string}|null} Error info or null
  */
-function extractCliError(output, providerName = 'claude') {
+function claudeFailureFromObject(obj) {
+  if (obj.type !== 'result') return null;
+  if (obj.is_error === true) {
+    const detail = cliErrorDetail(
+      Array.isArray(obj.errors) ? obj.errors : obj.error || obj.result,
+      'Unknown CLI error'
+    );
+    return { ...detail, provider: 'claude' };
+  }
+  if (obj.subtype !== 'error') return null;
+  return {
+    ...cliErrorDetail(obj.error || obj.result, 'CLI returned error'),
+    provider: 'claude',
+  };
+}
+
+function codexFailureFromObject(obj) {
+  if (obj.type !== 'turn.failed') return null;
+  return {
+    ...cliErrorDetail(obj.error?.message || obj.error?.code || obj.error, 'Turn failed'),
+    provider: 'codex',
+  };
+}
+
+function geminiFailureFromObject(obj) {
+  const geminiFailure =
+    (obj.type === 'result' && obj.status === 'error') ||
+    (obj.type === 'error' && obj.severity === 'error');
+  if (!geminiFailure) return null;
+  return {
+    ...cliErrorDetail(obj.error?.message || obj.message, 'Gemini CLI error'),
+    provider: 'gemini',
+  };
+}
+
+function opencodeFailureFromObject(obj) {
+  if (obj.type !== 'session.error' && obj.type !== 'error') return null;
+  return {
+    ...cliErrorDetail(
+      obj.error?.data?.message || obj.error?.message || obj.error?.name,
+      'Session error'
+    ),
+    provider: 'opencode',
+  };
+}
+
+function failureFromProviderObject(obj, providerName) {
+  if (providerName === 'claude') return claudeFailureFromObject(obj);
+  if (providerName === 'codex') return codexFailureFromObject(obj);
+  if (providerName === 'gemini') return geminiFailureFromObject(obj);
+  if (providerName === 'opencode') return opencodeFailureFromObject(obj);
+  return null;
+}
+
+function extractCliFailure(output, providerName = 'claude') {
   if (!output || typeof output !== 'string') return null;
 
   const lines = output.split('\n');
+  // Codex terminal truth is a turn.failed record at the newest end of JSONL output.
+  // Search it newest-first so a preserved terminal tail wins over older provider chatter.
+  if (providerName === 'codex') lines.reverse();
 
   for (const line of lines) {
     const content = stripTimestamp(line);
     if (!content.startsWith('{')) continue;
-
-    let obj;
     try {
-      obj = JSON.parse(content);
+      const failure = failureFromProviderObject(JSON.parse(content), providerName);
+      if (failure) return failure;
     } catch {
-      continue;
-    }
-
-    if (providerName === 'claude' && obj.type === 'result' && obj.is_error === true) {
-      const errorMsg = Array.isArray(obj.errors)
-        ? obj.errors.join('; ')
-        : obj.error || obj.result || 'Unknown CLI error';
-      return { error: errorMsg, provider: 'claude' };
-    }
-
-    if (providerName === 'claude' && obj.type === 'result' && obj.subtype === 'error') {
-      const errorMsg = obj.error || obj.result || 'CLI returned error';
-      return { error: errorMsg, provider: 'claude' };
-    }
-
-    if (providerName === 'codex' && obj.type === 'turn.failed') {
-      const errorMsg = obj.error?.message || obj.error || 'Turn failed';
-      return { error: errorMsg, provider: 'codex' };
-    }
-
-    if (
-      providerName === 'gemini' &&
-      ((obj.type === 'result' && obj.status === 'error') ||
-        (obj.type === 'error' && obj.severity === 'error'))
-    ) {
-      return {
-        error: obj.error?.message || obj.message || 'Gemini CLI error',
-        provider: 'gemini',
-      };
-    }
-
-    if (providerName === 'opencode' && (obj.type === 'session.error' || obj.type === 'error')) {
-      const errorMsg =
-        obj.error?.data?.message || obj.error?.message || obj.error?.name || 'Session error';
-      return { error: errorMsg, provider: 'opencode' };
+      // Ignore non-JSON output lines.
     }
   }
 
   return null;
 }
 
+function extractCliError(output, providerName = 'claude') {
+  const failure = extractCliFailure(output, providerName);
+  return failure ? { error: failure.error, provider: failure.provider } : null;
+}
+
 /**
  * Detects fatal standalone output lines that indicate no task output was produced.
  * Only matches when the line itself is the fatal message (not when it appears inside JSON).
@@ -419,8 +489,10 @@ function extractJsonFromOutput(output, providerName = 'claude') {
 }
 
 module.exports = {
+  MAX_CLI_ERROR_BYTES,
   extractJsonFromOutput,
   extractModelTextFromOutput,
+  extractCliFailure,
   extractCliError,
   extractClaudeVertexModelError,
   extractFromResultWrapper,

package/src/agent/provider-terminal-failure.js

@@ -0,0 +1,186 @@
+// @ts-nocheck
+
+const { getProvider } = require('../providers');
+const { extractCliFailure } = require('./output-extraction');
+
+function categoryForProviderFailure(error, classification) {
+  const isPermanent = classification.retryable === false;
+  const authenticationPattern =
+    /(?:invalid[_ -]?api[_ -]?key|api[_ -]?key.*invalid|unauthori[sz]ed|forbidden|authentication|permission denied)/i;
+  if (isPermanent && authenticationPattern.test(error)) return 'authentication';
+
+  const quotaPattern = /(?:insufficient[_ -]?quota|quota exceeded|resource_exhausted)/i;
+  if (isPermanent && quotaPattern.test(error)) return 'quota';
+  if (isPermanent) return 'permanent';
+  return classification.kind === 'unknown-retryable' ? 'unknown' : 'transient';
+}
+
+function classifyProviderFailure(providerName, error) {
+  let rawClassification = { retryable: true, kind: 'unknown-retryable' };
+  try {
+    rawClassification = getProvider(providerName).adapter.classifyError(new Error(error));
+  } catch {
+    // Extraction remains available if a provider adapter cannot be loaded.
+  }
+  return {
+    retryable: rawClassification?.retryable !== false,
+    kind:
+      typeof rawClassification?.kind === 'string' ? rawClassification.kind : 'unknown-retryable',
+  };
+}
+
+function extractProviderFailure(output, providerName) {
+  const cliError = extractCliFailure(output, providerName);
+  if (!cliError) return null;
+
+  const classification = classifyProviderFailure(providerName, cliError.error);
+  const category = categoryForProviderFailure(cliError.error, classification);
+  return {
+    error: `Provider ${cliError.provider} failed (${category}; ${classification.kind})`,
+    provider: cliError.provider,
+    event: cliError.provider === 'codex' ? 'turn.failed' : 'terminal_error',
+    category,
+    classification,
+    diagnostic: cliError.diagnostic,
+  };
+}
+
+function redactTerminalFailureForControlPlane(state, providerName, content) {
+  const failure = extractProviderFailure(content, providerName);
+  if (!failure) return content;
+
+  state.providerFailure = failure;
+  let eventType = 'provider.failure';
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed?.type === 'string') eventType = parsed.type;
+  } catch {
+    // extractProviderFailure already proved a supported terminal envelope.
+  }
+  return JSON.stringify({
+    type: eventType,
+    ...(providerName === 'claude' ? { is_error: true } : {}),
+    ...(providerName === 'gemini' ? { status: 'error', severity: 'error' } : {}),
+    error: { message: failure.error },
+    zeroshot_failure: {
+      provider: failure.provider,
+      event: failure.event,
+      category: failure.category,
+      kind: failure.classification.kind,
+      retryable: failure.classification.retryable,
+      diagnostic: failure.diagnostic,
+    },
+  });
+}
+
+function decorateError(error, failure) {
+  if (!failure) return error;
+  error.provider = failure.provider || null;
+  error.providerEvent = failure.event || null;
+  error.providerCategory = failure.category || null;
+  error.classification = failure.classification || null;
+  error.providerDiagnostic = failure.diagnostic || null;
+  if (failure.classification?.retryable === false) error.permanent = true;
+  return error;
+}
+
+function receiptFields(error) {
+  if (!error?.provider) return {};
+  return {
+    provider: error.provider,
+    event: error.providerEvent,
+    category: error.providerCategory,
+    kind: error.classification?.kind,
+    retryable: error.classification?.retryable,
+    diagnostic: error.providerDiagnostic,
+  };
+}
+
+function workerFailure(error) {
+  const authenticationFailure =
+    error?.provider &&
+    error?.classification?.retryable === false &&
+    error?.providerCategory === 'authentication';
+  return authenticationFailure
+    ? { code: 'refusal', reason: 'authentication_required' }
+    : { code: 'crash', reason: 'declared_failure' };
+}
+
+function publishCriticalFailure({
+  agent,
+  error,
+  attempts,
+  worker,
+  unsupportedCapability,
+  structuredOutputInvalid,
+}) {
+  const specific =
+    error?.hookFailure ||
+    structuredOutputInvalid ||
+    unsupportedCapability ||
+    error?.vertexModelError ||
+    error?.terminationExhausted;
+  const critical =
+    agent.role === 'implementation' ||
+    agent.role === 'coordinator' ||
+    agent.id === 'consensus-coordinator';
+  if (!critical || specific) return worker;
+
+  agent._publish({
+    topic: 'CLUSTER_FAILED',
+    receiver: 'broadcast',
+    content: {
+      text: `Critical agent ${agent.id} exhausted its retry budget`,
+      data: {
+        reason: error?.provider ? 'provider_execution_failed' : 'critical_agent_exhausted',
+        agentId: agent.id,
+        role: agent.role,
+        attempts,
+        code: worker.code,
+        workerReason: worker.reason,
+        ...receiptFields(error),
+      },
+    },
+  });
+  return worker;
+}
+
+function buildFinalFailureInfo({
+  agent,
+  error,
+  attempts,
+  worker,
+  unsupportedCapability,
+  structuredOutputInvalid,
+}) {
+  return {
+    ...(error?.terminationExhausted ? agent.cluster.failureInfo : {}),
+    agentId: agent.id,
+    taskId: error?.taskId || agent.currentTaskId,
+    iteration: agent.iteration,
+    error: error.message,
+    attempts,
+    ...receiptFields(error),
+    ...(error?.provider ? { code: worker.code, workerReason: worker.reason } : {}),
+    ...(unsupportedCapability
+      ? {
+          code: error.code,
+          permanent: true,
+          provider: error.provider,
+          capability: error.capability,
+        }
+      : {}),
+    ...(structuredOutputInvalid ? { code: error.code, details: error.details ?? null } : {}),
+    timestamp: Date.now(),
+  };
+}
+
+module.exports = {
+  buildFinalFailureInfo,
+  decorateError,
+  extractProviderFailure,
+  publishCriticalFailure,
+  receiptFields,
+  redactTerminalFailureForControlPlane,
+  workerFailure,
+};