@outputai/core 0.9.1-next.ca5a2f9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.9.1-next.ca5a2f9.0",
+  "version": "0.9.1",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/internal_activities/index.js

@@ -1,5 +1,5 @@
 import { FatalError } from '#errors';
-import { fetch } from 'undici';
+import { EnvHttpProxyAgent, fetch } from 'undici';
 import { serializeFetchResponse, serializeBodyAndInferContentType } from '#helpers/fetch';
 import { createChildLogger } from '#logger';
 import { getDestinations } from '#tracing';
@@ -8,6 +8,9 @@ import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#co
 
 const log = createChildLogger( 'HttpClient' );
 
+/* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
+const dispatcher = new EnvHttpProxyAgent( { allowH2: false } );
+
 /**
  * Send a HTTP request.
  *
@@ -26,7 +29,8 @@ export const sendHttpRequest = createInternalStep( {
     const args = {
       method,
       headers: new Headers( headers ?? {} ),
-      signal: AbortSignal.timeout( timeout )
+      signal: AbortSignal.timeout( timeout ),
+      dispatcher
     };
 
     const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];

package/src/internal_activities/index.spec.js

@@ -1,5 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MockAgent, setGlobalDispatcher } from 'undici';
 import { FatalError } from '#errors';
 import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 import { serializeBodyAndInferContentType, serializeFetchResponse } from '#helpers/fetch';
@@ -7,6 +6,15 @@ import { getTraceDestinations, sendHttpRequest } from './index.js';
 
 const getDestinationsMock = vi.hoisted( () => vi.fn() );
 const createInternalStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
+const fetchMock = vi.hoisted( () => vi.fn() );
+const EnvHttpProxyAgentMock = vi.hoisted( () => vi.fn( function EnvHttpProxyAgent( options ) {
+  this.options = options;
+} ) );
+
+vi.mock( 'undici', () => ( {
+  EnvHttpProxyAgent: EnvHttpProxyAgentMock,
+  fetch: fetchMock
+} ) );
 
 vi.mock( '#tracing', () => ( {
   getDestinations: getDestinationsMock
@@ -30,16 +38,20 @@ vi.mock( '#helpers/fetch', () => ( {
   serializeFetchResponse: vi.fn()
 } ) );
 
-const mockAgent = new MockAgent();
-mockAgent.disableNetConnect();
-
-setGlobalDispatcher( mockAgent );
-
 const url = 'https://growthx.ai';
 const method = 'GET';
 
+const response = ( { ok = true, status = 200, statusText = 'OK', headers = {} } = {} ) => ( {
+  ok,
+  status,
+  statusText,
+  headers: new Headers( headers ),
+  text: vi.fn()
+} );
+
 describe( 'internal_activities component registration', () => {
   it( 'creates internal step components for exported activities', () => {
+    expect( EnvHttpProxyAgentMock ).toHaveBeenCalledWith( { allowH2: false } );
     expect( createInternalStepMock ).toHaveBeenNthCalledWith( 1, {
       name: ACTIVITY_SEND_HTTP_REQUEST,
       handler: expect.any( Function )
@@ -55,18 +67,19 @@ describe( 'internal_activities component registration', () => {
 
 describe( 'internal_activities/sendHttpRequest', () => {
   beforeEach( async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
+    fetchMock.mockReset();
+    serializeBodyAndInferContentType.mockReset();
+    serializeFetchResponse.mockReset();
   } );
 
   it( 'succeeds and returns serialized JSON response', async () => {
     const payload = { a: 1 };
     const method = 'POST';
 
-    mockAgent.get( url ).intercept( { path: '/', method } )
-      .reply( 200, JSON.stringify( { ok: true, value: 42 } ), {
-        headers: { 'content-type': 'application/json' }
-      } );
+    fetchMock.mockResolvedValueOnce( response( {
+      status: 200,
+      headers: { 'content-type': 'application/json' }
+    } ) );
 
     // mock utils
     serializeBodyAndInferContentType.mockReturnValueOnce( {
@@ -81,6 +94,10 @@ describe( 'internal_activities/sendHttpRequest', () => {
     // utils mocked: verify calls and returned value
     expect( serializeBodyAndInferContentType ).toHaveBeenCalledTimes( 1 );
     expect( serializeBodyAndInferContentType ).toHaveBeenCalledWith( payload );
+    expect( fetchMock ).toHaveBeenCalledWith( url, expect.objectContaining( {
+      method,
+      dispatcher: expect.any( EnvHttpProxyAgentMock )
+    } ) );
     expect( serializeFetchResponse ).toHaveBeenCalledTimes( 1 );
     const respArg = serializeFetchResponse.mock.calls[0][0];
     expect( respArg && typeof respArg.text ).toBe( 'function' );
@@ -90,7 +107,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
   } );
 
   it( 'throws FatalError when response.ok is false', async () => {
-    mockAgent.get( url ).intercept( { path: '/', method } ).reply( 500, 'Internal error' );
+    fetchMock.mockResolvedValueOnce( response( { ok: false, status: 500, statusText: 'Internal Server Error' } ) );
 
     await expect( sendHttpRequest( { url, method } ) ).rejects
       .toThrow( new FatalError( 'GET https://growthx.ai 500' ) );
@@ -99,9 +116,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
   } );
 
   it( 'throws FatalError on timeout failure', async () => {
-    mockAgent.get( url ).intercept( { path: '/', method } )
-      .reply( 200, 'ok', { headers: { 'content-type': 'text/plain' } } )
-      .delay( 10_000 );
+    fetchMock.mockRejectedValueOnce( new Error( 'The operation was aborted due to timeout' ) );
 
     await expect( sendHttpRequest( { url, method, timeout: 250 } ) ).rejects
       .toThrow( new FatalError( 'GET https://growthx.ai The operation was aborted due to timeout' ) );
@@ -110,8 +125,9 @@ describe( 'internal_activities/sendHttpRequest', () => {
   } );
 
   it( 'wraps DNS resolution errors (ENOTFOUND) preserving cause message', async () => {
-    mockAgent.get( url ).intercept( { path: '/', method } )
-      .replyWithError( new Error( 'getaddrinfo ENOTFOUND nonexistent.example.test' ) );
+    fetchMock.mockRejectedValueOnce(
+      Object.assign( new Error( 'fetch failed' ), { cause: new Error( 'getaddrinfo ENOTFOUND nonexistent.example.test' ) } )
+    );
 
     await expect( sendHttpRequest( { url, method } ) ).rejects
       .toThrow( new FatalError( 'GET https://growthx.ai Error: getaddrinfo ENOTFOUND nonexistent.example.test' ) );
@@ -120,8 +136,9 @@ describe( 'internal_activities/sendHttpRequest', () => {
   } );
 
   it( 'wraps TCP connection errors (ECONNREFUSED) preserving cause message', async () => {
-    mockAgent.get( url ).intercept( { path: '/', method } )
-      .replyWithError( new Error( 'connect ECONNREFUSED 127.0.0.1:65500' ) );
+    fetchMock.mockRejectedValueOnce(
+      Object.assign( new Error( 'fetch failed' ), { cause: new Error( 'connect ECONNREFUSED 127.0.0.1:65500' ) } )
+    );
 
     await expect( sendHttpRequest( { url, method } ) ).rejects
       .toThrow( new FatalError( 'GET https://growthx.ai Error: connect ECONNREFUSED 127.0.0.1:65500' ) );

package/src/worker/proxy.js

@@ -5,28 +5,16 @@ const log = createChildLogger( 'Proxy' );
 
 /**
  * Routes all `fetch()` calls (including those inside Temporal activities)
- * through an HTTP/HTTPS proxy when standard proxy env vars are set
- * (`HTTPS_PROXY`, `https_proxy`, `HTTP_PROXY`, `http_proxy`). No-op when
- * none are set. Invalid URLs are logged and skipped so the worker keeps
- * running.
- *
- * Call once at worker startup, before any network activity.
+ * through an HTTP/HTTPS proxy when standard proxy env vars are set.
+ * No-op when none are set.
  */
 export const bootstrapFetchProxy = () => {
-  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy ||
-    process.env.HTTP_PROXY || process.env.http_proxy;
+  const httpProxyUrl = process.env.http_proxy ?? process.env.HTTP_PROXY;
+  const httpsProxyUrl = process.env.https_proxy ?? process.env.HTTPS_PROXY;
 
-  if ( !proxyUrl ) {
-    return;
+  if ( httpProxyUrl?.length > 0 || httpsProxyUrl?.length > 0 ) {
+    log.info( 'Proxy env vars detected, setting up global fetch dispatcher EnvHttpProxyAgent', { httpProxyUrl, httpsProxyUrl } );
+    /* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
+    setGlobalDispatcher( new EnvHttpProxyAgent( { allowH2: false } ) );
   }
-
-  try {
-    new URL( proxyUrl );
-  } catch {
-    log.warn( 'Ignoring invalid proxy URL', { proxyUrl } );
-    return;
-  }
-
-  log.info( 'Routing fetch() through HTTP proxy', { proxyUrl } );
-  setGlobalDispatcher( new EnvHttpProxyAgent() );
 };

package/src/worker/proxy.spec.js

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 const mockSetGlobalDispatcher = vi.fn();
 const MockEnvHttpProxyAgent = vi.fn();
+const mockLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
 
 vi.mock( 'undici', () => ( {
   EnvHttpProxyAgent: MockEnvHttpProxyAgent,
@@ -9,63 +10,42 @@ vi.mock( 'undici', () => ( {
 } ) );
 
 vi.mock( '#logger', () => ( {
-  createChildLogger: () => ( { info: vi.fn(), warn: vi.fn(), error: vi.fn() } )
+  createChildLogger: () => mockLogger
 } ) );
 
 describe( 'worker/proxy', () => {
-  const originalEnv = { ...process.env };
+  const proxyEnv = [ 'http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY' ];
 
   beforeEach( () => {
     vi.clearAllMocks();
-    delete process.env.HTTPS_PROXY;
-    delete process.env.https_proxy;
-    delete process.env.HTTP_PROXY;
-    delete process.env.http_proxy;
+    for ( const key of proxyEnv ) {
+      delete process.env[key];
+    }
   } );
 
   afterEach( () => {
-    process.env = { ...originalEnv };
+    vi.resetModules();
   } );
 
   it( 'does nothing when no proxy env vars are set', async () => {
     const { bootstrapFetchProxy } = await import( './proxy.js' );
     bootstrapFetchProxy();
 
+    expect( MockEnvHttpProxyAgent ).not.toHaveBeenCalled();
     expect( mockSetGlobalDispatcher ).not.toHaveBeenCalled();
+    expect( mockLogger.info ).not.toHaveBeenCalled();
   } );
 
-  it( 'sets global dispatcher when HTTPS_PROXY is set', async () => {
-    process.env.HTTPS_PROXY = 'http://proxy:8080';
+  it( 'sets global dispatcher when proxy URL is available', async () => {
+    process.env.HTTP_PROXY = 'http://proxy:8080/';
     const { bootstrapFetchProxy } = await import( './proxy.js' );
     bootstrapFetchProxy();
 
-    expect( MockEnvHttpProxyAgent ).toHaveBeenCalled();
+    expect( MockEnvHttpProxyAgent ).toHaveBeenCalledWith( { allowH2: false } );
     expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'sets global dispatcher when HTTP_PROXY is set', async () => {
-    process.env.HTTP_PROXY = 'http://proxy:8080';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).toHaveBeenCalled();
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'prefers HTTPS_PROXY over HTTP_PROXY for detection', async () => {
-    process.env.HTTPS_PROXY = 'http://secure-proxy:8080';
-    process.env.HTTP_PROXY = 'http://plain-proxy:8080';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'does not set global dispatcher when proxy URL is malformed', async () => {
-    process.env.HTTPS_PROXY = 'not a url';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( mockSetGlobalDispatcher ).not.toHaveBeenCalled();
+    expect( mockLogger.info ).toHaveBeenCalledWith(
+      'Proxy env vars detected, setting up global fetch dispatcher EnvHttpProxyAgent',
+      { httpProxyUrl: 'http://proxy:8080/', httpsProxyUrl: undefined }
+    );
   } );
 } );