@outputai/http 0.10.1-next.69a0f11.0 → 0.10.1-next.af37678.0

package/dist/fetch/events.d.ts

@@ -0,0 +1,20 @@
+export function emitError({ requestId, method, url, status, durationMs }: {
+    requestId: any;
+    method: any;
+    url: any;
+    status: any;
+    durationMs: any;
+}): boolean;
+export function emitSuccess({ requestId, method, url, status, durationMs }: {
+    requestId: any;
+    method: any;
+    url: any;
+    status: any;
+    durationMs: any;
+}): boolean;
+export function emitFailure({ requestId, method, url, durationMs }: {
+    requestId: any;
+    method: any;
+    url: any;
+    durationMs: any;
+}): boolean;

package/dist/fetch/events.js

@@ -0,0 +1,4 @@
+import { Event } from '@outputai/core/sdk/runtime';
+export const emitError = ({ requestId, method, url, status, durationMs }) => Event.emit('http:request', { requestId, method, url, status, durationMs, outcome: 'error' });
+export const emitSuccess = ({ requestId, method, url, status, durationMs }) => Event.emit('http:request', { requestId, method, url, status, durationMs, outcome: 'success' });
+export const emitFailure = ({ requestId, method, url, durationMs }) => Event.emit('http:request', { requestId, method, url, status: undefined, durationMs, outcome: 'failure' });

package/dist/fetch/events.spec.js

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@outputai/core/sdk/runtime', () => ({
+    Event: {
+        emit: vi.fn()
+    }
+}));
+import { Event } from '@outputai/core/sdk/runtime';
+import { emitError, emitFailure, emitSuccess } from './events.js';
+const event = vi.mocked(Event, true);
+beforeEach(() => {
+    event.emit.mockClear();
+});
+describe('instrumented_fetch/events', () => {
+    it('emits a successful request', async () => {
+        await emitSuccess({
+            requestId: 'request-success',
+            method: 'GET',
+            url: 'https://example.com/success',
+            status: 200,
+            durationMs: 12
+        });
+        expect(event.emit).toHaveBeenCalledWith('http:request', {
+            requestId: 'request-success',
+            method: 'GET',
+            url: 'https://example.com/success',
+            status: 200,
+            durationMs: 12,
+            outcome: 'success'
+        });
+    });
+    it('emits an HTTP error', async () => {
+        await emitError({
+            requestId: 'request-error',
+            method: 'POST',
+            url: 'https://example.com/error',
+            status: 503,
+            durationMs: 23
+        });
+        expect(event.emit).toHaveBeenCalledWith('http:request', {
+            requestId: 'request-error',
+            method: 'POST',
+            url: 'https://example.com/error',
+            status: 503,
+            durationMs: 23,
+            outcome: 'error'
+        });
+    });
+    it('emits a transport failure without a status', () => {
+        emitFailure({
+            requestId: 'request-failure',
+            method: 'DELETE',
+            url: 'https://example.com/failure',
+            durationMs: 34
+        });
+        expect(event.emit).toHaveBeenCalledWith('http:request', {
+            requestId: 'request-failure',
+            method: 'DELETE',
+            url: 'https://example.com/failure',
+            status: undefined,
+            durationMs: 34,
+            outcome: 'failure'
+        });
+    });
+});

package/dist/fetch/index.d.ts

@@ -1,17 +1,15 @@
-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 };
+import * as undici from 'undici';
+type NodeRequestInfo = string | URL | globalThis.Request;
+type NodeRequestInit = globalThis.RequestInit & Pick<undici.RequestInit, 'dispatcher'>;
+type OutputFetch = {
+    (input: NodeRequestInfo, init?: NodeRequestInit): Promise<Response>;
+    (input: undici.RequestInfo, init?: undici.RequestInit): Promise<Response>;
+};
 /**
  * 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;
+ * - 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;
  * - Emits a `http:request` event on every call (success, error, failure).
  *
@@ -20,4 +18,5 @@ RequestInit };
  * @param init - Request options
  * @returns The HTTP response
  */
