retrace-sdk 0.1.5 → 0.1.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yash Bogam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
-# retrace
+# retrace-sdk
 
-Record, replay, fork & share AI agent executions — TypeScript SDK.
+The execution replay engine for AI agents. Record, replay, fork & share AI agent executions — TypeScript SDK.
 
 ## Installation
 
@@ -8,26 +8,36 @@ Record, replay, fork & share AI agent executions — TypeScript SDK.
 npm install retrace-sdk
 ```
 
+Requires Node.js 20+. ESM-only package.
+
 ## Quick Start
 
 ```typescript
-import { configure, record, trace, TraceStatus } from "retrace-sdk";
+import { configure, trace } from "retrace-sdk";
 
-configure({ apiKey: "rt_live_...", projectId: "your-project-id" });
+configure({ apiKey: "rt_live_..." }); // Get your key at retrace.yashbogam.me/settings
 
-// Wrap a function with trace()
-const myAgent = trace((prompt: string) => {
-  // OpenAI calls are auto-captured
+const myAgent = trace(async (prompt: string) => {
   const response = await openai.chat.completions.create({
-    model: "gpt-4o",
+    model: "gpt-5.5",
     messages: [{ role: "user", content: prompt }],
   });
   return response.choices[0].message.content;
 }, { name: "my-agent" });
 
-const result = myAgent("What is the meaning of life?");
+await myAgent("What is quantum computing?");
 ```
 
+## Auto-Instrumentation
+
+LLM calls from all major providers are captured automatically:
+
+- **OpenAI** — `openai.chat.completions.create()` captured
+- **Anthropic** — `anthropic.messages.create()` captured
+- **Google Gemini** — `ai.models.generateContent()` captured
+
+No extra setup needed. Install the provider SDK alongside `retrace-sdk`.
+
 ## Configuration
 
 ```typescript
@@ -35,32 +45,13 @@ import { configure } from "retrace-sdk";
 
 configure({
   apiKey: "rt_live_...",           // or RETRACE_API_KEY env var
-  baseUrl: "http://localhost:3001", // or RETRACE_BASE_URL env var
+  baseUrl: "https://api.retrace.yashbogam.me",
   projectId: "...",                 // or RETRACE_PROJECT_ID env var
 });
 ```
 
 Set `RETRACE_ENABLED=false` to disable recording without changing code.
 
-## OpenAI Auto-Capture
-
-```typescript
-import { record, TraceStatus } from "retrace-sdk";
-import OpenAI from "openai";
-
-const openai = new OpenAI();
-const recorder = record({ name: "chat-agent" });
-recorder.start();
-
-const response = await openai.chat.completions.create({
-  model: "gpt-4o",
-  messages: [{ role: "user", content: "Hello!" }],
-});
-// LLM call is automatically captured as a span
-
-recorder.end(response.choices[0].message.content);
-```
-
 ## Manual Span Creation
 
 ```typescript
@@ -76,19 +67,12 @@ recorder.endSpan(span, { results: ["..."] });
 recorder.end("Done");
 ```
 
-## Transport Options
+## API Key
 
-The SDK uses WebSocket by default for real-time streaming. Falls back to HTTP if WS connection fails.
+A Retrace API key (`rt_live_...`) is required. Get yours free at [retrace.yashbogam.me/settings](https://retrace.yashbogam.me/settings).
 
-```typescript
-import { createTransport } from "retrace/transport";
-
-// Force HTTP transport
-const transport = createTransport("http");
+## Links
 
-// Force WebSocket
-const transport = createTransport("ws");
-
-// Auto-detect (default)
-const transport = createTransport("auto");
-```
+- [Documentation](https://retrace.yashbogam.me/docs)
+- [GitHub](https://github.com/yash1511-bogam/retrace)
+- [npm](https://www.npmjs.com/package/retrace-sdk)

package/dist/config.d.ts

@@ -6,4 +6,5 @@ export interface Config {
     enabled: boolean;
 }
 export declare function configure(opts: Partial<Config>): Config;
+export declare function requireApiKey(): string;
 export declare function getConfig(): Config;

package/dist/config.js

@@ -8,7 +8,7 @@ const config = {
 config.wsUrl = config.baseUrl.replace("https://", "wss://").replace("http://", "ws://");
 export function configure(opts) {
     if (opts.apiKey && !opts.apiKey.startsWith("rt_live_")) {
-        console.warn("[retrace] API key does not start with 'rt_live_'. This may be invalid.");
+        throw new Error("Invalid Retrace API key. Keys must start with 'rt_live_'. Get yours at https://retrace.yashbogam.me/settings");
     }
     Object.assign(config, opts);
     if (opts.baseUrl && !opts.wsUrl) {
@@ -16,6 +16,12 @@ export function configure(opts) {
     }
     return config;
 }
+export function requireApiKey() {
+    if (!config.apiKey) {
+        throw new Error("Retrace API key required. Call configure({ apiKey: 'rt_live_...' }) or set RETRACE_API_KEY. Get yours at https://retrace.yashbogam.me/settings");
+    }
+    return config.apiKey;
+}
 export function getConfig() {
     return config;
 }

package/dist/index.d.ts

@@ -4,3 +4,5 @@ export { SpanBuilder, TraceBuilder } from "./trace.js";
 export type { SpanData, TraceData } from "./trace.js";
 export { SpanType, TraceStatus } from "./trace.js";
 export { installGeminiInterceptor, uninstallGeminiInterceptor } from "./interceptors/gemini.js";
+export { installOpenAIInterceptor, uninstallOpenAIInterceptor } from "./interceptors/openai.js";
+export { installAnthropicInterceptor, uninstallAnthropicInterceptor } from "./interceptors/anthropic.js";

package/dist/index.js

@@ -3,3 +3,5 @@ export { record, trace, TraceRecorder } from "./recorder.js";
 export { SpanBuilder, TraceBuilder } from "./trace.js";
 export { SpanType, TraceStatus } from "./trace.js";
 export { installGeminiInterceptor, uninstallGeminiInterceptor } from "./interceptors/gemini.js";
+export { installOpenAIInterceptor, uninstallOpenAIInterceptor } from "./interceptors/openai.js";
+export { installAnthropicInterceptor, uninstallAnthropicInterceptor } from "./interceptors/anthropic.js";

package/dist/interceptors/anthropic.d.ts

@@ -0,0 +1,3 @@
+import { SpanData } from "../trace.js";
+export declare function installAnthropicInterceptor(onSpan: (span: SpanData) => void): void;
+export declare function uninstallAnthropicInterceptor(): void;

package/dist/interceptors/anthropic.js

@@ -0,0 +1,102 @@
+import { SpanType } from "../trace.js";
+import { genId, nowIso, truncateJson } from "../utils.js";
+const PRICING = {
+    "claude-opus-4.7": [5.0, 25.0],
+    "claude-opus-4.6": [5.0, 25.0],
+    "claude-sonnet-4.6": [3.0, 15.0],
+    "claude-sonnet-4": [3.0, 15.0],
+    "claude-haiku-4.5": [1.0, 5.0],
+    "claude-3-7-sonnet": [3.0, 15.0],
+    "claude-3-5-sonnet": [3.0, 15.0],
+    "claude-3-5-haiku": [0.80, 4.0],
+    "claude-3-opus": [15.0, 75.0],
+};
+function calcCost(model, inputTokens, outputTokens) {
+    for (const [key, p] of Object.entries(PRICING)) {
+        if (model.includes(key))
+            return (inputTokens * p[0] + outputTokens * p[1]) / 1_000_000;
+    }
+    return 0;
+}
+let originalCreate = null;
+let installed = false;
+let onSpanCallback = null;
+export function installAnthropicInterceptor(onSpan) {
+    if (installed) {
+        onSpanCallback = onSpan;
+        return;
+    }
+    onSpanCallback = onSpan;
+    import("@anthropic-ai/sdk").then((anthropicMod) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = anthropicMod;
+        const Anthropic = mod?.Anthropic || mod?.default;
+        if (!Anthropic)
+            return;
+        const proto = Anthropic.Messages?.prototype || Object.getPrototypeOf(new Anthropic({ apiKey: "dummy" }).messages);
+        if (!proto?.create)
+            return;
+        originalCreate = proto.create;
+        proto.create = createPatchedCreate();
+        installed = true;
+    }).catch(() => { });
+}
+function createPatchedCreate() {
+    return async function (...args) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const opts = args[0] || {};
+        const model = opts.model || "unknown";
+        const messages = opts.messages || [];
+        const spanId = genId();
+        const startedAt = nowIso();
+        const startMs = Date.now();
+        try {
+            const result = await originalCreate.apply(this, args);
+            const durationMs = Date.now() - startMs;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const res = result;
+            const inputTokens = res?.usage?.input_tokens || 0;
+            const outputTokens = res?.usage?.output_tokens || 0;
+            const output = res?.content?.[0]?.text || "";
+            const span = {
+                id: spanId, trace_id: "", parent_id: null,
+                span_type: SpanType.LLM_CALL, name: "anthropic.messages.create", model,
+                input: truncateJson({ messages: messages.slice(0, 10) }),
+                output: truncateJson(output),
+                input_tokens: inputTokens, output_tokens: outputTokens,
+                cost: calcCost(model, inputTokens, outputTokens),
+                duration_ms: durationMs, started_at: startedAt, ended_at: nowIso(),
+            };
+            onSpanCallback?.(span);
+            return result;
+        }
+        catch (err) {
+            const span = {
+                id: spanId, trace_id: "", parent_id: null,
+                span_type: SpanType.LLM_CALL, name: "anthropic.messages.create", model,
+                input: truncateJson({ messages: messages.slice(0, 10) }),
+                started_at: startedAt, ended_at: nowIso(),
+                duration_ms: Date.now() - startMs,
+                error: err instanceof Error ? err.message : String(err),
+            };
+            onSpanCallback?.(span);
+            throw err;
+        }
+    };
+}
+export function uninstallAnthropicInterceptor() {
+    if (!installed || !originalCreate)
+        return;
+    import("@anthropic-ai/sdk").then((anthropicMod) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = anthropicMod;
+        const Anthropic = mod?.Anthropic || mod?.default;
+        if (!Anthropic)
+            return;
+        const proto = Anthropic.Messages?.prototype;
+        if (proto)
+            proto.create = originalCreate;
+    }).catch(() => { });
+    installed = false;
+    onSpanCallback = null;
+}

package/dist/interceptors/gemini.js

@@ -1,10 +1,16 @@
 import { SpanType } from "../trace.js";
 import { genId, nowIso, truncateJson } from "../utils.js";
 const PRICING = {
+    "gemini-3.1-flash-lite": [0.10, 0.40],
+    "gemini-3.1-flash": [0.50, 3.0],
+    "gemini-3-flash": [0.50, 3.0],
+    "gemini-3-pro": [2.0, 12.0],
     "gemini-3.1-pro-preview": [2.0, 12.0],
     "gemini-2.5-pro": [1.25, 10.0],
-    "gemini-2.5-flash": [0.15, 0.60],
+    "gemini-2.5-flash": [0.30, 2.50],
+    "gemini-2.5-flash-lite": [0.10, 0.40],
     "gemini-2.0-flash": [0.10, 0.40],
+    "gemini-2.0-flash-lite": [0.05, 0.20],
 };
 function calcCost(model, inputTokens, outputTokens) {
     const p = PRICING[model] || [0, 0];

package/dist/interceptors/index.d.ts

@@ -1 +1,3 @@
 export { installGeminiInterceptor, uninstallGeminiInterceptor } from "./gemini.js";
+export { installOpenAIInterceptor, uninstallOpenAIInterceptor } from "./openai.js";
+export { installAnthropicInterceptor, uninstallAnthropicInterceptor } from "./anthropic.js";

package/dist/interceptors/index.js

@@ -1 +1,3 @@
 export { installGeminiInterceptor, uninstallGeminiInterceptor } from "./gemini.js";
+export { installOpenAIInterceptor, uninstallOpenAIInterceptor } from "./openai.js";
+export { installAnthropicInterceptor, uninstallAnthropicInterceptor } from "./anthropic.js";

package/dist/interceptors/openai.d.ts

@@ -0,0 +1,3 @@
+import { SpanData } from "../trace.js";
+export declare function installOpenAIInterceptor(onSpan: (span: SpanData) => void): void;
+export declare function uninstallOpenAIInterceptor(): void;

package/dist/interceptors/openai.js

@@ -0,0 +1,115 @@
+import { SpanType } from "../trace.js";
+import { genId, nowIso, truncateJson } from "../utils.js";
+const PRICING = {
+    "gpt-5.5-pro": [30.0, 180.0],
+    "gpt-5.5": [5.0, 30.0],
+    "gpt-5.4-pro": [15.0, 90.0],
+    "gpt-5.4-mini": [0.75, 4.50],
+    "gpt-5.4-nano": [0.20, 1.20],
+    "gpt-5.4": [2.50, 15.0],
+    "gpt-5-mini": [0.50, 3.0],
+    "gpt-5-nano": [0.10, 0.60],
+    "gpt-5": [1.25, 10.0],
+    "gpt-4.1-mini": [0.40, 1.60],
+    "gpt-4.1-nano": [0.10, 0.40],
+    "gpt-4.1": [2.0, 8.0],
+    "gpt-4o-mini": [0.15, 0.60],
+    "gpt-4o": [2.50, 10.0],
+    "o3": [10.0, 40.0],
+    "o4-mini": [1.10, 4.40],
+    "o3-mini": [1.10, 4.40],
+};
+function calcCost(model, inputTokens, outputTokens) {
+    for (const [key, p] of Object.entries(PRICING)) {
+        if (model.includes(key))
+            return (inputTokens * p[0] + outputTokens * p[1]) / 1_000_000;
+    }
+    return 0;
+}
+let originalCreate = null;
+let installed = false;
+let onSpanCallback = null;
+export function installOpenAIInterceptor(onSpan) {
+    if (installed) {
+        onSpanCallback = onSpan;
+        return;
+    }
+    onSpanCallback = onSpan;
+    import("openai").then((openaiMod) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = openaiMod;
+        const proto = mod?.OpenAI?.Chat?.Completions?.prototype || mod?.default?.Chat?.Completions?.prototype;
+        if (!proto?.create) {
+            // Try alternative path
+            const OpenAI = mod?.OpenAI || mod?.default;
+            if (OpenAI) {
+                const instance = Object.getPrototypeOf(new OpenAI({ apiKey: "dummy" }).chat.completions);
+                if (instance?.create) {
+                    originalCreate = instance.create;
+                    instance.create = createPatchedCreate();
+                    installed = true;
+                }
+            }
+            return;
+        }
+        originalCreate = proto.create;
+        proto.create = createPatchedCreate();
+        installed = true;
+    }).catch(() => { });
+}
+function createPatchedCreate() {
+    return async function (...args) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const opts = args[0] || {};
+        const model = opts.model || "unknown";
+        const messages = opts.messages || [];
+        const spanId = genId();
+        const startedAt = nowIso();
+        const startMs = Date.now();
+        try {
+            const result = await originalCreate.apply(this, args);
+            const durationMs = Date.now() - startMs;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const res = result;
+            const inputTokens = res?.usage?.prompt_tokens || 0;
+            const outputTokens = res?.usage?.completion_tokens || 0;
+            const output = res?.choices?.[0]?.message?.content || "";
+            const span = {
+                id: spanId, trace_id: "", parent_id: null,
+                span_type: SpanType.LLM_CALL, name: "openai.chat.completions.create", model,
+                input: truncateJson({ messages: messages.slice(0, 10) }),
+                output: truncateJson(output),
+                input_tokens: inputTokens, output_tokens: outputTokens,
+                cost: calcCost(model, inputTokens, outputTokens),
+                duration_ms: durationMs, started_at: startedAt, ended_at: nowIso(),
+            };
+            onSpanCallback?.(span);
+            return result;
+        }
+        catch (err) {
+            const span = {
+                id: spanId, trace_id: "", parent_id: null,
+                span_type: SpanType.LLM_CALL, name: "openai.chat.completions.create", model,
+                input: truncateJson({ messages: messages.slice(0, 10) }),
+                started_at: startedAt, ended_at: nowIso(),
+                duration_ms: Date.now() - startMs,
+                error: err instanceof Error ? err.message : String(err),
+            };
+            onSpanCallback?.(span);
+            throw err;
+        }
+    };
+}
+export function uninstallOpenAIInterceptor() {
+    if (!installed || !originalCreate)
+        return;
+    import("openai").then((openaiMod) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = openaiMod;
+        const proto = mod?.OpenAI?.Chat?.Completions?.prototype || mod?.default?.Chat?.Completions?.prototype;
+        if (proto)
+            proto.create = originalCreate;
+    }).catch(() => { });
+    installed = false;
+    onSpanCallback = null;
+}

package/dist/recorder.js

@@ -1,13 +1,16 @@
-import { getConfig } from "./config.js";
+import { getConfig, requireApiKey } from "./config.js";
 import { SpanBuilder, SpanType, TraceBuilder, TraceStatus } from "./trace.js";
 import { createTransport } from "./transport.js";
 import { installGeminiInterceptor } from "./interceptors/gemini.js";
+import { installOpenAIInterceptor } from "./interceptors/openai.js";
+import { installAnthropicInterceptor } from "./interceptors/anthropic.js";
 export class TraceRecorder {
     builder;
     transport;
     interceptorsInstalled = false;
     output = undefined;
     constructor(opts) {
+        requireApiKey();
         this.builder = new TraceBuilder();
         this.transport = createTransport();
         const cfg = getConfig();
@@ -84,6 +87,8 @@ export class TraceRecorder {
         if (this.interceptorsInstalled)
             return;
         installGeminiInterceptor((span) => this.addSpan(span));
+        installOpenAIInterceptor((span) => this.addSpan(span));
+        installAnthropicInterceptor((span) => this.addSpan(span));
         this.interceptorsInstalled = true;
     }
 }

package/dist/transport.d.ts

@@ -5,8 +5,10 @@ export interface Transport {
 export declare class WSTransport implements Transport {
     private ws;
     private connected;
+    private closed;
     private backoff;
     private queue;
+    get isConnected(): boolean;
     connect(): void;
     private reconnect;
     private flushQueue;

package/dist/transport.js

@@ -3,9 +3,13 @@ import { getConfig } from "./config.js";
 export class WSTransport {
     ws = null;
     connected = false;
+    closed = false;
     backoff = 1000;
     queue = [];
+    get isConnected() { return this.connected; }
     connect() {
+        if (this.closed)
+            return;
         const cfg = getConfig();
         const url = `${cfg.wsUrl}/ws/v1/stream`;
         this.ws = new WebSocket(url);
@@ -26,15 +30,17 @@ export class WSTransport {
         this.ws.on("close", () => {
             this.connected = false;
             this.ws = null;
-            setTimeout(() => this.reconnect(), this.backoff);
-            this.backoff = Math.min(this.backoff * 2, 30000);
+            if (!this.closed) {
+                setTimeout(() => this.reconnect(), this.backoff);
+                this.backoff = Math.min(this.backoff * 2, 30000);
+            }
         });
         this.ws.on("error", () => {
             this.ws?.close();
         });
     }
     reconnect() {
-        if (!this.connected && !this.ws)
+        if (!this.closed && !this.connected && !this.ws)
             this.connect();
     }
     flushQueue() {
@@ -49,11 +55,12 @@ export class WSTransport {
         }
         else {
             this.queue.push(msg);
-            if (!this.ws)
+            if (!this.ws && !this.closed)
                 this.connect();
         }
     }
     close() {
+        this.closed = true;
         if (this.ws) {
             this.ws.close();
             this.ws = null;
@@ -114,11 +121,61 @@ export function createTransport(mode = "auto") {
         return new HTTPTransport();
     if (mode === "ws")
         return new WSTransport();
-    // Auto: try WS
-    try {
-        return new WSTransport();
-    }
-    catch {
-        return new HTTPTransport();
-    }
+    // Auto: start with WS, fall back to HTTP if connection fails within timeout
+    const ws = new WSTransport();
+    const http = new HTTPTransport();
+    let useWs = true;
+    let decided = false;
+    const buffer = [];
+    const fallbackTimer = setTimeout(() => {
+        if (!decided && !ws.isConnected) {
+            decided = true;
+            useWs = false;
+            ws.close();
+            for (const item of buffer.splice(0))
+                http.send(item.eventType, item.data);
+        }
+    }, 5000);
+    ws.connect();
+    const originalSend = ws.send.bind(ws);
+    const checkConnected = () => {
+        if (!decided && ws.isConnected) {
+            decided = true;
+            clearTimeout(fallbackTimer);
+            for (const item of buffer.splice(0))
+                originalSend(item.eventType, item.data);
+        }
+    };
+    return {
+        send(eventType, data) {
+            checkConnected();
+            if (decided) {
+                if (useWs)
+                    originalSend(eventType, data);
+                else
+                    http.send(eventType, data);
+            }
+            else {
+                buffer.push({ eventType, data });
+            }
+        },
+        close() {
+            clearTimeout(fallbackTimer);
+            if (!decided) {
+                // WS not yet connected — force HTTP fallback to avoid data loss
+                decided = true;
+                useWs = false;
+                ws.close();
+                for (const item of buffer.splice(0))
+                    http.send(item.eventType, item.data);
+                http.close();
+            }
+            else if (useWs) {
+                ws.close();
+            }
+            else {
+                http.close();
+            }
+        },
+    };
 }

package/package.json

@@ -1,37 +1,61 @@
 {
   "name": "retrace-sdk",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "The execution replay engine for AI agents. Record, replay, fork, and share agent executions.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
+  "files": ["dist", "README.md", "LICENSE"],
+  "license": "MIT",
+  "author": "Yash Bogam",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yash1511-bogam/retrace",
+    "directory": "packages/sdk-typescript"
+  },
+  "homepage": "https://retrace.yashbogam.me/docs/sdk-typescript",
+  "keywords": ["ai", "agent", "tracing", "observability", "replay", "llm", "openai", "anthropic", "gemini"],
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "dev": "tsc --watch",
     "build": "tsc",
     "lint": "eslint src/",
-    "test": "vitest run"
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "ws": "8.20.0"
   },
   "peerDependencies": {
-    "@google/genai": ">=1.52.0"
+    "@google/genai": ">=1.52.0",
+    "openai": ">=4.0.0",
+    "@anthropic-ai/sdk": ">=0.30.0"
   },
   "peerDependenciesMeta": {
     "@google/genai": {
       "optional": true
+    },
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@google/genai": "^1.52.0",
     "@types/node": "22.15.3",
     "@types/ws": "8.18.1",
-    "typescript": "6.0.3"
+    "typescript": "6.0.3",
+    "openai": "^4.90.0",
+    "@anthropic-ai/sdk": "^0.95.0"
   }
 }

package/dist/config.test.d.ts

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