@juspay/neurolink 12.58.1 → 13.0.0

package/dist/providers/googleVertex/constants.js

@@ -1,6 +1,6 @@
-import { trace } from "@opentelemetry/api";
+import { scrubbedTracer } from "../../telemetry/tracers.js";
 export const MAX_IMAGE_DOWNLOAD_BYTES = 10 * 1024 * 1024;
-export const streamTracer = trace.getTracer("neurolink.provider.vertex");
+export const streamTracer = scrubbedTracer("provider.vertex");
 export let cachedCredentialsPath = null;
 export const VERTEX_MODEL_ALIASES = {
     // Claude 4.x shorthand aliases → versioned names

package/dist/providers/litellm/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { EmbedInput, OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners } from "../../types/index.js";
+import type { EmbedInput, OpenAICompatBuildBodyArgs } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /** Test hook: reset the discovery caches (state is module-global). */
 export declare function clearLiteLLMModelLimitsCache(): void;
@@ -28,8 +28,7 @@ export declare function ensureLiteLLMModelLimits(baseURL: string, apiKey: string
  *
  * All request/stream/tool-loop orchestration lives in
  * `OpenAIChatCompletionsProvider`. This class adds LiteLLM-specific
- * behaviour: OTel span wrap with cost (`onStreamStart`), Gemini 2.5
- * maxTokens skip (`adjustBuildBodyOptions`), ModelAccessDeniedError on
+ * behaviour: Gemini 2.5 maxTokens skip (`adjustBuildBodyOptions`), ModelAccessDeniedError on
  * 403, 10-minute model cache (`getAvailableModels`), `LITELLM_FALLBACK_MODELS`
  * env-driven fallback list, and native `/v1/embeddings`.
  */
@@ -70,12 +69,6 @@ export declare class LiteLLMProvider extends OpenAIChatCompletionsProvider {
      * both streaming and non-streaming paths.
      */
     protected adjustBuildBodyOptions(modelId: string, opts: OpenAICompatBuildBodyArgs["options"]): OpenAICompatBuildBodyArgs["options"];
-    /**
-     * Wrap the stream in an OTel span to capture provider-level latency,
-     * token usage, finish reason, and cost. Matches the pre-migration
-     * behaviour where streamText was wrapped in `neurolink.provider.streamText`.
-     */
-    protected onStreamStart(modelId: string): OpenAICompatStreamLifecycleListeners | undefined;
     formatProviderError(error: unknown): Error;
     /**
      * Get available models from LiteLLM proxy `/v1/models` endpoint.

package/dist/providers/litellm/client.js

@@ -1,4 +1,3 @@
-import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { registerRuntimeContextWindow, registerRuntimeOutputCeiling, } from "../../constants/contextWindows.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, ModelAccessDeniedError, NetworkError, ProviderError, RateLimitError, isModelAccessDeniedMessage, parseAllowedModels, } from "../../types/index.js";
@@ -7,12 +6,10 @@ import { isAbortError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { isGemini25Model as isCanonicalGemini25Model } from "../../utils/modelDetection.js";
-import { calculateCost } from "../../utils/pricing.js";
 import { getProviderModel } from "../../utils/providerConfig.js";
 import { createTimeoutController } from "../../utils/timeout.js";
 import { stripTrailingSlash } from "../openaiChatCompletionsClient.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
-const streamTracer = trace.getTracer("neurolink.provider.litellm");
 const FALLBACK_LITELLM_MODEL = "openai/gpt-5.4-mini";
 const getLiteLLMConfig = () => ({
     baseURL: process.env.LITELLM_BASE_URL || "http://localhost:4000",
@@ -195,8 +192,7 @@ const isGemini25Model = (modelName) => {
  *
  * All request/stream/tool-loop orchestration lives in
  * `OpenAIChatCompletionsProvider`. This class adds LiteLLM-specific
- * behaviour: OTel span wrap with cost (`onStreamStart`), Gemini 2.5
- * maxTokens skip (`adjustBuildBodyOptions`), ModelAccessDeniedError on
+ * behaviour: Gemini 2.5 maxTokens skip (`adjustBuildBodyOptions`), ModelAccessDeniedError on
  * 403, 10-minute model cache (`getAvailableModels`), `LITELLM_FALLBACK_MODELS`
  * env-driven fallback list, and native `/v1/embeddings`.
  */
@@ -276,64 +272,6 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         }
         return opts;
     }
-    /**
-     * Wrap the stream in an OTel span to capture provider-level latency,
-     * token usage, finish reason, and cost. Matches the pre-migration
-     * behaviour where streamText was wrapped in `neurolink.provider.streamText`.
-     */
-    onStreamStart(modelId) {
-        const span = streamTracer.startSpan("neurolink.provider.streamText", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-                "gen_ai.system": "litellm",
-                "gen_ai.request.model": modelId,
-            },
-        });
-        let spanEnded = false;
-        const endSpan = () => {
-            if (!spanEnded) {
-                spanEnded = true;
-                span.end();
-            }
-        };
-        return {
-            onUsage: (usage) => {
-                // promptTokens is the uncached remainder — the attribute reports the
-                // full prompt (uncached + cache read/creation), and the cache fields
-                // let calculateCost price tiers.
-                span.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens +
-                    (usage.cacheReadTokens ?? 0) +
-                    (usage.cacheCreationTokens ?? 0));
-                span.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens);
-                const cost = calculateCost(this.providerName, modelId, {
-                    input: usage.promptTokens,
-                    output: usage.completionTokens,
-                    total: usage.totalTokens,
-                    ...(usage.cacheReadTokens
-                        ? { cacheReadTokens: usage.cacheReadTokens }
-                        : {}),
-                    ...(usage.cacheCreationTokens
-                        ? { cacheCreationTokens: usage.cacheCreationTokens }
-                        : {}),
-                });
-                if (cost && cost > 0) {
-                    span.setAttribute("neurolink.cost", cost);
-                }
-            },
-            onFinish: (reason, capturedError) => {
-                span.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
-                if (reason === "error") {
-                    span.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: capturedError instanceof Error
-                            ? capturedError.message
-                            : String(capturedError ?? "stream error"),
-                    });
-                }
-                endSpan();
-            },
-        };
-    }
     formatProviderError(error) {
         // Curator P1-1: detect "team not allowed to access model" responses and
         // surface as ModelAccessDeniedError with the allowed_models array parsed

package/dist/providers/openAI/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { EmbedInput, EnhancedGenerateResult, NeurolinkCredentials, OpenAICompatStreamLifecycleListeners, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, EnhancedGenerateResult, NeurolinkCredentials, TextGenerationOptions } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /**
  * OpenAI Provider — direct HTTP, no AI SDK.
@@ -7,7 +7,6 @@ import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
  * OpenAI chat completions at api.openai.com/v1. All request / stream /
  * tool-loop orchestration lives in `OpenAIChatCompletionsProvider`; this
  * class adds:
- *   - OTel span wrap with cost (`onStreamStart`)
  *   - Native `/v1/embeddings` (`embed` / `embedMany`)
  *   - Image generation via `/v1/images/generations` (`executeImageGeneration`)
  *   - OpenAI-specific error mapping (`formatProviderError`)
@@ -25,12 +24,6 @@ export declare class OpenAIProvider extends OpenAIChatCompletionsProvider {
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     formatProviderError(error: unknown): Error;
-    /**
-     * Wrap the stream in an OTel span to capture provider-level latency,
-     * token usage, finish reason, and cost. Mirrors the pre-migration
-     * `streamText`-span behaviour.
-     */
-    protected onStreamStart(modelId: string): OpenAICompatStreamLifecycleListeners | undefined;
     /**
      * Default embedding model, overridable via OPENAI_EMBEDDING_MODEL env var.
      */

package/dist/providers/openAI/client.js

@@ -1,10 +1,8 @@
-import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { AIProviderName as AIProviderNameEnum } from "../../constants/enums.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
-import { calculateCost } from "../../utils/pricing.js";
 import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { safeDownload } from "../../utils/safeFetch.js";
@@ -45,14 +43,12 @@ const resolveOpenAIBaseURL = (credentialBaseURL, envBaseURL) => {
 };
 const getOpenAIApiKey = () => validateApiKey(createOpenAIConfig());
 const getOpenAIModel = () => getProviderModel("OPENAI_MODEL", "gpt-5.4");
-const streamTracer = trace.getTracer("neurolink.provider.openai");
 /**
  * OpenAI Provider — direct HTTP, no AI SDK.
  *
  * OpenAI chat completions at api.openai.com/v1. All request / stream /
  * tool-loop orchestration lives in `OpenAIChatCompletionsProvider`; this
  * class adds:
- *   - OTel span wrap with cost (`onStreamStart`)
  *   - Native `/v1/embeddings` (`embed` / `embedMany`)
  *   - Image generation via `/v1/images/generations` (`executeImageGeneration`)
  *   - OpenAI-specific error mapping (`formatProviderError`)
@@ -147,67 +143,6 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
         return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
-    // Optional hook overrides
-    // ===========================================================================
-    /**
-     * Wrap the stream in an OTel span to capture provider-level latency,
-     * token usage, finish reason, and cost. Mirrors the pre-migration
-     * `streamText`-span behaviour.
-     */
-    onStreamStart(modelId) {
-        const span = streamTracer.startSpan("neurolink.provider.streamText", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-                "gen_ai.system": "openai",
-                "gen_ai.request.model": modelId,
-            },
-        });
-        let spanEnded = false;
-        const endSpan = () => {
-            if (!spanEnded) {
-                spanEnded = true;
-                span.end();
-            }
-        };
-        return {
-            onUsage: (usage) => {
-                // promptTokens is the uncached remainder — the attribute reports the
-                // full prompt (uncached + cache read/creation), and the cache fields
-                // let calculateCost price tiers.
-                span.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens +
-                    (usage.cacheReadTokens ?? 0) +
-                    (usage.cacheCreationTokens ?? 0));
-                span.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens);
-                const cost = calculateCost(this.providerName, modelId, {
-                    input: usage.promptTokens,
-                    output: usage.completionTokens,
-                    total: usage.totalTokens,
-                    ...(usage.cacheReadTokens
-                        ? { cacheReadTokens: usage.cacheReadTokens }
-                        : {}),
-                    ...(usage.cacheCreationTokens
-                        ? { cacheCreationTokens: usage.cacheCreationTokens }
-                        : {}),
-                });
-                if (cost && cost > 0) {
-                    span.setAttribute("neurolink.cost", cost);
-                }
-            },
-            onFinish: (reason, capturedError) => {
-                span.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
-                if (reason === "error") {
-                    span.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: capturedError instanceof Error
-                            ? capturedError.message
-                            : String(capturedError ?? "stream error"),
-                    });
-                }
-                endSpan();
-            },
-        };
-    }
-    // ===========================================================================
     // Embeddings — native POST /v1/embeddings
     // ===========================================================================
     /**

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -301,6 +301,7 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
     private resolveStreamStructuredData;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     private runStreamLoop;
+    private streamObservedStep;
     private streamOneStep;
     private executeToolBatch;
     /**

package/dist/providers/openaiChatCompletionsBase.js

@@ -28,6 +28,8 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { observeGeneration } from "../telemetry/observation.js";
+import { StepSpans, withGeneration } from "../telemetry/withSpan.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { NoOutputGeneratedError } from "../utils/generationErrors.js";
@@ -964,6 +966,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         withTools = true) => {
             return runNativeGenerateLoop({
                 doGenerate,
+                provider: this.providerName,
                 ...createNativeGenerateGuard({
                     provider: this.providerName,
                     availableInputTokens: getAvailableInputTokens(this.providerName, modelId, options.maxTokens ?? undefined),
@@ -1469,6 +1472,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             const billed = { inputTokens: 0, outputTokens: 0 };
             const runLoop = (conv, format) => runNativeGenerateLoop({
                 doGenerate,
+                provider: this.providerName,
                 conversation: conv,
                 toolsRecord: {},
                 modelId,
@@ -2074,6 +2078,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
             };
         };
+        const stepSpans = new StepSpans();
         try {
             // May grow mid-turn: hydrated tools with wire-unsafe names need
             // reverse-mapping even when the initial name set required none.
@@ -2087,6 +2092,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // Completed-step records handed to a caller's prepareStep hook.
             const stepRecords = [];
             for (let step = 0; step < maxSteps; step++) {
+                stepSpans.begin(step + 1);
                 const openAIToolChoice = await stepToolChoice(step, stepRecords);
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
                 // new tools into toolsRecord between steps. Dispatch already re-reads
@@ -2141,7 +2147,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     conversation.length = 0;
                     conversation.push(...guarded);
                 }
-                const stepResult = await this.streamOneStep({
+                const stepResult = await stepSpans.run(() => this.streamObservedStep({
                     modelId,
                     url,
                     fetchImpl,
@@ -2152,7 +2158,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     openAIToolChoice,
                     pushChunk,
                     responseFormat,
-                });
+                }));
                 lastObservedPromptTokens = stepResult.usage?.prompt_tokens;
                 stepFinish = stepResult.finishReason;
                 if (stepResult.usage) {
@@ -2170,7 +2176,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 if (stepResult.toolCalls.size === 0) {
                     break;
                 }
-                await this.executeToolBatch({
+                await stepSpans.run(() => this.executeToolBatch({
                     stepResult,
                     conversation,
                     toolsRecord,
@@ -2179,7 +2185,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     toolExecutionSummaries,
                     options,
                     stepIndex: step,
-                });
+                }));
                 const executed = toolExecutionSummaries.slice(-stepResult.toolCalls.size);
                 stepRecords.push(toPrepareStepRecord({
                     stepNumber: step,
@@ -2243,6 +2249,57 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             closeChannel();
             throw err;
         }
+        finally {
+            stepSpans.end();
+        }
+    }
+    streamObservedStep(args) {
+        return withGeneration({
+            operation: "stream",
+            provider: this.providerName,
+            model: args.modelId,
+            modelParameters: {
+                temperature: args.options.temperature,
+                maxTokens: args.options.maxTokens,
+                topP: args.options.topP,
+                thinkingLevel: args.options.thinkingConfig?.thinkingLevel,
+            },
+            input: { messages: args.conversation },
+        }, async (span) => {
+            let firstChunkAt;
+            const result = await this.streamOneStep({
+                ...args,
+                pushChunk: (chunk) => {
+                    firstChunkAt ??= new Date();
+                    args.pushChunk(chunk);
+                },
+            });
+            const toolCalls = [...result.toolCalls.values()].map((call) => ({
+                id: call.id,
+                name: call.name,
+                args: call.argsBuffered,
+            }));
+            observeGeneration(span, {
+                provider: this.providerName,
+                model: args.modelId,
+                responseModel: result.model,
+                output: {
+                    text: result.text,
+                    ...(result.reasoning ? { reasoning: result.reasoning } : {}),
+                    ...(toolCalls.length > 0 ? { toolCalls } : {}),
+                },
+                usage: result.usage && {
+                    promptTokens: result.usage.prompt_tokens,
+                    completionTokens: result.usage.completion_tokens,
+                    prompt_tokens_details: result.usage.prompt_tokens_details,
+                    reasoning_tokens: result.usage.completion_tokens_details?.reasoning_tokens,
+                },
+                finishReason: result.finishReason ?? undefined,
+                aborted: args.abortSignal?.aborted,
+                completionStartTime: firstChunkAt,
+            });
+            return result;
+        });
     }
     async streamOneStep(args) {
         // Per-step max_tokens fit: the conversation grows every step of the

package/dist/providers/replicate.js

@@ -5,6 +5,8 @@ import { getReplicateAuth } from "../adapters/replicate/auth.js";
 import { downloadPredictionOutput, predict, } from "../adapters/replicate/predictionLifecycle.js";
 import { MAX_IMAGE_BYTES } from "../utils/sizeGuard.js";
 import { isNeuroLink } from "../neurolink.js";
+import { observeGeneration } from "../telemetry/observation.js";
+import { withGeneration } from "../telemetry/withSpan.js";
 import { logger } from "../utils/logger.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { createReplicateConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
@@ -227,10 +229,26 @@ export class ReplicateProvider extends BaseProvider {
         };
         let prediction;
         try {
-            prediction = await predict(auth, {
-                model: this.modelName,
-                input: replicateInput,
-            }, { abortSignal: options.abortSignal });
+            const call = { provider: this.providerName, model: this.modelName };
+            prediction = await withGeneration({
+                ...call,
+                modelParameters: {
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    topP: 1,
+                },
+                input: { prompt },
+            }, async (span) => {
+                const settled = await predict(auth, {
+                    model: this.modelName,
+                    input: replicateInput,
+                }, { abortSignal: options.abortSignal });
+                observeGeneration(span, {
+                    ...call,
+                    output: flattenReplicateOutput(settled.output),
+                });
+                return settled;
+            });
         }
         catch (err) {
             throw this.handleProviderError(err);

package/dist/proxy/codexUsage.js

@@ -273,6 +273,13 @@ export function createCodexUsageTap() {
                     evidence.firstUsefulOutputAt = Date.now();
                     evidence.firstUsefulOutputEvent = String(type);
                 }
+                if (typeof type === "string" &&
+                    type.startsWith("response.") &&
+                    completedResponse &&
+                    typeof completedResponse === "object" &&
+                    "output" in completedResponse) {
+                    evidence.response = completedResponse;
+                }
                 if (type === "response.completed") {
                     evidence.completed = true;
                     evidence.terminalBytes = totalBytes;

package/dist/proxy/proxyFetch.js

@@ -4,22 +4,13 @@
  * Lightweight implementation extracted from research of major proxy packages
  */
 import { logger } from "../utils/logger.js";
