bopodev-agent-sdk 0.1.25 → 0.1.27

package/src/provider-failures/anthropic-api.ts

@@ -0,0 +1,20 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeAnthropicFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected Anthropic model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|invalid_api_key|permission denied)/.test(lower)) {
+    return "Authentication failed for provider runtime. Verify credentials and account access.";
+  }
+  return normalized;
+};
+
+export const anthropicApiFailureResolver = {
+  normalize: normalizeAnthropicFailureDetail,
+  classify: createClassifier(normalizeAnthropicFailureDetail)
+};

package/src/provider-failures/claude-code.ts

@@ -0,0 +1,20 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeClaudeFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected Anthropic model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|invalid_api_key|permission denied|not logged in|claude login)/.test(lower)) {
+    return "Authentication failed for provider runtime. Verify credentials and account access.";
+  }
+  return normalized;
+};
+
+export const claudeCodeFailureResolver = {
+  normalize: normalizeClaudeFailureDetail,
+  classify: createClassifier(normalizeClaudeFailureDetail)
+};

package/src/provider-failures/codex.ts

@@ -0,0 +1,23 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeCodexFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/not supported/.test(lower) && lower.includes("chatgpt account") && lower.includes("model")) {
+    return "Codex model not supported for this ChatGPT account. Select a supported Codex model.";
+  }
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|invalid_api_key|permission denied)/.test(lower)) {
+    return "Authentication failed for provider runtime. Verify credentials and account access.";
+  }
+  return normalized;
+};
+
+export const codexFailureResolver = {
+  normalize: normalizeCodexFailureDetail,
+  classify: createClassifier(normalizeCodexFailureDetail)
+};

package/src/provider-failures/common.ts

@@ -0,0 +1,86 @@
+import { containsUsageLimitHardStopFailure } from "../runtime-core";
+import type {
+  ProviderFailureClassification,
+  ProviderFailureClassifier,
+  ProviderFailureInput,
+  ProviderFailureNormalizer
+} from "./types";
+
+export function normalizeWhitespace(value: string) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+export function hasModelUnsupportedSignal(haystack: string) {
+  return (
+    /model/.test(haystack) &&
+    /(not supported|unsupported|does not exist|not found|unavailable|invalid model|model_not_found)/.test(haystack)
+  );
+}
+
+export function hasAuthFailureSignal(haystack: string) {
+  return /(not logged in|login required|requires login|authentication required|authentication failed|unauthorized|invalid[_\s-]?api[_\s-]?key|api key)/.test(
+    haystack
+  );
+}
+
+export function hasUnknownSessionSignal(haystack: string) {
+  return /unknown session|session .* not found|could not resume|missing rollout path for thread|conversation .* not found|thread .* not found/.test(
+    haystack
+  );
+}
+
+export function classifyFromSignals(
+  normalize: ProviderFailureNormalizer,
+  input: ProviderFailureInput
+): ProviderFailureClassification {
+  const detail = normalize(input.detail);
+  const combined = `${detail}\n${input.stderr ?? ""}\n${input.stdout ?? ""}`.toLowerCase();
+  if (containsUsageLimitHardStopFailure(combined)) {
+    const blockerCode =
+      combined.includes("insufficient_quota") ||
+      combined.includes("billing_hard_limit_reached") ||
+      combined.includes("out of funds")
+        ? "provider_out_of_funds"
+        : "provider_quota_exhausted";
+    return {
+      detail,
+      blockerCode,
+      retryable: false,
+      providerUsageLimited: true
+    };
+  }
+  if (hasModelUnsupportedSignal(combined)) {
+    return {
+      detail,
+      blockerCode: "model_not_supported",
+      retryable: false,
+      providerUsageLimited: false
+    };
+  }
+  if (hasAuthFailureSignal(combined)) {
+    return {
+      detail,
+      blockerCode: "auth_required",
+      retryable: false,
+      providerUsageLimited: false
+    };
+  }
+  if (hasUnknownSessionSignal(combined)) {
+    return {
+      detail: "Saved provider session is no longer available. Retry with a fresh session.",
+      blockerCode: "unknown_session",
+      retryable: true,
+      providerUsageLimited: false
+    };
+  }
+  return {
+    detail,
+    blockerCode: input.failureType?.trim() || "runtime_failed",
+    retryable: input.failureType !== "auth" && input.failureType !== "bad_response",
+    providerUsageLimited: false
+  };
+}
+
+export function createClassifier(normalize: ProviderFailureNormalizer): ProviderFailureClassifier {
+  return (input) => classifyFromSignals(normalize, input);
+}

