@outputai/http 0.2.0 → 0.2.1-next.fd72d95.0

package/dist/fetch/index.d.ts

@@ -0,0 +1,22 @@
+import type { RequestInfo, RequestInit } from 'undici';
+/** Re-export undici library for convenience. */
+export * as undici from 'undici';
+/** Export fetch input types. Also available under in undici.* export. */
+export type { 
+/** Undici's fetch first argument: Either a URL string, a URL object or a undici.Request object. */
+RequestInfo, 
+/** Undici's fetch second argument: A plain object containing HTTP options. */
+RequestInit };
+/**
+ * A fetch compliant function, that wraps undici's fetch.
+ *
+ * Behaves the same as any fetch function except:
+ * - Sets a request header called `x-request--trace-id` with a random UUID;
+ * - Sends the request, response, error and/or failure to the Trace system;
+ *
+ * @see {@link https://fetch.spec.whatwg.org/}
+ * @param input - URL string, URL object or Request object (undici's or Node's)
+ * @param init - Request options
+ * @returns The HTTP response
+ */
+export declare const fetch: (input: RequestInfo | Request, init?: RequestInit) => Promise<Response>;

package/dist/fetch/index.js

@@ -0,0 +1,45 @@
+import * as undici from 'undici';
+import { randomUUID } from 'node:crypto';
+import { logRequest, logResponse, logError, logFailure } from './logger.js';
+/*
+ * Unifies undici and nodes realms
+ * https://github.com/nodejs/undici#keep-fetch-and-formdata-together
+ */
+undici.install();
+/** Re-export undici library for convenience. */
+export * as undici from 'undici';
+/**
+ * A fetch compliant function, that wraps undici's fetch.
+ *
+ * Behaves the same as any fetch function except:
+ * - Sets a request header called `x-request--trace-id` with a random UUID;
+ * - Sends the request, response, error and/or failure to the Trace system;
+ *
+ * @see {@link https://fetch.spec.whatwg.org/}
+ * @param input - URL string, URL object or Request object (undici's or Node's)
+ * @param init - Request options
+ * @returns The HTTP response
+ */
+export const fetch = async (input, init) => {
+    // Creates a Request object with the many shapes RequestInfo can have
+    const base = new undici.Request(input, init);
+    // Creates a headers object with the many shapes Request.Headers can have (object, array, Headers)
+    const headers = new undici.Headers(base.headers);
+    const requestId = randomUUID();
+    headers.set('x-request-trace-id', requestId);
+    const request = new undici.Request(base, { headers });
+    await logRequest({ requestId, request });
+    try {
+        const response = await undici.fetch(request);
+        if (response.status > 399) {
+            await logError({ requestId, response });
+            return response;
+        }
+        await logResponse({ requestId, response });
+        return response;
+    }
+    catch (error) {
+        logFailure({ requestId, error: error });
+        throw error;
+    }
+};

package/dist/fetch/index.spec.js

