@lelemondev/sdk 0.6.3 → 0.7.1

package/dist/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var async_hooks = require('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;
@@ -104,9 +106,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 {
@@ -288,6 +290,64 @@ function getNestedValue(obj, path) {
 function isValidNumber(value) {
   return typeof value === "number" && !isNaN(value) && isFinite(value);
 }
+var traceStorage = new async_hooks.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 = {};
@@ -305,7 +365,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,
@@ -316,10 +377,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);
@@ -334,7 +411,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,
@@ -347,10 +425,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 });
@@ -359,6 +445,93 @@ function captureError(params) {
     traceCaptureError(params.provider, err instanceof Error ? err : new Error(String(err)));
   }
 }
+function captureSpan(options) {
+  try {
+    const transport = getTransport();
+    if (!transport.isEnabled()) {
+      debug("Transport disabled, skipping span capture");
+      return;
+    }
+    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,
+      provider: "unknown",
+      // Manual spans don't have a provider
+      model: options.name,
+      // Use name as model for compatibility
+      input: sanitizeInput(options.input),
+      output: sanitizeOutput(options.output),
+      inputTokens: 0,
+      outputTokens: 0,
+      durationMs: options.durationMs,
+      status: options.status || "success",
+      errorMessage: options.errorMessage,
+      streaming: false,
+      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: cleanMetadata,
+      tags: globalContext2.tags
+    };
+    debug(`Span captured: ${options.type}/${options.name}`, { durationMs: options.durationMs });
+    transport.enqueue(request);
+  } catch (err) {
+    traceCaptureError("unknown", err instanceof Error ? err : new Error(String(err)));
+  }
+}
+function captureToolSpans(toolCalls, provider) {
+  for (const tool of toolCalls) {
+    try {
+      const transport = getTransport();
+      if (!transport.isEnabled()) continue;
+      const globalContext2 = getGlobalContext();
+      const traceContext = getTraceContext();
+      const request = {
+        spanType: "tool",
+        name: tool.name,
+        provider,
+        model: tool.name,
+        input: sanitizeInput(tool.input),
+        output: null,
+        // Tool result will come later
+        inputTokens: 0,
+        outputTokens: 0,
+        durationMs: 0,
+        // Duration unknown at this point
+        status: "success",
+        streaming: false,
+        sessionId: globalContext2.sessionId,
+        userId: globalContext2.userId,
+        // Hierarchy fields (Phase 7.2)
+        traceId: traceContext?.traceId,
+        spanId: generateId(),
+        parentSpanId: traceContext?.currentSpanId,
+        toolCallId: tool.id,
+        metadata: {
+          ...globalContext2.metadata,
+          toolUseDetected: true,
+          ...traceContext ? { _traceName: traceContext.name } : {}
+        },
+        tags: globalContext2.tags
+      };
+      debug(`Tool span captured: ${tool.name}`, { toolCallId: tool.id });
+      transport.enqueue(request);
+    } catch (err) {
+      traceCaptureError(provider, err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+}
 var MAX_STRING_LENGTH = 1e5;
 var SENSITIVE_KEYS = ["api_key", "apikey", "password", "secret", "token", "authorization"];
 function sanitizeInput(input) {
@@ -423,7 +596,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) {
@@ -553,14 +729,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;
       }
@@ -591,7 +779,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
       });
     }
   }
@@ -602,8 +794,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);
@@ -625,10 +821,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;
@@ -770,7 +972,8 @@ function wrapMessagesCreate(originalFn) {
         return wrapStream2(response, request, startTime);
       }
       const durationMs = Date.now() - startTime;
-      const extracted = extractMessageResponse(response);
+      const messageResponse = response;
+      const extracted = extractMessageResponse(messageResponse);
       captureTrace({
         provider: PROVIDER_NAME2,
         model: request.model || extracted.model || "unknown",
@@ -780,8 +983,17 @@ 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) {
+        captureToolSpans(toolCalls, PROVIDER_NAME2);
+      }
       return response;
     } catch (error) {
       const durationMs = Date.now() - startTime;
@@ -830,10 +1042,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) {
@@ -841,13 +1062,63 @@ 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 === "message_delta" && event.usage) {
-          outputTokens = event.usage.output_tokens || 0;
+        if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+          const block = event.content_block;
+          if (block.id && block.name) {
+            currentToolIndex = event.index ?? toolCalls.length;
+            toolCalls.push({
+              id: block.id,
+              name: block.name,
+              input: block.input ?? {},
+              inputJson: ""
+            });
+          }
+        }
+        if (event.type === "content_block_delta" && event.delta?.partial_json && currentToolIndex !== null) {
+          const tool = toolCalls.find((_, i) => i === currentToolIndex);
+          if (tool) {
+            tool.inputJson += event.delta.partial_json;
+          }
+        }
+        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;
+          }
+          currentBlockType = null;
+        }
+        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;
       }
