observa-sdk 0.0.10 → 0.0.11

package/README.md

@@ -88,6 +88,70 @@ for await (const chunk of stream) {
 }
 ```
 
+### Auto-Capture with Anthropic
+
+Works the same way with Anthropic:
+
+```typescript
+import { init } from "observa-sdk";
+import Anthropic from "@anthropic-ai/sdk";
+
+const observa = init({
+  apiKey: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+});
+
+const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+// Wrap with Observa (automatic tracing)
+const wrappedAnthropic = observa.observeAnthropic(anthropic, {
+  name: 'my-app',
+  userId: 'user_123',
+});
+
+// Use wrapped client - automatically tracked!
+const response = await wrappedAnthropic.messages.create({
+  model: 'claude-3-opus-20240229',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Hello!' }],
+});
+```
+
+### Auto-Capture with Vercel AI SDK
+
+Vercel AI SDK is a unified SDK that works with multiple providers:
+
+```typescript
+import { init } from "observa-sdk";
+import { generateText, streamText } from "ai";
+import { openai } from "@ai-sdk/openai";
+
+const observa = init({
+  apiKey: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+});
+
+// Wrap Vercel AI SDK functions (automatic tracing)
+const ai = observa.observeVercelAI({ generateText, streamText }, {
+  name: 'my-app',
+  userId: 'user_123',
+});
+
+// Use wrapped functions - automatically tracked!
+const result = await ai.generateText({
+  model: openai('gpt-4'),
+  prompt: 'Hello!',
+});
+
+// Streaming also works automatically
+const stream = await ai.streamText({
+  model: openai('gpt-4'),
+  prompt: 'Tell me a joke',
+});
+
+for await (const chunk of stream.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
 ### Legacy Manual Tracking
 
 For more control, you can still use the manual `track()` method:
@@ -290,6 +354,55 @@ const response = await wrapped.messages.create({
 });
 ```
 
+### `observa.observeVercelAI(aiSdk, options?)`
+
+Wrap Vercel AI SDK functions (`generateText`, `streamText`) with automatic tracing. Vercel AI SDK is a unified SDK that works with multiple providers (OpenAI, Anthropic, Google, etc.).
+
+**Parameters:**
+- `aiSdk` (required): Object containing Vercel AI SDK functions (e.g., `{ generateText, streamText }`)
+- `options` (optional):
+  - `name` (optional): Application/service name
+  - `tags` (optional): Array of tags
+  - `userId` (optional): User identifier
+  - `sessionId` (optional): Session identifier
+  - `redact` (optional): Function to sanitize data before sending to Observa
+
+**Returns**: Wrapped AI SDK object with the same functions (use them exactly like the original functions)
+
+**Example:**
+```typescript
+import { generateText, streamText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+
+const ai = observa.observeVercelAI({ generateText, streamText }, {
+  name: 'my-app',
+  userId: 'user_123',
+  redact: (data) => {
+    // Sanitize sensitive data
+    if (data?.prompt) {
+      return { ...data, prompt: '[REDACTED]' };
+    }
+    return data;
+  }
+});
+
+// Use wrapped functions - automatically tracked!
+const result = await ai.generateText({
+  model: openai('gpt-4'),
+  prompt: 'Hello!',
+});
+
+// Streaming also works automatically
+const stream = await ai.streamText({
+  model: openai('gpt-4'),
+  prompt: 'Tell me a joke',
+});
+
+for await (const chunk of stream.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
 ### `observa.startTrace(options)`
 
 Start a new trace for manual trace management. Returns the trace ID.

package/dist/index.cjs

@@ -104,11 +104,30 @@ async function* wrapStream(stream, onComplete, onError, provider = "openai") {
         if (text && typeof text === "string") {
           tokenCount += estimateTokens(text);
         }
+      } else if (provider === "vercel-ai") {
+        if (typeof chunk === "string") {
+          tokenCount += estimateTokens(chunk);
+        } else if (chunk?.textDelta) {
+          tokenCount += estimateTokens(chunk.textDelta);
+        }
       }
       chunks.push(chunk);
       yield chunk;
     }
-    const fullResponse = provider === "openai" ? reconstructOpenAIResponse(chunks) : reconstructAnthropicResponse(chunks);
+    let fullResponse;
+    if (provider === "openai") {
+      fullResponse = reconstructOpenAIResponse(chunks);
+    } else if (provider === "anthropic") {
+      fullResponse = reconstructAnthropicResponse(chunks);
+    } else if (provider === "vercel-ai") {
+      const fullText = chunks.map((chunk) => typeof chunk === "string" ? chunk : chunk?.textDelta || "").join("");
+      fullResponse = {
+        text: fullText,
+        tokenCount
+      };
+    } else {
+      fullResponse = { chunks, tokenCount };
+    }
     Promise.resolve().then(() => {
       try {
         onComplete({
@@ -406,6 +425,216 @@ function recordError2(req, error, start, opts) {
   }
 }
 
+// src/instrumentation/vercel-ai.ts
+function extractProviderFromModel(model) {
+  if (!model) return "unknown";
+  const parts = model.split("/");
+  if (parts.length > 1) {
+    return parts[0].toLowerCase();
+  }
+  const modelLower = model.toLowerCase();
+  if (modelLower.includes("gpt") || modelLower.includes("openai")) {
+    return "openai";
+  }
+  if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
+    return "anthropic";
+  }
+  if (modelLower.includes("gemini") || modelLower.includes("google")) {
+    return "google";
+  }
+  return "unknown";
+}
+async function traceGenerateText(originalFn, args, options) {
+  const startTime = Date.now();
+  const requestParams = args[0] || {};
+  const model = requestParams.model || "unknown";
+  const provider = extractProviderFromModel(model);
+  try {
+    const result = await originalFn(...args);
+    const responseText = result.text || "";
+    const usage = result.usage || {};
+    const finishReason = result.finishReason || null;
+    const responseId = result.response?.id || null;
+    recordTrace3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null,
+        messages: requestParams.messages || null
+      },
+      {
+        text: responseText,
+        usage,
+        finishReason,
+        responseId,
+        model: result.model || model
+      },
+      startTime,
+      options,
+      null,
+      // No streaming for generateText
+      null,
+      provider
+    );
+    return result;
+  } catch (error) {
+    recordError3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null
+      },
+      error,
+      startTime,
+      options
+    );
+    throw error;
+  }
+}
+async function traceStreamText(originalFn, args, options) {
+  const startTime = Date.now();
+  const requestParams = args[0] || {};
+  const model = requestParams.model || "unknown";
+  const provider = extractProviderFromModel(model);
+  try {
+    const result = await originalFn(...args);
+    if (result.textStream) {
+      const wrappedStream = wrapStream(
+        result.textStream,
+        (fullResponse) => {
+          recordTrace3(
+            {
+              model,
+              prompt: requestParams.prompt || requestParams.messages || null,
+              messages: requestParams.messages || null
+            },
+            fullResponse,
+            startTime,
+            options,
+            fullResponse.timeToFirstToken,
+            fullResponse.streamingDuration,
+            provider
+          );
+        },
+        (err) => recordError3(
+          {
+            model,
+            prompt: requestParams.prompt || requestParams.messages || null
+          },
+          err,
+          startTime,
+          options
+        ),
+        "vercel-ai"
+      );
+      return {
+        ...result,
+        textStream: wrappedStream
+      };
+    }
+    recordTrace3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null,
+        messages: requestParams.messages || null
+      },
+      result,
+      startTime,
+      options,
+      null,
+      null,
+      provider
+    );
+    return result;
+  } catch (error) {
+    recordError3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null
+      },
+      error,
+      startTime,
+      options
+    );
+    throw error;
+  }
+}
+function recordTrace3(req, res, start, opts, timeToFirstToken, streamingDuration, provider) {
+  const duration = Date.now() - start;
+  try {
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    const sanitizedRes = opts?.redact ? opts.redact(res) : req;
+    if (opts?.observa) {
+      let inputText = null;
+      if (sanitizedReq.prompt) {
+        inputText = typeof sanitizedReq.prompt === "string" ? sanitizedReq.prompt : JSON.stringify(sanitizedReq.prompt);
+      } else if (sanitizedReq.messages) {
+        inputText = sanitizedReq.messages.map((m) => m.content || m.text || "").filter(Boolean).join("\n");
+      }
+      const outputText = sanitizedRes.text || sanitizedRes.content || null;
+      const usage = sanitizedRes.usage || {};
+      const inputTokens = usage.promptTokens || usage.inputTokens || null;
+      const outputTokens = usage.completionTokens || usage.outputTokens || null;
+      const totalTokens = usage.totalTokens || null;
+      opts.observa.trackLLMCall({
+        model: sanitizedReq.model || sanitizedRes.model || "unknown",
+        input: inputText,
+        output: outputText,
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: sanitizedRes.messages || null,
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        latencyMs: duration,
+        timeToFirstTokenMs: timeToFirstToken || null,
+        streamingDurationMs: streamingDuration || null,
+        finishReason: sanitizedRes.finishReason || null,
+        responseId: sanitizedRes.responseId || sanitizedRes.id || null,
+        operationName: "generate_text",
+        providerName: provider || "vercel-ai",
+        responseModel: sanitizedRes.model || sanitizedReq.model || null,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.maxTokens || sanitizedReq.max_tokens || null
+      });
+    }
+  } catch (e) {
+    console.error("[Observa] Failed to record trace", e);
+  }
+}
+function recordError3(req, error, start, opts) {
+  try {
+    console.error("[Observa] \u26A0\uFE0F Error Captured:", error.message);
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    if (opts?.observa) {
+      opts.observa.trackError({
+        errorType: error.name || "UnknownError",
+        errorMessage: error.message || "An unknown error occurred",
+        stackTrace: error.stack,
+        context: { request: sanitizedReq },
+        errorCategory: "llm_error"
+      });
+    }
+  } catch (e) {
+  }
+}
+function observeVercelAI(aiSdk, options) {
+  try {
+    const wrapped = { ...aiSdk };
+    if (aiSdk.generateText && typeof aiSdk.generateText === "function") {
+      wrapped.generateText = async function(...args) {
+        return traceGenerateText(aiSdk.generateText.bind(aiSdk), args, options);
+      };
+    }
+    if (aiSdk.streamText && typeof aiSdk.streamText === "function") {
+      wrapped.streamText = async function(...args) {
+        return traceStreamText(aiSdk.streamText.bind(aiSdk), args, options);
+      };
+    }
+    return wrapped;
+  } catch (error) {
+    console.error("[Observa] Failed to wrap Vercel AI SDK:", error);
+    return aiSdk;
+  }
+}
+
 // src/index.ts
 var contextModule = null;
 try {
@@ -1384,6 +1613,38 @@ var Observa = class {
       return client;
     }
   }
