@slates/provider 1.0.0-rc.27 → 1.0.0-rc.29

package/src/error/api.ts

@@ -1,4 +1,9 @@
 import { badRequestError, type ErrorRecord, ServiceError } from '@lowerdeck/error';
+import {
+  BAGGAGE_REDACTED_VALUE,
+  BAGGAGE_TRUNCATED_VALUE,
+  BAGGAGE_UNSERIALIZABLE_VALUE
+} from './utils';
 
 export type ApiErrorStatus = number | string;
 export type ApiServiceError = ServiceError<ErrorRecord<any, any>>;
@@ -21,6 +26,7 @@ export type ApiErrorBuildHelpers = {
   collectDetails: (value: unknown, details: string[], options?: ApiErrorDetailOptions) => void;
   extractMessage: (error: unknown, options?: ApiErrorDetailOptions) => string;
   getResponse: (error: unknown) => ApiErrorResponse | undefined;
+  getResponseWithBody: (error: unknown) => ApiErrorResponse | undefined;
   getStatus: (error: unknown) => ApiErrorStatus | undefined;
   isRecord: (value: unknown) => value is Record<string, unknown>;
   statusLabelFor: (status?: ApiErrorStatus, statusText?: string) => string;
@@ -143,6 +149,147 @@ export let getApiErrorResponse = (error: unknown): ApiErrorResponse | undefined
 export let getApiErrorStatus = (error: unknown): ApiErrorStatus | undefined =>
   getApiErrorResponse(error)?.status;
 
+// Like getApiErrorResponse, but also recovers the upstream response body from
+// interceptor-normalized SlateErrors. createAxios stores the body (sanitized by
+// sanitizeForBaggage) at SlateError.data.baggage.response, so provider-specific
+// message extractors need this to read upstream error details in production.
+export let getApiErrorResponseWithBody = (error: unknown): ApiErrorResponse | undefined => {
+  let response = getApiErrorResponse(error);
+  if (response?.data !== undefined) return response;
+  if (
+    !isApiErrorRecord(error) ||
+    error.name !== 'SlateError' ||
+    !isApiErrorRecord(error.data)
+  ) {
+    return response;
+  }
+
+  let baggage = isApiErrorRecord(error.data.baggage) ? error.data.baggage : undefined;
+  if (baggage?.response === undefined) return response;
+
+  return { ...response, data: baggage.response };
+};
+
+export let API_ERROR_MAX_DETAILS = 5;
+export let API_ERROR_MAX_MESSAGE_LENGTH = 1_000;
+
+// sanitizeForBaggage replaces values nested past its depth limit (and values cut
+// by its size budget) with this placeholder; it never carries a useful upstream message.
+// Kept as an alias of BAGGAGE_TRUNCATED_VALUE for existing importers.
+export let API_ERROR_TRUNCATED_PLACEHOLDER = BAGGAGE_TRUNCATED_VALUE;
+
+// Sanitized-baggage placeholders that stand in for removed values, never messages.
+let BAGGAGE_PLACEHOLDERS = new Set([
+  BAGGAGE_TRUNCATED_VALUE,
+  BAGGAGE_REDACTED_VALUE,
+  BAGGAGE_UNSERIALIZABLE_VALUE
+]);
+
+// Detects HTML error pages (gateway, proxy, or login pages) so they are not shown
+// as error messages. Requires a doctype, a leading <html>/<head> tag (pages may be
+// cut off by baggage truncation), a closing document tag, or a leading markup tag
+// with its closing tag, so plain text such as "<id> is required" or
+// "Invalid <body> parameter" survives.
+export let looksLikeHtmlErrorBody = (value: string) =>
+  /^\s*<!doctype\s+html\b/i.test(value) ||
+  /^\s*<(html|head)\b[^>]*>/i.test(value) ||
+  /<\/(html|head|body)\s*>/i.test(value) ||
+  /^\s*<(title|h[1-6]|p|div|pre|center)\b[^>]*>[\s\S]*<\/\1\s*>/i.test(value);
+
+export let truncateApiErrorMessage = (
+  value: string,
+  maxLength: number = API_ERROR_MAX_MESSAGE_LENGTH
+) => (value.length > maxLength ? `${value.slice(0, maxLength)}...` : value);
+
+export type ApiErrorTextOptions = {
+  // Accept numeric values (for example numeric provider error codes). Defaults to true.
+  includeNumbers?: boolean;
+};
+
+// Returns a trimmed, displayable error detail, or undefined for non-text values,
+// empty strings, sanitized-baggage placeholders, and HTML error pages.
+export let readApiErrorText = (value: unknown, options: ApiErrorTextOptions = {}) => {
+  if (
+    typeof value !== 'string' &&
+    (options.includeNumbers === false || typeof value !== 'number')
+  ) {
+    return undefined;
+  }
+
+  let text = String(value).trim();
+  if (!text || BAGGAGE_PLACEHOLDERS.has(text) || looksLikeHtmlErrorBody(text)) {
+    return undefined;
+  }
+
+  return text;
+};
+
+export type BoundedApiErrorDetailOptions = ApiErrorTextOptions & {
+  // Stop collecting once this many details are present. Defaults to 5.
+  maxDetails?: number;
+  // Prefix the detail as `${field}: ${text}` (for example a field validation error).
+  field?: string;
+};
+
+// Appends a unique, displayable detail while keeping the list bounded.
+export let pushBoundedApiErrorDetail = (
+  details: string[],
+  value: unknown,
+  options: BoundedApiErrorDetailOptions = {}
+) => {
+  if (details.length >= (options.maxDetails ?? API_ERROR_MAX_DETAILS)) return;
+
+  let text = readApiErrorText(value, options);
+  if (!text) return;
+
+  let detail = options.field ? `${options.field}: ${text}` : text;
+  if (!details.includes(detail)) {
+    details.push(detail);
+  }
+};
+
+export type DecodeApiErrorBodyOptions = {
+  // Only decode this many leading bytes of binary bodies.
+  maxBytes?: number;
+};
+
+// Text and binary (arraybuffer) responses carry provider JSON error bodies as
+// strings or bytes. Decode them so the JSON structure is available to message
+// extractors and survives sanitizeForBaggage. Returns parsed JSON when the text
+// is a JSON object/array, the trimmed text otherwise, and other values unchanged.
+export let decodeApiErrorBody = (
+  data: unknown,
+  options: DecodeApiErrorBodyOptions = {}
+): unknown => {
+  let text: string;
+
+  if (typeof data === 'string') {
+    text = data;
+  } else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+    let bytes: Uint8Array =
+      data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (options.maxBytes !== undefined && bytes.byteLength > options.maxBytes) {
+      bytes = bytes.subarray(0, options.maxBytes);
+    }
+    text = new TextDecoder('utf-8').decode(bytes);
+  } else {
+    return data;
+  }
+
+  let trimmed = text.trim();
+  if (/^[{[]/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      // Not JSON after all; fall back to the trimmed text.
+    }
+  }
+
+  return trimmed;
+};
+
 export let statusLabelForApiError = (status?: ApiErrorStatus, statusText?: string) =>
   status !== undefined ? `HTTP ${status}${statusText ? ` ${statusText}` : ''}: ` : '';
 
@@ -200,6 +347,7 @@ let helpers: ApiErrorBuildHelpers = {
   collectDetails: collectApiErrorDetails,
   extractMessage: extractApiErrorMessage,
   getResponse: getApiErrorResponse,
+  getResponseWithBody: getApiErrorResponseWithBody,
   getStatus: getApiErrorStatus,
   isRecord: isApiErrorRecord,
   statusLabelFor: statusLabelForApiError

package/src/error/axios.ts

@@ -1,14 +1,20 @@
 import type { AxiosError } from 'axios';
 import { isAxiosError } from 'axios';
+import type { AuthConfigSecretRedactor } from '../auth/redact';
+import { sanitizeUrl } from '../axios/trace';
 import { getCurrentContext } from '../context/hook';
 import type { SlateAxiosErrorOptions, SlateErrorResponse } from './types';
 import {
+  BAGGAGE_MAX_STRING_LENGTH,
+  BAGGAGE_RESPONSE_MAX_DEPTH,
+  getCurrentAuthConfigRedactor,
   getDefaultMessage,
   isRecord,
   mergeRecords,
   normalizeKind,
   normalizeRetryable,
   normalizeSlateErrorInput,
+  sanitizeErrorText,
   sanitizeForBaggage
 } from './utils';
 
@@ -98,18 +104,29 @@ let getHeaderValue = (headers: unknown, key: string): string | undefined => {
   return undefined;
 };
 
-let buildRequestUrl = (error: AxiosError) => {
+// Credentials embedded in URL paths (Telegram `/bot<token>/`, Alchemy `/v2/<apiKey>`)
+// are only recognizable with the auth-config redactor, mirroring HTTP traces.
+let sanitizeRequestUrl = (url: string, redactor?: AuthConfigSecretRedactor) => {
+  try {
+    return sanitizeUrl(url, redactor);
+  } catch {
+    return sanitizeUrl(url);
+  }
+};
+
+let buildRequestUrl = (error: AxiosError, redactor?: AuthConfigSecretRedactor) => {
   let baseURL = error.config?.baseURL;
   let url = error.config?.url;
 
   if (!url) return undefined;
-  if (!baseURL) return url;
+  if (!baseURL) return sanitizeRequestUrl(url, redactor);
 
+  let absoluteUrl = url;
   try {
-    return new URL(url, baseURL).toString();
-  } catch {
-    return url;
-  }
+    absoluteUrl = new URL(url, baseURL).toString();
+  } catch {}
+
+  return sanitizeRequestUrl(absoluteUrl, redactor);
 };
 
 let getProviderDefaults = (): Partial<SlateErrorResponse> => {
@@ -158,13 +175,26 @@ let inferAxiosCode = (error: AxiosError, data: unknown) => {
   return 'upstream.error';
 };
 
-let inferAxiosMessage = (error: AxiosError, data: unknown, code: string) => {
-  return (
+// Upstream bodies can echo credentials back (request dumps, debug fields), so the
+// inferred message is scrubbed and bounded before it becomes SlateError.message.
+let inferAxiosMessage = (
+  error: AxiosError,
+  data: unknown,
+  code: string,
+  redactor?: AuthConfigSecretRedactor
+) => {
+  let message =
     getNestedMessage(data) ??
     error.response?.statusText ??
     error.message ??
-    getDefaultMessage(code)
-  );
+    getDefaultMessage(code);
+
+  // Scrub before cutting so the cut cannot leave a credential fragment the patterns
+  // no longer recognize; sanitizeErrorText bounds its own scan.
+  let scrubbed = sanitizeErrorText(message, redactor ?? null);
+  return scrubbed.length > BAGGAGE_MAX_STRING_LENGTH
+    ? `${scrubbed.slice(0, BAGGAGE_MAX_STRING_LENGTH)}...`
+    : scrubbed;
 };
 
 let inferAxiosRetryable = (error: AxiosError, code: string) => {
@@ -184,12 +214,14 @@ export let inferSlateErrorFromAxios = (
     : undefined;
 
   let code = inferAxiosCode(error, responseData);
+  let redactor = getCurrentAuthConfigRedactor();
 
   return normalizeSlateErrorInput({
     ...getProviderDefaults(),
     ...options.defaults,
     code: options.defaults?.code ?? code,
-    message: options.defaults?.message ?? inferAxiosMessage(error, responseData, code),
+    message:
+      options.defaults?.message ?? inferAxiosMessage(error, responseData, code, redactor),
     kind: options.defaults?.kind ?? normalizeKind(options.defaults?.code ?? code),
     retryable:
       options.defaults?.retryable ??
@@ -210,11 +242,14 @@ export let inferSlateErrorFromAxios = (
         getHeaderValue(error.response?.headers, 'x-correlation-id') ??
         options.defaults?.upstream?.requestId,
       method: error.config?.method?.toUpperCase() ?? options.defaults?.upstream?.method,
-      url: buildRequestUrl(error) ?? options.defaults?.upstream?.url
+      url: buildRequestUrl(error, redactor) ?? options.defaults?.upstream?.url
     },
     baggage: mergeRecords(options.defaults?.baggage, {
       axiosCode: error.code,
-      response: sanitizeForBaggage(responseData)
+      response: sanitizeForBaggage(responseData, {
+        maxDepth: BAGGAGE_RESPONSE_MAX_DEPTH,
+        redactor: redactor ?? null
+      })
     })
   });
 };