observa-sdk 0.0.16 → 0.0.18

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;
   }
@@ -616,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));
@@ -652,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;
   }
@@ -703,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) {
@@ -984,6 +1104,10 @@ var Observa = class {
   spanStack = [];
   // Stack for tracking parent-child relationships
   traceStartTime = null;
+  // Track traces with errors (for automatic trace_end generation when using instrumentation)
+  tracesWithErrors = /* @__PURE__ */ new Set();
+  // Track root span IDs for traces (for automatic trace_end generation)
+  traceRootSpanIds = /* @__PURE__ */ new Map();
   constructor(config) {
     this.apiKey = config.apiKey;
     let apiUrlEnv;
@@ -1074,9 +1198,13 @@ var Observa = class {
   addEvent(eventData) {
     const baseProps = this.createBaseEventProperties();
     const parentSpanId = this.spanStack.length > 0 ? this.spanStack[this.spanStack.length - 1] : null;
+    const spanId = eventData.span_id || crypto.randomUUID();
+    if (!this.currentTraceId && !this.traceRootSpanIds.has(baseProps.trace_id)) {
+      this.traceRootSpanIds.set(baseProps.trace_id, spanId);
+    }
     const event = {
       ...baseProps,
-      span_id: eventData.span_id || crypto.randomUUID(),
+      span_id: spanId,
       parent_span_id: (eventData.parent_span_id !== void 0 ? eventData.parent_span_id : parentSpanId) ?? null,
       timestamp: eventData.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
       event_type: eventData.event_type,
@@ -1261,6 +1389,8 @@ var Observa = class {
     if (!stackTrace && options.error instanceof Error && options.error.stack) {
       stackTrace = options.error.stack;
     }
+    const baseProps = this.createBaseEventProperties();
+    this.tracesWithErrors.add(baseProps.trace_id);
     this.addEvent({
       event_type: "error",
       span_id: spanId,
@@ -1628,6 +1758,65 @@ var Observa = class {
       eventsByTrace.get(event.trace_id).push(event);
     }
     for (const [traceId, events] of eventsByTrace.entries()) {
+      const hasTraceStart = events.some((e) => e.event_type === "trace_start");
+      const hasTraceEnd = events.some((e) => e.event_type === "trace_end");
+      const hasError = this.tracesWithErrors.has(traceId);
+      const rootSpanId = this.traceRootSpanIds.get(traceId) || events[0]?.span_id || crypto.randomUUID();
+      const firstEvent = events[0];
+      if (!firstEvent) continue;
+      if (!hasTraceStart) {
+        const traceStartEvent = {
+          tenant_id: firstEvent.tenant_id,
+          project_id: firstEvent.project_id,
+          environment: firstEvent.environment,
+          trace_id: traceId,
+          span_id: rootSpanId,
+          parent_span_id: null,
+          timestamp: firstEvent.timestamp,
+          event_type: "trace_start",
+          attributes: {
+            trace_start: {
+              name: null,
+              metadata: null
+            }
+          }
+        };
+        events.unshift(traceStartEvent);
+      }
+      if (!hasTraceEnd) {
+        const llmEvents = events.filter((e) => e.event_type === "llm_call");
+        const totalTokens = llmEvents.reduce(
+          (sum, e) => sum + (e.attributes.llm_call?.total_tokens || 0),
+          0
+        );
+        const totalCost = llmEvents.reduce(
+          (sum, e) => sum + (e.attributes.llm_call?.cost || 0),
+          0
+        );
+        const timestamps = events.map((e) => new Date(e.timestamp).getTime()).filter(Boolean);
+        const totalLatency = timestamps.length > 0 ? Math.max(...timestamps) - Math.min(...timestamps) : null;
+        const traceEndEvent = {
+          tenant_id: firstEvent.tenant_id,
+          project_id: firstEvent.project_id,
+          environment: firstEvent.environment,
+          trace_id: traceId,
+          span_id: rootSpanId,
+          parent_span_id: null,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          event_type: "trace_end",
+          attributes: {
+            trace_end: {
+              total_latency_ms: totalLatency,
+              total_tokens: totalTokens || null,
+              total_cost: totalCost || null,
+              outcome: hasError ? "error" : "success"
+            }
+          }
+        };
+        events.push(traceEndEvent);
+      }
+      this.tracesWithErrors.delete(traceId);
+      this.traceRootSpanIds.delete(traceId);
       await this._sendEventsWithRetry(events);
     }
   }
@@ -1669,11 +1858,11 @@ var Observa = class {
   }
   /**
    * 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';
@@ -1694,11 +1883,11 @@ var Observa = class {
   }
   /**
    * 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';
@@ -1719,21 +1908,21 @@ var Observa = class {
   }
   /**
    * 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',

package/dist/index.d.cts

@@ -38,6 +38,8 @@ declare class Observa {
     private rootSpanId;
     private spanStack;
     private traceStartTime;
+    private tracesWithErrors;
+    private traceRootSpanIds;
     constructor(config: ObservaInitConfig);
     /**
      * Flush buffered events to the API

package/dist/index.d.ts

@@ -38,6 +38,8 @@ declare class Observa {
     private rootSpanId;
     private spanStack;
     private traceStartTime;
+    private tracesWithErrors;
+    private traceRootSpanIds;
     constructor(config: ObservaInitConfig);
     /**
      * Flush buffered events to the API

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;
   }
@@ -596,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));
@@ -632,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;
   }
@@ -683,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) {
@@ -964,6 +1084,10 @@ var Observa = class {
   spanStack = [];
   // Stack for tracking parent-child relationships
   traceStartTime = null;
+  // Track traces with errors (for automatic trace_end generation when using instrumentation)
+  tracesWithErrors = /* @__PURE__ */ new Set();
+  // Track root span IDs for traces (for automatic trace_end generation)
+  traceRootSpanIds = /* @__PURE__ */ new Map();
   constructor(config) {
     this.apiKey = config.apiKey;
     let apiUrlEnv;
@@ -1054,9 +1178,13 @@ var Observa = class {
   addEvent(eventData) {
     const baseProps = this.createBaseEventProperties();
     const parentSpanId = this.spanStack.length > 0 ? this.spanStack[this.spanStack.length - 1] : null;
+    const spanId = eventData.span_id || crypto.randomUUID();
+    if (!this.currentTraceId && !this.traceRootSpanIds.has(baseProps.trace_id)) {
+      this.traceRootSpanIds.set(baseProps.trace_id, spanId);
+    }
     const event = {
       ...baseProps,
-      span_id: eventData.span_id || crypto.randomUUID(),
+      span_id: spanId,
       parent_span_id: (eventData.parent_span_id !== void 0 ? eventData.parent_span_id : parentSpanId) ?? null,
       timestamp: eventData.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
       event_type: eventData.event_type,
@@ -1241,6 +1369,8 @@ var Observa = class {
     if (!stackTrace && options.error instanceof Error && options.error.stack) {
       stackTrace = options.error.stack;
     }
+    const baseProps = this.createBaseEventProperties();
+    this.tracesWithErrors.add(baseProps.trace_id);
     this.addEvent({
       event_type: "error",
       span_id: spanId,
@@ -1608,6 +1738,65 @@ var Observa = class {
       eventsByTrace.get(event.trace_id).push(event);
     }
     for (const [traceId, events] of eventsByTrace.entries()) {
+      const hasTraceStart = events.some((e) => e.event_type === "trace_start");
+      const hasTraceEnd = events.some((e) => e.event_type === "trace_end");
+      const hasError = this.tracesWithErrors.has(traceId);
+      const rootSpanId = this.traceRootSpanIds.get(traceId) || events[0]?.span_id || crypto.randomUUID();
+      const firstEvent = events[0];
+      if (!firstEvent) continue;
+      if (!hasTraceStart) {
+        const traceStartEvent = {
+          tenant_id: firstEvent.tenant_id,
+          project_id: firstEvent.project_id,
+          environment: firstEvent.environment,
+          trace_id: traceId,
+          span_id: rootSpanId,
+          parent_span_id: null,
+          timestamp: firstEvent.timestamp,
+          event_type: "trace_start",
+          attributes: {
+            trace_start: {
+              name: null,
+              metadata: null
+            }
+          }
+        };
+        events.unshift(traceStartEvent);
+      }
+      if (!hasTraceEnd) {
+        const llmEvents = events.filter((e) => e.event_type === "llm_call");
+        const totalTokens = llmEvents.reduce(
+          (sum, e) => sum + (e.attributes.llm_call?.total_tokens || 0),
+          0
+        );
+        const totalCost = llmEvents.reduce(
+          (sum, e) => sum + (e.attributes.llm_call?.cost || 0),
+          0
+        );
+        const timestamps = events.map((e) => new Date(e.timestamp).getTime()).filter(Boolean);
+        const totalLatency = timestamps.length > 0 ? Math.max(...timestamps) - Math.min(...timestamps) : null;
+        const traceEndEvent = {
+          tenant_id: firstEvent.tenant_id,
+          project_id: firstEvent.project_id,
+          environment: firstEvent.environment,
+          trace_id: traceId,
+          span_id: rootSpanId,
+          parent_span_id: null,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          event_type: "trace_end",
+          attributes: {
+            trace_end: {
+              total_latency_ms: totalLatency,
+              total_tokens: totalTokens || null,
+              total_cost: totalCost || null,
+              outcome: hasError ? "error" : "success"
+            }
+          }
+        };
+        events.push(traceEndEvent);
+      }
+      this.tracesWithErrors.delete(traceId);
+      this.traceRootSpanIds.delete(traceId);
       await this._sendEventsWithRetry(events);
     }
   }
@@ -1649,11 +1838,11 @@ var Observa = class {
   }
   /**
    * 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';
@@ -1674,11 +1863,11 @@ var Observa = class {
   }
   /**
    * 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';
@@ -1699,21 +1888,21 @@ var Observa = class {
   }
   /**
    * 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',

package/package.json

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