+  /**
+   * Observe Vercel AI SDK - wraps generateText and streamText functions
+   * 
+   * @param aiSdk - Vercel AI SDK module (imported from 'ai')
+   * @param options - Observation options (name, tags, userId, sessionId, redact)
+   * @returns Wrapped AI SDK with automatic tracing
+   * 
+   * @example
+   * ```typescript
+   * import { generateText, streamText } from 'ai';
+   * const observa = init({ apiKey: '...' });
+   * 
+   * const ai = observa.observeVercelAI({ generateText, streamText }, {
+   *   name: 'my-app',
+   *   redact: (data) => ({ ...data, prompt: '[REDACTED]' })
+   * });
+   * 
+   * // Use wrapped functions - automatically tracked!
+   * const result = await ai.generateText({
+   *   model: 'openai/gpt-4',
+   *   prompt: 'Hello!'
+   * });
+   * ```
+   */
+  observeVercelAI(aiSdk, options) {
+    try {
+      return observeVercelAI(aiSdk, { ...options, observa: this });
+    } catch (error) {
+      console.error("[Observa] Failed to load Vercel AI SDK wrapper:", error);
+      return aiSdk;
+    }
+  }
   async track(event, action, options) {
     if (this.sampleRate < 1 && Math.random() > this.sampleRate) {
       return action();

package/dist/index.d.cts

@@ -328,6 +328,41 @@ declare class Observa {
         sessionId?: string;
         redact?: (data: any) => any;
     }): any;
+    /**
+     * Observe Vercel AI SDK - wraps generateText and streamText functions
+     *
+     * @param aiSdk - Vercel AI SDK module (imported from 'ai')
+     * @param options - Observation options (name, tags, userId, sessionId, redact)
+     * @returns Wrapped AI SDK with automatic tracing
+     *
+     * @example
+     * ```typescript
+     * import { generateText, streamText } from 'ai';
+     * const observa = init({ apiKey: '...' });
+     *
+     * const ai = observa.observeVercelAI({ generateText, streamText }, {
+     *   name: 'my-app',
+     *   redact: (data) => ({ ...data, prompt: '[REDACTED]' })
+     * });
+     *
+     * // Use wrapped functions - automatically tracked!
+     * const result = await ai.generateText({
+     *   model: 'openai/gpt-4',
+     *   prompt: 'Hello!'
+     * });
+     * ```
+     */
+    observeVercelAI(aiSdk: {
+        generateText?: any;
+        streamText?: any;
+        [key: string]: any;
+    }, options?: {
+        name?: string;
+        tags?: string[];
+        userId?: string;
+        sessionId?: string;
+        redact?: (data: any) => any;
+    }): any;
     track(event: TrackEventInput, action: () => Promise<Response>, options?: {
         trackBlocking?: boolean;
     }): Promise<any>;

package/dist/index.d.ts

@@ -328,6 +328,41 @@ declare class Observa {
         sessionId?: string;
         redact?: (data: any) => any;
     }): any;