@@ -0,0 +1,206 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getGlobalDispatcher, Headers, MockAgent, Request, setGlobalDispatcher } from 'undici';
+const FIXED_REQUEST_ID = 'aaaaaaaa-bbbb-4ccc-dddd-eeeeeeeeeeee';
+const randomUUIDMock = vi.hoisted(() => vi.fn(() => FIXED_REQUEST_ID));
+const loggerMock = vi.hoisted(() => ({
+    logRequest: vi.fn(async (_args) => { }),
+    logResponse: vi.fn(async (_args) => { }),
+    logError: vi.fn((_args) => { }),
+    logFailure: vi.fn((_args) => { })
+}));
+vi.mock('node:crypto', () => ({
+    randomUUID: () => randomUUIDMock()
+}));
+vi.mock('./logger.js', () => ({
+    logRequest: loggerMock.logRequest,
+    logResponse: loggerMock.logResponse,
+    logError: loggerMock.logError,
+    logFailure: loggerMock.logFailure
+}));
+import { fetch } from './index.js';
+const MOCK_ORIGIN = 'https://fetch-index.undici.test';
+describe('fetch/index', () => {
+    const undiciCtx = {
+        mockAgent: undefined,
+        previousDispatcher: undefined
+    };
+    beforeEach(() => {
+        undiciCtx.mockAgent = new MockAgent();
+        undiciCtx.mockAgent.disableNetConnect();
+        undiciCtx.previousDispatcher = getGlobalDispatcher();
+        setGlobalDispatcher(undiciCtx.mockAgent);
+        loggerMock.logRequest.mockClear();
+        loggerMock.logResponse.mockClear();
+        loggerMock.logError.mockClear();
+        loggerMock.logFailure.mockClear();
+        randomUUIDMock.mockClear();
+        randomUUIDMock.mockImplementation(() => FIXED_REQUEST_ID);
+    });
+    afterEach(async () => {
+        if (undiciCtx.previousDispatcher !== undefined) {
+            setGlobalDispatcher(undiciCtx.previousDispatcher);
+        }
+        if (undiciCtx.mockAgent !== undefined) {
+            await undiciCtx.mockAgent.close();
+        }
+    });
+    describe('fetch with MockAgent', () => {
+        it('returns 200, traces request start and response end', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/ok', method: 'GET' }).reply(200, 'hello', { headers: { 'content-type': 'text/plain' } });
+            const response = await fetch(`${MOCK_ORIGIN}/ok`);
+            expect(response.status).toBe(200);
+            expect(await response.text()).toBe('hello');
+            expect(loggerMock.logRequest).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logRequest.mock.calls[0][0].requestId).toBe(FIXED_REQUEST_ID);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('GET');
+            expect(loggerMock.logRequest.mock.calls[0][0].request.url).toBe(`${MOCK_ORIGIN}/ok`);
+            expect(loggerMock.logResponse).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logResponse.mock.calls[0][0].requestId).toBe(FIXED_REQUEST_ID);
+            expect(loggerMock.logResponse.mock.calls[0][0].response).toBe(response);
+            expect(loggerMock.logError).not.toHaveBeenCalled();
+            expect(loggerMock.logFailure).not.toHaveBeenCalled();
+        });
+        it('uses logError for status > 399 without logging response end', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/missing', method: 'GET' }).reply(404, 'nope', { headers: { 'content-type': 'text/plain' } });
+            const response = await fetch(`${MOCK_ORIGIN}/missing`);
+            expect(response.status).toBe(404);
+            expect(loggerMock.logRequest).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logResponse).not.toHaveBeenCalled();
+            expect(loggerMock.logError).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logError.mock.calls[0][0].requestId).toBe(FIXED_REQUEST_ID);
+            expect(loggerMock.logError.mock.calls[0][0].response).toBe(response);
+        });
+        it('treats status 399 as success (logs response end, not HTTP error)', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/edge', method: 'GET' }).reply(399, '', { headers: { 'content-type': 'text/plain' } });
+            const response = await fetch(`${MOCK_ORIGIN}/edge`);
+            expect(response.status).toBe(399);
+            expect(loggerMock.logResponse).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logError).not.toHaveBeenCalled();
+        });
+        it('sends x-request-trace-id and custom headers when init.headers is a plain object', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({
+                path: '/with-plain-headers',
+                method: 'GET',
+                headers: {
+                    'x-request-trace-id': FIXED_REQUEST_ID,
+                    'x-custom': 'plain-value'
+                }
+            }).reply(200, 'ok');
+            const response = await fetch(`${MOCK_ORIGIN}/with-plain-headers`, {
+                headers: { 'X-Custom': 'plain-value' }
+            });
+            expect(response.status).toBe(200);
+            const { request } = loggerMock.logRequest.mock.calls[0][0];
+            expect(request.headers.get('x-request-trace-id')).toBe(FIXED_REQUEST_ID);
+            expect(request.headers.get('x-custom')).toBe('plain-value');
+        });
+        it('sends x-request-trace-id and custom headers when init.headers is a Headers instance', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({
+                path: '/with-headers-instance',
+                method: 'GET',
+                headers: {
+                    'x-request-trace-id': FIXED_REQUEST_ID,
+                    'x-from-headers': 'yes'
+                }
+            }).reply(200, 'ok');
+            const userHeaders = new Headers();
+            userHeaders.set('X-From-Headers', 'yes');
+            const response = await fetch(`${MOCK_ORIGIN}/with-headers-instance`, {
+                headers: userHeaders
+            });
+            expect(response.status).toBe(200);
+            const { request } = loggerMock.logRequest.mock.calls[0][0];
+            expect(request.headers.get('x-request-trace-id')).toBe(FIXED_REQUEST_ID);
+            expect(request.headers.get('x-from-headers')).toBe('yes');
+        });
+        it('calls logFailure when the mock responds with replyWithError', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/boom', method: 'GET' }).replyWithError(new Error('simulated network failure'));
+            await expect(fetch(`${MOCK_ORIGIN}/boom`)).rejects.toThrow('fetch failed');
+            expect(loggerMock.logRequest).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logResponse).not.toHaveBeenCalled();
+            expect(loggerMock.logFailure).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logFailure.mock.calls[0][0].requestId).toBe(FIXED_REQUEST_ID);
+            const failure = loggerMock.logFailure.mock.calls[0][0].error;
+            expect(failure).toBeInstanceOf(TypeError);
+            expect(failure.message).toBe('fetch failed');
+            expect(failure.cause).toBeInstanceOf(Error);
+            expect(failure.cause.message).toBe('simulated network failure');
+        });
+        it('fails when no mock matches (disabled net)', async () => {
+            await expect(fetch(`${MOCK_ORIGIN}/unmocked`)).rejects.toThrow();
+            expect(loggerMock.logRequest).toHaveBeenCalledTimes(1);
+            expect(loggerMock.logResponse).not.toHaveBeenCalled();
+            expect(loggerMock.logFailure).toHaveBeenCalledTimes(1);
+        });
+        it('passes method and body through to undici for POST JSON', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/create', method: 'POST' }).reply(201, JSON.stringify({ id: 1 }), { headers: { 'content-type': 'application/json' } });
+            const response = await fetch(`${MOCK_ORIGIN}/create`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ name: 'a' })
+            });
+            expect(response.status).toBe(201);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('POST');
+            expect(loggerMock.logResponse).toHaveBeenCalledTimes(1);
+        });
+        it('works when the second argument is omitted', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/bare', method: 'GET' }).reply(204);
+            const response = await fetch(`${MOCK_ORIGIN}/bare`);
+            expect(response.status).toBe(204);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('GET');
+        });
+    });
+    describe('fetch RequestInfo / RequestInit shapes', () => {
+        it('accepts a URL object as the first argument', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/from-url', method: 'GET' }).reply(200, 'url-ok', { headers: { 'content-type': 'text/plain' } });
+            const href = new URL('/from-url', `${MOCK_ORIGIN}/`);
+            const response = await fetch(href);
+            expect(response.status).toBe(200);
+            expect(await response.text()).toBe('url-ok');
+            expect(loggerMock.logRequest.mock.calls[0][0].request.url).toBe(href.href);
+        });
+        it('accepts a Request as the first argument (no init)', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/req-only', method: 'GET' }).reply(200, 'r1');
+            const input = new Request(`${MOCK_ORIGIN}/req-only`, { method: 'GET' });
+            const response = await fetch(input);
+            expect(response.status).toBe(200);
+            expect(await response.text()).toBe('r1');
+            const { request } = loggerMock.logRequest.mock.calls[0][0];
+            expect(request.method).toBe('GET');
+            expect(request.url).toBe(`${MOCK_ORIGIN}/req-only`);
+        });
+        it('accepts Request plus init that overrides method and body', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/req-plus-init', method: 'POST' }).reply(201, JSON.stringify({ saved: true }), { headers: { 'content-type': 'application/json' } });
+            const input = new Request(`${MOCK_ORIGIN}/req-plus-init`, { method: 'GET' });
+            const response = await fetch(input, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ name: 'override' })
+            });
+            expect(response.status).toBe(201);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('POST');
+            expect(loggerMock.logResponse).toHaveBeenCalledTimes(1);
+        });
+        it('accepts string URL with explicit undefined init', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/explicit-undefined', method: 'GET' }).reply(200, 'ok');
+            const response = await fetch(`${MOCK_ORIGIN}/explicit-undefined`, undefined);
+            expect(response.status).toBe(200);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('GET');
+        });
+        it('accepts URL plus init with method and headers', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({
+                path: '/url-post',
+                method: 'POST',
+                headers: { 'content-type': 'application/json', 'x-request-trace-id': FIXED_REQUEST_ID }
+            }).reply(200, '{}');
+            const href = new URL('/url-post', `${MOCK_ORIGIN}/`);
+            const response = await fetch(href, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: '{}'
+            });
+            expect(response.status).toBe(200);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('POST');
+        });
+    });
+});

