observa-sdk 0.0.8 → 0.0.10

package/dist/index.js

@@ -1,3 +1,391 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/instrumentation/utils.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function reconstructOpenAIResponse(chunks) {
+  if (chunks.length === 0) {
+    return null;
+  }
+  const firstChunk = chunks[0];
+  const lastChunk = chunks[chunks.length - 1];
+  let fullContent = "";
+  const messages = [];
+  for (const chunk of chunks) {
+    if (chunk?.choices?.[0]?.delta?.content) {
+      fullContent += chunk.choices[0].delta.content;
+    }
+  }
+  const response = {
+    id: lastChunk?.id || firstChunk?.id || null,
+    model: lastChunk?.model || firstChunk?.model || null,
+    object: "chat.completion",
+    created: lastChunk?.created || firstChunk?.created || Math.floor(Date.now() / 1e3),
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: fullContent
+        },
+        finish_reason: lastChunk?.choices?.[0]?.finish_reason || null
+      }
+    ],
+    usage: lastChunk?.usage || null
+    // Usage info typically in last chunk
+  };
+  return response;
+}
+function reconstructAnthropicResponse(chunks) {
+  if (chunks.length === 0) {
+    return null;
+  }
+  const lastChunk = chunks[chunks.length - 1];
+  let fullContent = "";
+  for (const chunk of chunks) {
+    if (chunk?.type === "content_block_delta" && chunk?.delta?.text) {
+      fullContent += chunk.delta.text;
+    }
+  }
+  return {
+    id: lastChunk?.id || null,
+    model: lastChunk?.model || null,
+    type: "message",
+    role: "assistant",
+    content: [{ type: "text", text: fullContent }],
+    stop_reason: lastChunk?.stop_reason || null,
+    stop_sequence: lastChunk?.stop_sequence || null,
+    usage: lastChunk?.usage || null
+  };
+}
+async function* wrapStream(stream, onComplete, onError, provider = "openai") {
+  let firstTokenTime = null;
+  const chunks = [];
+  let tokenCount = 0;
+  const streamStartTime = Date.now();
+  try {
+    for await (const chunk of stream) {
+      if (firstTokenTime === null) {
+        firstTokenTime = Date.now();
+      }
+      if (provider === "openai") {
+        const content = chunk?.choices?.[0]?.delta?.content;
+        if (content && typeof content === "string") {
+          tokenCount += estimateTokens(content);
+        }
+      } else if (provider === "anthropic") {
+        const text = chunk?.delta?.text;
+        if (text && typeof text === "string") {
+          tokenCount += estimateTokens(text);
+        }
+      }
+      chunks.push(chunk);
+      yield chunk;
+    }
+    const fullResponse = provider === "openai" ? reconstructOpenAIResponse(chunks) : reconstructAnthropicResponse(chunks);
+    Promise.resolve().then(() => {
+      try {
+        onComplete({
+          ...fullResponse,
+          timeToFirstToken: firstTokenTime ? firstTokenTime - streamStartTime : null,
+          streamingDuration: firstTokenTime ? Date.now() - firstTokenTime : null,
+          estimatedTokenCount: tokenCount,
+          totalLatency: Date.now() - streamStartTime
+        });
+      } catch (e) {
+        onError(e);
+      }
+    }).catch((e) => {
+      onError(e);
+    });
+  } catch (error) {
+    onError(error);
+    throw error;
+  }
+}
+
+// src/instrumentation/semconv.ts
+var OTEL_SEMCONV = {
+  // Standard GenAI Attributes (Snake Case)
+  GEN_AI_SYSTEM: "gen_ai.system",
+  GEN_AI_REQUEST_MODEL: "gen_ai.request.model",
+  GEN_AI_RESPONSE_MODEL: "gen_ai.response.model",
+  GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+  GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+  GEN_AI_FINISH_REASONS: "gen_ai.response.finish_reasons",
+  // Observa Internal Attributes
+  OBSERVA_TRACE_ID: "observa.trace_id",
+  OBSERVA_SPAN_ID: "observa.span_id",
+  OBSERVA_VERSION: "observa.sdk_version"
+};
+function mapOpenAIToOTEL(request, response) {
+  return {
+    [OTEL_SEMCONV.GEN_AI_SYSTEM]: "openai",
+    [OTEL_SEMCONV.GEN_AI_REQUEST_MODEL]: request.model,
+    [OTEL_SEMCONV.GEN_AI_RESPONSE_MODEL]: response?.model || request.model,
+    [OTEL_SEMCONV.GEN_AI_USAGE_INPUT_TOKENS]: response?.usage?.prompt_tokens,
+    [OTEL_SEMCONV.GEN_AI_USAGE_OUTPUT_TOKENS]: response?.usage?.completion_tokens,
+    [OTEL_SEMCONV.GEN_AI_FINISH_REASONS]: response?.choices?.map((c) => c.finish_reason)
+  };
+}
+
+// src/context.ts
+var traceContextStorage = null;
+var edgeContextMap = null;
+try {
+  const { AsyncLocalStorage } = __require("async_hooks");
+  traceContextStorage = new AsyncLocalStorage();
+} catch {
+  edgeContextMap = /* @__PURE__ */ new WeakMap();
+}
+function getTraceContext() {
+  try {
+    if (traceContextStorage) {
+      return traceContextStorage.getStore();
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/instrumentation/openai.ts
+var proxyCache = /* @__PURE__ */ new WeakMap();
+function observeOpenAI(client, options) {
+  if (proxyCache.has(client)) {
+    return proxyCache.get(client);
+  }
+  try {
+    const wrapped = new Proxy(client, {
+      get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "object" && value !== null) {
+          if (prop === "prototype" || prop === "constructor") {
+            return value;
+          }
+          return observeOpenAI(value, options);
+        }
+        if (typeof value === "function" && prop === "create") {
+          return async function(...args) {
+            return traceOpenAICall(value.bind(target), args, options);
+          };
+        }
+        return value;
+      }
+    });
+    proxyCache.set(client, wrapped);
+    return wrapped;
+  } catch (error) {
+    console.error("[Observa] Failed to wrap OpenAI client:", error);
+    return client;
+  }
+}
+async function traceOpenAICall(originalFn, args, options) {
+  const startTime = Date.now();
+  const requestParams = args[0] || {};
+  const isStreaming = requestParams.stream === true;
+  try {
+    const result = await originalFn(...args);
+    if (isStreaming) {
+      return wrapStream(
+        result,
+        (fullResponse) => {
+          recordTrace(
+            requestParams,
+            fullResponse,
+            startTime,
+            options,
+            fullResponse.timeToFirstToken,
+            fullResponse.streamingDuration
+          );
+        },
+        (err) => recordError(requestParams, err, startTime, options),
+        "openai"
+      );
+    } else {
+      recordTrace(requestParams, result, startTime, options);
+      return result;
+    }
+  } catch (error) {
+    recordError(requestParams, error, startTime, options);
+    throw error;
+  }
+}
+function recordTrace(req, res, start, opts, timeToFirstToken, streamingDuration) {
+  const duration = Date.now() - start;
+  try {
+    const context = getTraceContext();
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    const sanitizedRes = opts?.redact ? opts.redact(res) : res;
+    const otelAttributes = mapOpenAIToOTEL(sanitizedReq, sanitizedRes);
+    if (opts?.observa) {
+      const inputText = sanitizedReq.messages?.map((m) => m.content).filter(Boolean).join("\n") || null;
+      const outputText = sanitizedRes?.choices?.[0]?.message?.content || null;
+      opts.observa.trackLLMCall({
+        model: sanitizedReq.model || sanitizedRes?.model || "unknown",
+        input: inputText,
+        output: outputText,
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: sanitizedRes?.choices?.map((c) => c.message) || null,
+        inputTokens: sanitizedRes?.usage?.prompt_tokens || null,
+        outputTokens: sanitizedRes?.usage?.completion_tokens || null,
+        totalTokens: sanitizedRes?.usage?.total_tokens || null,
+        latencyMs: duration,
+        timeToFirstTokenMs: timeToFirstToken || null,
+        streamingDurationMs: streamingDuration || null,
+        finishReason: sanitizedRes?.choices?.[0]?.finish_reason || null,
+        responseId: sanitizedRes?.id || null,
+        operationName: "chat",
+        providerName: "openai",
+        responseModel: sanitizedRes?.model || sanitizedReq.model || null,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.max_tokens || null
+      });
+    }
+  } catch (e) {
+    console.error("[Observa] Failed to record trace", e);
+  }
+}
+function recordError(req, error, start, opts) {
+  try {
+    console.error("[Observa] \u26A0\uFE0F Error Captured:", error?.message || error);
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    if (opts?.observa) {
+      opts.observa.trackError({
+        errorType: "openai_api_error",
+        errorMessage: error?.message || String(error),
+        stackTrace: error?.stack || null,
+        context: { request: sanitizedReq }
+      });
+    }
+  } catch (e) {
+  }
+}
+
+// src/instrumentation/anthropic.ts
+var proxyCache2 = /* @__PURE__ */ new WeakMap();
+function observeAnthropic(client, options) {
+  if (proxyCache2.has(client)) {
+    return proxyCache2.get(client);
+  }
+  try {
+    const wrapped = new Proxy(client, {
+      get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "object" && value !== null) {
+          if (prop === "prototype" || prop === "constructor") {
+            return value;
+          }
+          return observeAnthropic(value, options);
+        }
+        if (typeof value === "function" && prop === "create") {
+          return async function(...args) {
+            return traceAnthropicCall(value.bind(target), args, options);
+          };
+        }
+        return value;
+      }
+    });
+    proxyCache2.set(client, wrapped);
+    return wrapped;
+  } catch (error) {
+    console.error("[Observa] Failed to wrap Anthropic client:", error);
+    return client;
+  }
+}
+async function traceAnthropicCall(originalFn, args, options) {
+  const startTime = Date.now();
+  const requestParams = args[0] || {};
+  const isStreaming = requestParams.stream === true;
+  try {
+    const result = await originalFn(...args);
+    if (isStreaming) {
+      return wrapStream(
+        result,
+        (fullResponse) => {
+          recordTrace2(
+            requestParams,
+            fullResponse,
+            startTime,
+            options,
+            fullResponse.timeToFirstToken,
+            fullResponse.streamingDuration
+          );
+        },
+        (err) => recordError2(requestParams, err, startTime, options),
+        "anthropic"
+      );
+    } else {
+      recordTrace2(requestParams, result, startTime, options);
+      return result;
+    }
+  } catch (error) {
+    recordError2(requestParams, error, startTime, options);
+    throw error;
+  }
+}
+function recordTrace2(req, res, start, opts, timeToFirstToken, streamingDuration) {
+  const duration = Date.now() - start;
+  try {
+    const context = getTraceContext();
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    const sanitizedRes = opts?.redact ? opts.redact(res) : res;
+    if (opts?.observa) {
+      const inputText = sanitizedReq.messages?.map((m) => {
+        if (typeof m.content === "string") return m.content;
+        if (Array.isArray(m.content)) {
+          return m.content.map((c) => c.text || c.type).filter(Boolean).join("\n");
+        }
+        return null;
+      }).filter(Boolean).join("\n") || null;
+      const outputText = sanitizedRes?.content?.map((c) => c.text).filter(Boolean).join("\n") || null;
+      opts.observa.trackLLMCall({
+        model: sanitizedReq.model || sanitizedRes?.model || "unknown",
+        input: inputText,
+        output: outputText,
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: sanitizedRes?.content || null,
+        inputTokens: sanitizedRes?.usage?.input_tokens || null,
+        outputTokens: sanitizedRes?.usage?.output_tokens || null,
+        totalTokens: (sanitizedRes?.usage?.input_tokens || 0) + (sanitizedRes?.usage?.output_tokens || 0) || null,
+        latencyMs: duration,
+        timeToFirstTokenMs: timeToFirstToken || null,
+        streamingDurationMs: streamingDuration || null,
+        finishReason: sanitizedRes?.stop_reason || null,
+        responseId: sanitizedRes?.id || null,
+        operationName: "chat",
+        providerName: "anthropic",
+        responseModel: sanitizedRes?.model || sanitizedReq.model || null,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.max_tokens || null
+      });
+    }
+  } catch (e) {
+    console.error("[Observa] Failed to record trace", e);
+  }
+}
+function recordError2(req, error, start, opts) {
+  try {
+    console.error("[Observa] \u26A0\uFE0F Error Captured:", error?.message || error);
+    const sanitizedReq = opts?.redact ? opts.redact(req) : req;
+    if (opts?.observa) {
+      opts.observa.trackError({
+        errorType: "anthropic_api_error",
+        errorMessage: error?.message || String(error),
+        stackTrace: error?.stack || null,
+        context: { request: sanitizedReq }
+      });
+    }
+  } catch (e) {
+  }
+}
+
 // src/index.ts
 var contextModule = null;
 try {
@@ -383,7 +771,78 @@ var Observa = class {
     return this.currentTraceId;
   }
   /**
-   * Track a tool call
+   * Track an LLM call with full OTEL support
+   * CRITICAL: This is the primary method for tracking LLM calls with all SOTA parameters
+   */
+  trackLLMCall(options) {
+    const spanId = crypto.randomUUID();
+    let providerName = options.providerName;
+    if (!providerName && options.model) {
+      const modelLower = options.model.toLowerCase();
+      if (modelLower.includes("gpt") || modelLower.includes("openai")) {
+        providerName = "openai";
+      } else if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
+        providerName = "anthropic";
+      } else if (modelLower.includes("gemini") || modelLower.includes("google")) {
+        providerName = "google";
+      } else if (modelLower.includes("vertex")) {
+        providerName = "gcp.vertex_ai";
+      } else if (modelLower.includes("bedrock") || modelLower.includes("aws")) {
+        providerName = "aws.bedrock";
+      }
+    }
+    const operationName = options.operationName || "chat";
+    this.addEvent({
+      event_type: "llm_call",
+      span_id: spanId,
+      attributes: {
+        llm_call: {
+          model: options.model,
+          input: options.input || null,
+          output: options.output || null,
+          input_tokens: options.inputTokens || null,
+          output_tokens: options.outputTokens || null,
+          total_tokens: options.totalTokens || null,
+          latency_ms: options.latencyMs,
+          time_to_first_token_ms: options.timeToFirstTokenMs || null,
+          streaming_duration_ms: options.streamingDurationMs || null,
+          finish_reason: options.finishReason || null,
+          response_id: options.responseId || null,
+          system_fingerprint: options.systemFingerprint || null,
+          cost: options.cost || null,
+          temperature: options.temperature || null,
+          max_tokens: options.maxTokens || null,
+          // TIER 1: OTEL Semantic Conventions
+          operation_name: operationName,
+          provider_name: providerName || null,
+          response_model: options.responseModel || null,
+          // TIER 2: Sampling parameters
+          top_k: options.topK || null,
+          top_p: options.topP || null,
+          frequency_penalty: options.frequencyPenalty || null,
+          presence_penalty: options.presencePenalty || null,
+          stop_sequences: options.stopSequences || null,
+          seed: options.seed || null,
+          // TIER 2: Structured cost tracking
+          input_cost: options.inputCost || null,
+          output_cost: options.outputCost || null,
+          // TIER 1: Structured message objects
+          input_messages: options.inputMessages || null,
+          output_messages: options.outputMessages || null,
+          system_instructions: options.systemInstructions || null,
+          // TIER 2: Server metadata
+          server_address: options.serverAddress || null,
+          server_port: options.serverPort || null,
+          // TIER 2: Conversation grouping
+          conversation_id_otel: options.conversationIdOtel || null,
+          choice_count: options.choiceCount || null
+        }
+      }
+    });
+    return spanId;
+  }
+  /**
+   * Track a tool call with OTEL standardization
    */
   trackToolCall(options) {
     const spanId = crypto.randomUUID();
@@ -397,14 +856,21 @@ var Observa = class {
           result: options.result || null,
           result_status: options.resultStatus,
           latency_ms: options.latencyMs,
-          error_message: options.errorMessage || null
+          error_message: options.errorMessage || null,
+          // TIER 2: OTEL Tool Standardization
+          operation_name: options.operationName || "execute_tool",
+          tool_type: options.toolType || null,
+          tool_description: options.toolDescription || null,
+          tool_call_id: options.toolCallId || null,
+          error_type: options.errorType || null,
+          error_category: options.errorCategory || null
         }
       }
     });
     return spanId;
   }
   /**
-   * Track a retrieval operation
+   * Track a retrieval operation with vector metadata enrichment
    */
   trackRetrieval(options) {
     const spanId = crypto.randomUUID();
@@ -418,14 +884,23 @@ var Observa = class {
           k: options.k || null,
           top_k: options.k || null,
           similarity_scores: options.similarityScores || null,
-          latency_ms: options.latencyMs
+          latency_ms: options.latencyMs,
+          // TIER 2: Retrieval enrichment
+          retrieval_context: options.retrievalContext || null,
+          embedding_model: options.embeddingModel || null,
+          embedding_dimensions: options.embeddingDimensions || null,
+          vector_metric: options.vectorMetric || null,
+          rerank_score: options.rerankScore || null,
+          fusion_method: options.fusionMethod || null,
+          deduplication_removed_count: options.deduplicationRemovedCount || null,
+          quality_score: options.qualityScore || null
         }
       }
     });
     return spanId;
   }
   /**
-   * Track an error with stack trace support
+   * Track an error with structured error classification
    */
   trackError(options) {
     const spanId = crypto.randomUUID();
@@ -441,7 +916,10 @@ var Observa = class {
           error_type: options.errorType,
           error_message: options.errorMessage,
           stack_trace: stackTrace || null,
-          context: options.context || null
+          context: options.context || null,
+          // TIER 2: Structured error classification
+          error_category: options.errorCategory || null,
+          error_code: options.errorCode || null
         }
       }
     });
