@the-open-engine/zeroshot 6.36.0 → 6.38.0

package/src/agent/output-extraction.js

@@ -347,6 +347,7 @@ function extractClaudeVertexModelError(output, { useVertex = false } = {}) {
  * - Codex:  {type:"turn.failed", error:{message:"msg"}}
  * - Gemini: {type:"result", status:"error", error:{message:"msg"}} or {type:"error", severity:"error"}
  * - Opencode: {type:"session.error", error:{message:"msg"}}
+ * - Pi: latest assistant message_end, finalized only by a later agent_settled
  *
  * @param {string} providerName - Active provider whose terminal errors may be inspected
  * @returns {{error: string, provider: string}|null} Error info or null
@@ -397,6 +398,22 @@ function opencodeFailureFromObject(obj) {
   };
 }
 
+function piFailureFromMessage(message) {
+  const stopReason = message.stopReason;
+  const errorMessage = message.errorMessage;
+  if (stopReason === 'deferred') {
+    return {
+      ...cliErrorDetail('Pi turn deferred without completing.', 'Pi turn deferred'),
+      provider: 'pi',
+    };
+  }
+  if (stopReason !== 'error' && stopReason !== 'aborted' && !errorMessage) return null;
+  return {
+    ...cliErrorDetail(errorMessage || stopReason, 'Pi turn failed'),
+    provider: 'pi',
+  };
+}
+
 function failureFromProviderObject(obj, providerName) {
   if (providerName === 'claude') return claudeFailureFromObject(obj);
   if (providerName === 'codex') return codexFailureFromObject(obj);
@@ -405,7 +422,105 @@ function failureFromProviderObject(obj, providerName) {
   return null;
 }
 
+function piProtocolFailure(message) {
+  return { ...cliErrorDetail(message, message), provider: 'pi' };
+}
+
+const PI_STOP_REASONS = new Set(['stop', 'length', 'toolUse', 'error', 'aborted', 'deferred']);
+const PI_USAGE_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'];
+const PI_COST_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'total'];
+
+function parsePiProtocolObject(content) {
+  if (!content.startsWith('{')) return null;
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPiRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasPiNumericFields(value, fields) {
+  return isPiRecord(value) && fields.every((field) => typeof value[field] === 'number');
+}
+
+function isValidPiUsage(usage) {
+  if (!hasPiNumericFields(usage, PI_USAGE_FIELDS)) return false;
+  if (!hasPiNumericFields(usage.cost, PI_COST_FIELDS)) return false;
+  return (
+    (usage.cacheWrite1h === undefined || typeof usage.cacheWrite1h === 'number') &&
+    (usage.reasoning === undefined || typeof usage.reasoning === 'number')
+  );
+}
+
+function isValidPiAssistantMessage(message) {
+  return (
+    isPiRecord(message) &&
+    message.role === 'assistant' &&
+    Array.isArray(message.content) &&
+    isValidPiUsage(message.usage) &&
+    PI_STOP_REASONS.has(message.stopReason)
+  );
+}
+
+function piMessageRole(message) {
+  if (!message || typeof message !== 'object' || Array.isArray(message)) return null;
+  return typeof message.role === 'string' ? message.role : null;
+}
+
+function applyPiProtocolLine(content, state) {
+  if (!content) return null;
+  if (
+    content.startsWith('[ZEROSHOT] Earlier provider output omitted') ||
+    content.startsWith('[ZEROSHOT] Provider output record retained') ||
+    content.startsWith('[ZEROSHOT][PROVIDER_STDERR] ')
+  ) {
+    return null;
+  }
+  if (state.settled) return piProtocolFailure('Pi emitted output after agent_settled.');
+  const parsed = parsePiProtocolObject(content);
+  if (parsed === null) return piProtocolFailure('Pi JSON stream contained malformed output.');
+  if (typeof parsed.type !== 'string') {
+    return piProtocolFailure('Pi JSON stream contained an event without a valid type.');
+  }
+  if (parsed.type === 'message_end') {
+    const role = piMessageRole(parsed.message);
+    if (role === null) return piProtocolFailure('Pi message_end did not contain a valid message.');
+    if (role !== 'assistant') return null;
+    if (!isValidPiAssistantMessage(parsed.message)) {
+      return piProtocolFailure('Pi message_end did not contain a valid assistant message.');
+    }
+    state.latestAssistant = parsed.message;
+  } else if (parsed.type === 'agent_settled') {
+    state.settled = true;
+  }
+  return null;
+}
+
+function extractSettledPiFailure(lines) {
+  const state = { latestAssistant: null, settled: false };
+  for (const line of lines) {
+    const content = stripTimestamp(line);
+    const failure = applyPiProtocolLine(content, state);
+    if (failure) return failure;
+  }
+
+  if (!state.settled) return piProtocolFailure('Pi JSON stream ended before agent_settled.');
+  if (state.latestAssistant === null) {
+    return piProtocolFailure('Pi settled without a valid assistant message_end.');
+  }
+  return piFailureFromMessage(state.latestAssistant);
+}
+
 function extractCliFailure(output, providerName = 'claude') {
+  if (providerName === 'pi') {
+    const lines = typeof output === 'string' ? output.split('\n') : [];
+    return extractSettledPiFailure(lines);
+  }
   if (!output || typeof output !== 'string') return null;
 
   const lines = output.split('\n');

package/src/agent/pi-terminal-lifecycle.js

@@ -0,0 +1,242 @@
+// @ts-nocheck
+
+const { parseProviderEvent, providerFailureFields } = require('./provider-control-plane');
+
+const ZEROSHOT_PI_METADATA_PREFIXES = [
+  '[ZEROSHOT] Earlier provider output omitted',
+  '[ZEROSHOT][PROVIDER_STDERR] ',
+  '[ZEROSHOT][FATAL] ',
+];
+const ZEROSHOT_RETAINED_RECORD_PREFIX = '[ZEROSHOT] Provider output record retained';
+const PI_STOP_REASONS = new Set(['stop', 'length', 'toolUse', 'error', 'aborted', 'deferred']);
+const PI_REQUIRED_TOKEN_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'];
+const PI_OPTIONAL_TOKEN_FIELDS = ['cacheWrite1h', 'reasoning'];
+const PI_TOKEN_FIELDS = [...PI_REQUIRED_TOKEN_FIELDS, ...PI_OPTIONAL_TOKEN_FIELDS];
+const PI_COST_FIELDS = ['input', 'output', 'cacheRead', 'cacheWrite', 'total'];
+const PI_PENDING_EVENT_TYPES = new Set([
+  'turn_end',
+  'agent_end',
+  'auto_retry_start',
+  'auto_retry_end',
+]);
+
+function pendingFailureMetadata(failure) {
+  return {
+    zeroshot_pending_failure: {
+      provider: failure.provider,
+      category: failure.category,
+      kind: failure.classification.kind,
+      retryable: failure.classification.retryable,
+      diagnostic: failure.diagnostic,
+    },
+  };
+}
+
+function numericFields(fields, source) {
+  return Object.fromEntries(
+    fields.map((field) => [field, typeof source[field] === 'number' ? source[field] : 0])
+  );
+}
+
+function redactedUsage(usage) {
+  const value = usage && typeof usage === 'object' && !Array.isArray(usage) ? usage : {};
+  return {
+    ...numericFields(PI_REQUIRED_TOKEN_FIELDS, value),
+    ...(typeof value.cacheWrite1h === 'number' ? { cacheWrite1h: value.cacheWrite1h } : {}),
+    ...(typeof value.reasoning === 'number' ? { reasoning: value.reasoning } : {}),
+    cost: numericFields(PI_COST_FIELDS, isRecord(value.cost) ? value.cost : {}),
+  };
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasNumericFields(value, fields) {
+  return isRecord(value) && fields.every((field) => typeof value[field] === 'number');
+}
+
+function addNumericFields(target, source, fields) {
+  for (const field of fields) {
+    if (typeof source[field] === 'number') target[field] = (target[field] || 0) + source[field];
+  }
+}
+
+function rememberTokenUsage(state, usage) {
+  if (!hasNumericFields(usage, PI_REQUIRED_TOKEN_FIELDS)) return false;
+  if (!hasNumericFields(usage.cost, PI_COST_FIELDS)) return false;
+  if (
+    !PI_OPTIONAL_TOKEN_FIELDS.every(
+      (field) => usage[field] === undefined || typeof usage[field] === 'number'
+    )
+  ) {
+    return false;
+  }
+  state.piUsage = state.piUsage || { tokens: {}, cost: {} };
+  addNumericFields(state.piUsage.tokens, usage, PI_TOKEN_FIELDS);
+  addNumericFields(state.piUsage.cost, usage.cost, PI_COST_FIELDS);
+  return true;
+}
+
+function getPiTokenUsage(state) {
+  if (!state?.piUsage) return null;
+  const { tokens, cost } = state.piUsage;
+  return {
+    inputTokens: tokens.input || 0,
+    outputTokens: tokens.output || 0,
+    cacheReadInputTokens: tokens.cacheRead || 0,
+    cacheCreationInputTokens: tokens.cacheWrite || 0,
+    totalCostUsd: cost.total || 0,
+    durationMs: null,
+    modelUsage: { ...tokens, cost: { ...cost } },
+  };
+}
+
+function isValidAssistantMessage(message) {
+  return Array.isArray(message?.content) && PI_STOP_REASONS.has(message.stopReason);
+}
+
+function redactPendingFailure(failure, parsed) {
+  const pending = pendingFailureMetadata(failure);
+  if (parsed.type === 'agent_end') {
+    return JSON.stringify({
+      type: parsed.type,
+      messages: [],
+      willRetry: parsed.willRetry === true,
+      ...pending,
+    });
+  }
+  if (parsed.type === 'auto_retry_end') {
+    return JSON.stringify({ type: parsed.type, success: false, ...pending });
+  }
+  if (parsed.type === 'auto_retry_start') {
+    return JSON.stringify({
+      type: parsed.type,
+      ...numericFields(
+        ['attempt', 'maxAttempts', 'delayMs'].filter((field) => typeof parsed[field] === 'number'),
+        parsed
+      ),
+      ...pending,
+    });
+  }
+  return JSON.stringify({
+    type: parsed.type,
+    message: {
+      role: 'assistant',
+      content: [],
+      usage: redactedUsage(parsed.message?.usage),
+      stopReason: 'error',
+      errorMessage: 'Pi provider turn failed; awaiting agent settlement.',
+    },
+    ...(parsed.type === 'turn_end' ? { toolResults: [] } : {}),
+    ...pending,
+  });
+}
+
+function finalFailureEnvelope(failure) {
+  return JSON.stringify({
+    type: 'agent_settled',
+    ...providerFailureFields(failure),
+  });
+}
+
+function rememberProtocolFailure(state, content, extractProviderFailure) {
+  const failure = extractProviderFailure(content, 'pi');
+  if (failure) {
+    state.piProtocolFailure = failure;
+    state.providerFailure = failure;
+  }
+  return failure;
+}
+
+function failProtocolLine(state, content, extractProviderFailure) {
+  const failure = rememberProtocolFailure(state, content, extractProviderFailure);
+  return failure ? finalFailureEnvelope(failure) : content;
+}
+
+function handleMessageEnd(state, content, parsed, extractProviderFailure) {
+  const role = parsed.message?.role;
+  if (typeof role !== 'string') return failProtocolLine(state, content, extractProviderFailure);
+  const hasCountedUsage = role === 'assistant' || parsed.message?.usage !== undefined;
+  if (
+    ['assistant', 'toolResult'].includes(role) &&
+    hasCountedUsage &&
+    !rememberTokenUsage(state, parsed.message?.usage)
+  ) {
+    return failProtocolLine(state, 'invalid Pi usage', extractProviderFailure);
+  }
+  if (role !== 'assistant') return content;
+  if (!isValidAssistantMessage(parsed.message)) {
+    return failProtocolLine(state, content, extractProviderFailure);
+  }
+  const failure = extractProviderFailure(
+    `${content}\n${JSON.stringify({ type: 'agent_settled' })}`,
+    'pi'
+  );
+  state.piLatestAssistantObserved = true;
+  state.pendingPiFailure = failure;
+  if (failure) return redactPendingFailure(failure, parsed);
+  if (!state.piProtocolFailure) state.providerFailure = null;
+  return content;
+}
+
+function usageForEvent(parsed) {
+  if (parsed.type === 'compaction_end' && parsed.result?.usage !== undefined) {
+    return parsed.result.usage;
+  }
+  if (
+    parsed.type === 'entry_appended' &&
+    parsed.entry?.type === 'branch_summary' &&
+    parsed.entry.usage !== undefined
+  ) {
+    return parsed.entry.usage;
+  }
+  return undefined;
+}
+
+function handleSettlement(state, content, extractProviderFailure) {
+  state.piProtocolSettled = true;
+  const missingAssistantFailure = state.piLatestAssistantObserved
+    ? null
+    : extractProviderFailure(JSON.stringify({ type: 'agent_settled' }), 'pi');
+  const failure = state.piProtocolFailure || state.pendingPiFailure || missingAssistantFailure;
+  state.pendingPiFailure = null;
+  state.providerFailure = failure || null;
+  return failure ? finalFailureEnvelope(failure) : content;
+}
+
+function redactPiFailureForControlPlane(state, content, extractProviderFailure) {
+  if (content.startsWith(ZEROSHOT_RETAINED_RECORD_PREFIX)) {
+    state.piProtocolPrefixOmitted = true;
+    return content;
+  }
+  if (ZEROSHOT_PI_METADATA_PREFIXES.some((prefix) => content.startsWith(prefix))) return content;
+  const parsed = parseProviderEvent(content);
+  if (parsed === null || typeof parsed.type !== 'string') {
+    return failProtocolLine(state, content, extractProviderFailure);
+  }
+  if (state.piProtocolSettled) {
+    return failProtocolLine(
+      state,
+      `${JSON.stringify({ type: 'agent_settled' })}\n${content}`,
+      extractProviderFailure
+    );
+  }
+  state.piProtocolObserved = true;
+
+  if (parsed.type === 'message_end') {
+    return handleMessageEnd(state, content, parsed, extractProviderFailure);
+  }
+  const usage = usageForEvent(parsed);
+  if (usage !== undefined && !rememberTokenUsage(state, usage)) {
+    return failProtocolLine(state, 'invalid Pi usage', extractProviderFailure);
+  }
+  if (state.pendingPiFailure && PI_PENDING_EVENT_TYPES.has(parsed.type)) {
+    return redactPendingFailure(state.pendingPiFailure, parsed);
+  }
+  return parsed.type === 'agent_settled'
+    ? handleSettlement(state, content, extractProviderFailure)
+    : content;
+}
+
+module.exports = { getPiTokenUsage, redactPiFailureForControlPlane };

package/src/agent/provider-control-plane.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+
+function parseProviderEvent(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function providerFailureFields(failure) {
+  return {
+    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,
+    },
+  };
+}
+
+module.exports = { parseProviderEvent, providerFailureFields };

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

@@ -3,12 +3,23 @@
 const { getProvider } = require('../providers');
 const { isCriticalAgent } = require('./critical-agent-policy');
 const { extractCliFailure } = require('./output-extraction');
+const { getPiTokenUsage, redactPiFailureForControlPlane } = require('./pi-terminal-lifecycle');
+const { parseProviderEvent, providerFailureFields } = require('./provider-control-plane');
+
+const AUTHENTICATION_FAILURE_PATTERNS = [
+  /invalid[_ -]?api[_ -]?key/i,
+  /api[_ -]?key.*invalid/i,
+  /(?:missing|no) api key/i,
+  /run\s*\/login/i,
+  /unauthori[sz]ed/i,
+  /forbidden|authentication|permission denied/i,
+];
 
 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';
+  if (isPermanent && AUTHENTICATION_FAILURE_PATTERNS.some((pattern) => pattern.test(error))) {
+    return 'authentication';
+  }
 
   const quotaPattern = /(?:insufficient[_ -]?quota|quota exceeded|resource_exhausted)/i;
   if (isPermanent && quotaPattern.test(error)) return 'quota';
@@ -30,6 +41,12 @@ function classifyProviderFailure(providerName, error) {
   };
 }
 
+function providerFailureEvent(providerName) {
+  if (providerName === 'codex') return 'turn.failed';
+  if (providerName === 'pi') return 'agent_settled';
+  return 'terminal_error';
+}
+
 function extractProviderFailure(output, providerName) {
   const cliError = extractCliFailure(output, providerName);
   if (!cliError) return null;
@@ -39,41 +56,47 @@ function extractProviderFailure(output, providerName) {
   return {
     error: `Provider ${cliError.provider} failed (${category}; ${classification.kind})`,
     provider: cliError.provider,
-    event: cliError.provider === 'codex' ? 'turn.failed' : 'terminal_error',
+    event: providerFailureEvent(cliError.provider),
     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.
+function extractProviderCompletionFailure(output, providerName, state = {}) {
+  if (providerName !== 'pi') return extractProviderFailure(output, providerName);
+  if (state.providerFailure) return state.providerFailure;
+  if (state.piProtocolPrefixOmitted) return extractProviderFailure('', 'pi');
+  if (!state.piProtocolObserved) return extractProviderFailure(output, 'pi');
+  if (!state.piProtocolSettled || !state.piLatestAssistantObserved) {
+    return extractProviderFailure('', 'pi');
   }
+  return null;
+}
+
+function redactedFailureEnvelope(failure, providerName, eventType) {
   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,
-    },
+    ...providerFailureFields(failure),
   });
 }
 
+function redactTerminalFailureForControlPlane(state, providerName, content) {
+  if (providerName === 'pi') {
+    return redactPiFailureForControlPlane(state, content, extractProviderFailure);
+  }
+
+  const failure = extractProviderFailure(content, providerName);
+  if (!failure) return content;
+
+  state.providerFailure = failure;
+  const parsed = parseProviderEvent(content);
+  const eventType = typeof parsed?.type === 'string' ? parsed.type : 'provider.failure';
+  return redactedFailureEnvelope(failure, providerName, eventType);
+}
+
 function decorateError(error, failure) {
   if (!failure) return error;
   error.provider = failure.provider || null;
@@ -176,7 +199,9 @@ function buildFinalFailureInfo({
 module.exports = {
   buildFinalFailureInfo,
   decorateError,
+  extractProviderCompletionFailure,
   extractProviderFailure,
+  getPiTokenUsage,
   publishCriticalFailure,
   receiptFields,
   redactTerminalFailureForControlPlane,

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

@@ -25,8 +25,9 @@ export function detectProviderStreamingModeError(
 }
 
 export function detectProviderFatalError(provider: string, line: unknown): string | null {
-  if (!isClaudeProvider(provider)) return null;
-  return detectClaudeFatalError(line);
+  if (isClaudeProvider(provider)) return detectClaudeFatalError(line);
+  if (provider.toLowerCase() === 'pi') return detectPiFatalError(line);
+  return null;
 }
 
 export function recoverProviderStructuredOutput(
@@ -84,6 +85,18 @@ function detectClaudeFatalError(line: unknown): string | null {
   return null;
 }
 
+function detectPiFatalError(line: unknown): string | null {
+  if (typeof line !== 'string') return null;
+  const message = line.trim();
+  if (/\bno api key found\b/i.test(message)) {
+    return 'Pi authentication required: run /login';
+  }
+  if (/\bmodel\b.*\bnot found\b/i.test(message)) {
+    return 'Pi model not found: run pi --list-models';
+  }
+  return null;
+}
+
 function findSessionJsonlPath(sessionId: string): string | null {
   const claudeDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
   const projectsDir = join(claudeDir, 'projects');

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

@@ -90,6 +90,12 @@ export function parseProviderChunk(
     }
   }
 
+  const finalEvent = adapter.finishParsing?.(state);
+  if (finalEvent) {
+    if (isOutputEventArray(finalEvent)) events.push(...finalEvent);
+    else events.push(finalEvent);
+  }
+
   return events;
 }