+    /**
+     * Observe Vercel AI SDK - wraps generateText and streamText functions
+     *
+     * @param aiSdk - Vercel AI SDK module (imported from 'ai')
+     * @param options - Observation options (name, tags, userId, sessionId, redact)
+     * @returns Wrapped AI SDK with automatic tracing
+     *
+     * @example
+     * ```typescript
+     * import { generateText, streamText } from 'ai';
+     * const observa = init({ apiKey: '...' });
+     *
+     * const ai = observa.observeVercelAI({ generateText, streamText }, {
+     *   name: 'my-app',
+     *   redact: (data) => ({ ...data, prompt: '[REDACTED]' })
+     * });
+     *
+     * // Use wrapped functions - automatically tracked!
+     * const result = await ai.generateText({
+     *   model: 'openai/gpt-4',
+     *   prompt: 'Hello!'
+     * });
+     * ```
+     */
+    observeVercelAI(aiSdk: {
+        generateText?: any;
+        streamText?: any;
+        [key: string]: any;
+    }, options?: {
+        name?: string;
+        tags?: string[];
+        userId?: string;
+        sessionId?: string;
+        redact?: (data: any) => any;
+    }): any;
     track(event: TrackEventInput, action: () => Promise<Response>, options?: {
         trackBlocking?: boolean;
     }): Promise<any>;