package/src/provider-failures/cursor.ts

@@ -0,0 +1,20 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeCursorFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|invalid_api_key|permission denied)/.test(lower)) {
+    return "Authentication failed for provider runtime. Verify credentials and account access.";
+  }
+  return normalized;
+};
+
+export const cursorFailureResolver = {
+  normalize: normalizeCursorFailureDetail,
+  classify: createClassifier(normalizeCursorFailureDetail)
+};

package/src/provider-failures/gemini-cli.ts

@@ -0,0 +1,20 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeGeminiFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|permission denied)/.test(lower)) {
+    return "Gemini authentication failed. Verify Gemini credentials and account permissions.";
+  }
+  return normalized;
+};
+
+export const geminiCliFailureResolver = {
+  normalize: normalizeGeminiFailureDetail,
+  classify: createClassifier(normalizeGeminiFailureDetail)
+};

package/src/provider-failures/http.ts

@@ -0,0 +1,12 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeHttpFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  return normalized || detail;
+};
+
+export const httpFailureResolver = {
+  normalize: normalizeHttpFailureDetail,
+  classify: createClassifier(normalizeHttpFailureDetail)
+};

package/src/provider-failures/index.ts

@@ -0,0 +1,54 @@
+import type { AgentProviderType } from "../types";
+import { anthropicApiFailureResolver } from "./anthropic-api";
+import { claudeCodeFailureResolver } from "./claude-code";
+import { codexFailureResolver } from "./codex";
+import { cursorFailureResolver } from "./cursor";
+import { geminiCliFailureResolver } from "./gemini-cli";
+import { httpFailureResolver } from "./http";
+import { openAiApiFailureResolver } from "./openai-api";
+import { opencodeFailureResolver } from "./opencode";
+import { shellFailureResolver } from "./shell";
+import type {
+  ProviderFailureClassification,
+  ProviderFailureInput,
+  ProviderFailureResolverMap
+} from "./types";
+
+const providerFailureResolvers: ProviderFailureResolverMap = {
+  codex: codexFailureResolver,
+  claude_code: claudeCodeFailureResolver,
+  openai_api: openAiApiFailureResolver,
+  anthropic_api: anthropicApiFailureResolver,
+  cursor: cursorFailureResolver,
+  opencode: opencodeFailureResolver,
+  gemini_cli: geminiCliFailureResolver,
+  shell: shellFailureResolver,
+  http: httpFailureResolver
+};
+
+export function normalizeProviderFailureDetail(provider: AgentProviderType, detail: string) {
+  const resolver = providerFailureResolvers[provider];
+  if (!resolver) {
+    return detail.replace(/\s+/g, " ").trim() || detail;
+  }
+  return resolver.normalize(detail);
+}
+
+export function classifyProviderFailure(
+  provider: AgentProviderType,
+  input: ProviderFailureInput
+): ProviderFailureClassification {
+  const resolver = providerFailureResolvers[provider];
+  if (!resolver) {
+    const normalized = input.detail.replace(/\s+/g, " ").trim() || input.detail;
+    return {
+      detail: normalized,
+      blockerCode: input.failureType?.trim() || "runtime_failed",
+      retryable: input.failureType !== "auth" && input.failureType !== "bad_response",
+      providerUsageLimited: false
+    };
+  }
+  return resolver.classify(input);
+}
+
+export type { ProviderFailureClassification, ProviderFailureInput } from "./types";

package/src/provider-failures/openai-api.ts

@@ -0,0 +1,20 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeOpenAiFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|invalid_api_key|permission denied)/.test(lower)) {
+    return "Authentication failed for provider runtime. Verify credentials and account access.";
+  }
+  return normalized;
+};
+
+export const openAiApiFailureResolver = {
+  normalize: normalizeOpenAiFailureDetail,
+  classify: createClassifier(normalizeOpenAiFailureDetail)
+};