package/dist/fetch/logger.d.ts

@@ -0,0 +1,45 @@
+import type { Request, Response } from 'undici';
+/**
+ * Sends the trace start event for an http request
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.request - The HTTP Request object
+ */
+export declare const logRequest: ({ requestId, request }: {
+    requestId: string;
+    request: Request;
+}) => Promise<void>;
+/**
+ * Sends the trace error event for an http response with error status
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.response - The HTTP Response object
+ */
+export declare const logError: ({ requestId, response }: {
+    requestId: string;
+    response: Response;
+}) => Promise<void>;
+/**
+ * Sends the trace end event for an http response
+ *
+ * @param {object} options
+ * @param options.requestId - id of the request
+ * @param {Response} options.response - The HTTP Response object
+ */
+export declare const logResponse: ({ requestId, response }: {
+    requestId: string;
+    response: Response;
+}) => Promise<void>;
+/**
+ * Creates the trace error event for a network/connection failure
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.error - The error thrown
+ */
+export declare const logFailure: ({ requestId, error }: {
+    requestId: string;
+    error: Error;
+}) => void;

package/dist/fetch/logger.js

@@ -0,0 +1,54 @@
+import { Tracing } from '@outputai/core/sdk_activity_integration';
+import { config } from '../config.js';
+import { parseBody, redactHeaders, serializeError } from './utils.js';
+/**
+ * Sends the trace start event for an http request
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.request - The HTTP Request object
+ */
+export const logRequest = async ({ requestId, request }) => Tracing.addEventStart({
+    id: requestId, kind: 'http', name: 'request', details: {
+        method: request.method,
+        url: request.url,
+        ...(config.logVerbose && { headers: redactHeaders(request.headers), body: await parseBody(request) })
+    }
+});
+/**
+ * Sends the trace error event for an http response with error status
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.response - The HTTP Response object
+ */
+export const logError = async ({ requestId, response }) => Tracing.addEventError({
+    id: requestId, details: {
+        status: response.status,
+        statusText: response.statusText,
+        headers: redactHeaders(response.headers),
+        body: await parseBody(response)
+    }
+});
+/**
+ * Sends the trace end event for an http response
+ *
+ * @param {object} options
+ * @param options.requestId - id of the request
+ * @param {Response} options.response - The HTTP Response object
+ */
+export const logResponse = async ({ requestId, response }) => Tracing.addEventEnd({
+    id: requestId, details: {
+        status: response.status,
+        statusText: response.statusText,
+        ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
+    }
+});
+/**
+ * Creates the trace error event for a network/connection failure
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.error - The error thrown
+ */
+export const logFailure = ({ requestId, error }) => Tracing.addEventError({ id: requestId, details: serializeError(error) });