package/dist/index.js

@@ -84,11 +84,30 @@ async function* wrapStream(stream, onComplete, onError, provider = "openai") {
         if (text && typeof text === "string") {
           tokenCount += estimateTokens(text);
         }
+      } else if (provider === "vercel-ai") {
+        if (typeof chunk === "string") {
+          tokenCount += estimateTokens(chunk);
+        } else if (chunk?.textDelta) {
+          tokenCount += estimateTokens(chunk.textDelta);
+        }
       }
       chunks.push(chunk);
       yield chunk;
     }
-    const fullResponse = provider === "openai" ? reconstructOpenAIResponse(chunks) : reconstructAnthropicResponse(chunks);
+    let fullResponse;
+    if (provider === "openai") {
+      fullResponse = reconstructOpenAIResponse(chunks);
+    } else if (provider === "anthropic") {
+      fullResponse = reconstructAnthropicResponse(chunks);
+    } else if (provider === "vercel-ai") {
+      const fullText = chunks.map((chunk) => typeof chunk === "string" ? chunk : chunk?.textDelta || "").join("");
+      fullResponse = {
+        text: fullText,
+        tokenCount
+      };
+    } else {
+      fullResponse = { chunks, tokenCount };
+    }
     Promise.resolve().then(() => {
       try {
         onComplete({
@@ -386,6 +405,216 @@ function recordError2(req, error, start, opts) {
   }
 }
 
+// src/instrumentation/vercel-ai.ts
+function extractProviderFromModel(model) {
+  if (!model) return "unknown";
+  const parts = model.split("/");
+  if (parts.length > 1) {
+    return parts[0].toLowerCase();
+  }
+  const modelLower = model.toLowerCase();
+  if (modelLower.includes("gpt") || modelLower.includes("openai")) {
+    return "openai";
+  }
+  if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
+    return "anthropic";
+  }
+  if (modelLower.includes("gemini") || modelLower.includes("google")) {
+    return "google";
+  }
+  return "unknown";
+}
+async function traceGenerateText(originalFn, args, options) {
+  const startTime = Date.now();
+  const requestParams = args[0] || {};
+  const model = requestParams.model || "unknown";
+  const provider = extractProviderFromModel(model);
+  try {
+    const result = await originalFn(...args);
+    const responseText = result.text || "";
+    const usage = result.usage || {};
+    const finishReason = result.finishReason || null;
+    const responseId = result.response?.id || null;
+    recordTrace3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null,
+        messages: requestParams.messages || null
+      },
+      {
+        text: responseText,
+        usage,
+        finishReason,
+        responseId,
+        model: result.model || model
+      },
+      startTime,
+      options,
+      null,
+      // No streaming for generateText
+      null,
+      provider
+    );
+    return result;
+  } catch (error) {
+    recordError3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null
+      },
+      error,
+      startTime,
+      options
+    );
+    throw error;
+  }
+}
+async function traceStreamText(originalFn, args, options) {
+  const startTime = Date.now();
+  const requestParams = args[0] || {};
+  const model = requestParams.model || "unknown";
+  const provider = extractProviderFromModel(model);
+  try {
+    const result = await originalFn(...args);
+    if (result.textStream) {
+      const wrappedStream = wrapStream(
+        result.textStream,
+        (fullResponse) => {
+          recordTrace3(
+            {
+              model,
+              prompt: requestParams.prompt || requestParams.messages || null,
+              messages: requestParams.messages || null
+            },
+            fullResponse,
+            startTime,
+            options,
+            fullResponse.timeToFirstToken,
+            fullResponse.streamingDuration,
+            provider
+          );
+        },
+        (err) => recordError3(
+          {
+            model,
+            prompt: requestParams.prompt || requestParams.messages || null
+          },
+          err,
+          startTime,
+          options
+        ),
+        "vercel-ai"
+      );
+      return {
+        ...result,
+        textStream: wrappedStream
+      };
+    }
+    recordTrace3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null,
+        messages: requestParams.messages || null
+      },
+      result,
+      startTime,
+      options,
+      null,
+      null,
+      provider
+    );
+    return result;
+  } catch (error) {
+    recordError3(
+      {
+        model,
+        prompt: requestParams.prompt || requestParams.messages || null
+      },
+      error,
+      startTime,
+      options
+    );
+    throw error;
+  }
+}
+function recordTrace3(req, res, start, opts, timeToFirstToken, streamingDuration, provider) {
+  const duration = Date.now() - start;
+  try {
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    const sanitizedRes = opts?.redact ? opts.redact(res) : req;
+    if (opts?.observa) {
+      let inputText = null;
+      if (sanitizedReq.prompt) {
+        inputText = typeof sanitizedReq.prompt === "string" ? sanitizedReq.prompt : JSON.stringify(sanitizedReq.prompt);
+      } else if (sanitizedReq.messages) {
+        inputText = sanitizedReq.messages.map((m) => m.content || m.text || "").filter(Boolean).join("\n");
+      }
+      const outputText = sanitizedRes.text || sanitizedRes.content || null;
+      const usage = sanitizedRes.usage || {};
+      const inputTokens = usage.promptTokens || usage.inputTokens || null;
+      const outputTokens = usage.completionTokens || usage.outputTokens || null;
+      const totalTokens = usage.totalTokens || null;
+      opts.observa.trackLLMCall({
+        model: sanitizedReq.model || sanitizedRes.model || "unknown",
+        input: inputText,
+        output: outputText,
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: sanitizedRes.messages || null,
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        latencyMs: duration,
+        timeToFirstTokenMs: timeToFirstToken || null,
+        streamingDurationMs: streamingDuration || null,
+        finishReason: sanitizedRes.finishReason || null,
+        responseId: sanitizedRes.responseId || sanitizedRes.id || null,
+        operationName: "generate_text",
+        providerName: provider || "vercel-ai",
+        responseModel: sanitizedRes.model || sanitizedReq.model || null,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.maxTokens || sanitizedReq.max_tokens || null
+      });
+    }
+  } catch (e) {
+    console.error("[Observa] Failed to record trace", e);
+  }
+}
+function recordError3(req, error, start, opts) {
+  try {
+    console.error("[Observa] \u26A0\uFE0F Error Captured:", error.message);
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    if (opts?.observa) {
+      opts.observa.trackError({
+        errorType: error.name || "UnknownError",
+        errorMessage: error.message || "An unknown error occurred",
+        stackTrace: error.stack,
+        context: { request: sanitizedReq },
+        errorCategory: "llm_error"
+      });
+    }
+  } catch (e) {
+  }
+}
+function observeVercelAI(aiSdk, options) {
+  try {
+    const wrapped = { ...aiSdk };
+    if (aiSdk.generateText && typeof aiSdk.generateText === "function") {
+      wrapped.generateText = async function(...args) {
+        return traceGenerateText(aiSdk.generateText.bind(aiSdk), args, options);
+      };
+    }
+    if (aiSdk.streamText && typeof aiSdk.streamText === "function") {
+      wrapped.streamText = async function(...args) {
+        return traceStreamText(aiSdk.streamText.bind(aiSdk), args, options);
+      };
+    }
+    return wrapped;
+  } catch (error) {
+    console.error("[Observa] Failed to wrap Vercel AI SDK:", error);
+    return aiSdk;
+  }
+}
+
 // src/index.ts
 var contextModule = null;
 try {
@@ -1364,6 +1593,38 @@ var Observa = class {
       return client;
     }
   }