+import { getPropagatedAttributesFromContext } from "@langfuse/core";
+import { LangfuseOtelSpanAttributes } from "@langfuse/tracing";
 import { SpanStatusCode, propagation, context } from "@opentelemetry/api";
 import { tracers } from "../telemetry/tracers.js";
 import { shouldBypassProxy } from "./utils/noProxyUtils.js";
 import { createHash } from "node:crypto";
 import { TRANSIENT_NETWORK_CODES } from "../constants/networkErrorCodes.js";
-async function getLangfuseContext() {
-    try {
-        // Dynamic import to avoid hard dependency — getLangfuseContext is only
-        // available when the observability module is loaded.
-        const mod = await import("../services/server/ai/observability/instrumentation.js");
-        return mod.getLangfuseContext?.();
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Inject OTel trace context (traceparent/tracestate) and NeuroLink session context
  * into outgoing request headers. This enables:
@@ -36,19 +27,22 @@ function mergeTraceHeaders(input, init) {
     }
     return existingHeaders;
 }
-async function injectTraceContext(input, init) {
+function injectTraceContext(input, init) {
     const carrier = {};
     propagation.inject(context.active(), carrier);
-    // Also inject NeuroLink session context from Langfuse AsyncLocalStorage
-    const langfuseContext = await getLangfuseContext();
-    if (langfuseContext?.sessionId) {
-        carrier["x-neurolink-session-id"] = langfuseContext.sessionId;
-    }
-    if (langfuseContext?.userId) {
-        carrier["x-neurolink-user-id"] = langfuseContext.userId;
-    }
-    if (langfuseContext?.conversationId) {
-        carrier["x-neurolink-conversation-id"] = langfuseContext.conversationId;
+    const propagated = getPropagatedAttributesFromContext(context.active());
+    for (const [header, key] of [
+        ["x-neurolink-session-id", LangfuseOtelSpanAttributes.TRACE_SESSION_ID],
+        ["x-neurolink-user-id", LangfuseOtelSpanAttributes.TRACE_USER_ID],
+        [
+            "x-neurolink-conversation-id",
+            `${LangfuseOtelSpanAttributes.TRACE_METADATA}.conversationId`,
+        ],
+    ]) {
+        const value = propagated[key];
+        if (typeof value === "string" && value) {
+            carrier[header] = value;
+        }
     }
     if (Object.keys(carrier).length === 0) {
         return init ?? {};
@@ -119,7 +113,7 @@ export function isTransientNetworkError(error) {
  */
 async function fetchWithRetry(url, init, maxRetries = 3, baseDelay = 500) {
     const hostname = extractHostname(url);
-    return fetchTracer.startActiveSpan("neurolink.http.fetchWithRetry", async (span) => {
+    return fetchTracer.startActiveSpan("http.fetchWithRetry", async (span) => {
         span.setAttribute("http.request.max_retries", maxRetries);
         span.setAttribute("http.request.hostname", hostname);
         span.setAttribute("http.request.method", init?.method || "GET");
@@ -406,7 +400,7 @@ function getTargetUrl(input) {
 }
 function createDirectFetchHandler() {
     return async (input, init) => {
-        const enrichedInit = await injectTraceContext(input, init);
+        const enrichedInit = injectTraceContext(input, init);
         const reqId = `req-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
         const startTs = Date.now();
         const url = getTargetUrl(input);
@@ -451,7 +445,7 @@ function createDirectFetchHandler() {
 }
 async function executeProxiedFetch(input, init, proxyEnv) {
     const { httpsProxy, httpProxy, allProxy, socksProxy, noProxy } = proxyEnv;
-    init = await injectTraceContext(input, init);
+    init = injectTraceContext(input, init);
     const requestId = `req-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
     const requestStartTime = Date.now();
     const targetUrl = getTargetUrl(input);

package/dist/proxy/proxyTracer.d.ts

@@ -6,19 +6,17 @@
  *   receive -> account_selection -> upstream (per retry) -> stream -> end
  *
  * Uses the existing instrumentation infrastructure:
- * - getTracer() from instrumentation.ts for span creation
  * - setLangfuseContext() for Langfuse enrichment
- * - OtelBridge for context propagation to/from upstream
+ * - OTel propagation API for context propagation to/from upstream
  * - SpanAttributes from spanTypes.ts for attribute naming
  * - calculateCost() from pricing.ts for cost tracking
- * - TelemetryService for metrics recording
  */
 import { type Span } from "@opentelemetry/api";
 import type { AccountSelectionContext, ProxyRequestContext, ProxyRequestOrigin, ResponseInfoContext, UpstreamAttemptContext, UsageContext, ProxyUsageAttributionOptions, RuntimeRequestMetadata, ProxyLogTraceContext } from "../types/index.js";
 declare class ProxyTracer {
     private readonly rootSpan;
+    private readonly traceContext;
     private readonly proxyTracer;
-    private readonly bridge;
     private readonly requestId;
     /**
      * Model used for costing. Starts as the model the client asked for and is
@@ -42,12 +40,21 @@ declare class ProxyTracer {
     private mode;
     /** Where the Claude-shaped request originated, for cache/cost attribution. */
     private requestOrigin;
+    private readonly requestedModel;
+    private input?;
+    private output?;
+    private responseModel?;
+    private finishReason?;
+    private firstOutputAt?;
+    private upstreamStartedAt?;
+    private cost?;
+    private statusMessage?;
     private constructor();
     /**
      * Create a root span for a proxy request and set Langfuse context.
      *
      * If the incoming request carries a `traceparent` header, the root span
-     * will be linked to the caller's trace via OtelBridge.extractContext().
+     * will be linked to the caller's trace via the OTel propagation API.
      */
     static startRequest(ctx: ProxyRequestContext, incomingHeaders?: Record<string, string>): ProxyTracer;
     /** Span covering the initial request receive and parse phase. */
@@ -120,8 +127,8 @@ declare class ProxyTracer {
     getUsage(): UsageContext | undefined;
     /** End the root span with final HTTP status and duration, and emit OTEL metrics. */
     end(responseStatus: number, durationMs: number): void;
-    /** Record metrics via TelemetryService (call after setUsage). */
-    recordMetrics(): void;
+    private levelFor;
+    private observeOutcome;
     /**
      * Get trace context headers for propagation to the upstream Anthropic request.
      * Injects the current trace's `traceparent` / `tracestate` into a new header map.