@lelemondev/sdk 0.7.0 → 0.7.1

package/dist/index.mjs

@@ -1,3 +1,5 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
 /* @lelemondev/sdk - LLM Observability */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -102,9 +104,9 @@ var Transport = class {
    * Enqueue a trace for sending
    * Fire-and-forget - never blocks
    */
-  enqueue(trace) {
+  enqueue(trace2) {
     if (this.config.disabled) return;
-    this.queue.push(trace);
+    this.queue.push(trace2);
     if (this.queue.length >= this.config.batchSize) {
       this.flush();
     } else {
@@ -286,6 +288,64 @@ function getNestedValue(obj, path) {
 function isValidNumber(value) {
   return typeof value === "number" && !isNaN(value) && isFinite(value);
 }
+var traceStorage = new AsyncLocalStorage();
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function getTraceContext() {
+  return traceStorage.getStore();
+}
+async function trace(nameOrOptions, fn) {
+  const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
+  const parentContext = getTraceContext();
+  const traceId = parentContext?.traceId ?? generateId();
+  const rootSpanId = generateId();
+  const context = {
+    traceId,
+    rootSpanId,
+    currentSpanId: rootSpanId,
+    parentSpanId: parentContext?.currentSpanId,
+    name: options.name,
+    startTime: Date.now(),
+    input: options.input,
+    metadata: options.metadata,
+    tags: options.tags
+  };
+  return traceStorage.run(context, async () => {
+    try {
+      const result = await fn();
+      return result;
+    } finally {
+    }
+  });
+}
+function span(options) {
+  const context = getTraceContext();
+  if (!context) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("[Lelemon] span() called outside of trace() - span will not be captured");
+    }
+    return;
+  }
+  captureSpan({
+    type: options.type,
+    name: options.name,
+    input: options.input,
+    output: options.output,
+    durationMs: options.durationMs ?? 0,
+    status: options.status ?? "success",
+    errorMessage: options.errorMessage,
+    metadata: {
+      ...options.metadata,
+      // Include trace context
+      _traceId: context.traceId,
+      _parentSpanId: context.currentSpanId
+    }
+  });
+}
 
 // src/core/capture.ts
 var globalContext = {};
@@ -303,7 +363,8 @@ function captureTrace(params) {
       debug("Transport disabled, skipping trace capture");
       return;
     }
-    const context = getGlobalContext();
+    const globalContext2 = getGlobalContext();
+    const traceContext = getTraceContext();
     const request = {
       provider: params.provider,
       model: params.model,
@@ -314,10 +375,26 @@ function captureTrace(params) {
       durationMs: params.durationMs,
       status: params.status,
       streaming: params.streaming,
-      sessionId: context.sessionId,
-      userId: context.userId,
-      metadata: { ...context.metadata, ...params.metadata },
-      tags: context.tags
+      sessionId: globalContext2.sessionId,
+      userId: globalContext2.userId,
+      // Hierarchy fields (Phase 7.2) - use trace context if available
+      traceId: traceContext?.traceId,
+      spanId: generateId(),
+      parentSpanId: traceContext?.currentSpanId,
+      metadata: {
+        ...globalContext2.metadata,
+        ...params.metadata,
+        // Include trace name for debugging
+        ...traceContext ? { _traceName: traceContext.name } : {}
+      },
+      tags: globalContext2.tags,
+      // Extended fields (Phase 7.1)
+      stopReason: params.stopReason,
+      cacheReadTokens: params.cacheReadTokens,
+      cacheWriteTokens: params.cacheWriteTokens,
+      reasoningTokens: params.reasoningTokens,
+      firstTokenMs: params.firstTokenMs,
+      thinking: params.thinking
     };
     traceCapture(params.provider, params.model, params.durationMs, params.status);
     transport.enqueue(request);
@@ -332,7 +409,8 @@ function captureError(params) {
       debug("Transport disabled, skipping error capture");
       return;
     }
-    const context = getGlobalContext();
+    const globalContext2 = getGlobalContext();
+    const traceContext = getTraceContext();
     const request = {
       provider: params.provider,
       model: params.model,
@@ -345,10 +423,18 @@ function captureError(params) {
       errorMessage: params.error.message,
       errorStack: params.error.stack,
       streaming: params.streaming,
-      sessionId: context.sessionId,
-      userId: context.userId,
-      metadata: { ...context.metadata, ...params.metadata },
-      tags: context.tags
+      sessionId: globalContext2.sessionId,
+      userId: globalContext2.userId,
+      // Hierarchy fields (Phase 7.2)
+      traceId: traceContext?.traceId,
+      spanId: generateId(),
+      parentSpanId: traceContext?.currentSpanId,
+      metadata: {
+        ...globalContext2.metadata,
+        ...params.metadata,
+        ...traceContext ? { _traceName: traceContext.name } : {}
+      },
+      tags: globalContext2.tags
     };
     traceCapture(params.provider, params.model, params.durationMs, "error");
     debug("Error details", { message: params.error.message, stack: params.error.stack });
@@ -364,7 +450,13 @@ function captureSpan(options) {
       debug("Transport disabled, skipping span capture");
       return;
     }
-    const context = getGlobalContext();
+    const globalContext2 = getGlobalContext();
+    const traceContext = getTraceContext();
+    const metadataTraceId = options.metadata?._traceId;
+    const metadataParentSpanId = options.metadata?._parentSpanId;
+    const cleanMetadata = { ...globalContext2.metadata, ...options.metadata };
+    delete cleanMetadata._traceId;
+    delete cleanMetadata._parentSpanId;
     const request = {
       spanType: options.type,
       name: options.name,
@@ -380,11 +472,15 @@ function captureSpan(options) {
       status: options.status || "success",
       errorMessage: options.errorMessage,
       streaming: false,
-      sessionId: context.sessionId,
-      userId: context.userId,
+      sessionId: globalContext2.sessionId,
+      userId: globalContext2.userId,
+      // Hierarchy fields (Phase 7.2)
+      traceId: metadataTraceId ?? traceContext?.traceId,
+      spanId: generateId(),
+      parentSpanId: metadataParentSpanId ?? traceContext?.currentSpanId,
       toolCallId: options.toolCallId,
-      metadata: { ...context.metadata, ...options.metadata },
-      tags: context.tags
+      metadata: cleanMetadata,
+      tags: globalContext2.tags
     };
     debug(`Span captured: ${options.type}/${options.name}`, { durationMs: options.durationMs });
     transport.enqueue(request);
@@ -397,7 +493,8 @@ function captureToolSpans(toolCalls, provider) {
     try {
       const transport = getTransport();
       if (!transport.isEnabled()) continue;
-      const context = getGlobalContext();
+      const globalContext2 = getGlobalContext();
+      const traceContext = getTraceContext();
       const request = {
         spanType: "tool",
         name: tool.name,
@@ -412,11 +509,19 @@ function captureToolSpans(toolCalls, provider) {
         // Duration unknown at this point
         status: "success",
         streaming: false,
-        sessionId: context.sessionId,
-        userId: context.userId,
+        sessionId: globalContext2.sessionId,
+        userId: globalContext2.userId,
+        // Hierarchy fields (Phase 7.2)
+        traceId: traceContext?.traceId,
+        spanId: generateId(),
+        parentSpanId: traceContext?.currentSpanId,
         toolCallId: tool.id,
-        metadata: { ...context.metadata, toolUseDetected: true },
-        tags: context.tags
+        metadata: {
+          ...globalContext2.metadata,
+          toolUseDetected: true,
+          ...traceContext ? { _traceName: traceContext.name } : {}
+        },
+        tags: globalContext2.tags
       };
       debug(`Tool span captured: ${tool.name}`, { toolCallId: tool.id });
       transport.enqueue(request);
@@ -489,7 +594,10 @@ function wrapChatCreate(originalFn) {
         outputTokens: extracted.tokens?.outputTokens || 0,
         durationMs,
         status: "success",
-        streaming: false
+        streaming: false,
+        // Extended fields
+        stopReason: extracted.finishReason || void 0,
+        reasoningTokens: extracted.tokens?.reasoningTokens
       });
       return response;
     } catch (error) {
@@ -619,14 +727,26 @@ function isAsyncIterable(value) {
 async function* wrapStream(stream, request, startTime) {
   const chunks = [];
   let tokens = null;
+  let finishReason;
   let error = null;
+  let firstTokenMs;
+  let firstTokenReceived = false;
   try {
     for await (const chunk of stream) {
-      const content = extractStreamChunkContent(chunk);
+      const streamChunk = chunk;
+      const content = extractStreamChunkContent(streamChunk);
       if (content) {
+        if (!firstTokenReceived) {
+          firstTokenReceived = true;
+          firstTokenMs = Date.now() - startTime;
+        }
         chunks.push(content);
       }
-      const chunkTokens = extractStreamChunkTokens(chunk);
+      const chunkFinishReason = streamChunk?.choices?.[0]?.finish_reason;
+      if (chunkFinishReason) {
+        finishReason = chunkFinishReason;
+      }
+      const chunkTokens = extractStreamChunkTokens(streamChunk);
       if (chunkTokens) {
         tokens = chunkTokens;
       }
@@ -657,7 +777,11 @@ async function* wrapStream(stream, request, startTime) {
         outputTokens: tokens?.outputTokens || 0,
         durationMs,
         status: "success",
-        streaming: true
+        streaming: true,
+        // Extended fields
+        stopReason: finishReason,
+        reasoningTokens: tokens?.reasoningTokens,
+        firstTokenMs
       });
     }
   }
@@ -668,8 +792,12 @@ function extractChatCompletion(response) {
     () => getNestedValue(response, "choices.0.message.content"),
     null
   );
+  const finishReason = safeExtract(
+    () => getNestedValue(response, "choices.0.finish_reason"),
+    null
+  );
   const tokens = extractTokens(response);
-  return { model, output, tokens };
+  return { model, output, tokens, finishReason };
 }
 function extractLegacyCompletion(response) {
   const model = safeExtract(() => getNestedValue(response, "model"), null);
@@ -691,10 +819,16 @@ function extractTokens(response) {
     if (!isValidNumber(promptTokens) && !isValidNumber(completionTokens)) {
       return null;
     }
+    let reasoningTokens;
+    const completionDetails = u.completion_tokens_details;
+    if (completionDetails && isValidNumber(completionDetails.reasoning_tokens)) {
+      reasoningTokens = completionDetails.reasoning_tokens;
+    }
     return {
       inputTokens: isValidNumber(promptTokens) ? promptTokens : 0,
       outputTokens: isValidNumber(completionTokens) ? completionTokens : 0,
-      totalTokens: isValidNumber(totalTokens) ? totalTokens : 0
+      totalTokens: isValidNumber(totalTokens) ? totalTokens : 0,
+      reasoningTokens
     };
   } catch {
     return null;
@@ -847,7 +981,12 @@ function wrapMessagesCreate(originalFn) {
         outputTokens: extracted.tokens?.outputTokens || 0,
         durationMs,
         status: "success",
-        streaming: false
+        streaming: false,
+        // Extended fields
+        stopReason: extracted.stopReason || void 0,
+        cacheReadTokens: extracted.tokens?.cacheReadTokens,
+        cacheWriteTokens: extracted.tokens?.cacheWriteTokens,
+        thinking: extracted.thinking || void 0
       });
       const toolCalls = extractToolCalls(messageResponse);
       if (toolCalls.length > 0) {
@@ -901,12 +1040,19 @@ function wrapAnthropicStream(stream, request, startTime) {
     return stream;
   }
   const chunks = [];
+  const thinkingChunks = [];
   let inputTokens = 0;
   let outputTokens = 0;
+  let cacheReadTokens;
+  let cacheWriteTokens;
+  let stopReason;
   let model = request.model || "unknown";
   let captured = false;
+  let firstTokenMs;
+  let firstTokenReceived = false;
   const toolCalls = [];
   let currentToolIndex = null;
+  let currentBlockType = null;
   const wrappedIterator = async function* () {
     try {
       for await (const event of originalStream) {
@@ -914,10 +1060,23 @@ function wrapAnthropicStream(stream, request, startTime) {
           model = event.message.model || model;
           if (event.message.usage) {
             inputTokens = event.message.usage.input_tokens || 0;
+            cacheReadTokens = event.message.usage.cache_read_input_tokens;
+            cacheWriteTokens = event.message.usage.cache_creation_input_tokens;
           }
         }
+        if (event.type === "content_block_start" && event.content_block) {
+          currentBlockType = event.content_block.type;
+        }
         if (event.type === "content_block_delta" && event.delta?.text) {
-          chunks.push(event.delta.text);
+          if (!firstTokenReceived) {
+            firstTokenReceived = true;
+            firstTokenMs = Date.now() - startTime;
+          }
+          if (currentBlockType === "thinking") {
+            thinkingChunks.push(event.delta.text);
+          } else {
+            chunks.push(event.delta.text);
+          }
         }
         if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
           const block = event.content_block;
@@ -937,18 +1096,27 @@ function wrapAnthropicStream(stream, request, startTime) {
             tool.inputJson += event.delta.partial_json;
           }
         }
-        if (event.type === "content_block_stop" && currentToolIndex !== null) {
-          const tool = toolCalls[currentToolIndex];
-          if (tool && tool.inputJson) {
-            try {
-              tool.input = JSON.parse(tool.inputJson);
-            } catch {
+        if (event.type === "content_block_stop") {
+          if (currentToolIndex !== null) {
+            const tool = toolCalls[currentToolIndex];
+            if (tool && tool.inputJson) {
+              try {
+                tool.input = JSON.parse(tool.inputJson);
+              } catch {
+              }
             }
+            currentToolIndex = null;
           }
-          currentToolIndex = null;
+          currentBlockType = null;
         }
-        if (event.type === "message_delta" && event.usage) {
-          outputTokens = event.usage.output_tokens || 0;
+        if (event.type === "message_delta") {
+          if (event.usage) {
+            outputTokens = event.usage.output_tokens || 0;
+          }
+          const delta = event;
+          if (delta.delta?.stop_reason) {
+            stopReason = delta.delta.stop_reason;
+          }
         }
         yield event;
       }
@@ -979,7 +1147,13 @@ function wrapAnthropicStream(stream, request, startTime) {
           outputTokens,
           durationMs,
           status: "success",
-          streaming: true
+          streaming: true,
+          // Extended fields
+          stopReason,
+          cacheReadTokens,
+          cacheWriteTokens,
+          firstTokenMs,
+          thinking: thinkingChunks.length > 0 ? thinkingChunks.join("") : void 0
         });
         if (toolCalls.length > 0) {
           captureToolSpans(
@@ -1001,22 +1175,42 @@ function wrapAnthropicStream(stream, request, startTime) {
 }
 async function* wrapStream2(stream, request, startTime) {
   const chunks = [];
+  const thinkingChunks = [];
   let inputTokens = 0;
   let outputTokens = 0;
+  let cacheReadTokens;
+  let cacheWriteTokens;
+  let stopReason;
   let model = request.model || "unknown";
   let error = null;
+  let firstTokenMs;
+  let firstTokenReceived = false;
   const toolCalls = [];
   let currentToolIndex = null;
+  let currentBlockType = null;
   try {
     for await (const event of stream) {
       if (event.type === "message_start" && event.message) {
         model = event.message.model || model;
         if (event.message.usage) {
           inputTokens = event.message.usage.input_tokens || 0;
+          cacheReadTokens = event.message.usage.cache_read_input_tokens;
+          cacheWriteTokens = event.message.usage.cache_creation_input_tokens;
         }
       }
+      if (event.type === "content_block_start" && event.content_block) {
+        currentBlockType = event.content_block.type;
+      }
       if (event.type === "content_block_delta" && event.delta?.text) {
-        chunks.push(event.delta.text);
+        if (!firstTokenReceived) {
+          firstTokenReceived = true;
+          firstTokenMs = Date.now() - startTime;
+        }
+        if (currentBlockType === "thinking") {
+          thinkingChunks.push(event.delta.text);
+        } else {
+          chunks.push(event.delta.text);
+        }
       }
       if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
         const block = event.content_block;
@@ -1036,18 +1230,27 @@ async function* wrapStream2(stream, request, startTime) {
           tool.inputJson += event.delta.partial_json;
         }
       }
-      if (event.type === "content_block_stop" && currentToolIndex !== null) {
-        const tool = toolCalls[currentToolIndex];
-        if (tool && tool.inputJson) {
-          try {
-            tool.input = JSON.parse(tool.inputJson);
-          } catch {
+      if (event.type === "content_block_stop") {
+        if (currentToolIndex !== null) {
+          const tool = toolCalls[currentToolIndex];
+          if (tool && tool.inputJson) {
+            try {
+              tool.input = JSON.parse(tool.inputJson);
+            } catch {
+            }
           }
+          currentToolIndex = null;
         }
-        currentToolIndex = null;
+        currentBlockType = null;
       }
-      if (event.type === "message_delta" && event.usage) {
-        outputTokens = event.usage.output_tokens || 0;
+      if (event.type === "message_delta") {
+        if (event.usage) {
+          outputTokens = event.usage.output_tokens || 0;
+        }
+        const delta = event;
+        if (delta.delta?.stop_reason) {
+          stopReason = delta.delta.stop_reason;
+        }
       }
       yield event;
     }
@@ -1075,7 +1278,13 @@ async function* wrapStream2(stream, request, startTime) {
         outputTokens,
         durationMs,
         status: "success",
-        streaming: true
+        streaming: true,
+        // Extended fields
+        stopReason,
+        cacheReadTokens,
+        cacheWriteTokens,
+        firstTokenMs,
+        thinking: thinkingChunks.length > 0 ? thinkingChunks.join("") : void 0
       });
       if (toolCalls.length > 0) {
         captureToolSpans(
@@ -1088,13 +1297,19 @@ async function* wrapStream2(stream, request, startTime) {
 }
 function extractMessageResponse(response) {
   const model = safeExtract(() => response.model ?? null, null);
+  const stopReason = safeExtract(() => response.stop_reason ?? null, null);
   const output = safeExtract(() => {
     if (!response.content || !Array.isArray(response.content)) return null;
     const textBlocks = response.content.filter((block) => block.type === "text" && block.text).map((block) => block.text);
     return textBlocks.join("") || null;
   }, null);
+  const thinking = safeExtract(() => {
+    if (!response.content || !Array.isArray(response.content)) return null;
+    const thinkingBlocks = response.content.filter((block) => block.type === "thinking" && block.thinking).map((block) => block.thinking);
+    return thinkingBlocks.join("\n\n") || null;
+  }, null);
   const tokens = extractTokens2(response);
-  return { model, output, tokens };
+  return { model, output, tokens, stopReason, thinking };
 }
 function extractTokens2(response) {
   try {
@@ -1108,7 +1323,10 @@ function extractTokens2(response) {
     return {
       inputTokens: isValidNumber(inputTokens) ? inputTokens : 0,
       outputTokens: isValidNumber(outputTokens) ? outputTokens : 0,
-      totalTokens: (isValidNumber(inputTokens) ? inputTokens : 0) + (isValidNumber(outputTokens) ? outputTokens : 0)
+      totalTokens: (isValidNumber(inputTokens) ? inputTokens : 0) + (isValidNumber(outputTokens) ? outputTokens : 0),
+      // Cache tokens (Anthropic prompt caching)
+      cacheReadTokens: isValidNumber(usage.cache_read_input_tokens) ? usage.cache_read_input_tokens : void 0,
+      cacheWriteTokens: isValidNumber(usage.cache_creation_input_tokens) ? usage.cache_creation_input_tokens : void 0
     };
   } catch {
     return null;
@@ -1188,11 +1406,12 @@ async function handleConverse(send, command) {
       durationMs,
       status: "success",
       streaming: false,
+      // Extended fields (Phase 7.1)
+      stopReason: response.stopReason,
+      cacheReadTokens: extracted.cacheReadTokens,
+      cacheWriteTokens: extracted.cacheWriteTokens,
       metadata: {
-        stopReason: response.stopReason,
         hasToolUse: extracted.hasToolUse,
-        cacheReadTokens: extracted.cacheReadTokens,
-        cacheWriteTokens: extracted.cacheWriteTokens,
         latencyMs: response.metrics?.latencyMs
       }
     });
@@ -1242,10 +1461,17 @@ async function* wrapConverseStream(stream, input, startTime) {
   let inputTokens = 0;
   let outputTokens = 0;
   let error = null;
+  let stopReason;
+  let firstTokenMs;
+  let firstContentReceived = false;
   const toolCalls = /* @__PURE__ */ new Map();
   try {
     for await (const event of stream) {
-      if (event.contentBlockDelta?.delta?.text) {
+      if (event.contentBlockDelta?.delta?.text && !firstContentReceived) {
+        firstContentReceived = true;
+        firstTokenMs = Date.now() - startTime;
+        chunks.push(event.contentBlockDelta.delta.text);
+      } else if (event.contentBlockDelta?.delta?.text) {
         chunks.push(event.contentBlockDelta.delta.text);
       }
       if (event.contentBlockStart?.start?.toolUse) {
@@ -1262,6 +1488,9 @@ async function* wrapConverseStream(stream, input, startTime) {
           tool.inputJson += event.contentBlockDelta.delta.toolUse.input;
         }
       }
+      if (event.messageStop?.stopReason) {
+        stopReason = event.messageStop.stopReason;
+      }
       if (event.metadata?.usage) {
         inputTokens = event.metadata.usage.inputTokens || 0;
         outputTokens = event.metadata.usage.outputTokens || 0;
@@ -1292,7 +1521,10 @@ async function* wrapConverseStream(stream, input, startTime) {
         outputTokens,
         durationMs,
         status: "success",
-        streaming: true
+        streaming: true,
+        // Extended fields (Phase 7.1)
+        stopReason,
+        firstTokenMs
       });
       if (toolCalls.size > 0) {
         const tools = Array.from(toolCalls.values()).map((t) => {
@@ -2117,6 +2349,6 @@ function createObserve(defaultOptions) {
   };
 }
 
-export { captureSpan, createObserve, flush, init, isEnabled, observe };
+export { captureSpan, createObserve, flush, getTraceContext, init, isEnabled, observe, span, trace };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map