@outputai/http 0.10.1-dev.b7b2fbe.0 → 0.10.1-next.2caa4a1.0

package/dist/fetch/utils.spec.js

@@ -1,282 +1,119 @@
-import { describe, it, expect } from 'vitest';
-import { Response, Request, Headers } from 'undici';
+import { describe, expect, it } from 'vitest';
+import { Headers, Request, Response } from 'undici';
 import { requestIdSymbol } from '../consts.js';
 import { addRequestIdToResponse, parseBody, redactHeaders, serializeError } from './utils.js';
-const createMultiLevelError = (levels, depth = 1) => depth === levels ?
-    new Error(`level-${depth}`) :
-    new Error(`level-${depth}`, { cause: createMultiLevelError(levels, depth + 1) });
-const walkSerializedCause = (root, steps) => {
-    if (steps === 0) {
-        return root;
-    }
-    return walkSerializedCause(root.cause, steps - 1);
+const createErrorChain = levels => {
+    const root = new Error('level-1');
+    Array.from({ length: levels - 1 }, (_, index) => index + 2).reduce((current, level) => {
+        const cause = new Error(`level-${level}`);
+        current.cause = cause;
+        return cause;
+    }, root);
+    return root;
 };
-describe('fetch/utils', () => {
+describe('instrumented_fetch/utils', () => {
     describe('serializeError', () => {
-        it('serializes name, message, stack and sets code and cause to undefined when absent', () => {
-            const err = new Error('boom');
-            expect(serializeError(err)).toEqual({ name: 'Error', message: 'boom', stack: err.stack, code: undefined, cause: undefined });
-        });
-        it('uses the subclass constructor name', () => {
-            const err = new TypeError('bad type');
-            expect(serializeError(err).name).toBe('TypeError');
-            expect(serializeError(err).message).toBe('bad type');
-        });
-        it('includes string code when set on the error', () => {
-            const err = new Error('e');
-            err.code = 'ENOENT';
-            expect(serializeError(err).code).toBe('ENOENT');
-        });
-        it('serializes Error cause as a nested plain object', () => {
-            const root = new Error('root');
-            const leaf = new TypeError('leaf');
-            root.cause = leaf;
-            expect(serializeError(root)).toEqual({
+        it('serializes standard error properties and a nested cause', () => {
+            const cause = new TypeError('cause');
+            const error = new Error('failure', { cause });
+            error.code = 'E_FAILURE';
+            expect(serializeError(error)).toEqual({
                 name: 'Error',
-                message: 'root',
-                stack: root.stack,
-                code: undefined,
+                message: 'failure',
+                stack: error.stack,
+                code: 'E_FAILURE',
                 cause: {
                     name: 'TypeError',
-                    message: 'leaf',
-                    stack: leaf.stack,
+                    message: 'cause',
+                    stack: cause.stack,
                     code: undefined,
                     cause: undefined
                 }
             });
         });
-        it('does not recurse into cause when initial depth is already past the limit', () => {
-            const inner = new Error('inner');
-            const outer = new Error('outer');
-            outer.cause = inner;
-            expect(serializeError(outer, 6).cause).toBe('<Max recursion depth reached>');
-        });
-        it('serializes up to five nested Error causes without hitting the sentinel', () => {
-            const root = createMultiLevelError(5);
-            const innermost = walkSerializedCause(serializeError(root), 4);
-            expect(innermost.message).toBe('level-5');
-            expect(innermost.cause).toBeUndefined();
-        });
-        it('replaces cause with the max-depth sentinel on the sixth nested Error', () => {
-            const root = createMultiLevelError(6);
-            const innermost = walkSerializedCause(serializeError(root), 5);
-            expect(innermost.message).toBe('level-6');
-            expect(innermost.cause).toBe('<Max recursion depth reached>');
-        });
-        it('does not expose a seventh error when the chain is longer than the limit', () => {
-            const root = createMultiLevelError(7);
-            const innermost = walkSerializedCause(serializeError(root), 5);
-            expect(innermost.message).toBe('level-6');
-            expect(innermost.cause).toBe('<Max recursion depth reached>');
+        it('limits the serialized cause depth', () => {
+            const serialized = serializeError(createErrorChain(7));
+            const current = Array.from({ length: 5 }).reduce(cause => cause.cause, serialized);
+            expect(current.message).toBe('level-6');
+            expect(current.cause).toBe('<Max recursion depth reached>');
         });
     });
     describe('redactHeaders', () => {
-        it('redacts sensitive headers case-insensitively', () => {
-            const headers = new Headers([
-                ['Authorization', 'Bearer token123'],
-                ['X-API-Key', 'secret-key'],
-                ['apikey', 'another-secret'],
-                ['X-Auth-Token', 'auth-token'],
-                ['Secret-Header', 'top-secret'],
-                ['Password', 'password123'],
-                ['Private-Key', 'private-key-data'],
-                ['Cookie', 'session=abc123'],
-                ['Content-Type', 'application/json'],
-                ['User-Agent', 'test-agent']
-            ]);
-            expect(redactHeaders(headers)).toEqual({
-                authorization: '[REDACTED]',
-                'x-api-key': '[REDACTED]',
-                apikey: '[REDACTED]',
-                'x-auth-token': '[REDACTED]',
-                'secret-header': '[REDACTED]',
-                password: '[REDACTED]',
-                'private-key': '[REDACTED]',
-                cookie: '[REDACTED]',
-                'content-type': 'application/json',
-                'user-agent': 'test-agent'
-            });
-        });
-        it('leaves non-sensitive headers unchanged', () => {
+        it('redacts sensitive header names while preserving safe values', () => {
             const headers = new Headers({
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                'Cache-Control': 'no-cache'
-            });
-            expect(redactHeaders(headers)).toEqual({
-                'content-type': 'application/json',
-                accept: 'application/json',
-                'cache-control': 'no-cache'
+                authorization: 'Bearer secret',
+                'x-api-key': 'secret',
+                cookie: 'session=secret',
+                'content-type': 'application/json'
             });
-        });
-        it('handles empty Headers', () => {
-            expect(redactHeaders(new Headers())).toEqual({});
-        });
-        it('redacts sensitive keys even when values are empty', () => {
-            const headers = new Headers([
-                ['Authorization', ''],
-                ['Content-Type', 'application/json'],
-                ['X-API-Key', '']
-            ]);
             expect(redactHeaders(headers)).toEqual({
                 authorization: '[REDACTED]',
-                'content-type': 'application/json',
-                'x-api-key': '[REDACTED]'
+                'x-api-key': '[REDACTED]',
+                cookie: '[REDACTED]',
+                'content-type': 'application/json'
             });
         });
-        it('does not redact benign names that only contained sensitive substrings before', () => {
+        it('does not redact exempt or substring-only header names', () => {
             const headers = new Headers({
-                Keyboard: 'qwerty',
-                Secretary: 'admin',
-                Tokens: 'abc123',
-                'Content-Length': '123'
+                'x-csrf-token': 'csrf-value',
+                'public-key-pins': 'pin-value',
+                keyboard: 'keyboard-value',
+                tokens: 'token-count'
             });
             expect(redactHeaders(headers)).toEqual({
-                keyboard: 'qwerty',
-                secretary: 'admin',
-                tokens: 'abc123',
-                'content-length': '123'
-            });
-        });
-        it('does not redact exempt headers but still redacts any header whose name contains a key segment', () => {
-            const headers = new Headers([
-                ['X-Csrf-Token', 'abc'],
-                ['Public-Key-Pins', 'pin-sha256=dummy'],
-                ['ratelimit-tokens-left', '9'],
-                ['Cache-Key', 'lookup-1'],
-                ['X-Auth-Token', 'real-secret']
-            ]);
-            expect(redactHeaders(headers)).toEqual({
-                'x-csrf-token': 'abc',
-                'public-key-pins': 'pin-sha256=dummy',
-                'ratelimit-tokens-left': '9',
-                'cache-key': '[REDACTED]',
-                'x-auth-token': '[REDACTED]'
-            });
-        });
-        describe('key suffix pattern /key(?![a-z0-9])/i', () => {
-            it.each([
-                ['x-api-key', 'hyphen before key at end'],
-                ['apikey', 'single segment ending in key'],
-                ['X-LicenseKey', 'camel segment ending in Key'],
-                ['webhook-signing-key', 'key before end'],
-                ['pre-key-post', 'key surrounded by hyphens'],
-                ['encryption_key', 'underscore after key'],
-                ['signing-key-id', 'key in middle of kebab name'],
-                ['monkey', 'key followed by end of string (substring key)'],
-                ['turkey-vulture', 'key in first segment before hyphen'],
-                ['v1__key', 'non-alnum before key']
-            ])('redacts %s (%s)', headerName => {
-                const headers = new Headers([[headerName, 'secret-value']]);
-                const out = redactHeaders(headers);
-                const canonical = Object.keys(out)[0];
-                expect(out[canonical]).toBe('[REDACTED]');
-            });
-            it.each([
-                ['keyboard', 'key followed by letter b'],
-                ['KeyAccountId', 'key followed by letter a'],
-                ['WhiskeyBar', 'key followed by letter b'],
-                ['my-keyring', 'key followed by letter r'],
-                ['Cache-Control', 'no key substring with allowed lookahead']
-            ])('does not redact %s (%s)', headerName => {
-                const headers = new Headers([[headerName, 'visible']]);
-                const out = redactHeaders(headers);
-                const canonical = Object.keys(out)[0];
-                expect(out[canonical]).toBe('visible');
-            });
-            it('still applies exempt list when the key rule would match (e.g. public-key-pins)', () => {
-                const headers = new Headers([['Public-Key-Pins', 'pins-value']]);
-                expect(redactHeaders(headers)).toEqual({ 'public-key-pins': 'pins-value' });
+                'x-csrf-token': 'csrf-value',
+                'public-key-pins': 'pin-value',
+                keyboard: 'keyboard-value',
+                tokens: 'token-count'
             });
         });
     });
     describe('parseBody', () => {
-        it('parses JSON when content-type is application/json', async () => {
+        it('parses JSON bodies without consuming the original', async () => {
             const response = new Response(JSON.stringify({ ok: true }), {
-                headers: { 'content-type': 'application/json' }
-            });
-            await expect(parseBody(response)).resolves.toEqual({ ok: true });
-        });
-        it('parses JSON when content-type includes charset', async () => {
-            const response = new Response(JSON.stringify([1, 2]), {
                 headers: { 'content-type': 'application/json; charset=utf-8' }
             });
-            await expect(parseBody(response)).resolves.toEqual([1, 2]);
+            await expect(parseBody(response)).resolves.toEqual({ ok: true });
+            await expect(response.json()).resolves.toEqual({ ok: true });
         });
-        it('returns text when content-type is not JSON', async () => {
-            const response = new Response('hello', {
+        it('returns non-JSON and invalid JSON bodies as text', async () => {
+            const textResponse = new Response('plain text', {
                 headers: { 'content-type': 'text/plain' }
             });
-            await expect(parseBody(response)).resolves.toBe('hello');
-        });
-        it('uses text branch when content-type is missing', async () => {
-            const response = new Response('plain');
-            await expect(parseBody(response)).resolves.toBe('plain');
-        });
-        it('returns empty string for empty body (text)', async () => {
-            const response = new Response('', { headers: { 'content-type': 'text/plain' } });
-            await expect(parseBody(response)).resolves.toBe('');
-        });
-        it('returns empty string for empty body even when content-type is application/json', async () => {
-            const response = new Response('', { headers: { 'content-type': 'application/json' } });
-            await expect(parseBody(response)).resolves.toBe('');
-        });
-        it('returns raw text when content-type is application/json but the body is not valid JSON', async () => {
-            const raw = '{ not json';
-            const response = new Response(raw, { headers: { 'content-type': 'application/json' } });
-            const result = await parseBody(response);
-            expect(result).toBe(raw);
-            expect(result).toBeTypeOf('string');
-        });
-        it('does not consume the original body (clone)', async () => {
-            const response = new Response('read-me', { headers: { 'content-type': 'text/plain' } });
-            await parseBody(response);
-            await expect(response.text()).resolves.toBe('read-me');
-        });
-        it('parses JSON Request body', async () => {
-            const request = new Request('https://ex.com', {
+            const invalidJsonRequest = new Request('https://example.com', {
                 method: 'POST',
                 headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ a: 1 })
+                body: '{invalid'
             });
-            await expect(parseBody(request)).resolves.toEqual({ a: 1 });
+            await expect(parseBody(textResponse)).resolves.toBe('plain text');
+            await expect(parseBody(invalidJsonRequest)).resolves.toBe('{invalid');
         });
-        it('returns raw text for invalid JSON on a Request with application/json', async () => {
-            const raw = '{';
-            const request = new Request('https://ex.com', {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: raw
+        it('returns an empty string for an empty JSON body', async () => {
+            const response = new Response('', {
+                headers: { 'content-type': 'application/json' }
             });
-            await expect(parseBody(request)).resolves.toBe(raw);
+            await expect(parseBody(response)).resolves.toBe('');
         });
     });
     describe('addRequestIdToResponse', () => {
-        it('stores request id under requestIdSymbol on the response', () => {
-            const response = new Response('ok');
-            addRequestIdToResponse(response, 'req-123');
-            expect(response[requestIdSymbol]).toBe('req-123');
-        });
-        it('defines request id as non-enumerable, non-writable and non-configurable', () => {
+        it('stores an immutable, non-enumerable request id', () => {
             const response = new Response('ok');
-            addRequestIdToResponse(response, 'req-456');
-            const descriptor = Object.getOwnPropertyDescriptor(response, requestIdSymbol);
-            expect(descriptor).toBeDefined();
-            expect(descriptor).toMatchObject({
+            addRequestIdToResponse(response, 'request-1');
+            expect(response[requestIdSymbol]).toBe('request-1');
+            expect(Object.getOwnPropertyDescriptor(response, requestIdSymbol)).toEqual({
+                value: 'request-1',
                 enumerable: false,
                 configurable: false,
-                writable: false,
-                value: 'req-456'
+                writable: false
             });
         });
-        it('propagates the request id to clones (ky afterResponse passes the clone)', () => {
+        it('propagates the request id through repeated clones', () => {
             const response = new Response('ok');
-            addRequestIdToResponse(response, 'req-789');
-            const cloned = response.clone();
-            expect(cloned[requestIdSymbol]).toBe('req-789');
-            // recursion: clones of clones inherit too
-            const grandchild = cloned.clone();
-            expect(grandchild[requestIdSymbol]).toBe('req-789');
+            addRequestIdToResponse(response, 'request-clone');
+            const clone = response.clone();
+            const grandchild = clone.clone();
+            expect(clone[requestIdSymbol]).toBe('request-clone');
+            expect(grandchild[requestIdSymbol]).toBe('request-clone');
         });
     });
 });

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import type { Options } from 'ky';
 export type HttpRequestEvent = {
     requestId: string;
     method: string;
@@ -13,30 +12,9 @@ export type HttpRequestCostEvent = {
     url: string;
     total: number;
 };
-/**
- * Creates a ky client.
- *
- * This client uses a custom fetch that introduces hooks to integrate with Output.ai tracing.
- *
- * @example
- * ```ts
- * import { httpClient } from '@outputai/http';
- *
- * const client = httpClient({
- *   prefixUrl: 'https://api.example.com',
- *   timeout: 30000,
- *   retry: { limit: 3 }
- * });
- *
- * const response = await client.get('users/1');
- * const data = await response.json();
- * ```
- *
- * @param options - The ky options to extend the base client.
- * @returns A ky instance extended with Output.ai tracing hooks.
- */
-export declare function httpClient(options?: Options): import("ky").KyInstance;
-export { HTTPError, TimeoutError } from 'ky';
-export type { Options as HttpClientOptions } from 'ky';
-export * from './fetch/index.js';
+export { outputFetch } from './fetch/index.js';
+export { createKyClient } from './ky/index.js';
 export { addRequestCost } from './cost.js';
+/** Re-export ky library for convenience. */
+export * as ky from 'ky';
+export * as undici from 'undici';

package/dist/index.js

@@ -1,30 +1,6 @@
-import ky from 'ky';
-import { fetch as customFetch } from './fetch/index.js';
-/**
- * Creates a ky client.
- *
- * This client uses a custom fetch that introduces hooks to integrate with Output.ai tracing.
- *
- * @example
- * ```ts
- * import { httpClient } from '@outputai/http';
- *
- * const client = httpClient({
- *   prefixUrl: 'https://api.example.com',
- *   timeout: 30000,
- *   retry: { limit: 3 }
- * });
- *
- * const response = await client.get('users/1');
- * const data = await response.json();
- * ```
- *
- * @param options - The ky options to extend the base client.
- * @returns A ky instance extended with Output.ai tracing hooks.
- */
-export function httpClient(options = {}) {
-    return ky.create({ fetch: customFetch, ...options });
-}
-export { HTTPError, TimeoutError } from 'ky';
-export * from './fetch/index.js';
+export { outputFetch } from './fetch/index.js';
+export { createKyClient } from './ky/index.js';
 export { addRequestCost } from './cost.js';
+/** Re-export ky library for convenience. */
+export * as ky from 'ky';
+export * as undici from 'undici';

package/dist/ky/index.d.ts

@@ -0,0 +1,24 @@
+import type { KyInstance, Options } from 'ky';
+/**
+ * Creates a ky client.
+ *
+ * This client uses a custom fetch that introduces hooks to integrate with Output.ai tracing.
+ *
+ * @example
+ * ```ts
+ * import { createKyClient } from '@outputai/http';
+ *
+ * const client = createKyClient({
+ *   prefix: 'https://api.example.com',
+ *   timeout: 30000,
+ *   retry: { limit: 3 }
+ * });
+ *
+ * const response = await client.get('users/1');
+ * const data = await response.json();
+ * ```
+ *
+ * @param options - The ky options to extend the base client.
+ * @returns A ky instance extended with Output.ai tracing hooks.
+ */
+export declare const createKyClient: (options?: Options) => KyInstance;

package/dist/ky/index.js

@@ -0,0 +1,25 @@
+import ky from 'ky';
+import { outputFetch } from '../fetch/index.js';
+/**
+ * Creates a ky client.
+ *
+ * This client uses a custom fetch that introduces hooks to integrate with Output.ai tracing.
+ *
+ * @example
+ * ```ts
+ * import { createKyClient } from '@outputai/http';
+ *
+ * const client = createKyClient({
+ *   prefix: 'https://api.example.com',
+ *   timeout: 30000,
+ *   retry: { limit: 3 }
+ * });
+ *
+ * const response = await client.get('users/1');
+ * const data = await response.json();
+ * ```
+ *
+ * @param options - The ky options to extend the base client.
+ * @returns A ky instance extended with Output.ai tracing hooks.
+ */
+export const createKyClient = (options = {}) => ky.create({ fetch: outputFetch, ...options });

package/dist/ky/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ky/index.spec.js

@@ -0,0 +1,34 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { outputFetch } from '../fetch/index.js';
+const kyMock = vi.hoisted(() => ({
+    client: { get: vi.fn() },
+    create: vi.fn()
+}));
+vi.mock('ky', () => ({
+    default: { create: kyMock.create }
+}));
+import { createKyClient } from './index.js';
+describe('createKyClient', () => {
+    beforeEach(() => {
+        kyMock.create.mockReset();
+        kyMock.create.mockReturnValue(kyMock.client);
+    });
+    it('creates a Ky client using outputFetch', () => {
+        expect(createKyClient()).toBe(kyMock.client);
+        expect(kyMock.create).toHaveBeenCalledWith({ fetch: outputFetch });
+    });
+    it('forwards Ky options', () => {
+        const options = {
+            prefix: 'https://example.com',
+            timeout: 30_000,
+            retry: { limit: 3 }
+        };
+        createKyClient(options);
+        expect(kyMock.create).toHaveBeenCalledWith({ fetch: outputFetch, ...options });
+    });
+    it('allows callers to override fetch', () => {
+        const fetch = vi.fn(async () => new Response());
+        createKyClient({ fetch });
+        expect(kyMock.create).toHaveBeenCalledWith({ fetch });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/http",
-  "version": "0.10.1-dev.b7b2fbe.0",
+  "version": "0.10.1-next.2caa4a1.0",
   "description": "Framework abstraction to make HTTP calls with tracing",
   "type": "module",
   "main": "dist/index.js",
@@ -11,18 +11,21 @@
   "files": [
     "dist"
   ],
+  "peerDependencies": {
+    "ky": ">=2 <3",
+    "undici": ">=8 <9"
+  },
   "dependencies": {
-    "ky": "1.14.3",
-    "undici": "8.5.0",
-    "@outputai/core": "0.10.1-dev.b7b2fbe.0"
+    "@outputai/core": "0.10.1-next.2caa4a1.0"
+  },
+  "devDependencies": {
+    "ky": "2.0.2",
+    "undici": "8.9.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
   },
-  "imports": {
-    "#*": "./dist/*"
-  },
   "scripts": {
     "build": "rm -rf ./dist && tsc"
   }

package/dist/index.spec.js

@@ -1,13 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { httpClient } from './index.js';
-describe('httpClient', () => {
-    it('passes the injected fetch to ky so requests use the custom implementation', async () => {
-        const spyFetch = vi.fn((_input, _init) => Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 })));
-        const client = httpClient({
-            fetch: spyFetch,
-            prefixUrl: 'https://example.com'
-        });
-        await client.get('path');
-        expect(spyFetch).toHaveBeenCalled();
-    });
-});