recker 1.0.34 → 1.0.35-next.1b43fea

package/dist/browser/core/client.js

@@ -16,6 +16,8 @@ import { dedupPlugin } from '../plugins/dedup.js';
 import { createXSRFMiddleware } from '../plugins/xsrf.js';
 import { createCompressionMiddleware } from '../plugins/compression.js';
 import { serializeXML } from '../plugins/xml.js';
+import { serializeYaml } from '../plugins/yaml.js';
+import { serializeCsv } from '../plugins/csv.js';
 import { MemoryStorage } from '../cache/memory-storage.js';
 import { FileStorage } from '../cache/basic-file-storage.js';
 import { RequestRunner } from '../runner/request-runner.js';
@@ -509,7 +511,7 @@ export class Client {
             }
         }
         actualOptions = actualOptions || {};
-        const { json, form, xml, ...restOptions } = actualOptions;
+        const { json, form, xml, yaml, csv, ...restOptions } = actualOptions;
         let finalBody = actualBody;
         let explicitContentType;
         if (form !== undefined) {
@@ -524,6 +526,14 @@ export class Client {
             finalBody = '<?xml version="1.0" encoding="UTF-8"?>\n' + serializeXML(xml);
             explicitContentType = 'application/xml';
         }
+        else if (yaml !== undefined) {
+            finalBody = serializeYaml(yaml);
+            explicitContentType = 'application/yaml';
+        }
+        else if (csv !== undefined) {
+            finalBody = serializeCsv(csv);
+            explicitContentType = 'text/csv';
+        }
         else if (restOptions.body !== undefined) {
             finalBody = restOptions.body;
         }

package/dist/browser/core/error-handler.d.ts

@@ -0,0 +1,44 @@
+export type ErrorSeverity = 'error' | 'warning' | 'info';
+export interface ErrorCategory {
+    type: string;
+    label: string;
+    color: 'red' | 'yellow' | 'cyan' | 'gray' | 'magenta';
+    retriable: boolean;
+    retryDelay?: number;
+}
+export interface ClassifiedError {
+    original: Error | string;
+    category: ErrorCategory;
+    message: string;
+    explanation: string;
+    suggestion: string;
+    retry: {
+        should: boolean;
+        afterMs?: number;
+        reason?: string;
+    };
+    context?: Record<string, unknown>;
+}
+export declare const ERROR_CATEGORIES: Record<string, ErrorCategory>;
+export declare function classifyError(error: Error | string | unknown, context?: Record<string, unknown>): ClassifiedError;
+export declare function formatErrorForTerminal(classified: ClassifiedError, options?: {
+    verbose?: boolean;
+    colors?: {
+        red: (s: string) => string;
+        yellow: (s: string) => string;
+        cyan: (s: string) => string;
+        gray: (s: string) => string;
+        magenta: (s: string) => string;
+        bold: (s: string) => string;
+        green: (s: string) => string;
+    };
+}): string;
+export declare function formatErrorForJson(classified: ClassifiedError): Record<string, unknown>;
+export declare function isRetriable(error: Error | string | unknown): boolean;
+export declare function getRetryDelay(error: Error | string | unknown, context?: Record<string, unknown>): number;
+export declare function getUserFriendlyMessage(error: Error | string | unknown): string;
+export declare function createErrorReport(error: Error | string | unknown, context?: Record<string, unknown>): {
+    summary: string;
+    details: ClassifiedError;
+    formatted: string;
+};

package/dist/browser/core/error-handler.js

@@ -0,0 +1,520 @@
+export const ERROR_CATEGORIES = {
+    HTTP_400: {
+        type: 'HTTP_400',
+        label: 'Bad Request',
+        color: 'yellow',
+        retriable: false,
+    },
+    HTTP_401: {
+        type: 'HTTP_401',
+        label: 'Unauthorized',
+        color: 'yellow',
+        retriable: false,
+    },
+    HTTP_403: {
+        type: 'HTTP_403',
+        label: 'Forbidden',
+        color: 'yellow',
+        retriable: false,
+    },
+    HTTP_404: {
+        type: 'HTTP_404',
+        label: 'Not Found',
+        color: 'yellow',
+        retriable: false,
+    },
+    HTTP_405: {
+        type: 'HTTP_405',
+        label: 'Method Not Allowed',
+        color: 'yellow',
+        retriable: false,
+    },
+    HTTP_408: {
+        type: 'HTTP_408',
+        label: 'Request Timeout',
+        color: 'yellow',
+        retriable: true,
+        retryDelay: 1000,
+    },
+    HTTP_429: {
+        type: 'HTTP_429',
+        label: 'Rate Limited',
+        color: 'magenta',
+        retriable: true,
+        retryDelay: 60000,
+    },
+    HTTP_5XX: {
+        type: 'HTTP_5XX',
+        label: 'Server Error',
+        color: 'red',
+        retriable: true,
+        retryDelay: 5000,
+    },
+    TIMEOUT: {
+        type: 'TIMEOUT',
+        label: 'Timeout',
+        color: 'yellow',
+        retriable: true,
+        retryDelay: 2000,
+    },
+    DNS: {
+        type: 'DNS',
+        label: 'DNS Error',
+        color: 'red',
+        retriable: true,
+        retryDelay: 5000,
+    },
+    CONNECTION_REFUSED: {
+        type: 'CONN_REFUSED',
+        label: 'Connection Refused',
+        color: 'red',
+        retriable: true,
+        retryDelay: 5000,
+    },
+    CONNECTION_RESET: {
+        type: 'CONN_RESET',
+        label: 'Connection Reset',
+        color: 'red',
+        retriable: true,
+        retryDelay: 2000,
+    },
+    CONNECTION_CLOSED: {
+        type: 'CONN_CLOSED',
+        label: 'Connection Closed',
+        color: 'red',
+        retriable: true,
+        retryDelay: 1000,
+    },
+    NETWORK_UNREACHABLE: {
+        type: 'NET_UNREACHABLE',
+        label: 'Network Unreachable',
+        color: 'red',
+        retriable: true,
+        retryDelay: 10000,
+    },
+    TLS_CERT_EXPIRED: {
+        type: 'TLS_EXPIRED',
+        label: 'Certificate Expired',
+        color: 'red',
+        retriable: false,
+    },
+    TLS_CERT_INVALID: {
+        type: 'TLS_INVALID',
+        label: 'Invalid Certificate',
+        color: 'red',
+        retriable: false,
+    },
+    TLS_HANDSHAKE: {
+        type: 'TLS_HANDSHAKE',
+        label: 'TLS Handshake Failed',
+        color: 'red',
+        retriable: true,
+        retryDelay: 2000,
+    },
+    TLS_PROTOCOL: {
+        type: 'TLS_PROTOCOL',
+        label: 'TLS Protocol Error',
+        color: 'red',
+        retriable: false,
+    },
+    AUTH_MISSING: {
+        type: 'AUTH_MISSING',
+        label: 'Missing Credentials',
+        color: 'yellow',
+        retriable: false,
+    },
+    AUTH_INVALID: {
+        type: 'AUTH_INVALID',
+        label: 'Invalid Credentials',
+        color: 'yellow',
+        retriable: false,
+    },
+    AUTH_EXPIRED: {
+        type: 'AUTH_EXPIRED',
+        label: 'Token Expired',
+        color: 'yellow',
+        retriable: true,
+        retryDelay: 0,
+    },
+    PARSE_JSON: {
+        type: 'PARSE_JSON',
+        label: 'Invalid JSON',
+        color: 'yellow',
+        retriable: false,
+    },
+    PARSE_XML: {
+        type: 'PARSE_XML',
+        label: 'Invalid XML',
+        color: 'yellow',
+        retriable: false,
+    },
+    PARSE_HTML: {
+        type: 'PARSE_HTML',
+        label: 'Invalid HTML',
+        color: 'yellow',
+        retriable: false,
+    },
+    PROTOCOL_FTP: {
+        type: 'FTP_ERROR',
+        label: 'FTP Error',
+        color: 'red',
+        retriable: true,
+        retryDelay: 2000,
+    },
+    PROTOCOL_WEBSOCKET: {
+        type: 'WS_ERROR',
+        label: 'WebSocket Error',
+        color: 'red',
+        retriable: true,
+        retryDelay: 1000,
+    },
+    PROTOCOL_GRAPHQL: {
+        type: 'GRAPHQL_ERROR',
+        label: 'GraphQL Error',
+        color: 'yellow',
+        retriable: false,
+    },
+    UNKNOWN: {
+        type: 'UNKNOWN',
+        label: 'Unknown Error',
+        color: 'red',
+        retriable: false,
+    },
+};
+const ERROR_SUGGESTIONS = {
+    HTTP_400: {
+        explanation: 'The server could not understand the request due to invalid syntax.',
+        suggestion: 'Check the request body, headers, and URL parameters. Ensure JSON is valid if sending JSON data.',
+    },
+    HTTP_401: {
+        explanation: 'Authentication is required but was not provided or is invalid.',
+        suggestion: 'Check your API key, token, or credentials. Ensure the Authorization header is correct.',
+    },
+    HTTP_403: {
+        explanation: 'You do not have permission to access this resource.',
+        suggestion: 'Verify you have the correct permissions. Check API scopes or contact the API administrator.',
+    },
+    HTTP_404: {
+        explanation: 'The requested resource was not found on the server.',
+        suggestion: 'Check the URL path for typos. The resource may have been moved or deleted.',
+    },
+    HTTP_405: {
+        explanation: 'The HTTP method is not allowed for this endpoint.',
+        suggestion: 'Check the API documentation for allowed methods (GET, POST, PUT, DELETE, etc.).',
+    },
+    HTTP_408: {
+        explanation: 'The server timed out waiting for the request.',
+        suggestion: 'Retry the request. If it persists, check your network connection or try later.',
+    },
+    HTTP_429: {
+        explanation: 'You have sent too many requests in a given time period (rate limited).',
+        suggestion: 'Wait before retrying. Check the Retry-After header for the wait time. Consider reducing request frequency.',
+    },
+    HTTP_5XX: {
+        explanation: 'The server encountered an internal error.',
+        suggestion: 'This is a server-side issue. Wait and retry. If persistent, contact the API provider.',
+    },
+    TIMEOUT: {
+        explanation: 'The request took too long and was aborted.',
+        suggestion: 'Increase the timeout setting, reduce payload size, or check if the server is responding slowly.',
+    },
+    DNS: {
+        explanation: 'The domain name could not be resolved to an IP address.',
+        suggestion: 'Check the domain spelling. Verify DNS configuration. Try a different DNS server (8.8.8.8).',
+    },
+    CONN_REFUSED: {
+        explanation: 'The server actively refused the connection.',
+        suggestion: 'Verify the server is running and the port is correct. Check firewall rules.',
+    },
+    CONN_RESET: {
+        explanation: 'The connection was forcibly closed by the server.',
+        suggestion: 'The server may be overloaded. Retry after a brief delay. Check for rate limiting.',
+    },
+    CONN_CLOSED: {
+        explanation: 'The connection was closed unexpectedly.',
+        suggestion: 'The server may have closed idle connections. Retry the request.',
+    },
+    NET_UNREACHABLE: {
+        explanation: 'The network is unreachable.',
+        suggestion: 'Check your internet connection. Verify VPN or proxy settings.',
+    },
+    TLS_EXPIRED: {
+        explanation: 'The server\'s SSL certificate has expired.',
+        suggestion: 'Contact the server administrator to renew the certificate. Do NOT bypass SSL verification in production.',
+    },
+    TLS_INVALID: {
+        explanation: 'The server\'s SSL certificate is invalid or self-signed.',
+        suggestion: 'Verify you\'re connecting to the correct server. For testing, you can use rejectUnauthorized: false.',
+    },
+    TLS_HANDSHAKE: {
+        explanation: 'The TLS handshake failed.',
+        suggestion: 'The server may have TLS configuration issues. Try again or check supported TLS versions.',
+    },
+    TLS_PROTOCOL: {
+        explanation: 'TLS protocol error occurred.',
+        suggestion: 'The server may not support your TLS version. Try specifying a different TLS version.',
+    },
+    AUTH_MISSING: {
+        explanation: 'No authentication credentials were provided.',
+        suggestion: 'Set the required environment variable (e.g., OPENAI_API_KEY) or pass credentials in the request.',
+    },
+    AUTH_INVALID: {
+        explanation: 'The provided credentials are invalid.',
+        suggestion: 'Regenerate your API key or token. Ensure you\'re using the correct credentials.',
+    },
+    AUTH_EXPIRED: {
+        explanation: 'The authentication token has expired.',
+        suggestion: 'Refresh your token and retry. Enable automatic token refresh if available.',
+    },
+    PARSE_JSON: {
+        explanation: 'The response is not valid JSON.',
+        suggestion: 'The server may have returned HTML error page or plain text. Check the raw response.',
+    },
+    PARSE_XML: {
+        explanation: 'The response is not valid XML.',
+        suggestion: 'Verify the endpoint returns XML. Check for encoding issues.',
+    },
+    PARSE_HTML: {
+        explanation: 'Failed to parse HTML content.',
+        suggestion: 'The HTML may be malformed. Try a more lenient parser or check the source.',
+    },
+    FTP_ERROR: {
+        explanation: 'An FTP operation failed.',
+        suggestion: 'Check credentials, path permissions, and server status. Ensure passive mode if behind NAT.',
+    },
+    WS_ERROR: {
+        explanation: 'WebSocket connection or operation failed.',
+        suggestion: 'Check the WebSocket URL (ws:// or wss://). Verify the server supports WebSocket.',
+    },
+    GRAPHQL_ERROR: {
+        explanation: 'The GraphQL query returned errors.',
+        suggestion: 'Check the query syntax and field names. Verify required variables are provided.',
+    },
+    UNKNOWN: {
+        explanation: 'An unexpected error occurred.',
+        suggestion: 'Check the error details. If the issue persists, report it with the full error message.',
+    },
+};
+export function classifyError(error, context) {
+    const errorStr = error instanceof Error ? error.message : String(error);
+    const errorLower = errorStr.toLowerCase();
+    const httpStatusMatch = errorStr.match(/(?:status|code)[:\s]*(\d{3})/i) ||
+        errorStr.match(/HTTP[\/\s]*\d*\.?\d*[:\s]*(\d{3})/i) ||
+        errorStr.match(/^(\d{3})\s/);
+    if (httpStatusMatch) {
+        const status = parseInt(httpStatusMatch[1]);
+        return classifyHttpError(status, error, context);
+    }
+    if (errorLower.includes('timeout') || errorLower.includes('etimedout') || errorLower.includes('timed out')) {
+        return buildClassifiedError('TIMEOUT', error, context);
+    }
+    if (errorLower.includes('enotfound') || errorLower.includes('getaddrinfo') ||
+        errorLower.includes('dns') && errorLower.includes('fail')) {
+        return buildClassifiedError('DNS', error, context);
+    }
+    if (errorLower.includes('econnrefused') || errorLower.includes('connection refused')) {
+        return buildClassifiedError('CONNECTION_REFUSED', error, context);
+    }
+    if (errorLower.includes('econnreset') || errorLower.includes('connection reset')) {
+        return buildClassifiedError('CONNECTION_RESET', error, context);
+    }
+    if (errorLower.includes('socket hang up') || errorLower.includes('epipe') ||
+        errorLower.includes('closed')) {
+        return buildClassifiedError('CONNECTION_CLOSED', error, context);
+    }
+    if (errorLower.includes('enetunreach') || errorLower.includes('network unreachable') ||
+        errorLower.includes('ehostunreach')) {
+        return buildClassifiedError('NETWORK_UNREACHABLE', error, context);
+    }
+    if (errorLower.includes('certificate') && errorLower.includes('expired')) {
+        return buildClassifiedError('TLS_CERT_EXPIRED', error, context);
+    }
+    if (errorLower.includes('self signed') || errorLower.includes('unable to verify') ||
+        (errorLower.includes('certificate') && errorLower.includes('invalid'))) {
+        return buildClassifiedError('TLS_CERT_INVALID', error, context);
+    }
+    if (errorLower.includes('handshake') || errorLower.includes('ssl_error_handshake')) {
+        return buildClassifiedError('TLS_HANDSHAKE', error, context);
+    }
+    if (errorLower.includes('ssl') || errorLower.includes('tls')) {
+        return buildClassifiedError('TLS_PROTOCOL', error, context);
+    }
+    if (errorLower.includes('api key') || errorLower.includes('apikey') ||
+        (errorLower.includes('missing') && errorLower.includes('credential'))) {
+        return buildClassifiedError('AUTH_MISSING', error, context);
+    }
+    if (errorLower.includes('invalid') && (errorLower.includes('key') || errorLower.includes('token'))) {
+        return buildClassifiedError('AUTH_INVALID', error, context);
+    }
+    if (errorLower.includes('expired') && (errorLower.includes('token') || errorLower.includes('auth'))) {
+        return buildClassifiedError('AUTH_EXPIRED', error, context);
+    }
+    if (errorLower.includes('json') && (errorLower.includes('parse') || errorLower.includes('unexpected'))) {
+        return buildClassifiedError('PARSE_JSON', error, context);
+    }
+    if (errorLower.includes('xml') && (errorLower.includes('parse') || errorLower.includes('invalid'))) {
+        return buildClassifiedError('PARSE_XML', error, context);
+    }
+    if (errorLower.includes('ftp')) {
+        return buildClassifiedError('PROTOCOL_FTP', error, context);
+    }
+    if (errorLower.includes('websocket') || errorLower.includes('ws://')) {
+        return buildClassifiedError('PROTOCOL_WEBSOCKET', error, context);
+    }
+    if (errorLower.includes('graphql')) {
+        return buildClassifiedError('PROTOCOL_GRAPHQL', error, context);
+    }
+    return buildClassifiedError('UNKNOWN', error, context);
+}
+function classifyHttpError(status, error, context) {
+    if (status === 400)
+        return buildClassifiedError('HTTP_400', error, context, { status });
+    if (status === 401)
+        return buildClassifiedError('HTTP_401', error, context, { status });
+    if (status === 403)
+        return buildClassifiedError('HTTP_403', error, context, { status });
+    if (status === 404)
+        return buildClassifiedError('HTTP_404', error, context, { status });
+    if (status === 405)
+        return buildClassifiedError('HTTP_405', error, context, { status });
+    if (status === 408)
+        return buildClassifiedError('HTTP_408', error, context, { status });
+    if (status === 429)
+        return buildClassifiedError('HTTP_429', error, context, { status });
+    if (status >= 500 && status < 600) {
+        return buildClassifiedError('HTTP_5XX', error, context, { status });
+    }
+    if (status >= 400 && status < 500) {
+        const category = {
+            type: `HTTP_${status}`,
+            label: `HTTP ${status}`,
+            color: 'yellow',
+            retriable: false,
+        };
+        return {
+            original: error instanceof Error ? error : new Error(String(error)),
+            category,
+            message: `HTTP ${status} error`,
+            explanation: `The server returned status code ${status}.`,
+            suggestion: 'Check the API documentation for this status code.',
+            retry: { should: false },
+            context,
+        };
+    }
+    return buildClassifiedError('UNKNOWN', error, context);
+}
+function buildClassifiedError(categoryKey, error, context, extra) {
+    const category = ERROR_CATEGORIES[categoryKey] || ERROR_CATEGORIES.UNKNOWN;
+    const suggestions = ERROR_SUGGESTIONS[category.type] || ERROR_SUGGESTIONS.UNKNOWN;
+    let retryAfterMs = category.retryDelay;
+    if (context?.retryAfter) {
+        const retryAfter = context.retryAfter;
+        if (typeof retryAfter === 'number') {
+            retryAfterMs = retryAfter * 1000;
+        }
+        else if (typeof retryAfter === 'string') {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds)) {
+                retryAfterMs = seconds * 1000;
+            }
+            else {
+                const date = new Date(retryAfter);
+                if (!isNaN(date.getTime())) {
+                    retryAfterMs = Math.max(0, date.getTime() - Date.now());
+                }
+            }
+        }
+    }
+    return {
+        original: error instanceof Error ? error : new Error(String(error)),
+        category,
+        message: `${category.label}`,
+        explanation: suggestions.explanation,
+        suggestion: suggestions.suggestion,
+        retry: {
+            should: category.retriable,
+            afterMs: category.retriable ? retryAfterMs : undefined,
+            reason: category.retriable
+                ? `This error is usually temporary. Retry after ${formatRetryDelay(retryAfterMs)}.`
+                : 'This error requires fixing the request or configuration.',
+        },
+        context: { ...context, ...extra },
+    };
+}
+function formatRetryDelay(ms) {
+    if (!ms)
+        return 'a moment';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${Math.ceil(ms / 1000)}s`;
+    if (ms < 3600000)
+        return `${Math.ceil(ms / 60000)} minute${ms >= 120000 ? 's' : ''}`;
+    return `${Math.ceil(ms / 3600000)} hour${ms >= 7200000 ? 's' : ''}`;
+}
+export function formatErrorForTerminal(classified, options = {}) {
+    const colors = options.colors || {
+        red: (s) => s,
+        yellow: (s) => s,
+        cyan: (s) => s,
+        gray: (s) => s,
+        magenta: (s) => s,
+        bold: (s) => s,
+        green: (s) => s,
+    };
+    const colorFn = colors[classified.category.color] || colors.red;
+    const lines = [];
+    lines.push(`${colorFn('Error:')} ${classified.message}`);
+    lines.push(`${colors.gray(classified.explanation)}`);
+    lines.push('');
+    lines.push(`${colors.cyan('Fix:')} ${classified.suggestion}`);
+    if (classified.retry.should) {
+        const retryMsg = classified.retry.afterMs
+            ? `Retry after ${formatRetryDelay(classified.retry.afterMs)}`
+            : 'Safe to retry immediately';
+        lines.push(`${colors.green('Retry:')} ${retryMsg}`);
+    }
+    if (options.verbose && classified.original instanceof Error) {
+        lines.push('');
+        lines.push(colors.gray('Original error:'));
+        lines.push(colors.gray(`  ${classified.original.message}`));
+        if (classified.original.stack) {
+            const stackLines = classified.original.stack.split('\n').slice(1, 4);
+            stackLines.forEach((line) => lines.push(colors.gray(`  ${line.trim()}`)));
+        }
+    }
+    return lines.join('\n');
+}
+export function formatErrorForJson(classified) {
+    return {
+        error: {
+            type: classified.category.type,
+            label: classified.category.label,
+            message: classified.message,
+            explanation: classified.explanation,
+            suggestion: classified.suggestion,
+            retriable: classified.retry.should,
+            retryAfterMs: classified.retry.afterMs,
+            context: classified.context,
+        },
+    };
+}
+export function isRetriable(error) {
+    return classifyError(error).retry.should;
+}
+export function getRetryDelay(error, context) {
+    const classified = classifyError(error, context);
+    return classified.retry.afterMs || 1000;
+}
+export function getUserFriendlyMessage(error) {
+    const classified = classifyError(error);
+    return `${classified.message}: ${classified.explanation}`;
+}
+export function createErrorReport(error, context) {
+    const classified = classifyError(error, context);
+    return {
+        summary: getUserFriendlyMessage(error),
+        details: classified,
+        formatted: formatErrorForTerminal(classified, { verbose: true }),
+    };
+}

package/dist/browser/core/request-promise.d.ts

@@ -1,5 +1,7 @@
 import { ReckerResponse, SSEEvent, ProgressEvent } from '../types/index.js';
 import type { ZodSchema } from 'zod';
+import { type YamlParseOptions } from '../plugins/yaml.js';
+import { type CsvParseOptions } from '../plugins/csv.js';
 export declare class RequestPromise<T = unknown> implements Promise<ReckerResponse<T>> {
     private promise;
     private abortController?;
@@ -10,6 +12,8 @@ export declare class RequestPromise<T = unknown> implements Promise<ReckerRespon
     finally(onfinally?: (() => void) | null): Promise<ReckerResponse<T>>;
     cancel(): void;
     json<R = T>(): Promise<R>;
+    yaml<R = T>(options?: YamlParseOptions): Promise<R>;
+    csv<R = Record<string, string>>(options?: CsvParseOptions): Promise<R[]>;
     text(): Promise<string>;
     cleanText(): Promise<string>;
     blob(): Promise<Blob>;

package/dist/browser/core/request-promise.js

@@ -3,6 +3,8 @@ import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
 import { tryFn } from '../utils/try-fn.js';
 import { StreamError } from './errors.js';
+import { parseYaml } from '../plugins/yaml.js';
+import { parseCsv } from '../plugins/csv.js';
 export class RequestPromise {
     promise;
     abortController;
@@ -31,6 +33,16 @@ export class RequestPromise {
         const response = await this.promise;
         return response.json();
     }
+    async yaml(options) {
+        const response = await this.promise;
+        const text = await response.text();
+        return parseYaml(text, options);
+    }
+    async csv(options) {
+        const response = await this.promise;
+        const text = await response.text();
+        return parseCsv(text, options);
+    }
     async text() {
         const response = await this.promise;
         return response.text();

package/dist/browser/core/response.d.ts

@@ -3,6 +3,8 @@ import { Dispatcher } from 'undici';
 import { type HeaderInfo, type CacheInfo, type RateLimitInfo } from '../utils/header-parser.js';
 import { type LinkHeaderParser } from '../utils/link-header.js';
 import type { Readable } from 'node:stream';
+import { type YamlParseOptions } from '../plugins/yaml.js';
+import { type CsvParseOptions } from '../plugins/csv.js';
 export declare class HttpResponse<T = unknown> implements ReckerResponse<T> {
     readonly timings?: Timings;
     readonly connection?: ConnectionInfo;
@@ -21,6 +23,8 @@ export declare class HttpResponse<T = unknown> implements ReckerResponse<T> {
     links(): LinkHeaderParser | null;
     get headerInfo(): HeaderInfo;
     json<R = T>(): Promise<R>;
+    yaml<R = T>(options?: YamlParseOptions): Promise<R>;
+    csv<R = Record<string, string>>(options?: CsvParseOptions): Promise<R[]>;
     text(): Promise<string>;
     cleanText(): Promise<string>;
     blob(): Promise<Blob>;

package/dist/browser/core/response.js

@@ -4,6 +4,8 @@ import { webToNodeStream } from '../utils/streaming.js';
 import { parseHeaders } from '../utils/header-parser.js';
 import { parseLinkHeader } from '../utils/link-header.js';
 import { StreamError } from './errors.js';
+import { parseYaml } from '../plugins/yaml.js';
+import { parseCsv } from '../plugins/csv.js';
 export class HttpResponse {
     timings;
     connection;
@@ -52,6 +54,14 @@ export class HttpResponse {
     async json() {
         return (await this.raw.json());
     }
+    async yaml(options) {
+        const text = await this.raw.text();
+        return parseYaml(text, options);
+    }
+    async csv(options) {
+        const text = await this.raw.text();
+        return parseCsv(text, options);
+    }
     async text() {
         return this.raw.text();
     }