@turingpulse/sdk 1.0.1

package/tests/plugins/openai-wrapper.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Integration tests for @turingpulse/sdk-openai plugin.
+ *
+ * These tests verify that patchOpenAI actually monkey-patches the caller's
+ * OpenAI module, instruments LLM calls, and emits events with all required
+ * metadata fields (node_type, model, provider, tokens, I/O).
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { init } from '@turingpulse/sdk';
+import { patchOpenAI, unpatchOpenAI } from '../../packages/openai/src/wrapper.js';
+
+const MOCK_RESPONSE = {
+  id: 'chatcmpl-test',
+  object: 'chat.completion',
+  model: 'gpt-4o',
+  choices: [
+    { index: 0, message: { role: 'assistant', content: 'instrumented reply' }, finish_reason: 'stop' },
+  ],
+  usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+  created: Math.floor(Date.now() / 1000),
+  system_fingerprint: 'fp_test',
+};
+
+let capturedEvents: Record<string, unknown>[] = [];
+let originalFetch: typeof globalThis.fetch;
+
+beforeEach(() => {
+  capturedEvents = [];
+  originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (input: RequestInfo | URL, initOpts?: RequestInit): Promise<Response> => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : (input as Request).url;
+
+    if (url.includes('api.openai.com')) {
+      return new Response(JSON.stringify(MOCK_RESPONSE), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    if (url.includes('/api/v1/sdk/events') && initOpts?.body) {
+      try {
+        const parsed = JSON.parse(initOpts.body as string);
+        const events = parsed.events ?? [parsed];
+        capturedEvents.push(...events);
+      } catch { /* ignore */ }
+      return new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    return new Response('{}', { status: 200 });
+  };
+
+  init({
+    apiKey: 'test-key',
+    workflowName: 'test-openai-plugin',
+    endpoint: 'https://test-endpoint.turingpulse.ai',
+    fetchImpl: globalThis.fetch,
+  });
+});
+
+afterEach(async () => {
+  await unpatchOpenAI();
+  globalThis.fetch = originalFetch;
+});
+
+describe('patchOpenAI plugin wrapper', () => {
+  it('patches the caller-supplied OpenAI module prototype', async () => {
+    const openaiMod = await import('openai');
+    const proto = openaiMod.default.Chat.Completions.prototype;
+    const originalName = proto.create.name;
+
+    await patchOpenAI({ name: 'test-workflow', openaiModule: openaiMod });
+
+    expect(proto.create.name).toBe('instrumented');
+    expect(proto.create.name).not.toBe(originalName);
+  });
+
+  it('restores prototype on unpatch', async () => {
+    const openaiMod = await import('openai');
+    const proto = openaiMod.default.Chat.Completions.prototype;
+    const originalCreate = proto.create;
+
+    await patchOpenAI({ name: 'test-workflow', openaiModule: openaiMod });
+    expect(proto.create).not.toBe(originalCreate);
+
+    await unpatchOpenAI();
+    expect(proto.create).toBe(originalCreate);
+  });
+
+  it('emits event with correct node_type, model, provider, tokens, and I/O', async () => {
+    const openaiMod = await import('openai');
+    await patchOpenAI({ name: 'test-workflow', openaiModule: openaiMod });
+
+    const client = new openaiMod.default({ apiKey: 'mock-key' });
+    await client.chat.completions.create({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'hello from test' }],
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    expect(capturedEvents.length).toBeGreaterThanOrEqual(1);
+
+    const event = capturedEvents[0] as Record<string, unknown>;
+    const payload = event.payload as Record<string, unknown>;
+    const metadata = payload.metadata as Record<string, string>;
+
+    expect(metadata.node_type).toBe('llm');
+    expect(metadata.model).toBe('gpt-4o');
+    expect(metadata.provider).toBe('openai');
+    expect(metadata.framework).toBe('openai');
+    expect(metadata.input).toBeDefined();
+    expect(metadata.output).toBeDefined();
+
+    const tokens = payload.tokens as { prompt: number; completion: number };
+    expect(tokens.prompt).toBe(10);
+    expect(tokens.completion).toBe(5);
+  });
+
+  it('sets workflow_name in metadata', async () => {
+    const openaiMod = await import('openai');
+    await patchOpenAI({ name: 'my-agent-workflow', openaiModule: openaiMod });
+
+    const client = new openaiMod.default({ apiKey: 'mock-key' });
+    await client.chat.completions.create({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'workflow test' }],
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    const event = capturedEvents[0] as Record<string, unknown>;
+    const payload = event.payload as Record<string, unknown>;
+    const metadata = payload.metadata as Record<string, string>;
+
+    expect(metadata.workflow_name).toBe('my-agent-workflow');
+  });
+
+  it('without openaiModule falls back to dynamic import (same-module scenario)', async () => {
+    await patchOpenAI({ name: 'fallback-test' });
+
+    const openaiMod = await import('openai');
+    const client = new openaiMod.default({ apiKey: 'mock-key' });
+    await client.chat.completions.create({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'fallback' }],
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+    await unpatchOpenAI();
+
+    if (capturedEvents.length > 0) {
+      const metadata = ((capturedEvents[0] as Record<string, unknown>).payload as Record<string, unknown>)
+        .metadata as Record<string, string>;
+      expect(metadata.framework).toBe('openai');
+    }
+  });
+
+  it('throws when name is missing', async () => {
+    await expect(patchOpenAI({})).rejects.toThrow(/name or TP_WORKFLOW_NAME/);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"],
+  "exclude": ["src/__tests__"]
+}
+
+

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    globals: true,
+    testTimeout: 30_000,
+  },
+});