@@ -495,6 +973,114 @@ var Observa = class {
     });
     return spanId;
   }
+  /**
+   * Track an embedding operation (TIER 1: Critical)
+   */
+  trackEmbedding(options) {
+    const spanId = crypto.randomUUID();
+    let providerName = options.providerName;
+    if (!providerName && options.model) {
+      const modelLower = options.model.toLowerCase();
+      if (modelLower.includes("text-embedding") || modelLower.includes("openai")) {
+        providerName = "openai";
+      } else if (modelLower.includes("textembedding") || modelLower.includes("google")) {
+        providerName = "google";
+      } else if (modelLower.includes("vertex")) {
+        providerName = "gcp.vertex_ai";
+      }
+    }
+    this.addEvent({
+      event_type: "embedding",
+      span_id: spanId,
+      attributes: {
+        embedding: {
+          model: options.model,
+          dimension_count: options.dimensionCount || null,
+          encoding_formats: options.encodingFormats || null,
+          input_tokens: options.inputTokens || null,
+          output_tokens: options.outputTokens || null,
+          latency_ms: options.latencyMs,
+          cost: options.cost || null,
+          input_text: options.inputText || null,
+          input_hash: options.inputHash || null,
+          embeddings: options.embeddings || null,
+          embeddings_hash: options.embeddingsHash || null,
+          operation_name: options.operationName || "embeddings",
+          provider_name: providerName || null
+        }
+      }
+    });
+    return spanId;
+  }
+  /**
+   * Track a vector database operation (TIER 3)
+   */
+  trackVectorDbOperation(options) {
+    const spanId = crypto.randomUUID();
+    this.addEvent({
+      event_type: "vector_db_operation",
+      span_id: spanId,
+      attributes: {
+        vector_db_operation: {
+          operation_type: options.operationType,
+          index_name: options.indexName || null,
+          index_version: options.indexVersion || null,
+          vector_dimensions: options.vectorDimensions || null,
+          vector_metric: options.vectorMetric || null,
+          results_count: options.resultsCount || null,
+          scores: options.scores || null,
+          latency_ms: options.latencyMs,
+          cost: options.cost || null,
+          api_version: options.apiVersion || null,
+          provider_name: options.providerName || null
+        }
+      }
+    });
+    return spanId;
+  }
+  /**
+   * Track a cache operation (TIER 3)
+   */
+  trackCacheOperation(options) {
+    const spanId = crypto.randomUUID();
+    this.addEvent({
+      event_type: "cache_operation",
+      span_id: spanId,
+      attributes: {
+        cache_operation: {
+          cache_backend: options.cacheBackend || null,
+          cache_key: options.cacheKey || null,
+          cache_namespace: options.cacheNamespace || null,
+          hit_status: options.hitStatus,
+          latency_ms: options.latencyMs,
+          saved_cost: options.savedCost || null,
+          ttl: options.ttl || null,
+          eviction_info: options.evictionInfo || null
+        }
+      }
+    });
+    return spanId;
+  }
+  /**
+   * Track agent creation (TIER 3)
+   */
+  trackAgentCreate(options) {
+    const spanId = crypto.randomUUID();
+    this.addEvent({
+      event_type: "agent_create",
+      span_id: spanId,
+      attributes: {
+        agent_create: {
+          agent_name: options.agentName,
+          agent_config: options.agentConfig || null,
+          tools_bound: options.toolsBound || null,
+          model_config: options.modelConfig || null,
+          operation_name: options.operationName || "create_agent"
+        }
+      }
+    });
+    return spanId;
+  }
   /**
    * Execute a function within a span context (for nested operations)
    * This allows tool calls to be nested under LLM calls, etc.
@@ -595,6 +1181,21 @@ var Observa = class {
     });
     if (trace.model) {
       const llmSpanId = crypto.randomUUID();
+      let providerName = null;
+      if (trace.model) {
+        const modelLower = trace.model.toLowerCase();
+        if (modelLower.includes("gpt") || modelLower.includes("openai")) {
+          providerName = "openai";
+        } else if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
+          providerName = "anthropic";
+        } else if (modelLower.includes("gemini") || modelLower.includes("google")) {
+          providerName = "google";
+        } else if (modelLower.includes("vertex")) {
+          providerName = "gcp.vertex_ai";
+        } else if (modelLower.includes("bedrock") || modelLower.includes("aws")) {
+          providerName = "aws.bedrock";
+        }
+      }
       events.push({
         ...baseEvent,
         span_id: llmSpanId,
@@ -615,8 +1216,13 @@ var Observa = class {
             finish_reason: trace.finishReason || null,
             response_id: trace.responseId || null,
             system_fingerprint: trace.systemFingerprint || null,
-            cost: null
+            cost: null,
             // Cost calculation handled by backend
+            // TIER 1: OTEL Semantic Conventions (auto-inferred)
+            operation_name: "chat",
+            // Default for legacy track() method
+            provider_name: providerName
+            // Other OTEL fields can be added via trackLLMCall() method
           }
         }
       });
@@ -708,6 +1314,56 @@ var Observa = class {
     }
     await this.flush();
   }
+  /**
+   * Observe OpenAI client - wraps client with automatic tracing
+   * 
+   * @param client - OpenAI client instance
+   * @param options - Observation options (name, tags, userId, sessionId, redact)
+   * @returns Wrapped OpenAI client
+   * 
+   * @example
+   * ```typescript
+   * import OpenAI from 'openai';
+   * const openai = new OpenAI({ apiKey: '...' });
+   * const wrapped = observa.observeOpenAI(openai, {
+   *   name: 'my-app',
+   *   redact: (data) => ({ ...data, messages: '[REDACTED]' })
+   * });
+   * ```
+   */
+  observeOpenAI(client, options) {
+    try {
+      return observeOpenAI(client, { ...options, observa: this });
+    } catch (error) {
+      console.error("[Observa] Failed to load OpenAI wrapper:", error);
+      return client;
+    }
+  }
+  /**
+   * Observe Anthropic client - wraps client with automatic tracing
+   * 
+   * @param client - Anthropic client instance
+   * @param options - Observation options (name, tags, userId, sessionId, redact)
+   * @returns Wrapped Anthropic client
+   * 
+   * @example
+   * ```typescript
+   * import Anthropic from '@anthropic-ai/sdk';
+   * const anthropic = new Anthropic({ apiKey: '...' });
+   * const wrapped = observa.observeAnthropic(anthropic, {
+   *   name: 'my-app',
+   *   redact: (data) => ({ ...data, messages: '[REDACTED]' })
+   * });
+   * ```
+   */
+  observeAnthropic(client, options) {
+    try {
+      return observeAnthropic(client, { ...options, observa: this });
+    } catch (error) {
+      console.error("[Observa] Failed to load Anthropic wrapper:", error);
+      return client;
+    }
+  }
   async track(event, action, options) {
     if (this.sampleRate < 1 && Math.random() > this.sampleRate) {
       return action();