package/dist/fetch/logger.spec.js

@@ -0,0 +1,182 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Response, Request } from 'undici';
+vi.mock('@outputai/core/sdk_activity_integration', () => ({
+    Tracing: {
+        addEventStart: vi.fn(),
+        addEventEnd: vi.fn(),
+        addEventError: vi.fn()
+    }
+}));
+import { Tracing } from '@outputai/core/sdk_activity_integration';
+const tracing = vi.mocked(Tracing, true);
+/** Loads logger with optional verbose tracing env so `config.js` is evaluated fresh. */
+async function logLogger(verbose) {
+    vi.resetModules();
+    if (verbose) {
+        process.env.OUTPUT_TRACE_HTTP_VERBOSE = 'true';
+    }
+    else {
+        delete process.env.OUTPUT_TRACE_HTTP_VERBOSE;
+    }
+    return import('./logger.js');
+}
+beforeEach(() => {
+    tracing.addEventStart.mockClear();
+    tracing.addEventEnd.mockClear();
+    tracing.addEventError.mockClear();
+});
+describe('fetch/logger', () => {
+    describe('logRequest', () => {
+        it('records minimal details when verbose is off', async () => {
+            const { logRequest } = await logLogger(false);
+            const request = new Request('https://api.example.com/r', { method: 'GET' });
+            await logRequest({ requestId: 'req-1', request });
+            expect(tracing.addEventStart).toHaveBeenCalledWith({
+                id: 'req-1',
+                kind: 'http',
+                name: 'request',
+                details: {
+                    method: 'GET',
+                    url: 'https://api.example.com/r'
+                }
+            });
+        });
+        it('defaults method to GET', async () => {
+            const { logRequest } = await logLogger(false);
+            const request = new Request('https://x.test');
+            await logRequest({ requestId: 'r2', request });
+            expect(tracing.addEventStart.mock.calls[0][0].details.method).toBe('GET');
+        });
+        it('includes redacted headers and parsed body when verbose is on', async () => {
+            const { logRequest } = await logLogger(true);
+            const request = new Request('https://api.example.com/p', {
+                method: 'POST',
+                headers: {
+                    authorization: 'tok',
+                    'X-Custom': 'ok',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ x: 1 })
+            });
+            await logRequest({ requestId: 'req-v', request });
+            expect(tracing.addEventStart).toHaveBeenCalledWith({
+                id: 'req-v',
+                kind: 'http',
+                name: 'request',
+                details: {
+                    method: 'POST',
+                    url: 'https://api.example.com/p',
+                    headers: { authorization: '[REDACTED]', 'x-custom': 'ok', 'content-type': 'application/json' },
+                    body: { x: 1 }
+                }
+            });
+        });
+    });
+    describe('logError', () => {
+        it('records status, statusText, redacted headers, and parsed JSON body', async () => {
+            const { logError } = await logLogger(false);
+            const body = { message: 'Upstream unavailable', code: 'E_UPSTREAM' };
+            const response = new Response(JSON.stringify(body), {
+                status: 502,
+                statusText: 'Bad Gateway',
+                headers: {
+                    'X-API-Key': 'k',
+                    Accept: 'text/plain',
+                    'content-type': 'application/json'
+                }
+            });
+            await logError({ requestId: 'e1', response });
+            expect(tracing.addEventError).toHaveBeenCalledWith({
+                id: 'e1',
+                details: {
+                    status: 502,
+                    statusText: 'Bad Gateway',
+                    headers: {
+                        'x-api-key': '[REDACTED]',
+                        accept: 'text/plain',
+                        'content-type': 'application/json'
+                    },
+                    body
+                }
+            });
+        });
+        it('records error body as raw text when content-type is not application/json', async () => {
+            const { logError } = await logLogger(false);
+            const text = 'Bad Gateway: no healthy upstream';
+            const response = new Response(text, {
+                status: 502,
+                statusText: 'Bad Gateway',
+                headers: { 'content-type': 'text/plain' }
+            });
+            await logError({ requestId: 'e2', response });
+            expect(tracing.addEventError).toHaveBeenCalledWith({
+                id: 'e2',
+                details: {
+                    status: 502,
+                    statusText: 'Bad Gateway',
+                    headers: { 'content-type': 'text/plain' },
+                    body: text
+                }
+            });
+        });
+    });
+    describe('logResponse', () => {
+        it('records status and statusText without headers/body when verbose is off', async () => {
+            const { logResponse } = await logLogger(false);
+            const response = new Response(JSON.stringify({ a: 1 }), {
+                status: 200,
+                statusText: 'OK',
+                headers: { 'content-type': 'application/json', Authorization: 'x' }
+            });
+            await logResponse({ requestId: 'lr1', response });
+            expect(tracing.addEventEnd).toHaveBeenCalledWith({
+                id: 'lr1',
+                details: {
+                    status: 200,
+                    statusText: 'OK'
+                }
+            });
+        });
+        it('includes redacted headers and parsed body when verbose is on', async () => {
+            const { logResponse } = await logLogger(true);
+            const response = new Response(JSON.stringify({ ok: true }), {
+                status: 201,
+                statusText: 'Created',
+                headers: {
+                    'content-type': 'application/json',
+                    'Set-Cookie': 'a=b'
+                }
+            });
+            await logResponse({ requestId: 'lr-v', response });
+            expect(tracing.addEventEnd).toHaveBeenCalledWith({
+                id: 'lr-v',
+                details: {
+                    status: 201,
+                    statusText: 'Created',
+                    headers: {
+                        'content-type': 'application/json',
+                        'set-cookie': '[REDACTED]'
+                    },
+                    body: { ok: true }
+                }
+            });
+        });
+    });
+    describe('logFailure', () => {
+        it('forwards serialized error details (including stack) to Tracing.addEventError', async () => {
+            const { logFailure } = await logLogger(false);
+            const err = new TypeError('network');
+            logFailure({ requestId: 'f1', error: err });
+            expect(tracing.addEventError).toHaveBeenCalledWith({
+                id: 'f1',
+                details: {
+                    name: 'TypeError',
+                    message: 'network',
+                    cause: undefined,
+                    code: undefined,
+                    stack: expect.stringMatching(/TypeError:\s*network[\s\S]+at\s+/)
+                }
+            });
+        });
+    });
+});

