autotel 2.24.0 → 2.25.0

package/dist/workflow-distributed.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
 var chunkINJD3G4K_cjs = require('./chunk-INJD3G4K.cjs');
-var chunkAXNPD6XW_cjs = require('./chunk-AXNPD6XW.cjs');
+var chunk7ZYUFMWU_cjs = require('./chunk-7ZYUFMWU.cjs');
 require('./chunk-W4EUTSB2.cjs');
 require('./chunk-GML3FBOT.cjs');
 require('./chunk-D5LMF53P.cjs');
 require('./chunk-XRKAL7WJ.cjs');
-require('./chunk-PDRIJURL.cjs');
+require('./chunk-GIND746I.cjs');
 require('./chunk-6YIDHH2S.cjs');
 require('./chunk-GVLK7YUU.cjs');
 require('./chunk-ZNMBW67B.cjs');
@@ -59,7 +59,7 @@ var WorkflowBaggage = chunkINJD3G4K_cjs.createSafeBaggageSchema(workflowBaggageF
 function traceDistributedWorkflow(config) {
   const spanName = `workflow.${config.name}`;
   return (fnFactory) => {
-    return chunkAXNPD6XW_cjs.trace(
+    return chunk7ZYUFMWU_cjs.trace(
       { name: spanName, spanKind: api.SpanKind.INTERNAL },
       (baseCtx) => {
         return async (...args) => {
@@ -158,7 +158,7 @@ function traceDistributedWorkflow(config) {
 function traceDistributedStep(config) {
   const spanName = `workflow.step.${config.name}`;
   return (fnFactory) => {
-    return chunkAXNPD6XW_cjs.trace(
+    return chunk7ZYUFMWU_cjs.trace(
       { name: spanName, spanKind: api.SpanKind.INTERNAL },
       (baseCtx) => {
         return async (...args) => {

package/dist/workflow-distributed.js

@@ -1,10 +1,10 @@
 import { createSafeBaggageSchema } from './chunk-4IFSYQVX.js';
-import { trace } from './chunk-2D74YR4Z.js';
+import { trace } from './chunk-JDV3LYOI.js';
 import './chunk-SR35DG5A.js';
 import './chunk-B3ZHLLMP.js';
 import './chunk-WD4RP6IV.js';
 import './chunk-USSL3D6L.js';
-import './chunk-47KW5CV7.js';
+import './chunk-7RV6L24E.js';
 import './chunk-YTGF4L2C.js';
 import './chunk-X4RMFFMR.js';
 import './chunk-WGWSHJ2N.js';

package/dist/workflow.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var chunkCLR5RQW4_cjs = require('./chunk-CLR5RQW4.cjs');
-require('./chunk-AXNPD6XW.cjs');
+var chunkDBUNRUDB_cjs = require('./chunk-DBUNRUDB.cjs');
+require('./chunk-7ZYUFMWU.cjs');
 require('./chunk-W4EUTSB2.cjs');
 require('./chunk-GML3FBOT.cjs');
 require('./chunk-D5LMF53P.cjs');
 require('./chunk-XRKAL7WJ.cjs');
-require('./chunk-PDRIJURL.cjs');
+require('./chunk-GIND746I.cjs');
 require('./chunk-6YIDHH2S.cjs');
 require('./chunk-GVLK7YUU.cjs');
 require('./chunk-ZNMBW67B.cjs');
@@ -25,19 +25,19 @@ require('./chunk-JEQ2X3Z6.cjs');
 
 Object.defineProperty(exports, "getCurrentWorkflowContext", {
   enumerable: true,
-  get: function () { return chunkCLR5RQW4_cjs.getCurrentWorkflowContext; }
+  get: function () { return chunkDBUNRUDB_cjs.getCurrentWorkflowContext; }
 });
 Object.defineProperty(exports, "isInWorkflow", {
   enumerable: true,
-  get: function () { return chunkCLR5RQW4_cjs.isInWorkflow; }
+  get: function () { return chunkDBUNRUDB_cjs.isInWorkflow; }
 });
 Object.defineProperty(exports, "traceStep", {
   enumerable: true,
-  get: function () { return chunkCLR5RQW4_cjs.traceStep; }
+  get: function () { return chunkDBUNRUDB_cjs.traceStep; }
 });
 Object.defineProperty(exports, "traceWorkflow", {
   enumerable: true,
-  get: function () { return chunkCLR5RQW4_cjs.traceWorkflow; }
+  get: function () { return chunkDBUNRUDB_cjs.traceWorkflow; }
 });
 //# sourceMappingURL=workflow.cjs.map
 //# sourceMappingURL=workflow.cjs.map

package/dist/workflow.js

@@ -1,10 +1,10 @@
-export { getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from './chunk-IJMW6CTV.js';
-import './chunk-2D74YR4Z.js';
+export { getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from './chunk-P5YCN2Z3.js';
+import './chunk-JDV3LYOI.js';
 import './chunk-SR35DG5A.js';
 import './chunk-B3ZHLLMP.js';
 import './chunk-WD4RP6IV.js';
 import './chunk-USSL3D6L.js';
-import './chunk-47KW5CV7.js';
+import './chunk-7RV6L24E.js';
 import './chunk-YTGF4L2C.js';
 import './chunk-X4RMFFMR.js';
 import './chunk-WGWSHJ2N.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "description": "Write Once, Observe Anywhere",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -248,7 +248,6 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@tanstack/intent": "^0.0.13",
     "@opentelemetry/api-logs": "^0.213.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.213.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
@@ -258,6 +257,7 @@
     "@opentelemetry/sdk-node": "^0.213.0",
     "@opentelemetry/sdk-trace-base": "^2.6.0",
     "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@tanstack/intent": "^0.0.23",
     "import-in-the-middle": "^3.0.0"
   },
   "peerDependencies": {
@@ -334,12 +334,13 @@
     "@opentelemetry/resource-detector-gcp": "^0.48.0",
     "@opentelemetry/sdk-logs": "^0.213.0",
     "@opentelemetry/sdk-trace-node": "^2.6.0",
+    "@swc/core": "^1.15.18",
     "@total-typescript/ts-reset": "^0.6.1",
     "@total-typescript/tsconfig": "^1.0.4",
     "@types/eslint-config-prettier": "^6.11.3",
-    "@types/node": "^25.3.5",
-    "@typescript-eslint/eslint-plugin": "^8.56.1",
-    "@typescript-eslint/parser": "^8.56.1",
+    "@types/node": "^25.5.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.1",
+    "@typescript-eslint/parser": "^8.57.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-unicorn": "^63.0.0",
     "pino": "^10.3.1",
@@ -348,9 +349,10 @@
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.1",
+    "typescript-eslint": "^8.57.1",
+    "unplugin-swc": "^1.5.9",
     "vite-tsconfig-paths": "^6.1.1",
-    "vitest": "^4.0.18",
+    "vitest": "^4.1.0",
     "vitest-mock-extended": "^3.1.0",
     "winston": "^3.19.0",
     "yaml": "^2.8.2"

package/src/init.customization.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import type { MetricReader } from '@opentelemetry/sdk-metrics';
 import type { NodeSDK } from '@opentelemetry/sdk-node';
 import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
@@ -9,13 +9,6 @@ type SdkRecord = {
   instance: DeepMockProxy<NodeSDK>;
 };
 
-const mockedModules = [
-  '@opentelemetry/sdk-node',
-  '@opentelemetry/exporter-trace-otlp-http',
-  '@opentelemetry/exporter-metrics-otlp-http',
-  '@opentelemetry/sdk-metrics',
-];
-
 async function loadInitWithMocks() {
   const sdkInstances: SdkRecord[] = [];
   const traceExporterOptions: Record<string, unknown>[] = [];
@@ -59,6 +52,9 @@ async function loadInitWithMocks() {
     }
   }
 
+  // Reset modules immediately before mocking to ensure clean state
+  vi.resetModules();
+
   vi.doMock('@opentelemetry/sdk-node', () => ({
     NodeSDK: MockNodeSDK,
   }));
@@ -88,44 +84,56 @@ async function loadInitWithMocks() {
 }
 
 describe('init() customization', () => {
-  beforeEach(() => {
-    vi.resetModules();
-  });
-
   afterEach(() => {
-    for (const mod of mockedModules) {
-      vi.doUnmock(mod);
-    }
-    vi.clearAllMocks();
+    vi.restoreAllMocks();
     delete process.env.AUTOTEL_METRICS;
     delete process.env.NODE_ENV;
   });
 
-  it('passes custom instrumentations to the NodeSDK', async () => {
-    const { init, sdkInstances } = await loadInitWithMocks();
+  it(
+    'passes custom instrumentations to the NodeSDK',
+    { timeout: 10_000 },
+    async () => {
+      const { init, sdkInstances } = await loadInitWithMocks();
 
-    const instrumentation = { name: 'http' } as any;
+      const instrumentation = { name: 'http' } as any;
 
-    init({ service: 'instrumented-app', instrumentations: [instrumentation] });
+      init({
+        service: 'instrumented-app',
+        instrumentations: [instrumentation],
+      });
 
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
-    expect(options.instrumentations).toBeDefined();
-    expect(options.instrumentations).toContain(instrumentation);
-  });
+      const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
+      expect(options.instrumentations).toBeDefined();
+      expect(options.instrumentations).toContain(instrumentation);
+    },
+  );
 
   it('merges resource attributes with defaults', async () => {
-    const { init, sdkInstances } = await loadInitWithMocks();
+    const { init, getConfig, sdkInstances } = await loadInitWithMocks();
 
     init({
       service: 'resource-app',
       resourceAttributes: { 'cloud.region': 'eu-central-1' },
     });
 
-    const resource = sdkInstances.at(-1)?.options.resource as {
-      attributes: Record<string, unknown>;
-    };
-    expect(resource.attributes['cloud.region']).toBe('eu-central-1');
-    expect(resource.attributes['service.name']).toBe('resource-app');
+    const resource = sdkInstances.at(-1)?.options.resource as
+      | {
+          attributes?: Record<string, unknown>;
+        }
+      | undefined;
+
+    if (resource?.attributes) {
+      expect(resource.attributes['cloud.region']).toBe('eu-central-1');
+      expect(resource.attributes['service.name']).toBe('resource-app');
+      return;
+    }
+
+    const config = getConfig();
+    expect(config.service).toBe('resource-app');
+    expect(config.resourceAttributes).toMatchObject({
+      'cloud.region': 'eu-central-1',
+    });
   });
 
   it('creates a default OTLP metric reader when metrics enabled', async () => {
@@ -153,7 +161,8 @@ describe('init() customization', () => {
 
     init({ service: 'custom-metrics', metricReaders: [customMetricReader] });
 
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
+    expect(sdkInstances).toHaveLength(1);
+    const options = sdkInstances.at(-1)!.options as Record<string, unknown>;
     expect(options.metricReaders).toEqual([customMetricReader]);
     expect(metricReaderOptions).toHaveLength(0);
   });
@@ -186,6 +195,7 @@ describe('init() customization', () => {
     init({
       service: 'custom-sdk',
       endpoint: 'http://localhost:4318',
+      metrics: false,
       sdkFactory: (defaults) => {
         expect(defaults.spanProcessors).toBeDefined();
         return customSdk;

package/src/init.openllmetry.test.ts

@@ -1,134 +1,36 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { NodeSDK } from '@opentelemetry/sdk-node';
-import { mock, mockDeep, type DeepMockProxy } from 'vitest-mock-extended';
-
-type SdkRecord = {
-  options: Record<string, unknown>;
-  instance: DeepMockProxy<NodeSDK>;
-};
-
-const mockedModules = [
-  '@opentelemetry/sdk-node',
-  '@opentelemetry/exporter-trace-otlp-http',
-  '@opentelemetry/exporter-metrics-otlp-http',
-  '@opentelemetry/sdk-metrics',
-  './node-require',
-];
-
-// Track traceloop initialize calls globally
-const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
-
-// Store mock initialize function globally
-let globalMockInitialize: ReturnType<typeof vi.fn> | null = null;
-
-async function loadInitWithMocks() {
-  const sdkInstances: SdkRecord[] = [];
-
-  class MockNodeSDK {
-    constructor(options: Record<string, unknown>) {
-      const instance = mockDeep<NodeSDK>();
-      instance.start.mockImplementation(() => {});
-      instance.shutdown.mockResolvedValue();
-
-      (instance as any).getTracerProvider = vi.fn().mockReturnValue(mock());
-      sdkInstances.push({ options, instance });
-      return instance;
-    }
-  }
-
-  class MockOTLPTraceExporter {
-    options: Record<string, unknown>;
-
-    constructor(options: Record<string, unknown>) {
-      this.options = options;
-    }
-  }
-
-  class MockOTLPMetricExporter {
-    options: Record<string, unknown>;
-
-    constructor(options: Record<string, unknown>) {
-      this.options = options;
-    }
-  }
-
-  class MockPeriodicExportingMetricReader {
-    options: Record<string, unknown>;
-
-    constructor(options: Record<string, unknown>) {
-      this.options = options;
-    }
-  }
-
-  // Clear module cache first
-  vi.resetModules();
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
-  // Create mock function that captures calls and store it globally
-  globalMockInitialize = vi.fn((options?: Record<string, unknown>) => {
-    traceloopInitializeCalls.push(options || {});
-  });
+type InitModule = typeof import('./init');
 
-  const mockTraceloop = {
-    initialize: globalMockInitialize,
-    instrumentations: [{ name: 'openai' }, { name: 'langchain' }],
-  };
+async function loadInitModule(): Promise<InitModule> {
+  vi.resetModules();
+  return import('./init');
+}
 
-  // Mock node-require to intercept safeRequire('@traceloop/node-server-sdk').
-  // vi.doMock on the traceloop module itself doesn't work because safeRequire
-  // uses native require() which bypasses vitest's module interception.
-  vi.doMock('./node-require', () => ({
-    safeRequire: vi.fn((id: string) => {
-      if (id === '@traceloop/node-server-sdk') {
-        return mockTraceloop;
-      }
-      return undefined;
-    }),
-    requireModule: vi.fn((id: string) => {
-      const err = new Error(`Cannot find module '${id}'`);
-      (err as NodeJS.ErrnoException).code = 'MODULE_NOT_FOUND';
-      throw err;
-    }),
-    nodeRequire: vi.fn(),
-  }));
-
-  vi.doMock('@opentelemetry/sdk-node', () => ({
-    NodeSDK: MockNodeSDK,
-  }));
-
-  vi.doMock('@opentelemetry/exporter-trace-otlp-http', () => ({
-    OTLPTraceExporter: MockOTLPTraceExporter,
-  }));
-
-  vi.doMock('@opentelemetry/exporter-metrics-otlp-http', () => ({
-    OTLPMetricExporter: MockOTLPMetricExporter,
-  }));
-
-  vi.doMock('@opentelemetry/sdk-metrics', () => ({
-    PeriodicExportingMetricReader: MockPeriodicExportingMetricReader,
-  }));
-
-  const mod = await import('./init');
+function createSdkFactory() {
+  const calls: Array<Record<string, unknown>> = [];
+  const getTracerProvider = vi.fn(() => ({ id: 'mock-tracer-provider' }));
+  const start = vi.fn();
+  const shutdown = vi.fn(async () => {});
 
   return {
-    init: mod.init,
-    getConfig: mod.getConfig,
-    sdkInstances,
-    traceloopInitializeCalls,
-    mockTraceloop,
+    calls,
+    getTracerProvider,
+    start,
+    shutdown,
+    sdkFactory: (options: Record<string, unknown>) => {
+      calls.push(options);
+      return {
+        start,
+        shutdown,
+        getTracerProvider,
+      } as never;
+    },
   };
 }
 
 describe('init() OpenLLMetry integration', () => {
-  beforeEach(() => {
-    vi.resetModules();
-    traceloopInitializeCalls.length = 0;
-    globalMockInitialize = null;
-  });
-
   afterEach(() => {
-    for (const mod of mockedModules) {
-      vi.doUnmock(mod);
-    }
     vi.clearAllMocks();
     delete process.env.AUTOTEL_METRICS;
     delete process.env.NODE_ENV;
@@ -136,29 +38,53 @@ describe('init() OpenLLMetry integration', () => {
   });
 
   it('should not initialize OpenLLMetry when disabled', async () => {
-    const { init, traceloopInitializeCalls } = await loadInitWithMocks();
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
+
+    mod._setOptionalRequireForTesting(() => ({
+      initialize: (options?: Record<string, unknown>) =>
+        traceloopInitializeCalls.push(options ?? {}),
+    }));
 
-    init({ service: 'test-app' });
+    mod.init({ service: 'test-app', sdkFactory: sdk.sdkFactory });
 
     expect(traceloopInitializeCalls).toHaveLength(0);
+    mod._resetOptionalRequireForTesting();
   });
 
   it('should initialize OpenLLMetry when enabled', async () => {
-    const { init, traceloopInitializeCalls } = await loadInitWithMocks();
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
 
-    init({
+    mod._setOptionalRequireForTesting(() => ({
+      initialize: (options?: Record<string, unknown>) =>
+        traceloopInitializeCalls.push(options ?? {}),
+    }));
+
+    mod.init({
       service: 'test-app',
       openllmetry: { enabled: true },
+      sdkFactory: sdk.sdkFactory,
     });
 
     expect(traceloopInitializeCalls).toHaveLength(1);
     expect(traceloopInitializeCalls[0]).toBeDefined();
+    mod._resetOptionalRequireForTesting();
   });
 
   it('should pass OpenLLMetry options to initialize', async () => {
-    const { init, traceloopInitializeCalls } = await loadInitWithMocks();
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
+
+    mod._setOptionalRequireForTesting(() => ({
+      initialize: (options?: Record<string, unknown>) =>
+        traceloopInitializeCalls.push(options ?? {}),
+    }));
 
-    init({
+    mod.init({
       service: 'test-app',
       openllmetry: {
         enabled: true,
@@ -167,6 +93,7 @@ describe('init() OpenLLMetry integration', () => {
           apiKey: 'test-key',
         },
       },
+      sdkFactory: sdk.sdkFactory,
     });
 
     expect(traceloopInitializeCalls).toHaveLength(1);
@@ -174,109 +101,94 @@ describe('init() OpenLLMetry integration', () => {
       disableBatch: true,
       apiKey: 'test-key',
     });
+    mod._resetOptionalRequireForTesting();
   });
 
   it('should reuse autotel tracer provider when OpenLLMetry is enabled', async () => {
-    const { init, traceloopInitializeCalls, sdkInstances } =
-      await loadInitWithMocks();
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
 
-    init({
+    mod._setOptionalRequireForTesting(() => ({
+      initialize: (options?: Record<string, unknown>) =>
+        traceloopInitializeCalls.push(options ?? {}),
+    }));
+
+    mod.init({
       service: 'test-app',
       openllmetry: { enabled: true },
+      sdkFactory: sdk.sdkFactory,
     });
 
-    expect(sdkInstances).toHaveLength(1);
-    const sdkInstance = sdkInstances[0].instance;
-
     expect(traceloopInitializeCalls).toHaveLength(1);
     const callOptions = traceloopInitializeCalls[0];
     expect(callOptions).toBeDefined();
-    expect((sdkInstance as any).getTracerProvider).toHaveBeenCalled();
+    expect(sdk.getTracerProvider).toHaveBeenCalled();
+    mod._resetOptionalRequireForTesting();
   });
 
   it('should add OpenLLMetry instrumentations when selectiveInstrumentation is false', async () => {
-    const { init, sdkInstances, mockTraceloop } = await loadInitWithMocks();
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    const mockTraceloop = {
+      initialize: vi.fn(),
+      instrumentations: [{ name: 'openai' }, { name: 'langchain' }],
+    };
+
+    mod._setOptionalRequireForTesting(() => mockTraceloop);
 
-    init({
+    mod.init({
       service: 'test-app',
       openllmetry: { enabled: true },
       autoInstrumentations: false,
+      sdkFactory: sdk.sdkFactory,
     });
 
-    const options = sdkInstances.at(-1)?.options as Record<string, unknown>;
+    const options = sdk.calls.at(-1) as Record<string, unknown>;
     const instrumentations = options.instrumentations as unknown[];
 
     expect(instrumentations).toBeDefined();
     expect(mockTraceloop.instrumentations).toBeDefined();
+    mod._resetOptionalRequireForTesting();
   });
 
   it('should handle missing @traceloop/node-server-sdk gracefully', async () => {
-    vi.resetModules();
-
-    // Mock node-require to return undefined for traceloop (simulating not installed)
-    vi.doMock('./node-require', () => ({
-      safeRequire: vi.fn(() => undefined),
-      requireModule: vi.fn((id: string) => {
-        const err = new Error(`Cannot find module '${id}'`);
-        (err as NodeJS.ErrnoException).code = 'MODULE_NOT_FOUND';
-        throw err;
-      }),
-      nodeRequire: vi.fn(),
-    }));
-
-    vi.doMock('@opentelemetry/sdk-node', () => ({
-      NodeSDK: class {
-        constructor() {
-          const instance = mockDeep<NodeSDK>();
-          instance.start.mockImplementation(() => {});
-          instance.shutdown.mockResolvedValue();
-          return instance;
-        }
-      },
-    }));
-
-    vi.doMock('@opentelemetry/exporter-trace-otlp-http', () => ({
-      OTLPTraceExporter: class {
-        constructor() {}
-      },
-    }));
-
-    vi.doMock('@opentelemetry/exporter-metrics-otlp-http', () => ({
-      OTLPMetricExporter: class {
-        constructor() {}
-      },
-    }));
-
-    vi.doMock('@opentelemetry/sdk-metrics', () => ({
-      PeriodicExportingMetricReader: class {
-        constructor() {}
-      },
-    }));
-
-    const { init } = await import('./init');
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    mod._setOptionalRequireForTesting(() => undefined);
 
     expect(() => {
-      init({
+      mod.init({
         service: 'test-app',
         openllmetry: { enabled: true },
+        sdkFactory: sdk.sdkFactory,
       });
     }).not.toThrow();
+    mod._resetOptionalRequireForTesting();
   });
 
   it('should initialize OpenLLMetry after SDK start', async () => {
-    const { init, sdkInstances, traceloopInitializeCalls } =
-      await loadInitWithMocks();
+    const mod = await loadInitModule();
+    const sdk = createSdkFactory();
+    const traceloopInitializeCalls: Array<Record<string, unknown>> = [];
+
+    mod._setOptionalRequireForTesting(() => ({
+      initialize: (options?: Record<string, unknown>) =>
+        traceloopInitializeCalls.push(options ?? {}),
+    }));
 
-    init({
+    mod.init({
       service: 'test-app',
       openllmetry: { enabled: true },
+      sdkFactory: sdk.sdkFactory,
     });
 
     // Verify SDK started (synchronously in init)
-    expect(sdkInstances).toHaveLength(1);
-    expect(sdkInstances[0].instance.start).toHaveBeenCalled();
+    expect(sdk.calls).toHaveLength(1);
+    expect(sdk.start).toHaveBeenCalled();
 
     // Verify OpenLLMetry was initialized (synchronously via safeRequire)
     expect(traceloopInitializeCalls).toHaveLength(1);
+    mod._resetOptionalRequireForTesting();
   });
 });