@@ -878,8 +1149,20 @@ 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(
+            toolCalls.map((t) => ({ id: t.id, name: t.name, input: t.input })),
+            PROVIDER_NAME2
+          );
+        }
       }
     }
   };
@@ -894,23 +1177,82 @@ 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 === "message_delta" && event.usage) {
-        outputTokens = event.usage.output_tokens || 0;
+      if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+        const block = event.content_block;
+        if (block.id && block.name) {
+          currentToolIndex = event.index ?? toolCalls.length;
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            input: block.input ?? {},
+            inputJson: ""
+          });
+        }
+      }
+      if (event.type === "content_block_delta" && event.delta?.partial_json && currentToolIndex !== null) {
+        const tool = toolCalls.find((_, i) => i === currentToolIndex);
+        if (tool) {
+          tool.inputJson += event.delta.partial_json;
+        }
+      }
+      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;
+        }
+        currentBlockType = null;
+      }
+      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;
     }
@@ -938,20 +1280,38 @@ 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(
+          toolCalls.map((t) => ({ id: t.id, name: t.name, input: t.input })),
+          PROVIDER_NAME2
+        );
+      }
     }
   }
 }
 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 {
@@ -965,12 +1325,31 @@ 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;
   }
 }
+function extractToolCalls(response) {
+  try {
+    if (!response.content || !Array.isArray(response.content)) {
+      return [];
+    }
+    return response.content.filter(
+      (block) => block.type === "tool_use" && !!block.id && !!block.name
+    ).map((block) => ({
+      id: block.id,
+      name: block.name,
+      input: block.input ?? {}
+    }));
+  } catch {
+    return [];
+  }
+}
 
 // src/providers/bedrock.ts
 var PROVIDER_NAME3 = "bedrock";
@@ -1029,14 +1408,19 @@ 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
       }
     });
+    const toolCalls = extractToolCalls2(response);
+    if (toolCalls.length > 0) {
+      captureToolSpans(toolCalls, PROVIDER_NAME3);
+    }
     return response;
   } catch (error) {
     captureError({
@@ -1079,11 +1463,36 @@ 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) {
+        const tool = event.contentBlockStart.start.toolUse;
+        toolCalls.set(event.contentBlockStart.contentBlockIndex, {
+          id: tool.toolUseId,
+          name: tool.name,
+          inputJson: ""
+        });
+      }
+      if (event.contentBlockDelta?.delta?.toolUse?.input) {
+        const tool = toolCalls.get(event.contentBlockDelta.contentBlockIndex);
+        if (tool) {
+          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;
@@ -1114,8 +1523,24 @@ 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) => {
+          let parsedInput = {};
+          try {
+            if (t.inputJson) {
+              parsedInput = JSON.parse(t.inputJson);
+            }
+          } catch {
+          }
+          return { id: t.id, name: t.name, input: parsedInput };
+        });
+        captureToolSpans(tools, PROVIDER_NAME3);
+      }
     }
   }
 }
@@ -1240,6 +1665,23 @@ function extractConverseOutput(response) {
     hasToolUse
   };
 }
+function extractToolCalls2(response) {
+  try {
+    const content = response.output?.message?.content;
+    if (!content || !Array.isArray(content)) {
+      return [];
+    }
+    return content.filter(
+      (block) => !!block.toolUse && !!block.toolUse.toolUseId && !!block.toolUse.name
+    ).map((block) => ({
+      id: block.toolUse.toolUseId,
+      name: block.toolUse.name,
+      input: block.toolUse.input ?? {}
+    }));
+  } catch {
+    return [];
+  }
+}
 function parseInvokeModelBody(body) {
   try {
     const text = new TextDecoder().decode(body);
@@ -1909,10 +2351,14 @@ function createObserve(defaultOptions) {
   };
 }
 
+exports.captureSpan = captureSpan;
 exports.createObserve = createObserve;
 exports.flush = flush;
+exports.getTraceContext = getTraceContext;
 exports.init = init;
 exports.isEnabled = isEnabled;
 exports.observe = observe;
+exports.span = span;
+exports.trace = trace;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map