@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-M6UHOC4I.js

@@ -0,0 +1,553 @@
+// src/core/providers/shared/error-parser-core.ts
+var VARIANT_WORKER_SIGTERM_SOURCE = "variant_worker_sigterm";
+var HostTimeoutError = class extends Error {
+  /** Deadline that fired, when the abort site knows it. Omitted when the
+   *  stop is host-initiated but the scope (per-variant vs global) is unknown. */
+  limitMs;
+  source;
+  /** Structured reason so JSON-round-tripped errors still classify as timeout. */
+  reason = "timeout";
+  constructor(message, options) {
+    super(message);
+    this.name = "HostTimeoutError";
+    this.limitMs = options.limitMs;
+    this.source = options.source;
+  }
+};
+var HOST_TIMEOUT_ABORT_MESSAGE_RE = /timeout|did not return within|deadline|idle/i;
+var HOST_TIMEOUT_REASONS = /* @__PURE__ */ new Set([
+  "timeout",
+  "hard_timeout",
+  "idle_timeout",
+  "plm_timeout",
+  // Build declined to start (or continue) an attempt because the remaining
+  // run deadline was too small: a host deadline decision, not a provider fault.
+  "deadline_exhausted"
+]);
+function isHostTimeoutAbortReason(reason) {
+  if (reason instanceof HostTimeoutError) {
+    return true;
+  }
+  if (reason instanceof Error) {
+    return HOST_TIMEOUT_ABORT_MESSAGE_RE.test(reason.message);
+  }
+  if (typeof reason === "string") {
+    return HOST_TIMEOUT_ABORT_MESSAGE_RE.test(reason);
+  }
+  return false;
+}
+function providerAbortReasonFromSignal(signal) {
+  return isHostTimeoutAbortReason(signal?.reason) ? "timeout" : "aborted";
+}
+function classifyHostTermination(fields) {
+  const reason = fields.reason;
+  if (reason && HOST_TIMEOUT_REASONS.has(reason)) {
+    return "timeout";
+  }
+  if (reason === "abort" || reason === "aborted" || fields.terminationSource === "abortSignal") {
+    return "aborted";
+  }
+  return null;
+}
+function hostTimeoutUserMessage(limitMs) {
+  if (typeof limitMs === "number" && Number.isFinite(limitMs) && limitMs > 0) {
+    const minutes = Math.max(1, Math.round(limitMs / 6e4));
+    return `Build stopped this run at its time limit (${minutes} min). Raise --executor-timeout-minutes or split the task.`;
+  }
+  return "Build stopped this run at its time limit. Raise --executor-timeout-minutes or split the task.";
+}
+var HOST_ABORT_USER_MESSAGE = "Run was cancelled.";
+function formatHostTimeoutTerminationDetail(reason) {
+  if (reason instanceof HostTimeoutError) {
+    if (typeof reason.limitMs === "number" && Number.isFinite(reason.limitMs) && reason.limitMs > 0) {
+      const minutes = Math.max(1, Math.round(reason.limitMs / 6e4));
+      return `time limit ${minutes} min`;
+    }
+    return "time limit reached";
+  }
+  if (reason instanceof Error && reason.message.trim().length > 0) {
+    return reason.message;
+  }
+  if (typeof reason === "string" && reason.trim().length > 0) {
+    return reason;
+  }
+  return void 0;
+}
+function extractHostTimeoutLimitMs(text) {
+  if (!text) return void 0;
+  const timeLimitMin = text.match(/time limit (\d+) min/i);
+  if (timeLimitMin?.[1]) {
+    return parseInt(timeLimitMin[1], 10) * 6e4;
+  }
+  const orchestratorMin = text.match(/Orchestrator timeout after ([\d.]+) minutes/i);
+  if (orchestratorMin?.[1]) {
+    return Math.round(parseFloat(orchestratorMin[1]) * 6e4);
+  }
+  const withinMs = text.match(/did not return within (\d+)ms/i);
+  if (withinMs?.[1]) {
+    return parseInt(withinMs[1], 10);
+  }
+  const timeoutAfterS = text.match(/timeout after (\d+)s/i);
+  if (timeoutAfterS?.[1]) {
+    return parseInt(timeoutAfterS[1], 10) * 1e3;
+  }
+  return void 0;
+}
+function hostTerminationMetadataFromUnknown(error) {
+  if (error instanceof HostTimeoutError) {
+    return { reason: "timeout", limitMs: error.limitMs };
+  }
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const record = error;
+  const reason = typeof record.reason === "string" ? record.reason : void 0;
+  const terminationSource = typeof record.terminationSource === "string" ? record.terminationSource : void 0;
+  const signal = typeof record.signal === "string" ? record.signal : void 0;
+  const limitMs = record.cause instanceof HostTimeoutError ? record.cause.limitMs : typeof record.message === "string" ? extractHostTimeoutLimitMs(record.message) : void 0;
+  if (reason === void 0 && terminationSource === void 0 && signal === void 0 && limitMs === void 0) {
+    return void 0;
+  }
+  return { reason, terminationSource, signal, limitMs };
+}
+function isHostCancellationError(error) {
+  if (error instanceof Error && error.name === "AbortError") return true;
+  const fields = hostTerminationMetadataFromUnknown(error);
+  if (!fields) return false;
+  return classifyHostTermination(fields) === "aborted" || fields.reason === "cancelled";
+}
+function createHostTerminationParsedError(classification, originalError, options) {
+  if (classification === "timeout") {
+    return {
+      type: "timeout",
+      retryable: false,
+      userMessage: hostTimeoutUserMessage(options?.limitMs),
+      debugInfo: { exitCode: options?.exitCode },
+      originalError
+    };
+  }
+  return {
+    type: "aborted",
+    retryable: false,
+    userMessage: HOST_ABORT_USER_MESSAGE,
+    debugInfo: { exitCode: options?.exitCode },
+    originalError
+  };
+}
+function parseHostTermination(fields, originalError, exitCode) {
+  if (!fields) return null;
+  const classification = classifyHostTermination(fields);
+  if (classification === null) return null;
+  return createHostTerminationParsedError(classification, originalError, {
+    exitCode,
+    limitMs: fields.limitMs
+  });
+}
+var DEFAULT_ERROR_PATTERNS = {
+  rateLimit: [
+    "rate limit",
+    "too many requests",
+    "resource_exhausted",
+    // HTTP 429 must carry status-code context. A bare '429' substring matches
+    // unrelated text (counts, ids, offsets, token totals) and false-positives
+    // into a retryable classification. The worded patterns above still catch
+    // the common phrasings; these gate the numeric form to genuine HTTP status.
+    "http 429",
+    "status 429",
+    "status code 429",
+    "code: 429",
+    "429 too many requests",
+    // Colon/equals/JSON variants of the same status-code context (literal substrings).
+    "status: 429",
+    "status=429",
+    '"code":429',
+    '"code": 429'
+  ],
+  auth: [
+    "unauthorized",
+    "not authorized",
+    "access to model",
+    "invalid api key",
+    "authentication failed",
+    "api key",
+    "invalid_api_key",
+    "not authenticated",
+    "login required",
+    "authentication required",
+    "session expired",
+    "credentials invalid",
+    "could not load credentials",
+    "load credentials",
+    "credentials from any providers",
+    "unauthenticated",
+    "forbidden"
+  ],
+  network: [
+    "econnrefused",
+    "enotfound",
+    "enetunreach",
+    "network error",
+    "connection",
+    "fetch failed",
+    "etimedout",
+    "connection timeout",
+    "econnreset",
+    "eai_again",
+    "socket hang up",
+    "getaddrinfo"
+  ],
+  timeout: [
+    "timed out",
+    "execution timed out",
+    "hard_timeout",
+    "process-limiter",
+    "process timeout"
+  ],
+  validation: [
+    "invalid",
+    "unknown option",
+    "unrecognized",
+    "usage:",
+    "bad request",
+    "invalid arguments"
+  ],
+  capacity: [
+    "service unavailable",
+    "upstream connect error",
+    "upstream connection reset",
+    "disconnect/reset before headers",
+    "temporarily unavailable",
+    "server is overloaded",
+    "overloaded",
+    // Transient HTTP statuses must carry status-code context. A bare numeric
+    // substring (e.g. '503' inside "Processed 503 items") false-positives into
+    // a retryable capacity classification. The worded patterns above still
+    // catch the common phrasings; these gate the numeric forms to genuine HTTP
+    // status. Retryable transient set: 408 (request timeout), 425 (too early),
+    // 500 (internal server error), 502 (bad gateway), 503 (service
+    // unavailable), 504 (gateway timeout). 429 lives in rateLimit above.
+    // Deterministic client errors (400/401/403/404/422) and conflicts (409)
+    // are intentionally absent: retrying them only burns the retry budget.
+    // For each code: 'http <n>' / 'status <n>' / 'status code <n>' / 'code: <n>'
+    // plus the colon/equals/JSON variants 'status: <n>' / 'status=<n>' /
+    // '"code":<n>' / '"code": <n>' (all literal lowercased substrings). The bare
+    // number is deliberately excluded so it never matches counts/ids in prose.
+    "http 408",
+    "status 408",
+    "status code 408",
+    "code: 408",
+    "status: 408",
+    "status=408",
+    '"code":408',
+    '"code": 408',
+    "408 request timeout",
+    "http 425",
+    "status 425",
+    "status code 425",
+    "code: 425",
+    "status: 425",
+    "status=425",
+    '"code":425',
+    '"code": 425',
+    "http 500",
+    "status 500",
+    "status code 500",
+    "code: 500",
+    "status: 500",
+    "status=500",
+    '"code":500',
+    '"code": 500',
+    "500 internal server error",
+    "http 502",
+    "status 502",
+    "status code 502",
+    "code: 502",
+    "status: 502",
+    "status=502",
+    '"code":502',
+    '"code": 502',
+    "502 bad gateway",
+    "http 503",
+    "status 503",
+    "status code 503",
+    "code: 503",
+    "status: 503",
+    "status=503",
+    '"code":503',
+    '"code": 503',
+    "503 service unavailable",
+    "http 504",
+    "status 504",
+    "status code 504",
+    "code: 504",
+    "status: 504",
+    "status=504",
+    '"code":504',
+    '"code": 504',
+    "504 gateway timeout"
+  ],
+  contextOverflow: [
+    "maximum context length",
+    "maximum context window",
+    "max context length",
+    "max context window",
+    "context window exceeded",
+    "context length exceeded",
+    "context length exceeds",
+    "context window is full",
+    "prompt is too long",
+    "prompt too long",
+    "input is too long",
+    "request is too long",
+    "too many tokens",
+    "token limit exceeded",
+    "exceeds the token limit",
+    "maximum number of tokens"
+    // Deliberately no bare 'context window' / 'token limit' / 'request exceeds'
+    // patterns: stderr that merely mentions these phrases is not an overflow,
+    // and misclassification here makes the run non-retryable.
+  ]
+};
+var ERROR_EXIT_CODES = {
+  rateLimit: [],
+  auth: [],
+  network: [7],
+  // curl-style network error
+  timeout: [124, 137, 143, 252],
+  // timeout command, SIGKILL, SIGTERM, bash timeout
+  validation: [2]
+  // Standard "usage error"
+};
+function matchesErrorPattern(lowerCombined, pattern) {
+  const normalizedPattern = pattern.toLowerCase();
+  if (/^\d+$/.test(normalizedPattern)) {
+    return new RegExp(`(^|\\D)${normalizedPattern}(\\D|$)`).test(lowerCombined);
+  }
+  return lowerCombined.includes(normalizedPattern);
+}
+function isRateLimitError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.rateLimit) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.rateLimit.includes(exitCode);
+}
+function isAuthError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.auth) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.auth.includes(exitCode);
+}
+function isNetworkError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.network) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.network.includes(exitCode);
+}
+function isTimeoutError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.timeout) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.timeout.includes(exitCode);
+}
+function isValidationError(combined, exitCode, patterns = DEFAULT_ERROR_PATTERNS.validation) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern)) || exitCode !== void 0 && ERROR_EXIT_CODES.validation.includes(exitCode);
+}
+function isContextOverflowError(combined, patterns = DEFAULT_ERROR_PATTERNS.contextOverflow) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern));
+}
+function isCapacityError(combined, _exitCode, patterns = DEFAULT_ERROR_PATTERNS.capacity) {
+  const lowerCombined = combined.toLowerCase();
+  return patterns.some((pattern) => matchesErrorPattern(lowerCombined, pattern));
+}
+function extractRetryAfter(combined, defaultSeconds = 60) {
+  const headerMatch = combined.match(/retry[- _]after["']?[:\s]+(\d+)/i);
+  if (headerMatch?.[1]) {
+    return parseInt(headerMatch[1], 10);
+  }
+  const naturalMatch = combined.match(/rate\s+limit[\s\S]{0,100}?(\d+)\s*seconds?/i);
+  if (naturalMatch?.[1]) {
+    return parseInt(naturalMatch[1], 10);
+  }
+  const waitMatch = combined.match(/(?:wait|try again in)\s+(\d+)\s*seconds?/i);
+  if (waitMatch?.[1]) {
+    return parseInt(waitMatch[1], 10);
+  }
+  return defaultSeconds;
+}
+function createRateLimitError(errorOutput, exitCode, providerName, defaultRetryAfter = 60) {
+  const retryAfterSeconds = extractRetryAfter(errorOutput, defaultRetryAfter);
+  return {
+    type: "rate_limit",
+    retryable: true,
+    retryAfter: retryAfterSeconds,
+    userMessage: `${providerName} API rate limit exceeded. Will retry after ${retryAfterSeconds}s cooldown.`,
+    debugInfo: {
+      exitCode,
+      retryAfterSeconds
+    },
+    originalError: errorOutput
+  };
+}
+function createAuthError(stderr, exitCode, authMessage, context, telemetryCallback) {
+  if (telemetryCallback && context) {
+    let errorType = "unknown";
+    const lowerStderr = stderr.toLowerCase();
+    const lowerMessage = authMessage.toLowerCase();
+    if (lowerStderr.includes("command not found") || lowerMessage.includes("not found")) {
+      errorType = "cli_not_found";
+    } else if (lowerStderr.includes("invalid") || lowerStderr.includes("expired") || lowerMessage.includes("invalid")) {
+      errorType = "token_invalid";
+    } else if (lowerStderr.includes("authentication") || lowerStderr.includes("login") || lowerMessage.includes("authentication") || lowerMessage.includes("login")) {
+      errorType = "auth_required";
+    }
+    telemetryCallback({
+      provider: context.provider,
+      stage: context.stage,
+      errorType,
+      errorMessage: authMessage,
+      suggestion: context.suggestion,
+      taskId: context.taskId,
+      exitCode
+    });
+  }
+  return {
+    type: "auth",
+    retryable: false,
+    userMessage: authMessage,
+    debugInfo: { exitCode },
+    originalError: stderr
+  };
+}
+function createNetworkError(stderr, exitCode, providerName, retryAfter = 5) {
+  return {
+    type: "network",
+    retryable: true,
+    retryAfter,
+    userMessage: `Network error connecting to ${providerName} API. Will retry with exponential backoff.`,
+    debugInfo: { exitCode },
+    originalError: stderr
+  };
+}
+function createTimeoutError(stderr, exitCode, timeoutMessage = "Execution timed out after configured timeout. Consider simplifying the task or splitting into smaller chunks.") {
+  return {
+    type: "timeout",
+    retryable: false,
+    userMessage: timeoutMessage,
+    debugInfo: { exitCode },
+    originalError: stderr
+  };
+}
+function createValidationError(stderr, stdout, exitCode, validationMessage) {
+  return {
+    type: "validation",
+    retryable: false,
+    userMessage: validationMessage,
+    debugInfo: { exitCode, stderr, stdout },
+    originalError: stderr
+  };
+}
+var CAPACITY_HTTP_STATUSES = [408, 425, 500, 502, 503, 504];
+function extractCapacityHttpStatus(errorText) {
+  const statusAlternation = CAPACITY_HTTP_STATUSES.join("|");
+  const trimmed = errorText.trim();
+  const bareLine = trimmed.match(new RegExp(`^(${statusAlternation})$`));
+  if (bareLine?.[1]) {
+    return parseInt(bareLine[1], 10);
+  }
+  const contextual = errorText.match(
+    new RegExp(
+      String.raw`(?:` + // HTTP 502 / http 502 / HTTP/502
+      String.raw`\bhttp\s*[/\s]\s*|` + // status 503 / status: 503 / status=503 / status code 503
+      String.raw`\bstatus(?:\s*code)?\s*[:=\s]\s*|` + // code: 504 / "code":504 / "code": 504
+      String.raw`(?:"code"|\bcode)\s*[:=]\s*|` + // code 504 (space-separated, no colon)
+      String.raw`\bcode\s+|` + // API Error: 503
+      String.raw`\bapi\s+error\s*[:=]\s*` + String.raw`)(${statusAlternation})\b`,
+      "i"
+    )
+  );
+  if (contextual?.[1]) {
+    return parseInt(contextual[1], 10);
+  }
+  const reasonPhrase = errorText.match(
+    new RegExp(
+      String.raw`\b(${statusAlternation})\s+(?:` + String.raw`service\s+unavailable|` + String.raw`internal\s+server\s+error|` + String.raw`bad\s+gateway|` + String.raw`gateway\s+timeout|` + String.raw`request\s+timeout|` + String.raw`too\s+early` + String.raw`)\b`,
+      "i"
+    )
+  );
+  if (reasonPhrase?.[1]) {
+    return parseInt(reasonPhrase[1], 10);
+  }
+  return void 0;
+}
+function createCapacityError(stderr, exitCode, providerName, retryAfter = 30) {
+  const httpStatus = extractCapacityHttpStatus(stderr);
+  const statusSuffix = httpStatus !== void 0 ? ` (${httpStatus})` : "";
+  return {
+    type: "capacity",
+    retryable: true,
+    retryAfter,
+    userMessage: `${providerName} service is temporarily unavailable${statusSuffix}. Will retry after ${retryAfter}s.`,
+    debugInfo: {
+      exitCode,
+      ...httpStatus !== void 0 ? { httpStatus } : {}
+    },
+    originalError: stderr
+  };
+}
+function createUnknownError(stderr, stdout, exitCode, providerName, retryAfter = 2) {
+  return {
+    type: "unknown",
+    retryable: true,
+    retryAfter,
+    userMessage: `${providerName} execution failed with exit code ${exitCode || "unknown"}. Error: ${stderr.slice(0, 200)}`,
+    debugInfo: {
+      exitCode,
+      stderrLength: stderr.length,
+      stdoutLength: stdout.length
+    },
+    originalError: stderr
+  };
+}
+function formatParsedError(parsed, providerName) {
+  const lines = [];
+  lines.push(`[${providerName} Error] Type: ${parsed.type}`);
+  lines.push(`[${providerName} Error] Retryable: ${parsed.retryable ? "yes" : "no"}`);
+  if (parsed.retryAfter) {
+    lines.push(`[${providerName} Error] Retry after: ${parsed.retryAfter}s`);
+  }
+  lines.push(`[${providerName} Error] Message: ${parsed.userMessage}`);
+  if (Object.keys(parsed.debugInfo).length > 0) {
+    lines.push(`[${providerName} Error] Debug: ${JSON.stringify(parsed.debugInfo)}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  VARIANT_WORKER_SIGTERM_SOURCE,
+  HostTimeoutError,
+  isHostTimeoutAbortReason,
+  providerAbortReasonFromSignal,
+  classifyHostTermination,
+  hostTimeoutUserMessage,
+  HOST_ABORT_USER_MESSAGE,
+  formatHostTimeoutTerminationDetail,
+  extractHostTimeoutLimitMs,
+  hostTerminationMetadataFromUnknown,
+  isHostCancellationError,
+  createHostTerminationParsedError,
+  parseHostTermination,
+  DEFAULT_ERROR_PATTERNS,
+  ERROR_EXIT_CODES,
+  matchesErrorPattern,
+  isRateLimitError,
+  isAuthError,
+  isNetworkError,
+  isTimeoutError,
+  isValidationError,
+  isContextOverflowError,
+  isCapacityError,
+  extractRetryAfter,
+  createRateLimitError,
+  createAuthError,
+  createNetworkError,
+  createTimeoutError,
+  createValidationError,
+  createCapacityError,
+  createUnknownError,
+  formatParsedError
+};
+//# sourceMappingURL=chunk-M6UHOC4I.js.map