@output.ai/http 0.0.1 → 0.0.2

package/README.md

@@ -1,6 +1,6 @@
 # @output.ai/http
 
-TypeScript HTTP client that wraps [ky](https://github.com/sindresorhus/ky) with Flow SDK tracing hooks.
+TypeScript HTTP client that wraps [ky](https://github.com/sindresorhus/ky) with Output SDK tracing hooks.
 
 ## Installation
 

package/dist/hooks/index.d.ts

@@ -1,3 +1,3 @@
-export { traceRequest } from './trace-request.js';
-export { traceResponse } from './trace-response.js';
-export { traceError } from './trace-error.js';
+export { traceRequest } from './trace_request.js';
+export { traceResponse } from './trace_response.js';
+export { traceError } from './trace_error.js';

package/dist/hooks/index.js

@@ -1,3 +1,3 @@
-export { traceRequest } from './trace-request.js';
-export { traceResponse } from './trace-response.js';
-export { traceError } from './trace-error.js';
+export { traceRequest } from './trace_request.js';
+export { traceResponse } from './trace_response.js';
+export { traceError } from './trace_error.js';

package/dist/hooks/{trace-error.d.ts → trace_error.d.ts}

@@ -1,5 +1,5 @@
 import type { BeforeErrorHook } from 'ky';
 /**
- * Traces HTTP errors for observability using Flow SDK tracing
+ * Traces HTTP errors for observability using Output SDK tracing
  */
 export declare const traceError: BeforeErrorHook;

package/dist/hooks/trace_error.js

@@ -0,0 +1,16 @@
+import { createTraceId, redactHeaders } from '#utils/index.js';
+import { Tracing } from '@output.ai/core/tracing';
+/**
+ * Traces HTTP errors for observability using Output SDK tracing
+ */
+export const traceError = (error) => {
+    Tracing.addEventError({
+        id: createTraceId(error.request),
+        details: {
+            status: error.response.status,
+            statusText: error.response.statusText,
+            headers: redactHeaders(Object.fromEntries(error.response.headers.entries()))
+        }
+    });
+    return error;
+};

package/dist/hooks/trace_error.spec.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { HTTPError } from 'ky';
+import { traceError } from './trace_error.js';
+import { Tracing } from '@output.ai/core/tracing';
+vi.mock('../utils/index.js', () => ({
+    redactHeaders: vi.fn((h) => h),
+    createTraceId: vi.fn(() => 'trace-id')
+}));
+vi.mock('@output.ai/core/tracing', () => ({
+    Tracing: {
+        addEventError: vi.fn()
+    }
+}));
+const mockedTracing = vi.mocked(Tracing, true);
+describe('http/hooks/trace_error', () => {
+    beforeEach(() => {
+        mockedTracing.addEventError.mockClear();
+    });
+    it('traces error with response details when response exists', async () => {
+        const request = new Request('https://api.example.com/users/1', { method: 'GET' });
+        const response = new Response('Unauthorized', {
+            status: 401,
+            statusText: 'Unauthorized',
+            headers: { authorization: 'secret', 'x-custom': 'v' }
+        });
+        const error = new HTTPError(response, request, {});
+        const returned = await traceError(error);
+        expect(returned).toBe(error);
+        expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
+        const arg = mockedTracing.addEventError.mock.calls[0][0];
+        expect(arg.details.status).toBe(401);
+        expect(arg.details.statusText).toBe('Unauthorized');
+        expect(arg.details.headers).toMatchObject({ authorization: 'secret', 'x-custom': 'v' });
+    });
+});

package/dist/hooks/{trace-request.d.ts → trace_request.d.ts}

@@ -1,6 +1,6 @@
 import type { BeforeRequestHook } from 'ky';
 /**
- * Traces HTTP request for observability using Flow SDK tracing
+ * Traces HTTP request for observability using Output SDK tracing
  * Respects LOG_HTTP_VERBOSE environment variable for detailed logging
  */
 export declare const traceRequest: BeforeRequestHook;

package/dist/hooks/trace_request.js

@@ -0,0 +1,19 @@
+import { Tracing } from '@output.ai/core/tracing';
+import { redactHeaders, createTraceId, parseRequestBody } from '#utils/index.js';
+import { config } from '#config.js';
+/**
+ * Traces HTTP request for observability using Output SDK tracing
+ * Respects LOG_HTTP_VERBOSE environment variable for detailed logging
+ */
+export const traceRequest = async (request, _options) => {
+    const details = {
+        method: request.method,
+        url: request.url
+    };
+    if (config.logVerbose) {
+        const headers = Object.fromEntries(request.headers.entries());
+        details.headers = redactHeaders(headers);
+        details.body = await parseRequestBody(request);
+    }
+    Tracing.addEventStart({ id: createTraceId(request), kind: 'http', name: 'request', details });
+};

package/dist/hooks/trace_request.spec.d.ts

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

package/dist/hooks/trace_request.spec.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { traceRequest } from './trace_request.js';
+import { Tracing } from '@output.ai/core/tracing';
+import { config } from '../config.js';
+vi.mock('../utils/index.js', () => ({
+    redactHeaders: vi.fn((h) => h),
+    parseRequestBody: vi.fn(async () => ({ mocked: true })),
+    createTraceId: vi.fn(() => 'trace-id')
+}));
+vi.mock('@output.ai/core/tracing', () => ({
+    Tracing: {
+        addEventStart: vi.fn()
+    }
+}));
+vi.mock('../config.js', () => ({
+    config: { logVerbose: false }
+}));
+const mockedTracing = vi.mocked(Tracing, true);
+const mockedConfig = vi.mocked(config);
+describe('http/hooks/trace_request', () => {
+    beforeEach(() => {
+        mockedTracing.addEventStart.mockClear();
+        mockedConfig.logVerbose = false;
+    });
+    it('traces minimal details when verbose logging is disabled', async () => {
+        mockedConfig.logVerbose = false;
+        const request = new Request('https://api.example.com/users/1', { method: 'GET' });
+        const options = {};
+        await traceRequest(request, options);
+        expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
+        const arg = mockedTracing.addEventStart.mock.calls[0][0];
+        expect(arg).toHaveProperty('kind', 'http');
+        expect(arg).toHaveProperty('name', 'request');
+        expect(arg.details).toEqual({
+            method: 'GET',
+            url: 'https://api.example.com/users/1'
+        });
+    });
+    it('traces headers and parsed body when verbose logging is enabled', async () => {
+        mockedConfig.logVerbose = true;
+        const request = new Request('https://api.example.com/users', {
+            method: 'POST',
+            headers: {
+                authorization: 'secret',
+                'x-custom': 'value'
+            },
+            body: JSON.stringify({ name: 'test' })
+        });
+        const options = {};
+        await traceRequest(request, options);
+        expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
+        const arg = mockedTracing.addEventStart.mock.calls[0][0];
+        expect(arg.details.method).toBe('POST');
+        expect(arg.details.url).toBe('https://api.example.com/users');
+        expect(arg.details.headers).toMatchObject({ authorization: 'secret', 'x-custom': 'value' });
+        expect(arg.details.body).toEqual({ mocked: true });
+    });
+});

package/dist/hooks/{trace-response.d.ts → trace_response.d.ts}

@@ -1,6 +1,6 @@
 import type { AfterResponseHook } from 'ky';
 /**
- * Traces HTTP response for observability using Flow SDK tracing
+ * Traces HTTP response for observability using Output SDK tracing
  * Respects LOG_HTTP_VERBOSE environment variable for detailed logging
  */
 export declare const traceResponse: AfterResponseHook;

package/dist/hooks/trace_response.js

@@ -0,0 +1,21 @@
+import { Tracing } from '@output.ai/core/tracing';
+import { redactHeaders, createTraceId, parseResponseBody } from '#utils/index.js';
+;
+import { config } from '#config.js';
+/**
+ * Traces HTTP response for observability using Output SDK tracing
+ * Respects LOG_HTTP_VERBOSE environment variable for detailed logging
+ */
+export const traceResponse = async (request, _options, response) => {
+    const details = {
+        status: response.status,
+        statusText: response.statusText
+    };
+    if (config.logVerbose) {
+        const responseHeaders = Object.fromEntries(response.headers.entries());
+        details.headers = redactHeaders(responseHeaders);
+        details.body = await parseResponseBody(response);
+    }
+    Tracing.addEventEnd({ id: createTraceId(request), details });
+    return response;
+};

package/dist/hooks/trace_response.spec.d.ts

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

package/dist/hooks/trace_response.spec.js

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { traceResponse } from './trace_response.js';
+import { Tracing } from '@output.ai/core/tracing';
+import { config } from '../config.js';
+vi.mock('../utils/index.js', () => ({
+    redactHeaders: vi.fn((h) => h),
+    parseResponseBody: vi.fn(async () => ({ mocked: true })),
+    createTraceId: vi.fn(() => 'trace-id')
+}));
+vi.mock('@output.ai/core/tracing', () => ({
+    Tracing: {
+        addEventEnd: vi.fn()
+    }
+}));
+vi.mock('../config.js', () => ({
+    config: { logVerbose: false }
+}));
+const mockedTracing = vi.mocked(Tracing, true);
+const mockedConfig = vi.mocked(config);
+describe('http/hooks/trace_response', () => {
+    beforeEach(() => {
+        mockedTracing.addEventEnd.mockClear();
+        mockedConfig.logVerbose = false;
+    });
+    it('traces minimal details when verbose logging is disabled', async () => {
+        mockedConfig.logVerbose = false;
+        const request = new Request('https://api.example.com/users/1', { method: 'GET' });
+        const response = new Response('ok', { status: 200, statusText: 'OK' });
+        const options = {};
+        const result = await traceResponse(request, options, response);
+        expect(result).toBe(response);
+        expect(mockedTracing.addEventEnd).toHaveBeenCalledTimes(1);
+        const arg = mockedTracing.addEventEnd.mock.calls[0][0];
+        expect(arg.details).toEqual({ status: 200, statusText: 'OK' });
+    });
+    it('traces headers and parsed JSON body when verbose logging is enabled', async () => {
+        mockedConfig.logVerbose = true;
+        const request = new Request('https://api.example.com/users', { method: 'POST' });
+        const response = new Response(JSON.stringify({ success: true }), {
+            status: 201,
+            statusText: 'Created',
+            headers: { 'content-type': 'application/json', authorization: 'secret', 'x-custom': 'v' }
+        });
+        const options = {};
+        await traceResponse(request, options, response);
+        const arg = mockedTracing.addEventEnd.mock.calls[0][0];
+        expect(arg.details.status).toBe(201);
+        expect(arg.details.statusText).toBe('Created');
+        expect(arg.details.headers).toEqual({ 'content-type': 'application/json', authorization: 'secret', 'x-custom': 'v' });
+        expect(arg.details.body).toEqual({ mocked: true });
+    });
+    it('traces text body for non-JSON content types', async () => {
+        mockedConfig.logVerbose = true;
+        const request = new Request('https://api.example.com/ping', { method: 'GET' });
+        const response = new Response('pong', {
+            status: 200,
+            statusText: 'OK',
+            headers: { 'content-type': 'text/plain' }
+        });
+        const options = {};
+        await traceResponse(request, options, response);
+        const arg = mockedTracing.addEventEnd.mock.calls[0][0];
+        expect(arg.details.body).toEqual({ mocked: true });
+    });
+});

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import type { Options } from 'ky';
 /**
- * Creates an HTTP client with Flow SDK tracing
+ * Creates an HTTP client with Output SDK tracing
  *
  * @param options - ky options to extend the base client with
- * @returns Extended ky instance with Flow SDK hooks
+ * @returns Extended ky instance with Output SDK hooks
  *
  * @example
  * ```typescript

package/dist/index.js

@@ -1,6 +1,6 @@
 import ky from 'ky';
 import { traceRequest, traceResponse, traceError } from './hooks/index.js';
-// Create base HTTP client with standard Flow SDK tracing hooks
+// Create base HTTP client with standard Output SDK tracing hooks
 const baseHttpClient = ky.create({
     hooks: {
         beforeRequest: [
@@ -15,10 +15,10 @@ const baseHttpClient = ky.create({
     }
 });
 /**
- * Creates an HTTP client with Flow SDK tracing
+ * Creates an HTTP client with Output SDK tracing
  *
  * @param options - ky options to extend the base client with
- * @returns Extended ky instance with Flow SDK hooks
+ * @returns Extended ky instance with Output SDK hooks
  *
  * @example
  * ```typescript

package/dist/index.spec.js

@@ -1,9 +1,13 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { httpClient, HTTPError, TimeoutError } from './index.js';
-import { trace } from '@output.ai/trace';
+import { Tracing } from '@output.ai/core/tracing';
 import { config } from './config.js';
-vi.mock('@output.ai/trace', () => ({
-    trace: vi.fn()
+vi.mock('@output.ai/core/tracing', () => ({
+    Tracing: {
+        addEventStart: vi.fn(),
+        addEventEnd: vi.fn(),
+        addEventError: vi.fn()
+    }
 }));
 vi.mock('./config.js', () => ({
     config: {
@@ -90,11 +94,13 @@ vi.mock('ky', () => {
         }
     };
 });
-const mockedTrace = trace;
+const mockedTracing = vi.mocked(Tracing, true);
 const mockedConfig = vi.mocked(config);
 describe('HTTP Client', () => {
     beforeEach(() => {
-        mockedTrace.mockClear();
+        mockedTracing.addEventStart.mockClear();
+        mockedTracing.addEventEnd.mockClear();
+        mockedTracing.addEventError.mockClear();
     });
     describe('httpClient function', () => {
         it('should create an HTTP client with default options', () => {
@@ -148,13 +154,7 @@ describe('HTTP Client', () => {
                 prefixUrl: 'https://api.example.com'
             });
             await client.get('users/1');
-            expect(mockedTrace).toHaveBeenCalled();
-            const traceCall = mockedTrace.mock.calls.find(call => call[0].event === 'http.request');
-            expect(traceCall).toBeDefined();
-            if (traceCall) {
-                expect(traceCall[0].input.headers).toBeUndefined();
-                expect(traceCall[0].input.body).toBeUndefined();
-            }
+            expect(mockedTracing.addEventStart).toHaveBeenCalled();
         });
         it('should trace headers and bodies when verbose logging is enabled', async () => {
             mockedConfig.logVerbose = true;
@@ -162,13 +162,7 @@ describe('HTTP Client', () => {
                 prefixUrl: 'https://api.example.com'
             });
             await client.post('users', { json: { name: 'test', email: 'test@example.com' } });
-            expect(mockedTrace).toHaveBeenCalled();
-            const requestTraceCall = mockedTrace.mock.calls.find(call => call[0].event === 'http.request');
-            expect(requestTraceCall).toBeDefined();
-            if (requestTraceCall) {
-                expect(requestTraceCall[0].input.headers).toBeDefined();
-                expect(requestTraceCall[0].input.body).toBeDefined();
-            }
+            expect(mockedTracing.addEventStart).toHaveBeenCalled();
         });
     });
     describe('Hook Preservation', () => {
@@ -204,11 +198,8 @@ describe('HTTP Client', () => {
             await extendedClient.get('users/1');
             expect(customBeforeRequestCalled).toHaveBeenCalled();
             expect(customAfterResponseCalled).toHaveBeenCalled();
-            expect(mockedTrace).toHaveBeenCalled();
-            const requestTraceCall = mockedTrace.mock.calls.find(call => call[0].event === 'http.request');
-            const responseTraceCall = mockedTrace.mock.calls.find(call => call[0].event === 'http.response');
-            expect(requestTraceCall).toBeDefined();
-            expect(responseTraceCall).toBeDefined();
+            expect(mockedTracing.addEventStart).toHaveBeenCalled();
+            expect(mockedTracing.addEventEnd).toHaveBeenCalled();
         });
     });
     describe('Mocking Verification', () => {

package/dist/utils/create_trace_id.d.ts

@@ -0,0 +1,8 @@
+import type { KyRequest } from 'ky';
+/**
+ * Created an trace id based on the KyRequest
+ *
+ * @param {KyRequest} request
+ * @returns {string} A unique trace id
+ */
+export default function createTraceId(request: KyRequest): string;

package/dist/utils/create_trace_id.js

@@ -0,0 +1,10 @@
+import { createHash } from 'node:crypto';
+/**
+ * Created an trace id based on the KyRequest
+ *
+ * @param {KyRequest} request
+ * @returns {string} A unique trace id
+ */
+export default function createTraceId(request) {
+    return createHash('md5').update(JSON.stringify(request)).digest('hex');
+}

package/dist/utils/create_trace_id.spec.d.ts

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

package/dist/utils/create_trace_id.spec.js

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import createTraceId from './create_trace_id.js';
+describe('utils/create_trace_id', () => {
+    it('creates a deterministic md5 hash id from request', () => {
+        const req = new Request('https://ex.com/users/1', { method: 'GET' });
+        const id1 = createTraceId(req);
+        const id2 = createTraceId(req);
+        expect(typeof id1).toBe('string');
+        expect(id1).toHaveLength(32);
+        expect(id1).toBe(id2);
+    });
+});

package/dist/utils/index.d.ts

@@ -1 +1,4 @@
-export { redactHeaders } from './redact-headers.js';
+export { default as parseResponseBody } from './parse_response_body.js';
+export { default as parseRequestBody } from './parse_request_body.js';
+export { default as redactHeaders } from './redact_headers.js';
+export { default as createTraceId } from './create_trace_id.js';

package/dist/utils/index.js

@@ -1 +1,4 @@
-export { redactHeaders } from './redact-headers.js';
+export { default as parseResponseBody } from './parse_response_body.js';
+export { default as parseRequestBody } from './parse_request_body.js';
+export { default as redactHeaders } from './redact_headers.js';
+export { default as createTraceId } from './create_trace_id.js';

package/dist/utils/parse_request_body.d.ts

@@ -0,0 +1,8 @@
+import type { KyRequest } from 'ky';
+/**
+ * Safely parses request body as JSON, falling back to string if parsing fails
+ *
+ * @param {KyRequest} request
+ * @returns {object|string|null} The parsed response
+ */
+export default function parseRequestBody(request: KyRequest): Promise<object | string | null>;

package/dist/utils/parse_request_body.js

@@ -0,0 +1,19 @@
+/**
+ * Safely parses request body as JSON, falling back to string if parsing fails
+ *
+ * @param {KyRequest} request
+ * @returns {object|string|null} The parsed response
+ */
+export default async function parseRequestBody(request) {
+    if (!request.body) {
+        return null;
+    }
+    const cloned = request.clone();
+    const body = await cloned.text();
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return body;
+    }
+}

package/dist/utils/parse_request_body.spec.d.ts

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

package/dist/utils/parse_request_body.spec.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import parseRequestBody from './parse_request_body.js';
+describe('utils/parse_request_body', () => {
+    it('returns null when no body is present', async () => {
+        const req = new Request('https://ex.com', { method: 'GET' });
+        const result = await parseRequestBody(req);
+        expect(result).toBeNull();
+    });
+    it('parses JSON body when present', async () => {
+        const req = new Request('https://ex.com', { method: 'POST', body: JSON.stringify({ a: 1 }) });
+        const result = await parseRequestBody(req);
+        expect(result).toEqual({ a: 1 });
+    });
+    it('returns raw text when not valid JSON', async () => {
+        const req = new Request('https://ex.com', { method: 'POST', body: 'not-json' });
+        const result = await parseRequestBody(req);
+        expect(result).toBe('not-json');
+    });
+});

package/dist/utils/parse_response_body.d.ts

@@ -0,0 +1,10 @@
+import type { KyResponse } from 'ky';
+/**
+ * Parses response body based on content type:
+ * - application/json = object
+ * - text/plain = string
+ *
+ * @param {KyResponse} response
+ * @returns {object|string|null} The parsed response
+ */
+export default function parseResponseBody(response: KyResponse): Promise<object | string | null>;

package/dist/utils/parse_response_body.js

@@ -0,0 +1,14 @@
+/**
+ * Parses response body based on content type:
+ * - application/json = object
+ * - text/plain = string
+ *
+ * @param {KyResponse} response
+ * @returns {object|string|null} The parsed response
+ */
+export default async function parseResponseBody(response) {
+    const cloned = response.clone();
+    const contentType = response.headers.get('content-type') || '';
+    const body = await cloned[contentType.includes('application/json') ? 'json' : 'text']();
+    return body || null;
+}

package/dist/utils/parse_response_body.spec.d.ts

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

package/dist/utils/parse_response_body.spec.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import parseResponseBody from './parse_response_body.js';
+describe('utils/parse_response_body', () => {
+    it('parses JSON when content-type is application/json', async () => {
+        const res = new Response(JSON.stringify({ ok: true }), { headers: { 'content-type': 'application/json' } });
+        const result = await parseResponseBody(res);
+        expect(result).toEqual({ ok: true });
+    });
+    it('returns text when content-type is not JSON', async () => {
+        const res = new Response('hello', { headers: { 'content-type': 'text/plain' } });
+        const result = await parseResponseBody(res);
+        expect(result).toBe('hello');
+    });
+    it('returns null for empty body', async () => {
+        const res = new Response('', { headers: { 'content-type': 'text/plain' } });
+        const result = await parseResponseBody(res);
+        expect(result).toBeNull();
+    });
+});

package/dist/utils/{redact-headers.d.ts → redact_headers.d.ts}

@@ -3,4 +3,4 @@
  * @param headers - Headers object to redact
  * @returns Object with sensitive headers redacted
  */
-export declare function redactHeaders(headers: Record<string, string> | Headers): Record<string, string>;
+export default function redactHeaders(headers: Record<string, string> | Headers): Record<string, string>;

package/dist/utils/{redact-headers.js → redact_headers.js}

@@ -5,9 +5,9 @@ const SENSITIVE_HEADER_PATTERNS = [
     /authorization/i,
     /token/i,
     /api-?key/i,
-    /apikey/i,
     /secret/i,
     /password/i,
+    /pwd/i,
     /key/i,
     /cookie/i
 ];
@@ -16,7 +16,7 @@ const SENSITIVE_HEADER_PATTERNS = [
  * @param headers - Headers object to redact
  * @returns Object with sensitive headers redacted
  */
-export function redactHeaders(headers) {
+export default function redactHeaders(headers) {
     const result = {};
     const entries = headers instanceof Headers ? headers.entries() : Object.entries(headers);
     for (const [key, value] of entries) {

package/dist/utils/redact_headers.spec.d.ts

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

package/dist/utils/{redact-headers.spec.js → redact_headers.spec.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { redactHeaders } from './redact-headers.js';
+import redactHeaders from './redact_headers.js';
 describe('redactHeaders', () => {
     describe('with Record<string, string> input', () => {
         it('should redact sensitive headers (case insensitive)', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/http",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Framework abstraction to make HTTP calls with tracing",
   "type": "module",
   "main": "dist/index.js",
@@ -11,12 +11,12 @@
   "scripts": {
     "build": "rm -rf ./dist && tsc"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/growthxai/flow-sdk"
-  },
   "dependencies": {
-    "@output.ai/trace": "0.0.1",
+    "@output.ai/core": ">=0.0.1",
     "ky": "~1.9.1"
+  },
+  "license": "UNLICENSED",
+  "imports": {
+    "#*": "./dist/*"
   }
 }

package/dist/hooks/trace-error.js

@@ -1,34 +0,0 @@
-import { HTTPError } from 'ky';
-import { trace } from '@output.ai/trace';
-import { redactHeaders } from '../utils/index.js';
-/**
- * Traces HTTP errors for observability using Flow SDK tracing
- */
-export const traceError = async (error) => {
-    const request = error.request;
-    const response = error.response;
-    const requestHeaders = Object.fromEntries(request.headers.entries());
-    trace({
-        lib: 'flow-http',
-        event: 'http.error',
-        input: {
-            method: request.method,
-            url: request.url,
-            requestHeaders: redactHeaders(requestHeaders)
-        },
-        output: {
-            error: error instanceof HTTPError && response ? {
-                name: error.name,
-                message: error.message,
-                status: response.status,
-                statusText: response.statusText,
-                headers: redactHeaders(Object.fromEntries(response.headers.entries()))
-            } : {
-                name: error.name,
-                message: error.message,
-                type: 'network'
-            }
-        }
-    });
-    return error;
-};

package/dist/hooks/trace-request.js

@@ -1,42 +0,0 @@
-import { trace } from '@output.ai/trace';
-import { redactHeaders } from '../utils/index.js';
-import { config } from '../config.js';
-/**
- * Safely parses request body as JSON, falling back to string if parsing fails
- */
-async function safeParseBody(request) {
-    if (!request.body) {
-        return null;
-    }
-    const cloned = request.clone();
-    const body = await cloned.text();
-    if (!body) {
-        return null;
-    }
-    try {
-        return JSON.parse(body);
-    }
-    catch {
-        return body;
-    }
-}
-/**
- * Traces HTTP request for observability using Flow SDK tracing
- * Respects LOG_HTTP_VERBOSE environment variable for detailed logging
- */
-export const traceRequest = async (request) => {
-    const traceData = {
-        method: request.method,
-        url: request.url
-    };
-    if (config.logVerbose) {
-        const headers = Object.fromEntries(request.headers.entries());
-        traceData.headers = redactHeaders(headers);
-        traceData.body = await safeParseBody(request);
-    }
-    trace({
-        lib: 'flow-http',
-        event: 'http.request',
-        input: traceData
-    });
-};

package/dist/hooks/trace-response.js

@@ -1,45 +0,0 @@
-import { trace } from '@output.ai/trace';
-import { redactHeaders } from '../utils/index.js';
-import { config } from '../config.js';
-/**
- * Safely parses response body based on content type
- */
-async function safeParseResponseBody(response) {
-    const cloned = response.clone();
-    const contentType = response.headers.get('content-type') || '';
-    const body = contentType.includes('application/json') ?
-        await cloned.json() :
-        await cloned.text();
-    if (body !== null && body !== undefined && body !== '') {
-        return body;
-    }
-    return null;
-}
-/**
- * Traces HTTP response for observability using Flow SDK tracing
- * Respects LOG_HTTP_VERBOSE environment variable for detailed logging
- */
-export const traceResponse = async (request, options, response) => {
-    const inputData = {
-        method: request.method,
-        url: request.url
-    };
-    const outputData = {
-        status: response.status,
-        statusText: response.statusText
-    };
-    if (config.logVerbose) {
-        const requestHeaders = Object.fromEntries(request.headers.entries());
-        const responseHeaders = Object.fromEntries(response.headers.entries());
-        inputData.requestHeaders = redactHeaders(requestHeaders);
-        outputData.headers = redactHeaders(responseHeaders);
-        outputData.body = await safeParseResponseBody(response);
-    }
-    trace({
-        lib: 'flow-http',
-        event: 'http.response',
-        input: inputData,
-        output: outputData
-    });
-    return response;
-};