toad-eye 2.4.3 → 2.4.5

package/dist/core/tracer.js

@@ -3,7 +3,7 @@ import { resourceFromAttributes } from "@opentelemetry/resources";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { TraceIdRatioBasedSampler, ParentBasedSampler, } from "@opentelemetry/sdk-trace-node";
+import { TraceIdRatioBasedSampler, ParentBasedSampler, BatchSpanProcessor, } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { initMetrics, resetMetrics } from "./metrics.js";
 import { resetCustomPricing } from "./pricing.js";
@@ -74,9 +74,11 @@ export function initObservability(config) {
         exporter: metricExporter,
         exportIntervalMillis: isCloudMode ? 10_000 : 5_000,
     });
-    // Add Vercel AI SDK SpanProcessor if 'ai' is in instrument list
+    // When custom SpanProcessors are needed (e.g., Vercel AI SDK),
+    // we must also include a BatchSpanProcessor for trace export —
+    // NodeSDK won't create one automatically when spanProcessors is provided.
     const spanProcessors = config.instrument?.includes("ai")
-        ? [new ToadEyeAISpanProcessor()]
+        ? [new BatchSpanProcessor(traceExporter), new ToadEyeAISpanProcessor()]
         : [];
     // SDK-side head sampling (default: 1.0 = send everything to Collector)
     const sdkRate = config.sampling?.sdkRate ?? 1.0;

package/dist/instrumentations/anthropic.js

@@ -50,6 +50,23 @@ const messagesCreate = {
         if (event.type === "content_block_delta" && event.delta?.text) {
             acc.completion += event.delta.text;
         }
+        // Tool use: content_block_start with type "tool_use"
+        if (event.type === "content_block_start" &&
+            event.content_block?.type === "tool_use") {
+            acc.toolCalls.push({
+                name: event.content_block.name ?? "",
+                arguments: "",
+                id: event.content_block.id,
+            });
+        }
+        // Tool use: input_json_delta accumulates arguments
+        if (event.type === "content_block_delta" &&
+            event.delta?.type === "input_json_delta" &&
+            event.delta.partial_json) {
+            const last = acc.toolCalls[acc.toolCalls.length - 1];
+            if (last)
+                last.arguments += event.delta.partial_json;
+        }
         if (event.type === "message_start" && event.message?.usage) {
             acc.inputTokens = event.message.usage.input_tokens ?? 0;
         }

package/dist/instrumentations/create.js

@@ -33,6 +33,7 @@ async function* wrapAsyncIterable(stream, accumulate, onFirstChunk, onComplete,
         completion: "",
         inputTokens: 0,
         outputTokens: 0,
+        toolCalls: [],
     };
     let firstChunk = true;
     let completed = false;
@@ -66,6 +67,14 @@ function createStreamingHandler(
 original, patch, providerName) {
     const tracer = trace.getTracer(INSTRUMENTATION_NAME);
     return async function handleStreaming(thisArg, body, rest) {
+        // OpenAI does not send usage in streaming chunks by default.
+        // Auto-inject stream_options to get token counts in the final chunk.
+        if (providerName === "openai") {
+            const b = body;
+            if (!b["stream_options"]) {
+                b["stream_options"] = { include_usage: true };
+            }
+        }
         // Pass thisArg so extractRequest can access instance properties (e.g., Gemini model name)
         const req = patch.extractRequest(body, thisArg);
         const start = performance.now();
@@ -132,6 +141,11 @@ original, patch, providerName) {
             const duration = performance.now() - start;
             const cost = calculateCost(effectiveModel, acc.inputTokens, acc.outputTokens);
             const processedCompletion = processContent(acc.completion);
+            // Record tool calls from streaming chunks
+            if (acc.toolCalls.length > 0) {
+                span.setAttribute(GEN_AI_ATTRS.TOOL_NAME, acc.toolCalls.map((t) => t.name).join(", "));
+                span.setAttribute("gen_ai.tool.call.count", acc.toolCalls.length);
+            }
             span.setAttributes({
                 ...(processedCompletion !== undefined && {
                     [GEN_AI_ATTRS.COMPLETION]: processedCompletion,

package/dist/instrumentations/gemini.js

@@ -66,6 +66,18 @@ const generateContentStream = {
         catch {
             // text() may throw if content is blocked
         }
+        // Gemini function calls in streaming
+        const parts = c?.candidates?.[0]?.content?.parts;
+        if (parts) {
+            for (const part of parts) {
+                if (part.functionCall) {
+                    acc.toolCalls.push({
+                        name: part.functionCall.name,
+                        arguments: JSON.stringify(part.functionCall.args ?? {}),
+                    });
+                }
+            }
+        }
         if (c?.usageMetadata) {
             acc.inputTokens = c.usageMetadata.promptTokenCount ?? acc.inputTokens;
             acc.outputTokens =

package/dist/instrumentations/openai.js

@@ -47,9 +47,26 @@ const chatCompletions = {
     isStreaming: (body) => !!body?.stream,
     accumulateChunk: (acc, chunk) => {
         const c = chunk;
-        const delta = c?.choices?.[0]?.delta?.content;
-        if (delta)
-            acc.completion += delta;
+        const delta = c?.choices?.[0]?.delta;
+        if (delta?.content)
+            acc.completion += delta.content;
+        // Accumulate tool calls from streaming chunks
+        if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+                const existing = acc.toolCalls[tc.index];
+                if (existing) {
+                    if (tc.function?.arguments)
+                        existing.arguments += tc.function.arguments;
+                }
+                else {
+                    acc.toolCalls[tc.index] = {
+                        name: tc.function?.name ?? "",
+                        arguments: tc.function?.arguments ?? "",
+                        id: tc.id,
+                    };
+                }
+            }
+        }
         if (c?.usage) {
             acc.inputTokens = c.usage.prompt_tokens ?? acc.inputTokens;
             acc.outputTokens = c.usage.completion_tokens ?? acc.outputTokens;

package/dist/instrumentations/types.d.ts

@@ -6,11 +6,18 @@ export interface Instrumentation {
     /** Restore original methods. */
     disable(): void;
 }
+/** Tool call accumulated from streaming chunks. */
+export interface AccumulatedToolCall {
+    name: string;
+    arguments: string;
+    id?: string | undefined;
+}
 /** Accumulated stream data — only primitives, no raw SDK objects. */
 export interface StreamAccumulator {
     completion: string;
     inputTokens: number;
     outputTokens: number;
+    toolCalls: AccumulatedToolCall[];
 }
 /** Describes a single method to monkey-patch on an SDK prototype. */
 export interface PatchTarget {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toad-eye",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "Auto-instrumentation, cost tracking, budget guards, and observability for LLM services",
   "type": "module",
   "main": "dist/index.js",