observa-sdk 0.0.15 → 0.0.17

package/dist/index.cjs

@@ -292,18 +292,50 @@ function recordTrace(req, res, start, opts, timeToFirstToken, streamingDuration)
   }
 }
 function recordError(req, error, start, opts) {
+  const duration = Date.now() - start;
   try {
     console.error("[Observa] \u26A0\uFE0F Error Captured:", error?.message || error);
     const sanitizedReq = opts?.redact ? opts.redact(req) : req;
     if (opts?.observa) {
+      const model = sanitizedReq.model || "unknown";
+      const inputText = sanitizedReq.messages?.map((m) => m.content).filter(Boolean).join("\n") || null;
+      opts.observa.trackLLMCall({
+        model,
+        input: inputText,
+        output: null,
+        // No output on error
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+        latencyMs: duration,
+        timeToFirstTokenMs: null,
+        streamingDurationMs: null,
+        finishReason: null,
+        responseId: null,
+        operationName: "chat",
+        providerName: "openai",
+        responseModel: model,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.max_tokens || null
+      });
       opts.observa.trackError({
         errorType: "openai_api_error",
         errorMessage: error?.message || String(error),
         stackTrace: error?.stack || null,
-        context: { request: sanitizedReq }
+        context: {
+          request: sanitizedReq,
+          model,
+          input: inputText,
+          provider: "openai",
+          duration_ms: duration
+        },
+        errorCategory: "llm_error"
       });
     }
   } catch (e) {
+    console.error("[Observa] Failed to record error", e);
   }
 }
 
@@ -410,18 +442,56 @@ function recordTrace2(req, res, start, opts, timeToFirstToken, streamingDuration
   }
 }
 function recordError2(req, error, start, opts) {
+  const duration = Date.now() - start;
   try {
     console.error("[Observa] \u26A0\uFE0F Error Captured:", error?.message || error);
     const sanitizedReq = opts?.redact ? opts.redact(req) : req;
     if (opts?.observa) {
+      const model = sanitizedReq.model || "unknown";
+      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;
+      opts.observa.trackLLMCall({
+        model,
+        input: inputText,
+        output: null,
+        // No output on error
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+        latencyMs: duration,
+        timeToFirstTokenMs: null,
+        streamingDurationMs: null,
+        finishReason: null,
+        responseId: null,
+        operationName: "chat",
+        providerName: "anthropic",
+        responseModel: model,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.max_tokens || null
+      });
       opts.observa.trackError({
         errorType: "anthropic_api_error",
         errorMessage: error?.message || String(error),
         stackTrace: error?.stack || null,
-        context: { request: sanitizedReq }
+        context: {
+          request: sanitizedReq,
+          model,
+          input: inputText,
+          provider: "anthropic",
+          duration_ms: duration
+        },
+        errorCategory: "llm_error"
       });
     }
   } catch (e) {
+    console.error("[Observa] Failed to record error", e);
   }
 }
 
@@ -528,11 +598,15 @@ async function traceGenerateText(originalFn, args, options) {
     recordError3(
       {
         model: modelIdentifier,
-        prompt: requestParams.prompt || requestParams.messages || null
+        prompt: requestParams.prompt || null,
+        messages: requestParams.messages || null,
+        temperature: requestParams.temperature || null,
+        maxTokens: requestParams.maxTokens || requestParams.max_tokens || null
       },
       error,
       startTime,
-      options
+      options,
+      provider
     );
     throw error;
   }
@@ -549,10 +623,26 @@ function wrapReadableStream(stream, onComplete, onError) {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        if (firstTokenTime === null && value) {
+        if (firstTokenTime === null && value !== null && value !== void 0) {
           firstTokenTime = Date.now();
         }
-        const text = decoder.decode(value, { stream: true });
+        let text;
+        if (typeof value === "string") {
+          text = value;
+        } else if (value !== null && value !== void 0) {
+          try {
+            const testValue = value;
+            if (testValue instanceof Uint8Array || typeof ArrayBuffer !== "undefined" && typeof ArrayBuffer.isView === "function" && ArrayBuffer.isView(testValue)) {
+              text = decoder.decode(testValue, { stream: true });
+            } else {
+              text = String(value);
+            }
+          } catch {
+            text = String(value);
+          }
+        } else {
+          continue;
+        }
         chunks.push(text);
       }
       const fullText = chunks.join("");
@@ -600,11 +690,15 @@ async function traceStreamText(originalFn, args, options) {
           (err) => recordError3(
             {
               model: modelIdentifier,
-              prompt: requestParams.prompt || requestParams.messages || null
+              prompt: requestParams.prompt || null,
+              messages: requestParams.messages || null,
+              temperature: requestParams.temperature || null,
+              maxTokens: requestParams.maxTokens || requestParams.max_tokens || null
             },
             err,
             startTime,
-            options
+            options,
+            provider
           )
         );
         const wrappedResult = Object.create(Object.getPrototypeOf(result));
@@ -636,11 +730,15 @@ async function traceStreamText(originalFn, args, options) {
     recordError3(
       {
         model: modelIdentifier,
-        prompt: requestParams.prompt || requestParams.messages || null
+        prompt: requestParams.prompt || null,
+        messages: requestParams.messages || null,
+        temperature: requestParams.temperature || null,
+        maxTokens: requestParams.maxTokens || requestParams.max_tokens || null
       },
       error,
       startTime,
-      options
+      options,
+      provider
     );
     throw error;
   }
@@ -687,20 +785,58 @@ function recordTrace3(req, res, start, opts, timeToFirstToken, streamingDuration
     console.error("[Observa] Failed to record trace", e);
   }
 }