+  /**
+   * Observe Vercel AI SDK - wraps generateText and streamText functions
+   * 
+   * @param aiSdk - Vercel AI SDK module (imported from 'ai')
+   * @param options - Observation options (name, tags, userId, sessionId, redact)
+   * @returns Wrapped AI SDK with automatic tracing
+   * 
+   * @example
+   * ```typescript
+   * import { generateText, streamText } from 'ai';
+   * const observa = init({ apiKey: '...' });
+   * 
+   * const ai = observa.observeVercelAI({ generateText, streamText }, {
+   *   name: 'my-app',
+   *   redact: (data) => ({ ...data, prompt: '[REDACTED]' })
+   * });
+   * 
+   * // Use wrapped functions - automatically tracked!
+   * const result = await ai.generateText({
+   *   model: 'openai/gpt-4',
+   *   prompt: 'Hello!'
+   * });
+   * ```
+   */
+  observeVercelAI(aiSdk, options) {
+    try {
+      return observeVercelAI(aiSdk, { ...options, observa: this });
+    } catch (error) {
+      console.error("[Observa] Failed to load Vercel AI SDK wrapper:", error);
+      return aiSdk;
+    }
+  }
   async track(event, action, options) {
     if (this.sampleRate < 1 && Math.random() > this.sampleRate) {
       return action();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "observa-sdk",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Enterprise-grade observability SDK for AI applications. Track and monitor LLM interactions with zero friction.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -34,5 +34,12 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "observa-sdk": "^0.0.10"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
   }
 }