package/src/provider-failures/opencode.ts

@@ -0,0 +1,20 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeOpenCodeFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  if (!normalized) return detail;
+  const lower = normalized.toLowerCase();
+  if (/model/.test(lower) && /(not supported|does not exist|not found|unavailable|unsupported)/.test(lower)) {
+    return "Selected model is unavailable for this account. Choose a supported model.";
+  }
+  if (/(auth|unauthorized|api key|invalid_api_key|permission denied)/.test(lower)) {
+    return "Authentication failed for provider runtime. Verify credentials and account access.";
+  }
+  return normalized;
+};
+
+export const opencodeFailureResolver = {
+  normalize: normalizeOpenCodeFailureDetail,
+  classify: createClassifier(normalizeOpenCodeFailureDetail)
+};

package/src/provider-failures/shell.ts

@@ -0,0 +1,12 @@
+import { createClassifier, normalizeWhitespace } from "./common";
+import type { ProviderFailureNormalizer } from "./types";
+
+const normalizeShellFailureDetail: ProviderFailureNormalizer = (detail) => {
+  const normalized = normalizeWhitespace(detail);
+  return normalized || detail;
+};
+
+export const shellFailureResolver = {
+  normalize: normalizeShellFailureDetail,
+  classify: createClassifier(normalizeShellFailureDetail)
+};

package/src/provider-failures/types.ts

@@ -0,0 +1,28 @@
+import type { AgentProviderType } from "../types";
+
+export type ProviderFailureInput = {
+  detail: string;
+  stderr?: string;
+  stdout?: string;
+  failureType?: string | null;
+};
+
+export type ProviderFailureClassification = {
+  detail: string;
+  blockerCode: string;
+  retryable: boolean;
+  providerUsageLimited: boolean;
+};
+
+export type ProviderFailureClassifier = (
+  input: ProviderFailureInput
+) => ProviderFailureClassification;
+
+export type ProviderFailureNormalizer = (detail: string) => string;
+
+export type ProviderFailureResolver = {
+  normalize: ProviderFailureNormalizer;
+  classify: ProviderFailureClassifier;
+};
+
+export type ProviderFailureResolverMap = Partial<Record<AgentProviderType, ProviderFailureResolver>>;

package/src/runtime-core.ts

@@ -4,4 +4,10 @@ export type {
   RuntimeExecutionOutput,
   RuntimeTranscriptEvent
 } from "./runtime";
-export { checkRuntimeCommandHealth, containsRateLimitFailure, executeAgentRuntime, executePromptRuntime } from "./runtime";
+export {
+  checkRuntimeCommandHealth,
+  containsUsageLimitHardStopFailure,
+  containsRateLimitFailure,
+  executeAgentRuntime,
+  executePromptRuntime
+} from "./runtime";

package/src/runtime-http.ts

@@ -1,4 +1,6 @@
 import type { AgentRuntimeConfig } from "./types";
+import type { AgentFinalRunOutput } from "bopodev-contracts";
+import { containsUsageLimitHardStopFailure, parseAgentFinalRunOutput } from "./runtime";
 
 export type DirectApiProvider = "openai_api" | "anthropic_api";
 
@@ -10,10 +12,19 @@ export type DirectApiExecutionOutput = {
   elapsedMs: number;
   statusCode: number;
   summary?: string;
+  finalRunOutput?: AgentFinalRunOutput;
   tokenInput?: number;
   tokenOutput?: number;
   usdCost?: number;
-  failureType?: "auth" | "rate_limit" | "timeout" | "network" | "bad_response" | "http_error";
+  failureType?:
+    | "auth"
+    | "rate_limit"
+    | "out_of_funds"
+    | "quota_exhausted"
+    | "timeout"
+    | "network"
+    | "bad_response"
+    | "http_error";
   error?: string;
   responsePreview?: string;
   attemptCount: number;
@@ -21,7 +32,15 @@ export type DirectApiExecutionOutput = {
     attempt: number;
     statusCode: number;
     elapsedMs: number;
-    failureType?: "auth" | "rate_limit" | "timeout" | "network" | "bad_response" | "http_error";
+    failureType?:
+      | "auth"
+      | "rate_limit"
+      | "out_of_funds"
+      | "quota_exhausted"
+      | "timeout"
+      | "network"
+      | "bad_response"
+      | "http_error";
     error?: string;
   }>;
 };