package/dist/fetch/utils.d.ts

@@ -0,0 +1,36 @@
+import type { Request, Response, Headers } from 'undici';
+/**
+ * Serialize a given error to a plain object keeping main properties:
+ * - name (from constructor.name)
+ * - message
+ * - stack
+ * - code (optional, but present on Node errors)
+ * - cause (error chain)
+ *
+ * @param error Error to serialize
+ * @param depth Current recursion depth for the error.cause chain
+ * @returns Object
+ */
+export declare const serializeError: (error: Error, depth?: number) => {
+    name: string;
+    message: string;
+    stack: string | undefined;
+    code: string | undefined;
+    cause: string | object | undefined;
+};
+/**
+ * Redacts sensitive headers for safe logging
+ *
+ * @param headers
+ * @returns Plain object with sensitive headers redacted
+ */
+export declare const redactHeaders: (headers: Headers) => Record<string, unknown>;
+/**
+ * Clones a Request or Response object and reads the body as text, then:
+ * - non-JSON content-type, or empty body: returns the text as-is
+ * - application/json with a non-empty body: returns JSON.parse result, or the raw text if parsing fails
+ *
+ * @param r
+ * @returns Parsed JSON value or raw body string
+ */
+export declare const parseBody: (r: Request | Response) => Promise<string | object>;