-export declare const fetch: (input: RequestInfo | Request, init?: RequestInit) => Promise<Response>;
+export declare const outputFetch: OutputFetch;
+export {};

package/dist/fetch/index.default_dispatcher.spec.d.ts

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

package/dist/fetch/index.default_dispatcher.spec.js

@@ -0,0 +1,47 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const undiciMock = vi.hoisted(() => ({
+    dispatcher: { dispatch: vi.fn() },
+    envHttpProxyAgent: vi.fn(),
+    fetch: vi.fn()
+}));
+vi.mock('undici', async (importOriginal) => {
+    const actual = await importOriginal();
+    class EnvHttpProxyAgent {
+        constructor(options) {
+            undiciMock.envHttpProxyAgent(options);
+            return undiciMock.dispatcher;
+        }
+    }
+    return {
+        ...actual,
+        EnvHttpProxyAgent,
+        fetch: undiciMock.fetch
+    };
+});
+vi.mock('./logger.js', () => ({
+    logRequest: vi.fn(),
+    logResponse: vi.fn(),
+    logError: vi.fn(),
+    logFailure: vi.fn()
+}));
+vi.mock('./events.js', () => ({
+    emitSuccess: vi.fn(),
+    emitError: vi.fn(),
+    emitFailure: vi.fn()
+}));
+vi.mock('./utils.js', () => ({
+    addRequestIdToResponse: vi.fn()
+}));
+import { Request, Response } from 'undici';
+import { outputFetch } from './index.js';
+describe('outputFetch default dispatcher', () => {
+    beforeEach(() => {
+        undiciMock.fetch.mockReset();
+        undiciMock.fetch.mockResolvedValue(new Response('ok'));
+    });
+    it('uses an EnvHttpProxyAgent when dispatcher is omitted', async () => {
+        await outputFetch('https://example.com');
+        expect(undiciMock.envHttpProxyAgent).toHaveBeenCalledWith({ allowH2: false });
+        expect(undiciMock.fetch).toHaveBeenCalledWith(expect.any(Request), { dispatcher: undiciMock.dispatcher });
+    });
+});

package/dist/fetch/index.js

@@ -1,21 +1,29 @@
-import * as undici from 'undici';
 import { randomUUID } from 'node:crypto';
 import { logRequest, logResponse, logError, logFailure } from './logger.js';
+import { emitSuccess, emitError, emitFailure } from './events.js';
 import { addRequestIdToResponse } from './utils.js';
+import * as undici from 'undici';
 /* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
 const customDispatcher = new undici.EnvHttpProxyAgent({ allowH2: false });
-/*
- * 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';
+const createUndiciRequest = (input, init) => {
+    const isNodeRequest = input instanceof globalThis.Request;
+    const hasNodeFormData = init?.body instanceof globalThis.FormData;
+    const isUndiciRequest = input instanceof undici.Request;
+    const hasUndiciFormData = init?.body instanceof undici.FormData;
+    if ((isNodeRequest && hasUndiciFormData) || (isUndiciRequest && hasNodeFormData)) {
+        throw new TypeError('Cannot mix Node and Undici Request/FormData realms.');
+    }
+    if (!isNodeRequest && !hasNodeFormData) {
+        return new undici.Request(input, init);
+    }
+    const request = new globalThis.Request(input, init);
+    return new undici.Request(request.url, request);
+};
 /**
  * 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;
+ * - 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;
  * - Emits a `http:request` event on every call (success, error, failure).
  *
@@ -24,9 +32,10 @@ export * as undici from 'undici';
  * @param init - Request options
  * @returns The HTTP response
  */