@@ -133,8 +152,9 @@ export async function executeDirectApiRuntime(
       const preview = toPreview(text);
       const parsed = tryParseJson(text);
       if (!response.ok) {
-        const failureType = classifyHttpFailure(response.status);
         const error = extractErrorMessage(provider, parsed, text) || `HTTP ${response.status}`;
+        const providerUsageLimited = containsUsageLimitHardStopFailure(`${error}\n${preview}\n${text}`);
+        const failureType = classifyHttpFailure(response.status, providerUsageLimited, error);
         attempts.push({
           attempt,
           statusCode: response.status,
@@ -149,7 +169,7 @@ export async function executeDirectApiRuntime(
           error,
           responsePreview: preview
         };
-        if (!isRetryableFailure(failureType, response.status) || attempt >= maxAttempts) {
+        if (providerUsageLimited || !isRetryableFailure(failureType, response.status) || attempt >= maxAttempts) {
           break;
         }
         await sleep(retryBackoffMs * attempt);
@@ -175,6 +195,7 @@ export async function executeDirectApiRuntime(
         break;
       }
       const summary = provider === "openai_api" ? extractOpenAiSummary(parsed) : extractAnthropicSummary(parsed);
+      const finalRunOutput = parseAgentFinalRunOutput(summary);
       const usage = provider === "openai_api" ? extractOpenAiUsage(parsed) : extractAnthropicUsage(parsed);
       attempts.push({
         attempt,
@@ -189,6 +210,7 @@ export async function executeDirectApiRuntime(
         elapsedMs,
         statusCode: response.status,
         summary,
+        finalRunOutput: finalRunOutput.output,
         tokenInput: usage.tokenInput,
         tokenOutput: usage.tokenOutput,
         usdCost: usage.usdCost ?? 0,
@@ -349,14 +371,22 @@ function extractAnthropicUsage(parsed: Record<string, unknown>) {
 function extractErrorMessage(provider: DirectApiProvider, parsed: Record<string, unknown> | null, fallback: string) {
   const fallbackMessage = toPreview(fallback, 320);
   if (!parsed) return fallbackMessage;
+  if (typeof parsed.detail === "string" && parsed.detail.trim()) {
+    return parsed.detail.trim();
+  }
+  if (typeof parsed.reason === "string" && parsed.reason.trim()) {
+    return parsed.reason.trim();
+  }
   const error = parsed.error;
   if (typeof error === "string" && error.trim()) return error.trim();
   if (error && typeof error === "object") {
     const errorRecord = error as Record<string, unknown>;
     const candidates = [
       errorRecord.message,
+      errorRecord.detail,
       errorRecord.error?.toString(),
-      (errorRecord.details as string | undefined) ?? undefined
+      (errorRecord.details as string | undefined) ?? undefined,
+      errorRecord.reason
     ];
     for (const candidate of candidates) {
       if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
@@ -368,8 +398,23 @@ function extractErrorMessage(provider: DirectApiProvider, parsed: Record<string,
   return fallbackMessage;
 }
 
-function classifyHttpFailure(statusCode: number): "auth" | "rate_limit" | "http_error" {
+function classifyHttpFailure(
+  statusCode: number,
+  providerUsageLimited: boolean,
+  detail: string
+): "auth" | "rate_limit" | "out_of_funds" | "quota_exhausted" | "http_error" {
   if (statusCode === 401 || statusCode === 403) return "auth";
+  if (providerUsageLimited) {
+    const normalized = detail.toLowerCase();
+    if (
+      normalized.includes("insufficient_quota") ||
+      normalized.includes("billing_hard_limit_reached") ||
+      normalized.includes("out of funds")
+    ) {
+      return "out_of_funds";
+    }
+    return "quota_exhausted";
+  }
   if (statusCode === 429) return "rate_limit";
   return "http_error";
 }

package/src/runtime-parsers.ts

@@ -1,4 +1,5 @@
 export {
+  parseAgentFinalRunOutput,
   parseClaudeStreamOutput,
   parseCursorStreamOutput,
   parseGeminiStreamOutput,