toad-eye 2.1.1 → 2.3.0

package/dist/core/metrics.js

@@ -10,9 +10,12 @@ let agentToolUsage;
 let guardEvaluations;
 let guardWouldBlock;
 let semanticDrift;
+let timeToFirstToken;
 let budgetExceeded;
 let budgetBlocked;
 let budgetDowngraded;
+let responseEmpty;
+let responseLatencyPerToken;
 let initialized = false;
 export function initMetrics() {
     if (initialized)
@@ -50,6 +53,10 @@ export function initMetrics() {
     semanticDrift = meter.createHistogram(GEN_AI_METRICS.SEMANTIC_DRIFT, {
         description: "Semantic drift from baseline (0 = identical, 1 = completely different)",
     });
+    timeToFirstToken = meter.createHistogram(GEN_AI_METRICS.TIME_TO_FIRST_TOKEN, {
+        description: "Time from request start to first streaming token (ms)",
+        unit: "ms",
+    });
     budgetExceeded = meter.createCounter(GEN_AI_METRICS.BUDGET_EXCEEDED, {
         description: "Number of times a budget limit was exceeded",
     });
@@ -59,8 +66,19 @@ export function initMetrics() {
     budgetDowngraded = meter.createCounter(GEN_AI_METRICS.BUDGET_DOWNGRADED, {
         description: "Number of LLM calls downgraded due to budget limits",
     });
+    responseEmpty = meter.createCounter(GEN_AI_METRICS.RESPONSE_EMPTY, {
+        description: "Number of LLM responses with empty or whitespace-only completion",
+    });
+    responseLatencyPerToken = meter.createHistogram(GEN_AI_METRICS.RESPONSE_LATENCY_PER_TOKEN, {
+        description: "Generation latency normalized per output token (ms/token). Higher values indicate slower generation speed.",
+        unit: "ms",
+    });
     initialized = true;
 }
+/** Reset metrics state so the next initMetrics() creates fresh instruments. Called from shutdown(). */
+export function resetMetrics() {
+    initialized = false;
+}
 /** Build metric labels: provider + model + optional FinOps attributes. */
 function baseLabels(provider, model, attrs) {
     return {
@@ -108,6 +126,12 @@ export function recordSemanticDrift(drift, provider, model) {
         [GEN_AI_ATTRS.REQUEST_MODEL]: model,
     });
 }
+export function recordTimeToFirstToken(ms, provider, model) {
+    timeToFirstToken.record(ms, {
+        [GEN_AI_ATTRS.PROVIDER]: provider,
+        [GEN_AI_ATTRS.REQUEST_MODEL]: model,
+    });
+}
 export function recordBudgetExceeded(budgetType) {
     budgetExceeded.add(1, { budget_type: budgetType });
 }
@@ -117,3 +141,9 @@ export function recordBudgetBlocked(budgetType) {
 export function recordBudgetDowngraded(budgetType) {
     budgetDowngraded.add(1, { budget_type: budgetType });
 }
+export function recordResponseEmpty(provider, model, attrs) {
+    responseEmpty.add(1, baseLabels(provider, model, attrs));
+}
+export function recordResponseLatencyPerToken(msPerToken, provider, model, attrs) {
+    responseLatencyPerToken.record(msPerToken, baseLabels(provider, model, attrs));
+}

package/dist/core/pricing.d.ts

@@ -12,6 +12,8 @@ export interface ModelPricing {
  * Useful for enterprise contracts or custom/fine-tuned models.
  */
 export declare function setCustomPricing(pricing: Record<string, ModelPricing>): void;
+/** Reset custom pricing to empty. Called from shutdown() to avoid stale state across re-inits. */
+export declare function resetCustomPricing(): void;
 /**
  * Get pricing for a model. Custom pricing takes precedence.
  * Returns undefined if model is not in any pricing table.

package/dist/core/pricing.js

@@ -31,6 +31,10 @@ let customPricing = {};
 export function setCustomPricing(pricing) {
     customPricing = { ...pricing };
 }
+/** Reset custom pricing to empty. Called from shutdown() to avoid stale state across re-inits. */
+export function resetCustomPricing() {
+    customPricing = {};
+}
 /**
  * Get pricing for a model. Custom pricing takes precedence.
  * Returns undefined if model is not in any pricing table.
@@ -43,6 +47,8 @@ export function getModelPricing(model) {
  * Returns 0 if model pricing is not found.
  */
 export function calculateCost(model, inputTokens, outputTokens) {
+    if (inputTokens < 0 || outputTokens < 0)
+        return 0;
     const pricing = getModelPricing(model);
     if (!pricing)
         return 0;

package/dist/core/spans.d.ts

@@ -1,7 +1,7 @@
-import type { LLMSpanAttributes } from "../types/index.js";
+import type { LLMProvider } from "../types/index.js";
 /** Input for traceLLMCall — what the user knows before calling the LLM */
 export interface LLMCallInput {
-    readonly provider: LLMSpanAttributes["provider"];
+    readonly provider: LLMProvider;
     readonly model: string;
     readonly prompt: string;
     readonly temperature?: number | undefined;
@@ -13,6 +13,8 @@ export interface LLMCallOutput {
     readonly completion: string;
     readonly inputTokens: number;
     readonly outputTokens: number;
-    readonly cost: number;
+    /** Cost in USD. If omitted, auto-calculated from model pricing table. */
+    readonly cost?: number | undefined;
 }
+export declare function processContent(text: string): string | undefined;
 export declare function traceLLMCall(input: LLMCallInput, fn: () => Promise<LLMCallOutput>): Promise<LLMCallOutput>;

package/dist/core/spans.js

@@ -1,26 +1,73 @@
 import { createHash } from "node:crypto";
 import { trace, SpanStatusCode } from "@opentelemetry/api";
 import { GEN_AI_ATTRS, INSTRUMENTATION_NAME } from "../types/index.js";
-import { recordRequestDuration, recordRequestCost, recordTokens, recordRequest, recordError, recordBudgetExceeded, recordBudgetBlocked, recordBudgetDowngraded, } from "./metrics.js";
+import { recordRequestDuration, recordRequestCost, recordTokens, recordRequest, recordError, recordBudgetExceeded, recordBudgetBlocked, recordBudgetDowngraded, recordResponseEmpty, recordResponseLatencyPerToken, } from "./metrics.js";
 import { getConfig, getBudgetTracker } from "./tracer.js";
-import { GEN_AI_ATTRS as ATTRS } from "../types/index.js";
+import { calculateCost } from "./pricing.js";
+import { ToadBudgetExceededError } from "../budget/index.js";
 const tracer = trace.getTracer(INSTRUMENTATION_NAME);
+let saltWarningEmitted = false;
+// Track the last config ref so saltWarningEmitted resets across re-inits without circular imports
+let lastConfigRef = null;
 function sha256(text) {
-    const salt = getConfig()?.salt ?? "";
+    const config = getConfig();
+    const salt = config?.salt ?? "";
+    // Auto-reset saltWarningEmitted when SDK is re-initialized (config ref changes)
+    if (config !== lastConfigRef) {
+        lastConfigRef = config;
+        saltWarningEmitted = false;
+    }
+    if (config?.hashContent && !config.salt && !saltWarningEmitted) {
+        console.warn("toad-eye: hashContent is enabled without salt — short strings may be reversible. Set salt in config for stronger privacy.");
+        saltWarningEmitted = true;
+    }
     return createHash("sha256")
         .update(salt + text)
         .digest("hex");
 }
-function processContent(text) {
+// Built-in PII patterns — enabled via redactDefaults: true
+// Note: no `g` flag here — a fresh RegExp is created per call to avoid lastIndex state issues
+const DEFAULT_REDACT_PATTERNS = [
+    /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/, // email
+    /\b\d{3}-\d{2}-\d{4}\b/, // SSN (US)
+    /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/, // credit card
+    /\b\+?\d{1,3}[\s.-]?\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]?\d{3,4}\b/, // phone
+];
+function applyRedaction(text, pattern) {
+    let count = 0;
+    const regex = new RegExp(pattern.source, "g");
+    const result = text.replace(regex, () => {
+        count++;
+        return "[REDACTED]";
+    });
+    return [result, count];
+}
+export function processContent(text) {
     const config = getConfig();
     if (config?.recordContent === false)
         return undefined;
     let processed = text;
+    let totalRedacted = 0;
+    // Apply default PII patterns if enabled
+    if (config?.redactDefaults) {
+        for (const pattern of DEFAULT_REDACT_PATTERNS) {
+            const [result, count] = applyRedaction(processed, pattern);
+            processed = result;
+            totalRedacted += count;
+        }
+    }
+    // Apply custom patterns
     if (config?.redactPatterns?.length) {
         for (const pattern of config.redactPatterns) {
-            processed = processed.replace(pattern, "[REDACTED]");
+            const [result, count] = applyRedaction(processed, pattern);
+            processed = result;
+            totalRedacted += count;
         }
     }
+    // Audit mode — log a summary only, never the original content (would re-expose PII)
+    if (config?.auditMasking && totalRedacted > 0) {
+        console.log(`[toad-eye audit] Content masked: ${totalRedacted} pattern(s) applied, ${text.length} chars → ${processed.length} chars`);
+    }
     if (config?.hashContent) {
         return `sha256:${sha256(processed)}`;
     }
@@ -56,14 +103,14 @@ function recordBaseMetrics(duration, provider, model, attrs) {
     recordRequest(provider, model, attrs);
     recordRequestDuration(duration, provider, model, attrs);
 }
-function setSuccessAttributes(span, input, output) {
+function setSuccessAttributes(span, input, output, resolvedCost) {
     const completion = processContent(output.completion);
     span.setAttributes({
         ...(completion !== undefined && { [GEN_AI_ATTRS.COMPLETION]: completion }),
         [GEN_AI_ATTRS.RESPONSE_MODEL]: input.model,
         [GEN_AI_ATTRS.INPUT_TOKENS]: output.inputTokens,
         [GEN_AI_ATTRS.OUTPUT_TOKENS]: output.outputTokens,
-        [GEN_AI_ATTRS.COST]: output.cost,
+        [GEN_AI_ATTRS.COST]: resolvedCost,
         [GEN_AI_ATTRS.STATUS]: "success",
         [GEN_AI_ATTRS.FINISH_REASONS]: ["stop"],
     });
@@ -84,12 +131,18 @@ function setErrorAttributes(span, message) {
     });
 }
 export async function traceLLMCall(input, fn) {
+    if (!getConfig()) {
+        console.warn("toad-eye: traceLLMCall called before initObservability() — no telemetry will be recorded.");
+    }
     const budget = getBudgetTracker();
     let effectiveInput = input;
+    // Estimated cost for reservation — reduces race window for concurrent requests.
+    // Uses conservative token estimates; actual cost is reconciled in recordCost.
+    const estimatedCost = budget ? calculateCost(input.model, 500, 200) : 0;
     // Budget check BEFORE the LLM call
     if (budget) {
-        const userId = input.attributes?.[ATTRS.USER_ID];
-        const override = budget.checkBefore(input.provider, input.model, userId);
+        const userId = input.attributes?.[GEN_AI_ATTRS.USER_ID];
+        const override = budget.checkBefore(input.provider, input.model, userId, estimatedCost);
         if (override) {
             // Downgrade mode — use modified provider/model
             effectiveInput = {
@@ -97,7 +150,7 @@ export async function traceLLMCall(input, fn) {
                 provider: override.provider,
                 model: override.model,
             };
-            recordBudgetDowngraded("daily");
+            recordBudgetDowngraded(override.budget);
         }
     }
     return tracer.startActiveSpan(`gen_ai.${effectiveInput.provider}.${effectiveInput.model}`, async (span) => {
@@ -107,14 +160,23 @@ export async function traceLLMCall(input, fn) {
             const output = await fn();
             const duration = performance.now() - start;
             const attrs = resolveAttributes(effectiveInput);
-            setSuccessAttributes(span, effectiveInput, output);
+            const resolvedCost = output.cost ??
+                calculateCost(effectiveInput.model, output.inputTokens, output.outputTokens);
+            setSuccessAttributes(span, effectiveInput, output, resolvedCost);
             recordBaseMetrics(duration, effectiveInput.provider, effectiveInput.model, attrs);
-            recordRequestCost(output.cost, effectiveInput.provider, effectiveInput.model, attrs);
+            recordRequestCost(resolvedCost, effectiveInput.provider, effectiveInput.model, attrs);
             recordTokens(output.inputTokens + output.outputTokens, effectiveInput.provider, effectiveInput.model, attrs);
-            // Budget recording AFTER the call
+            // Proxy quality metrics — no extra dependencies, response text analysis only
+            if (output.completion.trim() === "") {
+                recordResponseEmpty(effectiveInput.provider, effectiveInput.model, attrs);
+            }
+            if (output.outputTokens > 0) {
+                recordResponseLatencyPerToken(duration / output.outputTokens, effectiveInput.provider, effectiveInput.model, attrs);
+            }
+            // Budget recording AFTER the call — releases the cost reservation
             if (budget) {
-                const userId = effectiveInput.attributes?.[ATTRS.USER_ID];
-                const exceeded = budget.recordCost(output.cost, effectiveInput.model, userId);
+                const userId = effectiveInput.attributes?.[GEN_AI_ATTRS.USER_ID];
+                const exceeded = budget.recordCost(resolvedCost, effectiveInput.model, userId, estimatedCost);
                 if (exceeded) {
                     recordBudgetExceeded(exceeded.budget);
                     console.warn(`toad-eye: ${exceeded.budget} budget exceeded — limit $${exceeded.limit}, current $${exceeded.current.toFixed(2)}`);
@@ -129,10 +191,13 @@ export async function traceLLMCall(input, fn) {
             setErrorAttributes(span, message);
             recordBaseMetrics(duration, effectiveInput.provider, effectiveInput.model, attrs);
             recordError(effectiveInput.provider, effectiveInput.model, attrs);
-            // If this was a budget block, record the metric
-            if (error instanceof Error &&
-                error.name === "ToadBudgetExceededError") {
-                recordBudgetBlocked("daily");
+            // Release cost reservation on any error (no cost was incurred)
+            if (budget) {
+                budget.releaseReservation(estimatedCost);
+            }
+            // If this was a budget block, record the metric with the correct budget type
+            if (error instanceof ToadBudgetExceededError) {
+                recordBudgetBlocked(error.budget);
             }
             throw error;
         }

package/dist/core/tracer.d.ts

@@ -1,8 +1,5 @@
 import type { ToadEyeConfig } from "../types/index.js";
 import { BudgetTracker } from "../budget/index.js";
-import "../instrumentations/openai.js";
-import "../instrumentations/anthropic.js";
-import "../instrumentations/gemini.js";
 export declare function getConfig(): ToadEyeConfig | null;
 export declare function getBudgetTracker(): BudgetTracker | null;
 export declare function initObservability(config: ToadEyeConfig): void;

package/dist/core/tracer.js

@@ -3,14 +3,13 @@ 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 { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { initMetrics } from "./metrics.js";
+import { initMetrics, resetMetrics } from "./metrics.js";
+import { resetCustomPricing } from "./pricing.js";
 import { enableAll, disableAll } from "../instrumentations/registry.js";
 import { BudgetTracker } from "../budget/index.js";
-// Side-effect imports: register provider instrumentations
-import "../instrumentations/openai.js";
-import "../instrumentations/anthropic.js";
-import "../instrumentations/gemini.js";
+import { ToadEyeAISpanProcessor } from "../vercel.js";
 const DEFAULT_ENDPOINT = "http://localhost:4318";
 const DEFAULT_CLOUD_ENDPOINT = "https://cloud.toad-eye.dev";
 let sdk = null;
@@ -45,8 +44,10 @@ function resolveTransport(config) {
     return { endpoint, headers, isCloudMode };
 }
 export function initObservability(config) {
-    if (sdk)
+    if (sdk) {
+        console.warn("toad-eye: initObservability() already called. Call shutdown() first to reconfigure.");
         return;
+    }
     validateConfig(config);
     const { endpoint, headers, isCloudMode } = resolveTransport(config);
     const resource = resourceFromAttributes({
@@ -64,22 +65,55 @@ export function initObservability(config) {
         exporter: metricExporter,
         exportIntervalMillis: isCloudMode ? 10_000 : 5_000,
     });
+    // Add Vercel AI SDK SpanProcessor if 'ai' is in instrument list
+    const spanProcessors = config.instrument?.includes("ai")
+        ? [new ToadEyeAISpanProcessor()]
+        : [];
+    // SDK-side head sampling (default: 1.0 = send everything to Collector)
+    const sdkRate = config.sampling?.sdkRate ?? 1.0;
+    const sampler = sdkRate < 1.0
+        ? new ParentBasedSampler({
+            root: new TraceIdRatioBasedSampler(sdkRate),
+        })
+        : undefined;
     sdk = new NodeSDK({
         resource,
         traceExporter,
         metricReader,
+        spanProcessors,
+        ...(sampler !== undefined && { sampler }),
     });
     sdk.start();
     currentConfig = config;
     initMetrics();
+    // Non-blocking connectivity check — warns the user if the OTel Collector is unreachable.
+    // Fire-and-forget: does not block initObservability(). Cloud mode skips this check.
+    if (!isCloudMode) {
+        void fetch(`${endpoint}/v1/traces`, {
+            method: "POST",
+            body: "[]",
+            signal: AbortSignal.timeout(2000),
+        }).catch(() => {
+            console.warn(`toad-eye: cannot reach OTel Collector at ${endpoint} — no telemetry will be exported. Is the stack running? Run: npx toad-eye up`);
+        });
+    }
     if (isCloudMode) {
-        console.log(`toad-eye: cloud mode enabled → sending telemetry to ${endpoint}`);
+        const masked = config.apiKey
+            ? config.apiKey.slice(0, 8) + "..." + config.apiKey.slice(-4)
+            : "";
+        console.log(`toad-eye: cloud mode enabled (${masked}) → sending telemetry to ${endpoint}`);
     }
     if (config.budgets) {
         budgetTracker = new BudgetTracker(config.budgets, config.onBudgetExceeded ?? "warn", config.downgradeCallback);
     }
     if (config.instrument?.length) {
-        enableAll(config.instrument);
+        // Filter out 'ai' — it uses SpanProcessor, not monkey-patching
+        const patchProviders = config.instrument.filter((i) => i !== "ai");
+        if (patchProviders.length > 0) {
+            // enableAll is async (lazy-loads provider modules on first call).
+            // Fire-and-forget: patching completes before any async SDK call.
+            void enableAll(patchProviders);
+        }
     }
 }
 export async function shutdown() {
@@ -90,4 +124,6 @@ export async function shutdown() {
     sdk = null;
     currentConfig = null;
     budgetTracker = null;
+    resetMetrics();
+    resetCustomPricing();
 }

package/dist/drift/baseline.js

@@ -12,5 +12,11 @@ export function loadBaseline(filepath) {
     if (!existsSync(filepath))
         return undefined;
     const raw = readFileSync(filepath, "utf-8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !Array.isArray(parsed["embeddings"])) {
+        throw new Error(`toad-eye: baseline file at "${filepath}" is malformed — missing "embeddings" array`);
+    }
+    return parsed;
 }

package/dist/drift/monitor.js

@@ -39,9 +39,13 @@ export function createDriftMonitor(config) {
     return {
         check: performCheck,
         checkInBackground(response, providerName, model) {
-            void performCheck(response, providerName, model).catch((err) => {
+            let timer;
+            const timeout = new Promise((_, reject) => (timer = setTimeout(() => reject(new Error("Drift check timeout (5s)")), 5000)));
+            void Promise.race([performCheck(response, providerName, model), timeout])
+                .catch((err) => {
                 console.warn(`[toad-eye] Drift check failed (non-blocking): ${err instanceof Error ? err.message : String(err)}`);
-            });
+            })
+                .finally(() => clearTimeout(timer));
         },
     };
 }

package/dist/drift/openai-embeddings.js

@@ -20,7 +20,11 @@ export function createOpenAIEmbeddingProvider(apiKey, model = DEFAULT_MODEL) {
                 throw new Error(`OpenAI Embeddings API error: ${response.status} ${response.statusText}`);
             }
             const body = (await response.json());
-            return body.data[0].embedding;
+            const embedding = body.data?.[0]?.embedding;
+            if (!embedding) {
+                throw new Error("OpenAI Embeddings API returned no embeddings");
+            }
+            return embedding;
         },
     };
 }

package/dist/export.js

@@ -31,7 +31,7 @@ function buildAssertions(completion) {
             value: Math.ceil(completion.length * LENGTH_BUFFER_MULTIPLIER),
         });
         if (!completion.toLowerCase().includes(REFUSAL_MARKER)) {
-            assertions.push({ type: "not_contains", value: "I cannot" });
+            assertions.push({ type: "not_contains", value: REFUSAL_MARKER });
         }
         if (isJson(completion)) {
             assertions.push({ type: "is_json", value: true });

package/dist/guard.d.ts

@@ -2,10 +2,9 @@
  * Shadow Guardrails integration — records toad-guard validation results
  * as span attributes and metrics without blocking LLM responses.
  *
- * toad-guard validates each LLM response and passes the result here.
- * In shadow mode, validation runs but never throws — results are recorded
- * for observability only, letting you tune guardrail thresholds on
- * production traffic before switching to enforce mode.
+ * Results are recorded as attributes on the currently active span
+ * (typically the LLM call span from traceLLMCall). This avoids
+ * trace bloat — no extra child spans per guard rule.
  *
  * Usage from toad-guard:
  * ```ts
@@ -17,10 +16,9 @@
  */
 import type { GuardResult } from "./types/index.js";
 /**
- * Record a guard validation result as span attributes and metrics.
+ * Record a guard validation result as attributes on the active span.
  *
- * Attaches guard attributes to a child span and increments counters.
- * If the guard failed, also increments the `would_block` counter —
- * useful for measuring how often shadow guardrails would have blocked.
+ * Attaches guard attributes directly to the current span (no child span created).
+ * Increments guard evaluation counter, and would_block counter if failed.
  */
 export declare function recordGuardResult(result: GuardResult): void;

package/dist/guard.js

@@ -2,10 +2,9 @@
  * Shadow Guardrails integration — records toad-guard validation results
  * as span attributes and metrics without blocking LLM responses.
  *
- * toad-guard validates each LLM response and passes the result here.
- * In shadow mode, validation runs but never throws — results are recorded
- * for observability only, letting you tune guardrail thresholds on
- * production traffic before switching to enforce mode.
+ * Results are recorded as attributes on the currently active span
+ * (typically the LLM call span from traceLLMCall). This avoids
+ * trace bloat — no extra child spans per guard rule.
  *
  * Usage from toad-guard:
  * ```ts
@@ -16,28 +15,27 @@
  * ```
  */
 import { trace } from "@opentelemetry/api";
-import { GEN_AI_ATTRS, INSTRUMENTATION_NAME } from "./types/index.js";
+import { GEN_AI_ATTRS } from "./types/index.js";
 import { recordGuardEvaluation, recordGuardWouldBlock, } from "./core/metrics.js";
-const tracer = trace.getTracer(INSTRUMENTATION_NAME);
 /**
- * Record a guard validation result as span attributes and metrics.
+ * Record a guard validation result as attributes on the active span.
  *
- * Attaches guard attributes to a child span and increments counters.
- * If the guard failed, also increments the `would_block` counter —
- * useful for measuring how often shadow guardrails would have blocked.
+ * Attaches guard attributes directly to the current span (no child span created).
+ * Increments guard evaluation counter, and would_block counter if failed.
  */
 export function recordGuardResult(result) {
-    const span = tracer.startSpan(`guard.evaluate.${result.ruleName}`);
-    span.setAttributes({
-        [GEN_AI_ATTRS.GUARD_MODE]: result.mode,
-        [GEN_AI_ATTRS.GUARD_PASSED]: result.passed,
-        [GEN_AI_ATTRS.GUARD_RULE_NAME]: result.ruleName,
-        ...(!result.passed &&
-            result.failureReason !== undefined && {
-            [GEN_AI_ATTRS.GUARD_FAILURE_REASON]: result.failureReason,
-        }),
-    });
-    span.end();
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan) {
+        activeSpan.setAttributes({
+            [GEN_AI_ATTRS.GUARD_MODE]: result.mode,
+            [GEN_AI_ATTRS.GUARD_PASSED]: result.passed,
+            [GEN_AI_ATTRS.GUARD_RULE_NAME]: result.ruleName,
+            ...(!result.passed &&
+                result.failureReason !== undefined && {
+                [GEN_AI_ATTRS.GUARD_FAILURE_REASON]: result.failureReason,
+            }),
+        });
+    }
     recordGuardEvaluation(result.ruleName);
     if (!result.passed) {
         recordGuardWouldBlock(result.ruleName);

package/dist/index.d.ts

@@ -13,5 +13,10 @@ export type { ExportTraceOptions } from "./export.js";
 export { calculateCost, setCustomPricing, getModelPricing, } from "./core/pricing.js";
 export type { ModelPricing } from "./core/pricing.js";
 export type { LLMCallInput, LLMCallOutput } from "./core/spans.js";
-export type { ToadEyeConfig, LLMSpanAttributes, LLMProvider, SpanStatus, MetricName, AgentStepType, AgentStepInput, GuardMode, GuardResult, } from "./types/index.js";
-export { GEN_AI_METRICS, GEN_AI_ATTRS, LLM_METRICS, LLM_ATTRS, } from "./types/index.js";
+export type { ToadEyeConfig, LLMSpanAttributes, LLMProvider, SpanStatus, MetricName, AgentStepType, AgentStepInput, AgentQueryOptions, GuardMode, GuardResult, InstrumentTarget, SamplingConfig, } from "./types/index.js";
+export { GEN_AI_METRICS, GEN_AI_ATTRS } from "./types/index.js";
+/** @deprecated Use GEN_AI_METRICS instead */
+export { LLM_METRICS } from "./types/index.js";
+/** @deprecated Use GEN_AI_ATTRS instead */
+export { LLM_ATTRS } from "./types/index.js";
+export { ToadEyeAISpanProcessor, withToadEye } from "./vercel.js";

package/dist/index.js

@@ -7,4 +7,9 @@ export { recordGuardResult } from "./guard.js";
 export { createDriftMonitor, createOpenAIEmbeddingProvider, cosineSimilarity, cosineDrift, saveBaseline, loadBaseline, } from "./drift/index.js";
 export { exportTrace, fetchTrace, traceToEvalYaml } from "./export.js";
 export { calculateCost, setCustomPricing, getModelPricing, } from "./core/pricing.js";
-export { GEN_AI_METRICS, GEN_AI_ATTRS, LLM_METRICS, LLM_ATTRS, } from "./types/index.js";
+export { GEN_AI_METRICS, GEN_AI_ATTRS } from "./types/index.js";
+/** @deprecated Use GEN_AI_METRICS instead */
+export { LLM_METRICS } from "./types/index.js";
+/** @deprecated Use GEN_AI_ATTRS instead */
+export { LLM_ATTRS } from "./types/index.js";
+export { ToadEyeAISpanProcessor, withToadEye } from "./vercel.js";

package/dist/instrumentations/anthropic.d.ts

@@ -1 +1 @@
-export {};
+export declare const anthropicInstrumentation: import("./types.js").Instrumentation;

package/dist/instrumentations/anthropic.js

@@ -1,4 +1,3 @@
-import { register } from "./registry.js";
 import { createInstrumentation } from "./create.js";
 function extractMessages(messages) {
     if (!Array.isArray(messages))
@@ -46,28 +45,21 @@ const messagesCreate = {
         };
     },
     isStreaming: (body) => !!body?.stream,
-    extractStreamResponse: (chunks) => {
-        // Anthropic stream events: message_start, content_block_delta, message_delta, message_stop
-        let completion = "";
-        let inputTokens = 0;
-        let outputTokens = 0;
-        for (const chunk of chunks) {
-            const event = chunk;
-            if (event.type === "content_block_delta" && event.delta?.text) {
-                completion += event.delta.text;
-            }
-            if (event.type === "message_start" && event.message?.usage) {
-                inputTokens = event.message.usage.input_tokens ?? 0;
-            }
-            if (event.type === "message_delta" && event.usage) {
-                outputTokens = event.usage.output_tokens ?? 0;
-            }
+    accumulateChunk: (acc, chunk) => {
+        const event = chunk;
+        if (event.type === "content_block_delta" && event.delta?.text) {
+            acc.completion += event.delta.text;
+        }
+        if (event.type === "message_start" && event.message?.usage) {
+            acc.inputTokens = event.message.usage.input_tokens ?? 0;
+        }
+        if (event.type === "message_delta" && event.usage) {
+            acc.outputTokens = event.usage.output_tokens ?? 0;
         }
-        return { completion, inputTokens, outputTokens };
     },
 };
-register(createInstrumentation({
+export const anthropicInstrumentation = createInstrumentation({
     name: "anthropic",
     moduleName: "@anthropic-ai/sdk",
     patches: [messagesCreate],
-}));
+});

package/dist/instrumentations/create.d.ts

@@ -1,9 +1,5 @@
 import type { LLMProvider } from "../types/index.js";
 import type { Instrumentation, PatchTarget } from "./types.js";
-/**
- * Factory for creating SDK instrumentations.
- * Eliminates boilerplate: SDK resolution, prototype patching, error handling, cleanup.
- */
 export declare function createInstrumentation(config: {
     name: LLMProvider;
     moduleName: string;