@juspay/neurolink 9.54.5 → 9.54.7

package/dist/providers/litellm.js

@@ -7,6 +7,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { isAbortError } from "../utils/errorHandling.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { getProviderModel } from "../utils/providerConfig.js";
@@ -190,6 +191,7 @@ export class LiteLLMProvider extends BaseProvider {
                     chunkCount++;
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     logger.info("Tool execution completed", { toolResults, toolCalls });
                     for (const toolCall of toolCalls) {
                         collectedToolCalls.push({

package/dist/providers/mistral.js

@@ -4,6 +4,7 @@ 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 { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -69,6 +70,7 @@ export class MistralProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[MistralProvider] Failed to store tool executions", {
                             provider: this.providerName,

package/dist/providers/ollama.js

@@ -9,6 +9,7 @@ import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { InvalidModelError, NetworkError, ProviderError, } from "../types/index.js";
 import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
 const DEFAULT_OLLAMA_MODEL = process.env.OLLAMA_MODEL || "llama3.1:8b";
@@ -743,13 +744,22 @@ export class OllamaProvider extends BaseProvider {
                     content: options.input.text,
                 });
             }
+            // Capture instance references before the stream for use in the finally block.
+            const ollamaNeurolink = this.neurolink;
+            const ollamaProviderName = this.providerName;
+            const ollamaModelName = this.modelName || FALLBACK_OLLAMA_MODEL;
             // Conversation loop for multi-step tool execution
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            let lastFinishReason;
+            let ollamaStreamErrored = false;
             const stream = new ReadableStream({
                 start: async (controller) => {
                     try {
                         while (iteration < maxIterations) {
                             logger.debug(`[OllamaProvider] Conversation iteration ${iteration + 1}/${maxIterations}`);
-                            // Make API request
+                            // Make API request — request usage in stream_options so
+                            // Pipeline B gets real token counts for Langfuse cost dashboards.
                             const response = await proxyFetch(`${this.baseUrl}/v1/chat/completions`, {
                                 method: "POST",
                                 headers: { "Content-Type": "application/json" },
@@ -759,6 +769,7 @@ export class OllamaProvider extends BaseProvider {
                                     tools: ollamaTools,
                                     tool_choice: "auto",
                                     stream: true,
+                                    stream_options: { include_usage: true },
                                     temperature: options.temperature,
                                     max_tokens: options.maxTokens,
                                 }),
@@ -768,7 +779,15 @@ export class OllamaProvider extends BaseProvider {
                                 throw this.handleProviderError(await createOllamaHttpError(response));
                             }
                             // Process response stream
-                            const { content, toolCalls, finishReason } = await this.processOllamaResponse(response, controller);
+                            const { content, toolCalls, finishReason, usage } = await this.processOllamaResponse(response, controller);
+                            // Accumulate usage across iterations for Pipeline B
+                            if (usage) {
+                                totalInputTokens += usage.input;
+                                totalOutputTokens += usage.output;
+                            }
+                            if (finishReason) {
+                                lastFinishReason = finishReason;
+                            }
                             // Add assistant message to history
                             const assistantMessage = {
                                 role: "assistant",
@@ -822,20 +841,53 @@ export class OllamaProvider extends BaseProvider {
                             }
                         }
                         if (iteration >= maxIterations) {
+                            ollamaStreamErrored = true;
                             controller.error(new Error(`Ollama conversation exceeded maximum iterations (${maxIterations})`));
                         }
                     }
                     catch (error) {
+                        ollamaStreamErrored = true;
                         controller.error(error);
                     }
                     finally {
-                        // Resolve analytics with final values now that the loop has completed.
-                        resolveAnalytics(createAnalytics(this.providerName, this.modelName || FALLBACK_OLLAMA_MODEL, { usage: { input: 0, output: 0, total: 0 } }, Date.now() - startTime, {
+                        // Resolve analytics with accumulated token counts so Pipeline A
+                        // and Pipeline B both get real usage data from Ollama.
+                        const aggregatedUsage = {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        };
+                        resolveAnalytics(createAnalytics(this.providerName, this.modelName || FALLBACK_OLLAMA_MODEL, { usage: aggregatedUsage }, Date.now() - startTime, {
                             requestId: `ollama-stream-${Date.now()}`,
                             streamingMode: true,
                             iterations: iteration,
-                            note: "Token usage not available from Ollama streaming responses",
                         }));
+                        // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
+                        // observation. Ollama bypasses the Vercel AI SDK so
+                        // experimental_telemetry is never injected; we emit manually.
+                        const ollamaEmitter = ollamaNeurolink?.getEventEmitter();
+                        if (ollamaEmitter) {
+                            // Collect accumulated text from conversation history
+                            const accumulatedContent = conversationHistory
+                                .filter((m) => m.role === "assistant")
+                                .map((m) => m.content)
+                                .join("");
+                            ollamaEmitter.emit("generation:end", {
+                                provider: ollamaProviderName,
+                                responseTime: Date.now() - startTime,
+                                timestamp: Date.now(),
+                                result: {
+                                    content: accumulatedContent,
+                                    usage: aggregatedUsage,
+                                    model: ollamaModelName,
+                                    provider: ollamaProviderName,
+                                    finishReason: ollamaStreamErrored
+                                        ? "error"
+                                        : (lastFinishReason ?? "stop"),
+                                },
+                                success: !ollamaStreamErrored,
+                            });
+                        }
                     }
                 },
             });
@@ -1075,6 +1127,7 @@ export class OllamaProvider extends BaseProvider {
         let aggregatedContent = "";
         let aggregatedToolCalls = [];
         let finalFinishReason;
+        let finalUsage;
         try {
             while (true) {
                 const { done, value } = await reader.read();
@@ -1092,6 +1145,19 @@ export class OllamaProvider extends BaseProvider {
                         }
                         try {
                             const parsed = JSON.parse(dataLine);
+                            // OpenAI-compatible usage chunk (Ollama may include usage
+                            // in the final chunk when stream_options.include_usage is set,
+                            // or as a standalone chunk with empty choices).
+                            const parsedUsage = parsed.usage;
+                            if (parsedUsage) {
+                                const input = parsedUsage.prompt_tokens ?? 0;
+                                const output = parsedUsage.completion_tokens ?? 0;
+                                finalUsage = {
+                                    input,
+                                    output,
+                                    total: parsedUsage.total_tokens ?? input + output,
+                                };
+                            }
                             const processed = this.processOllamaStreamData(parsed);
                             if (!processed) {
                                 continue;
@@ -1129,6 +1195,7 @@ export class OllamaProvider extends BaseProvider {
             content: aggregatedContent || undefined,
             toolCalls: aggregatedToolCalls.length > 0 ? aggregatedToolCalls : undefined,
             finishReason: finalFinishReason,
+            usage: finalUsage,
         };
     }
     /**
@@ -1413,6 +1480,18 @@ export class OllamaProvider extends BaseProvider {
                 });
             }
         }
+        // Emit tool:end for each completed tool result so Pipeline B
+        // captures telemetry for Ollama-driven tool calls (gap S2).
+        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResultsForStorage.map((tr) => {
+            const hasError = tr.result && typeof tr.result === "object" && "error" in tr.result;
+            return {
+                toolName: tr.toolName,
+                result: tr.result,
+                error: hasError
+                    ? String(tr.result.error)
+                    : undefined,
+            };
+        }));
         // Store tool executions (similar to Bedrock)
         this.handleToolExecutionStorage(toolCallsForStorage, toolResultsForStorage, options, new Date()).catch((error) => {
             logger.warn("[OllamaProvider] Failed to store tool executions", {

package/dist/providers/openAI.d.ts

@@ -42,6 +42,8 @@ export declare class OpenAIProvider extends BaseProvider {
      * Validate tool structure for OpenAI compatibility
      * More lenient validation to avoid filtering out valid tools
      */
+    /** Shared helper: mark a stream span as ERROR, record the exception, and end it. */
+    private endStreamSpanWithError;
     private isValidToolStructure;
     /**
      * Validate tool parameters for OpenAI compatibility

package/dist/providers/openAI.js

@@ -13,6 +13,7 @@ import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/
 import { isZodSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { getModelId } from "./providerTypeUtils.js";
 /**
  * Retrieve a tool's schema, handling both AI SDK v6 (`inputSchema`) and
@@ -154,6 +155,17 @@ export class OpenAIProvider extends BaseProvider {
      * Validate tool structure for OpenAI compatibility
      * More lenient validation to avoid filtering out valid tools
      */
+    /** Shared helper: mark a stream span as ERROR, record the exception, and end it. */
+    endStreamSpanWithError(span, error) {
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: error instanceof Error ? error.message : String(error),
+        });
+        if (error instanceof Error) {
+            span.recordException(error);
+        }
+        span.end();
+    }
     isValidToolStructure(tool) {
         if (!tool || typeof tool !== "object") {
             return false;
@@ -337,6 +349,9 @@ export class OpenAIProvider extends BaseProvider {
                             toolResults,
                             toolCalls,
                         });
+                        // Emit tool:end for each completed tool result so Pipeline B
+                        // captures telemetry for AI-SDK-driven tool calls (gap S2).
+                        emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                         // Handle tool execution storage
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                             logger.warn("[OpenAIProvider] Failed to store tool executions", {
@@ -348,7 +363,7 @@ export class OpenAIProvider extends BaseProvider {
                 });
             }
             catch (streamError) {
-                streamSpan.end();
+                this.endStreamSpanWithError(streamSpan, streamError);
                 throw streamError;
             }
             // Collect token usage and finish reason asynchronously when the stream completes,
@@ -381,11 +396,7 @@ export class OpenAIProvider extends BaseProvider {
                 streamSpan.end();
             })
                 .catch((err) => {
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: err instanceof Error ? err.message : String(err),
-                });
-                streamSpan.end();
+                this.endStreamSpanWithError(streamSpan, err);
             });
             timeoutController?.cleanup();
             // Debug the actual result structure

package/dist/providers/openRouter.js

@@ -6,6 +6,7 @@ import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { isAbortError } from "../utils/errorHandling.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -273,6 +274,7 @@ export class OpenRouterProvider extends BaseProvider {
                     chunkCount++;
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
                     logger.info("Tool execution completed", {
                         toolCallCount: toolCalls?.length || 0,
                         toolResultCount: toolResults?.length || 0,

package/dist/providers/openaiCompatible.js

@@ -4,6 +4,7 @@ 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 { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -197,6 +198,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), event.toolResults);
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {
                             provider: this.providerName,

package/dist/providers/sagemaker/detection.d.ts

@@ -4,38 +4,7 @@
  * This module provides intelligent detection of SageMaker endpoint capabilities
  * including model type identification and streaming protocol support.
  */
-import type { SageMakerConfig, SageMakerModelConfig, StreamingCapability } from "../../types/index.js";
-/**
- * Model type detection result
- */
-type ModelDetectionResult = {
-    /** Primary model type */
-    type: StreamingCapability["modelType"];
-    /** Detection confidence (0-1) */
-    confidence: number;
-    /** Evidence used for detection */
-    evidence: string[];
-    /** Suggested configuration */
-    suggestedConfig?: Partial<SageMakerModelConfig>;
-};
-/**
- * Endpoint health and metadata information
- */
-type EndpointHealth = {
-    /** Health status */
-    status: "healthy" | "unhealthy" | "unknown";
-    /** Response time in milliseconds */
-    responseTime: number;
-    /** Endpoint metadata if available */
-    metadata?: Record<string, unknown>;
-    /** Model information if discoverable */
-    modelInfo?: {
-        name?: string;
-        version?: string;
-        framework?: string;
-        architecture?: string;
-    };
-};
+import type { EndpointHealth, ModelDetectionResult, SageMakerConfig, StreamingCapability } from "../../types/index.js";
 /**
  * SageMaker Model Detection and Capability Discovery Service
  */
@@ -150,4 +119,3 @@ export declare class SageMakerDetector {
  * Create a detector instance with configuration
  */
 export declare function createSageMakerDetector(config: SageMakerConfig): SageMakerDetector;
-export {};

package/dist/providers/sagemaker/diagnostics.d.ts

@@ -3,30 +3,7 @@
  *
  * Provides basic diagnostic functions for SageMaker configuration and connectivity.
  */
-/**
- * Simple diagnostic result interface
- */
-type DiagnosticResult = {
-    name: string;
-    category: "configuration" | "connectivity" | "streaming";
-    status: "pass" | "fail" | "warning";
-    message: string;
-    details?: string;
-    recommendation?: string;
-};
-/**
- * Diagnostic report interface
- */
-type DiagnosticReport = {
-    overallStatus: "healthy" | "issues" | "critical";
-    results: DiagnosticResult[];
-    summary: {
-        total: number;
-        passed: number;
-        failed: number;
-        warnings: number;
-    };
-};
+import type { DiagnosticReport } from "../../types/index.js";
 /**
  * Run quick diagnostics for SageMaker configuration
  */
@@ -35,4 +12,3 @@ export declare function runQuickDiagnostics(endpoint?: string): Promise<Diagnost
  * Format diagnostic report for console output
  */
 export declare function formatDiagnosticReport(report: DiagnosticReport): string;
-export {};

package/dist/providers/sagemaker/language-model.d.ts

@@ -4,7 +4,7 @@
  * This module implements the LanguageModel interface for Amazon SageMaker
  * integration with the Vercel AI SDK.
  */
-import type { SageMakerAsLanguageModel, SageMakerConfig, SageMakerModelConfig, ConnectivityResult } from "../../types/index.js";
+import type { ConnectivityResult, SageMakerAsLanguageModel, SageMakerConfig, SageMakerModelConfig } from "../../types/index.js";
 /**
  * SageMaker Language Model implementing LanguageModel interface
  *

package/dist/proxy/proxyConfig.js

@@ -136,6 +136,10 @@ function failOnUnresolvedAccountCredentials(obj) {
             "Set the required environment variables or provide defaults with ${VAR:-default}.");
     }
 }
+// ---------------------------------------------------------------------------
+// YAML parsing (dynamic import with fallback)
+// ---------------------------------------------------------------------------
+/** Shape of the dynamically-imported `js-yaml` module. */
 /**
  * Parse YAML content into a JS object.
  * Uses `js-yaml` if available (dynamic import), otherwise falls back to

package/dist/proxy/proxyEnv.d.ts

@@ -1,19 +1,3 @@
-type ProxyEnvSource = "cli" | "environment" | "default" | "none";
-type ProxyEnvResolution = {
-    path?: string;
-    source: ProxyEnvSource;
-    required: boolean;
-};
-type ProxyEnvLoadResult = {
-    loaded: boolean;
-    path?: string;
-    source: ProxyEnvSource;
-};
-type ProxyEnvOptions = {
-    explicitEnvFile?: string;
-    env?: NodeJS.ProcessEnv;
-    homeDir?: string;
-};
+import type { ProxyEnvLoadResult, ProxyEnvOptions, ProxyEnvResolution } from "../types/index.js";
 export declare function resolveProxyEnvFile(options?: ProxyEnvOptions): ProxyEnvResolution;
 export declare function loadProxyEnvFile(options?: ProxyEnvOptions): Promise<ProxyEnvLoadResult>;
-export {};

package/dist/proxy/proxyHealth.d.ts

@@ -1,5 +1,4 @@
 import type { ProxyHealthResponse, ProxyReadinessState } from "../types/index.js";
-export type { ProxyHealthResponse, ProxyReadinessState };
 export declare function createProxyReadinessState(startTimeMs?: number): ProxyReadinessState;
 export declare function markProxyReady(state: ProxyReadinessState, readyAtMs?: number): void;
 export declare function buildProxyHealthResponse(state: ProxyReadinessState, options: {

package/dist/proxy/proxyTracer.d.ts

@@ -14,42 +14,7 @@
  * - TelemetryService for metrics recording
  */
 import { type Span } from "@opentelemetry/api";
-type ProxyRequestContext = {
-    requestId: string;
-    method: string;
-    path: string;
-    model: string;
-    stream: boolean;
-    toolCount: number;
-    sessionId?: string;
-    userAgent?: string;
-    clientApp?: string;
-};
-type AccountSelectionContext = {
-    strategy: string;
-    accountsTotal: number;
-    accountsHealthy: number;
-    selectedAccount: string;
-    accountType: string;
-    rateLimitBefore5h?: number;
-    rateLimitBefore7d?: number;
-};
-type UpstreamAttemptContext = {
-    attempt: number;
-    account: string;
-    polyfillHeaders: boolean;
-    polyfillBody: boolean;
-    upstreamUrl: string;
-};
-type UsageContext = {
-    inputTokens: number;
-    outputTokens: number;
-    cacheCreationTokens: number;
-    cacheReadTokens: number;
-    reasoningTokens?: number;
-    rateLimitAfter5h?: number;
-    rateLimitAfter7d?: number;
-};
+import type { AccountSelectionContext, ProxyRequestContext, UpstreamAttemptContext, UsageContext } from "../types/index.js";
 declare class ProxyTracer {
     private readonly rootSpan;
     private readonly proxyTracer;

package/dist/proxy/proxyTracer.js

@@ -20,6 +20,15 @@ import { calculateCost } from "../utils/pricing.js";
 import { TelemetryService } from "../telemetry/telemetryService.js";
 import { logger } from "../utils/logger.js";
 const LOG_PREFIX = "[ProxyTracer]";
+// ---------------------------------------------------------------------------
+// OTEL Metric Instruments — lazy singleton
+//
+// The MeterProvider is registered in initializeOpenTelemetry() which runs
+// *after* module import time.  @opentelemetry/api v1.x getMeter() returns a
+// NoopMeter if called before a real MeterProvider is set.  We therefore
+// defer instrument creation until the first ProxyTracer.end() call, at which
+// point the MeterProvider is guaranteed to be registered.
+// ---------------------------------------------------------------------------
 let _metrics = null;
 function getProxyMetrics() {
     if (_metrics) {

package/dist/proxy/quietDetector.d.ts

@@ -4,12 +4,7 @@
  * threshold by efficiently reading only the tail of today's debug log file.
  * Used by the auto-update system to find safe windows for restarts.
  */
-/** Result of a traffic-quiet check. */
-type QuietStatus = {
-    isQuiet: boolean;
-    lastActivityAt: Date | null;
-    silenceDurationMs: number;
-};
+import type { QuietStatus } from "../types/index.js";
 /**
  * Check whether proxy traffic has been quiet (no requests) for at least
  * `quietThresholdMs` milliseconds.
@@ -20,4 +15,3 @@ type QuietStatus = {
  * @returns QuietStatus with the idle analysis.
  */
 export declare function checkTrafficQuiet(quietThresholdMs?: number): QuietStatus;
-export {};

package/dist/proxy/rawStreamCapture.d.ts

@@ -1,11 +1,2 @@
-type RawStreamCapture = {
-    totalBytes: number;
-    text: string;
-    truncated: boolean;
-};
-type RawStreamCaptureResult = {
-    stream: TransformStream<Uint8Array, Uint8Array>;
-    capture: Promise<RawStreamCapture>;
-};
+import type { RawStreamCaptureResult } from "../types/index.js";
 export declare function createRawStreamCapture(): RawStreamCaptureResult;
-export {};

package/dist/proxy/requestLogger.d.ts

@@ -5,7 +5,7 @@
  * when a LoggerProvider is configured via OpenTelemetry instrumentation.
  * Useful for debugging and auditing proxy traffic.
  */
-import type { RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
+import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
 export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
 /**
@@ -15,25 +15,6 @@ export declare function logRequest(entry: RequestLogEntry): Promise<void>;
  */
 export declare function logRequestAttempt(entry: RequestAttemptLogEntry): Promise<void>;
 export declare function getLogDir(): string | null;
-type ProxyBodyCaptureEntry = {
-    timestamp: string;
-    requestId: string;
-    phase: string;
-    model: string;
-    stream: boolean;
-    headers?: Record<string, string>;
-    body?: unknown;
-    bodySize?: number;
-    contentType?: string;
-    responseStatus?: number;
-    durationMs?: number;
-    account?: string;
-    accountType?: string;
-    attempt?: number;
-    traceId?: string;
-    spanId?: string;
-    metadata?: Record<string, unknown>;
-};
 export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;
 /**
  * Log the FULL raw request and response for debugging.
@@ -74,4 +55,3 @@ export declare function logStreamError(entry: {
  * Non-fatal — proxy keeps working even if cleanup fails.
  */
 export declare function cleanupLogs(maxAgeDays?: number, maxSizeMb?: number): void;
-export {};

package/dist/proxy/routingPolicy.d.ts

@@ -1,5 +1,4 @@
-import type { ClaudeProxyModelTier, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan } from "../types/index.js";
-export type { ClaudeProxyModelTier, ProxyTranslationAttempt, ProxyTranslationPlan, };
+import type { ClaudeProxyModelTier, FallbackEntry, ParsedClaudeRequest, ProxyTranslationPlan } from "../types/index.js";
 export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
 /**
  * Build a translation plan for a Claude-compatible proxy request.

package/dist/proxy/sseInterceptor.d.ts

@@ -15,71 +15,7 @@
  *   upstreamResponse.body.pipeThrough(stream).pipeTo(clientWritable);
  *   const data = await telemetry; // resolves on stream end
  */
-type SSEContentBlock = {
-    index: number;
-    type: "text" | "thinking" | "tool_use" | "tool_result";
-    /** Accumulated text for text blocks. Capped at MAX_BLOCK_CONTENT_BYTES. */
-    text?: string;
-    /** Accumulated thinking content. Capped at MAX_BLOCK_CONTENT_BYTES. */
-    thinking?: string;
-    /** Tool name for tool_use blocks. */
-    toolName?: string;
-    /** Tool call id for tool_use blocks. */
-    toolId?: string;
-    /** Accumulated partial JSON input for tool_use blocks. Capped at MAX_BLOCK_CONTENT_BYTES. */
-    toolInput?: string;
-};
-type SSETelemetry = {
-    /** Message id from message_start. */
-    messageId: string;
-    /** Model string from message_start. */
-    model: string;
-    /** Token usage aggregated from message_start + message_delta. */
-    usage: {
-        inputTokens: number;
-        outputTokens: number;
-        cacheCreationInputTokens: number;
-        cacheReadInputTokens: number;
-        totalTokens: number;
-    };
-    /** All content blocks accumulated during the stream. */
-    contentBlocks: SSEContentBlock[];
-    /** Stop reason from message_delta, e.g. "end_turn". */
-    stopReason: string | null;
-    /** Stop sequence from message_delta, if any. */
-    stopSequence: string | null;
-    /** Total number of SSE events observed. */
-    eventCount: number;
-    /** Wall-clock duration from first byte to stream end (ms). */
-    streamDurationMs: number;
-    /** Total bytes received from upstream (raw SSE stream size). */
-    totalBytesReceived: number;
-    /**
-     * Raw SSE event log. For content_block_delta events only the type is
-     * stored (not the full data payload) to avoid excessive memory use.
-     * All other events store the full data string.
-     */
-    events: Array<{
-        type: string;
-        timestamp: number;
-        data: string;
-    }>;
-    /** Full raw SSE transcript, when captureRawText is enabled. */
-    rawText?: string;
-};
-type SSEInterceptorResult = {
-    /** Pipe the upstream response through this stream. */
-    stream: TransformStream<Uint8Array, Uint8Array>;
-    /**
-     * Resolves with the accumulated telemetry when the stream finishes.
-     * If the stream errors, the promise resolves with whatever telemetry
-     * was gathered up to that point (never rejects).
-     */
-    telemetry: Promise<SSETelemetry>;
-};
-type SSEInterceptorOptions = {
-    captureRawText?: boolean;
-};
+import type { SSEInterceptorOptions, SSEInterceptorResult } from "../types/index.js";
 /**
  * Create an SSE interceptor that extracts telemetry from an Anthropic
  * streaming response while passing all bytes through unmodified.
@@ -95,4 +31,3 @@ type SSEInterceptorOptions = {
  * ```
  */
 export declare function createSSEInterceptor(options?: SSEInterceptorOptions): SSEInterceptorResult;
-export {};