-function recordError3(req, error, start, opts) {
+function recordError3(req, error, start, opts, provider) {
+  const duration = Date.now() - start;
   try {
     console.error("[Observa] \u26A0\uFE0F Error Captured:", error.message);
     const sanitizedReq = opts?.redact ? opts.redact(req) : req;
     if (opts?.observa) {
+      const model = sanitizedReq.model || "unknown";
+      let inputText = null;
+      let inputMessages = null;
+      if (sanitizedReq.prompt) {
+        inputText = typeof sanitizedReq.prompt === "string" ? sanitizedReq.prompt : JSON.stringify(sanitizedReq.prompt);
+      } else if (sanitizedReq.messages) {
+        inputMessages = sanitizedReq.messages;
+        inputText = sanitizedReq.messages.map((m) => m.content || m.text || "").filter(Boolean).join("\n");
+      }
+      opts.observa.trackLLMCall({
+        model,
+        input: inputText,
+        output: null,
+        // No output on error
+        inputMessages,
+        outputMessages: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+        latencyMs: duration,
+        timeToFirstTokenMs: null,
+        streamingDurationMs: null,
+        finishReason: null,
+        responseId: null,
+        operationName: "generate_text",
+        providerName: provider || "vercel-ai",
+        responseModel: model,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.maxTokens || sanitizedReq.max_tokens || null
+      });
       opts.observa.trackError({
         errorType: error.name || "UnknownError",
         errorMessage: error.message || "An unknown error occurred",
         stackTrace: error.stack,
-        context: { request: sanitizedReq },
+        context: {
+          request: sanitizedReq,
+          model,
+          input: inputText,
+          provider: provider || "vercel-ai",
+          duration_ms: duration
+        },
         errorCategory: "llm_error"
       });
     }
   } catch (e) {
+    console.error("[Observa] Failed to record error", e);
   }
 }
 function observeVercelAI(aiSdk, options) {

package/dist/index.js

@@ -272,18 +272,50 @@ function recordTrace(req, res, start, opts, timeToFirstToken, streamingDuration)
   }
 }
 function recordError(req, error, start, opts) {
+  const duration = Date.now() - start;
   try {
     console.error("[Observa] \u26A0\uFE0F Error Captured:", error?.message || error);
     const sanitizedReq = opts?.redact ? opts.redact(req) : req;
     if (opts?.observa) {
+      const model = sanitizedReq.model || "unknown";
+      const inputText = sanitizedReq.messages?.map((m) => m.content).filter(Boolean).join("\n") || null;
+      opts.observa.trackLLMCall({
+        model,
+        input: inputText,
+        output: null,
+        // No output on error
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+        latencyMs: duration,
+        timeToFirstTokenMs: null,
+        streamingDurationMs: null,
+        finishReason: null,
+        responseId: null,
+        operationName: "chat",
+        providerName: "openai",
+        responseModel: model,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.max_tokens || null
+      });
       opts.observa.trackError({
         errorType: "openai_api_error",
         errorMessage: error?.message || String(error),
         stackTrace: error?.stack || null,
-        context: { request: sanitizedReq }
+        context: {
+          request: sanitizedReq,
+          model,
+          input: inputText,
+          provider: "openai",
+          duration_ms: duration
+        },
+        errorCategory: "llm_error"
       });
     }
   } catch (e) {
+    console.error("[Observa] Failed to record error", e);
   }
 }
 
@@ -390,18 +422,56 @@ function recordTrace2(req, res, start, opts, timeToFirstToken, streamingDuration
   }
 }
 function recordError2(req, error, start, opts) {
+  const duration = Date.now() - start;
   try {
     console.error("[Observa] \u26A0\uFE0F Error Captured:", error?.message || error);
     const sanitizedReq = opts?.redact ? opts.redact(req) : req;
     if (opts?.observa) {
+      const model = sanitizedReq.model || "unknown";
+      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;
+      opts.observa.trackLLMCall({
+        model,
+        input: inputText,
+        output: null,
+        // No output on error
+        inputMessages: sanitizedReq.messages || null,
+        outputMessages: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+        latencyMs: duration,
+        timeToFirstTokenMs: null,
+        streamingDurationMs: null,
+        finishReason: null,
+        responseId: null,
+        operationName: "chat",
+        providerName: "anthropic",
+        responseModel: model,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.max_tokens || null
+      });
       opts.observa.trackError({
         errorType: "anthropic_api_error",
         errorMessage: error?.message || String(error),
         stackTrace: error?.stack || null,
-        context: { request: sanitizedReq }
+        context: {
+          request: sanitizedReq,
+          model,
+          input: inputText,
+          provider: "anthropic",
+          duration_ms: duration
+        },
+        errorCategory: "llm_error"
       });
     }
   } catch (e) {
+    console.error("[Observa] Failed to record error", e);
   }
 }
 