-export const fetch = async (input, init) => {
+export const outputFetch = async (input, init) => {
+    const { dispatcher: inputDispatcher, ...requestInit } = (init ?? {});
     // Creates a Request object with the many shapes RequestInfo can have
-    const base = new undici.Request(input, init);
+    const base = createUndiciRequest(input, requestInit);
     // 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();
@@ -34,25 +43,29 @@ export const fetch = async (input, init) => {
     const request = new undici.Request(base, { headers });
     const method = request.method;
     const url = request.url;
-    const startedAt = performance.now();
+    const startedAt = Date.now();
     await logRequest({ requestId, request });
     // this allows for users not only to override the dispatcher but also to define it as undefined and remove it altogether.
-    const dispatcher = Object.hasOwn(init ?? {}, 'dispatcher') ? init?.dispatcher : customDispatcher;
+    const dispatcher = Object.hasOwn(init ?? {}, 'dispatcher') ? inputDispatcher : customDispatcher;
     try {
         const response = await undici.fetch(request, dispatcher ? { dispatcher } : undefined);
-        const durationMs = performance.now() - startedAt;
+        const durationMs = Date.now() - startedAt;
+        const { status } = response;
         // This enriches the response of the request id, so it is identifiable later.
         addRequestIdToResponse(response, requestId);
-        if (response.status > 399) {
-            await logError({ requestId, response, method, url, durationMs });
+        if (status > 399) {
+            await logError({ requestId, response });
+            emitError({ requestId, method, url, status, durationMs });
             return response;
         }
-        await logResponse({ requestId, response, method, url, durationMs });
+        await logResponse({ requestId, response });
+        emitSuccess({ requestId, method, url, status, durationMs });
         return response;
     }
     catch (error) {
-        const durationMs = performance.now() - startedAt;
-        logFailure({ requestId, error: error, method, url, durationMs });
+        const durationMs = Date.now() - startedAt;
+        logFailure({ requestId, error });
+        emitFailure({ requestId, method, url, durationMs });
         throw error;
     }
 };

package/dist/fetch/index.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { getGlobalDispatcher, Headers, MockAgent, Request, setGlobalDispatcher } from 'undici';
+import { FormData as UndiciFormData, 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(() => ({
@@ -11,6 +11,11 @@ const loggerMock = vi.hoisted(() => ({
 const utilsMock = vi.hoisted(() => ({
     addRequestIdToResponse: vi.fn()
 }));
+const eventsMock = vi.hoisted(() => ({
+    emitSuccess: vi.fn(),
+    emitError: vi.fn(),
+    emitFailure: vi.fn()
+}));
 vi.mock('node:crypto', () => ({
     randomUUID: () => randomUUIDMock()
 }));
@@ -23,14 +28,19 @@ vi.mock('./logger.js', () => ({
 vi.mock('./utils.js', () => ({
     addRequestIdToResponse: utilsMock.addRequestIdToResponse
 }));
-import { fetch } from './index.js';
+vi.mock('./events.js', () => ({
+    emitSuccess: eventsMock.emitSuccess,
+    emitError: eventsMock.emitError,
+    emitFailure: eventsMock.emitFailure
+}));
+import { outputFetch } from './index.js';
 const MOCK_ORIGIN = 'https://fetch-index.undici.test';
-describe('fetch/index', () => {
+describe('instrumented_fetch/index', () => {
     const undiciCtx = {
         mockAgent: undefined,
         previousDispatcher: undefined
     };
-    const fetchWithMockDispatcher = (input, init) => fetch(input, { ...init, dispatcher: undiciCtx.mockAgent });
+    const fetchWithMockDispatcher = (input, init) => outputFetch(input, { ...init, dispatcher: undiciCtx.mockAgent });
     beforeEach(() => {
         undiciCtx.mockAgent = new MockAgent();
         undiciCtx.mockAgent.disableNetConnect();
@@ -41,6 +51,9 @@ describe('fetch/index', () => {
         loggerMock.logError.mockClear();
         loggerMock.logFailure.mockClear();
         utilsMock.addRequestIdToResponse.mockClear();
+        eventsMock.emitSuccess.mockClear();
+        eventsMock.emitError.mockClear();
+        eventsMock.emitFailure.mockClear();
         randomUUIDMock.mockClear();
         randomUUIDMock.mockImplementation(() => FIXED_REQUEST_ID);
     });
@@ -66,14 +79,17 @@ describe('fetch/index', () => {
             const responseCall = loggerMock.logResponse.mock.calls[0][0];
             expect(responseCall.requestId).toBe(FIXED_REQUEST_ID);
             expect(responseCall.response).toBe(response);
-            expect(responseCall.method).toBe('GET');
-            expect(responseCall.url).toBe(`${MOCK_ORIGIN}/ok`);
-            expect(typeof responseCall.durationMs).toBe('number');
-            expect(responseCall.durationMs).toBeGreaterThanOrEqual(0);
             expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledTimes(1);
             expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledWith(response, FIXED_REQUEST_ID);
             expect(loggerMock.logError).not.toHaveBeenCalled();
             expect(loggerMock.logFailure).not.toHaveBeenCalled();
+            expect(eventsMock.emitSuccess).toHaveBeenCalledWith({
+                requestId: FIXED_REQUEST_ID,
+                method: 'GET',
+                url: `${MOCK_ORIGIN}/ok`,
+                status: 200,
+                durationMs: expect.any(Number)
+            });
         });
         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' } });
@@ -86,6 +102,13 @@ describe('fetch/index', () => {
             expect(loggerMock.logError.mock.calls[0][0].response).toBe(response);
             expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledTimes(1);
             expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledWith(response, FIXED_REQUEST_ID);
+            expect(eventsMock.emitError).toHaveBeenCalledWith({
+                requestId: FIXED_REQUEST_ID,
+                method: 'GET',
+                url: `${MOCK_ORIGIN}/missing`,
+                status: 404,
+                durationMs: expect.any(Number)
+            });
         });
         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' } });
@@ -142,6 +165,12 @@ describe('fetch/index', () => {
             expect(failure.message).toBe('fetch failed');
             expect(failure.cause).toBeInstanceOf(Error);
             expect(failure.cause.message).toBe('simulated network failure');
+            expect(eventsMock.emitFailure).toHaveBeenCalledWith({
+                requestId: FIXED_REQUEST_ID,
+                method: 'GET',
+                url: `${MOCK_ORIGIN}/boom`,
+                durationMs: expect.any(Number)
+            });
         });
         it('fails when no mock matches (disabled net)', async () => {
             await expect(fetchWithMockDispatcher(`${MOCK_ORIGIN}/unmocked`)).rejects.toThrow();
@@ -168,7 +197,7 @@ describe('fetch/index', () => {
             expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('GET');
         });
     });
-    describe('fetch RequestInfo / RequestInit shapes', () => {
+    describe('outputFetch 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}/`);
@@ -187,6 +216,80 @@ describe('fetch/index', () => {
             expect(request.method).toBe('GET');
             expect(request.url).toBe(`${MOCK_ORIGIN}/req-only`);
         });
+        it('accepts Node built-in Request and Headers instances', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({
+                path: '/node-request',
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'x-node-header': 'node-value',
+                    'x-request-trace-id': FIXED_REQUEST_ID
+                }
+            }).reply(201, JSON.stringify({ created: true }), {
+                headers: { 'content-type': 'application/json' }
+            });
+            const headers = new globalThis.Headers({
+                'content-type': 'application/json',
+                'x-node-header': 'node-value'
+            });
+            const input = new globalThis.Request(`${MOCK_ORIGIN}/node-request`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ name: 'node' })
+            });
+            const response = await fetchWithMockDispatcher(input);
+            const nodeResponse = response;
+            expect(input).not.toBeInstanceOf(Request);
+            expect(nodeResponse.status).toBe(201);
+            await expect(nodeResponse.json()).resolves.toEqual({ created: true });
+            expect(loggerMock.logRequest.mock.calls[0][0].request).toBeInstanceOf(Request);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('POST');
+        });
+        it('encodes Node built-in FormData before entering the Undici realm', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({
+                path: '/node-form-data',
+                method: 'POST'
+            }).reply(200, 'ok');
+            const body = new globalThis.FormData();
+            body.set('name', 'node');
+            loggerMock.logRequest.mockImplementationOnce(async ({ request }) => {
+                expect(request).toBeInstanceOf(Request);
+                expect(request.headers.get('content-type')).toMatch(/^multipart\/form-data; boundary=/);
+                await expect(request.clone().text()).resolves.toContain('name="name"\r\n\r\nnode');
+            });
+            const response = await fetchWithMockDispatcher(`${MOCK_ORIGIN}/node-form-data`, {
+                method: 'POST',
+                body
+            });
+            expect(response.status).toBe(200);
+        });
+        it('rejects mixed Request and FormData realms', async () => {
+            const input = new globalThis.Request(`${MOCK_ORIGIN}/mixed-realms`, { method: 'POST', body: 'node' });
+            const body = new UndiciFormData();
+            body.set('name', 'undici');
+            await expect(fetchWithMockDispatcher(input, {
+                method: 'POST',
+                body: body
+            })).rejects.toThrow('Cannot mix Node and Undici Request/FormData realms.');
+        });
+        it('accepts Node built-in RequestInit with a string input', async () => {
+            undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({
+                path: '/node-init',
+                method: 'PATCH',
+                headers: {
+                    'x-node-init': 'yes',
+                    'x-request-trace-id': FIXED_REQUEST_ID
+                }
+            }).reply(204);
+            const init = {
+                method: 'PATCH',
+                headers: new globalThis.Headers({ 'x-node-init': 'yes' })
+            };
+            const response = await fetchWithMockDispatcher(`${MOCK_ORIGIN}/node-init`, init);
+            expect(response.status).toBe(204);
+            expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('PATCH');
+            expect(loggerMock.logRequest.mock.calls[0][0].request.headers.get('x-node-init')).toBe('yes');
+        });
         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' });
@@ -232,7 +335,7 @@ describe('fetch/index', () => {
                     'x-custom': 'custom-value'
                 }
             }).reply(200, 'ok');
-            const response = await fetch(`${MOCK_ORIGIN}/custom-dispatcher`, {
+            const response = await outputFetch(`${MOCK_ORIGIN}/custom-dispatcher`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -253,7 +356,7 @@ describe('fetch/index', () => {
                 method: 'GET',
                 headers: { 'x-request-trace-id': FIXED_REQUEST_ID }
             }).reply(200, 'ok');
-            const response = await fetch(`${MOCK_ORIGIN}/undefined-dispatcher`, {
+            const response = await outputFetch(`${MOCK_ORIGIN}/undefined-dispatcher`, {
                 dispatcher: undefined
             });
             expect(response.status).toBe(200);

package/dist/fetch/logger.d.ts

@@ -1,66 +1,16 @@
-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
- * and emits a `http:request` event with `outcome: 'error'`.
- *
- * @param options
- * @param options.requestId - id of the request
- * @param options.response - The HTTP Response object
- * @param options.method - HTTP method of the request
- * @param options.url - URL of the request
- * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
- */
-export declare const logError: ({ requestId, response, method, url, durationMs }: {
-    requestId: string;
-    response: Response;
-    method: string;
-    url: string;
-    durationMs: number;
-}) => Promise<void>;
-/**
- * Sends the trace end event for an http response
- * and emits a `http:request` event with `outcome: 'success'`.
- *
- * @param {object} options
- * @param options.requestId - id of the request
- * @param {Response} options.response - The HTTP Response object
- * @param options.method - HTTP method of the request
- * @param options.url - URL of the request
- * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
- */
-export declare const logResponse: ({ requestId, response, method, url, durationMs }: {
-    requestId: string;
-    response: Response;
-    method: string;
-    url: string;
-    durationMs: number;
-}) => Promise<void>;
-/**
- * Creates the trace error event for a network/connection failure
- * and emits a `http:request` event with `outcome: 'failure'`.
- *
- * @param options
- * @param options.requestId - id of the request
- * @param options.error - The error thrown
- * @param options.method - HTTP method of the request
- * @param options.url - URL of the request
- * @param options.durationMs - elapsed time from request issuance to failure, in milliseconds
- */
-export declare const logFailure: ({ requestId, error, method, url, durationMs }: {
-    requestId: string;
-    error: Error;
-    method: string;
-    url: string;
-    durationMs: number;
-}) => void;
+export function logRequest({ requestId, request }: {
+    requestId: any;
+    request: any;
+}): Promise<void>;
+export function logError({ requestId, response }: {
+    requestId: any;
+    response: any;
+}): Promise<void>;
+export function logResponse({ requestId, response }: {
+    requestId: any;
+    response: any;
+}): Promise<void>;
+export function logFailure({ requestId, error }: {
+    requestId: any;
+    error: any;
+}): void;

package/dist/fetch/logger.js

@@ -1,10 +1,6 @@
-import { Tracing, Event } from '@outputai/core/sdk/runtime';
+import { Tracing } from '@outputai/core/sdk/runtime';
 import { config } from '../config.js';
 import { parseBody, redactHeaders, serializeError } from './utils.js';
-/** Single source of truth for the `http:request` event shape. */
-const emitHttpRequestEvent = (payload) => {
-    Event.emit('http:request', payload);
-};
 /**
  * Sends the trace start event for an http request
  *
@@ -22,67 +18,18 @@ export const logRequest = async ({ requestId, request }) => {
     });
     Tracing.addEventAttribute({ eventId: requestId, attribute: new Tracing.Attribute.HTTPRequestCount(request.url, requestId) });
 };
-/**
- * Sends the trace error event for an http response with error status
- * and emits a `http:request` event with `outcome: 'error'`.
- *
- * @param options
- * @param options.requestId - id of the request
- * @param options.response - The HTTP Response object
- * @param options.method - HTTP method of the request
- * @param options.url - URL of the request
- * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
- */
-export const logError = async ({ requestId, response, method, url, durationMs }) => {
-    await Tracing.addEventError({
-        id: requestId, details: {
-            status: response.status,
-            statusText: response.statusText,
-            headers: redactHeaders(response.headers),
-            body: await parseBody(response)
-        }
-    });
-    emitHttpRequestEvent({
-        requestId, method, url, status: response.status, durationMs, outcome: 'error'
-    });
-};
-/**
- * Sends the trace end event for an http response
- * and emits a `http:request` event with `outcome: 'success'`.
- *
- * @param {object} options
- * @param options.requestId - id of the request
- * @param {Response} options.response - The HTTP Response object
- * @param options.method - HTTP method of the request
- * @param options.url - URL of the request
- * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
- */
-export const logResponse = async ({ requestId, response, method, url, durationMs }) => {
-    await Tracing.addEventEnd({
-        id: requestId, details: {
-            status: response.status,
-            statusText: response.statusText,
-            ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
-        }
-    });
-    emitHttpRequestEvent({
-        requestId, method, url, status: response.status, durationMs, outcome: 'success'
-    });
-};
-/**
- * Creates the trace error event for a network/connection failure
- * and emits a `http:request` event with `outcome: 'failure'`.
- *
- * @param options
- * @param options.requestId - id of the request
- * @param options.error - The error thrown
- * @param options.method - HTTP method of the request
- * @param options.url - URL of the request
- * @param options.durationMs - elapsed time from request issuance to failure, in milliseconds
- */
-export const logFailure = ({ requestId, error, method, url, durationMs }) => {
-    Tracing.addEventError({ id: requestId, details: serializeError(error) });
-    emitHttpRequestEvent({
-        requestId, method, url, status: undefined, durationMs, outcome: 'failure'
-    });
-};
+export const logError = async ({ requestId, response }) => Tracing.addEventError({
+    id: requestId, details: {
+        status: response.status,
+        statusText: response.statusText,
+        ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
+    }
+});
+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) })
+    }
+});
+export const logFailure = ({ requestId, error }) => Tracing.addEventError({ id: requestId, details: serializeError(error) });