@@ -508,11 +578,15 @@ async function traceGenerateText(originalFn, args, options) {
     recordError3(
       {
         model: modelIdentifier,
-        prompt: requestParams.prompt || requestParams.messages || null
+        prompt: requestParams.prompt || null,
+        messages: requestParams.messages || null,
+        temperature: requestParams.temperature || null,
+        maxTokens: requestParams.maxTokens || requestParams.max_tokens || null
       },
       error,
       startTime,
-      options
+      options,
+      provider
     );
     throw error;
   }
@@ -529,10 +603,26 @@ function wrapReadableStream(stream, onComplete, onError) {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        if (firstTokenTime === null && value) {
+        if (firstTokenTime === null && value !== null && value !== void 0) {
           firstTokenTime = Date.now();
         }
-        const text = decoder.decode(value, { stream: true });
+        let text;
+        if (typeof value === "string") {
+          text = value;
+        } else if (value !== null && value !== void 0) {
+          try {
+            const testValue = value;
+            if (testValue instanceof Uint8Array || typeof ArrayBuffer !== "undefined" && typeof ArrayBuffer.isView === "function" && ArrayBuffer.isView(testValue)) {
+              text = decoder.decode(testValue, { stream: true });
+            } else {
+              text = String(value);
+            }
+          } catch {
+            text = String(value);
+          }
+        } else {
+          continue;
+        }
         chunks.push(text);
       }
       const fullText = chunks.join("");
@@ -580,11 +670,15 @@ async function traceStreamText(originalFn, args, options) {
           (err) => recordError3(
             {
               model: modelIdentifier,
-              prompt: requestParams.prompt || requestParams.messages || null
+              prompt: requestParams.prompt || null,
+              messages: requestParams.messages || null,
+              temperature: requestParams.temperature || null,
+              maxTokens: requestParams.maxTokens || requestParams.max_tokens || null
             },
             err,
             startTime,
-            options
+            options,
+            provider
           )
         );
         const wrappedResult = Object.create(Object.getPrototypeOf(result));
@@ -616,11 +710,15 @@ async function traceStreamText(originalFn, args, options) {
     recordError3(
       {
         model: modelIdentifier,
-        prompt: requestParams.prompt || requestParams.messages || null
+        prompt: requestParams.prompt || null,
+        messages: requestParams.messages || null,
+        temperature: requestParams.temperature || null,
+        maxTokens: requestParams.maxTokens || requestParams.max_tokens || null
       },
       error,
       startTime,
-      options
+      options,
+      provider
     );
     throw error;
   }
@@ -667,20 +765,58 @@ function recordTrace3(req, res, start, opts, timeToFirstToken, streamingDuration
     console.error("[Observa] Failed to record trace", e);
   }
 }
-function recordError3(req, error, start, opts) {
+function recordError3(req, error, start, opts, provider) {
+  const duration = Date.now() - start;
   try {
     console.error("[Observa] \u26A0\uFE0F Error Captured:", error.message);
     const sanitizedReq = opts?.redact ? opts.redact(req) : req;
     if (opts?.observa) {
+      const model = sanitizedReq.model || "unknown";
+      let inputText = null;
+      let inputMessages = null;
+      if (sanitizedReq.prompt) {
+        inputText = typeof sanitizedReq.prompt === "string" ? sanitizedReq.prompt : JSON.stringify(sanitizedReq.prompt);
+      } else if (sanitizedReq.messages) {
+        inputMessages = sanitizedReq.messages;
+        inputText = sanitizedReq.messages.map((m) => m.content || m.text || "").filter(Boolean).join("\n");
+      }
+      opts.observa.trackLLMCall({
+        model,
+        input: inputText,
+        output: null,
+        // No output on error
+        inputMessages,
+        outputMessages: null,
+        inputTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+        latencyMs: duration,
+        timeToFirstTokenMs: null,
+        streamingDurationMs: null,
+        finishReason: null,
+        responseId: null,
+        operationName: "generate_text",
+        providerName: provider || "vercel-ai",
+        responseModel: model,
+        temperature: sanitizedReq.temperature || null,
+        maxTokens: sanitizedReq.maxTokens || sanitizedReq.max_tokens || null
+      });
       opts.observa.trackError({
         errorType: error.name || "UnknownError",
         errorMessage: error.message || "An unknown error occurred",
         stackTrace: error.stack,
-        context: { request: sanitizedReq },
+        context: {
+          request: sanitizedReq,
+          model,
+          input: inputText,
+          provider: provider || "vercel-ai",
+          duration_ms: duration
+        },
         errorCategory: "llm_error"
       });
     }
   } catch (e) {
+    console.error("[Observa] Failed to record error", e);
   }
 }
 function observeVercelAI(aiSdk, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "observa-sdk",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Enterprise-grade observability SDK for AI applications. Track and monitor LLM interactions with zero friction.",
   "type": "module",
   "main": "./dist/index.cjs",