@juspay/neurolink 11.12.0 → 11.13.1

package/dist/proxy/proxyTracer.js

@@ -191,16 +191,28 @@ class ProxyTracer {
     proxyTracer = getTracer("neurolink.proxy");
     bridge = new OtelBridge();
     requestId;
+    /**
+     * Model used for costing. Starts as the model the client asked for and is
+     * updated by setModelSubstitution(), so cost follows the model that actually
+     * served the request rather than the one that was requested.
+     */
     model;
+    /**
+     * Provider used for costing. See ProxyRequestContext.provider. Mutable for
+     * the same reason `model` is: a fallback can serve the request from a
+     * different provider, and pricing has to follow it.
+     */
+    billingProvider;
     startTime;
     isStream;
     accountEmail;
     usage;
     mode = "full";
-    constructor(rootSpan, requestId, model, stream) {
+    constructor(rootSpan, requestId, model, stream, billingProvider) {
         this.rootSpan = rootSpan;
         this.requestId = requestId;
         this.model = model;
+        this.billingProvider = billingProvider;
         this.startTime = Date.now();
         this.isStream = stream;
     }
@@ -257,7 +269,7 @@ class ProxyTracer {
         if (nlConversationId) {
             rootSpan.setAttribute("neurolink.conversation_id", nlConversationId);
         }
-        const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream);
+        const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream, ctx.provider ?? "anthropic");
         // Set Langfuse context (fire-and-forget — non-blocking)
         // Prefer NeuroLink session/user from calling SDK over Claude Code session
         setLangfuseContext({
@@ -370,7 +382,7 @@ class ProxyTracer {
             "gen_ai.usage.total_tokens": totalTokens,
         });
         // Cost calculation via pricing.ts
-        const cost = calculateCost("anthropic", this.model, {
+        const cost = calculateCost(this.billingProvider, this.model, {
             input: ctx.inputTokens,
             output: ctx.outputTokens,
             total: totalTokens,
@@ -433,12 +445,22 @@ class ProxyTracer {
      * Record that the proxy substituted a different model than was requested.
      * Sets span attributes and increments the substitution metric counter.
      */
-    setModelSubstitution(requestedModel, actualModel) {
+    setModelSubstitution(requestedModel, actualModel, actualProvider) {
+        // Cost must follow the model that served the request, not the alias the
+        // client typed — otherwise a claude-* alias routed to another provider is
+        // billed at Claude rates. The provider has to move with it: leaving it at
+        // the tracer's default means the substituted model is looked up in the
+        // wrong pricing table, which yields no rate and so no charge at all.
+        this.model = actualModel;
+        if (actualProvider) {
+            this.billingProvider = actualProvider;
+        }
         this.rootSpan.setAttributes({
             "proxy.model_substituted": true,
             "proxy.original_model": requestedModel,
             "proxy.actual_model": actualModel,
             "gen_ai.response.model": actualModel,
+            ...(actualProvider ? { "proxy.actual_provider": actualProvider } : {}),
         });
         const m = getProxyMetrics();
         m.modelSubstitutionTotal.add(1, {
@@ -644,7 +666,7 @@ class ProxyTracer {
                 this.usage.cacheCreationTokens +
                 this.usage.cacheReadTokens +
                 (this.usage.reasoningTokens ?? 0);
-            const cost = calculateCost("anthropic", this.model, {
+            const cost = calculateCost(this.billingProvider, this.model, {
                 input: this.usage.inputTokens,
                 output: this.usage.outputTokens,
                 total: totalTokens,
@@ -683,14 +705,14 @@ class ProxyTracer {
             this.usage.cacheReadTokens +
             (this.usage.reasoningTokens ?? 0);
         const durationMs = Date.now() - this.startTime;
-        const cost = calculateCost("anthropic", this.model, {
+        const cost = calculateCost(this.billingProvider, this.model, {
             input: this.usage.inputTokens,
             output: this.usage.outputTokens,
             total: totalTokens,
             cacheCreationTokens: this.usage.cacheCreationTokens,
             cacheReadTokens: this.usage.cacheReadTokens,
         });
-        TelemetryService.getInstance().recordAIRequest("anthropic", this.model, totalTokens, durationMs, cost > 0 ? cost : undefined);
+        TelemetryService.getInstance().recordAIRequest(this.billingProvider, this.model, totalTokens, durationMs, cost > 0 ? cost : undefined);
     }
     // -------------------------------------------------------------------------
     // Context propagation

package/dist/proxy/proxyTranslationEngine.js

@@ -249,6 +249,8 @@ export async function handleTranslatedStreamRequest(args) {
     let succeeded = false;
     let streamInterruptedAfterOutput = false;
     let translatedModel;
+    /** Provider that actually served the successful attempt, for costing. */
+    let translatedProvider;
     let finalStreamError = "No translation providers succeeded";
     let upstreamIterator;
     let lastAttemptLabel = "translation";
@@ -328,6 +330,19 @@ export async function handleTranslatedStreamRequest(args) {
                                 controller.enqueue(encoder.encode(frame));
                             }
                         }
+                        translatedModel = streamResult.model;
+                        translatedProvider = attempt.provider;
+                        // Substitution BEFORE usage: setUsage() and recordMetrics() price
+                        // the request immediately, against the tracer's current model and
+                        // billing provider. Recording first and substituting afterwards
+                        // bills the model the client ASKED for — which is exactly what
+                        // ProxyTracer.setModelSubstitution() documents as wrong, since a
+                        // claude-* alias served by another provider would be charged at
+                        // Claude rates. The finally block below still calls it, harmlessly,
+                        // for paths that never reach here.
+                        if (tracer && translatedModel && translatedModel !== requestModel) {
+                            tracer.setModelSubstitution(requestModel, translatedModel, translatedProvider);
+                        }
                         // Track usage and metrics
                         const resolvedUsageForTracer = extractUsageFromStreamResult(streamResult.usage);
                         tracer?.setUsage({
@@ -337,7 +352,6 @@ export async function handleTranslatedStreamRequest(args) {
                             cacheReadTokens: 0,
                         });
                         tracer?.recordMetrics();
-                        translatedModel = streamResult.model;
                         succeeded = true;
                         return;
                     }
@@ -378,7 +392,7 @@ export async function handleTranslatedStreamRequest(args) {
                     controller.close();
                 }
                 if (tracer && translatedModel && translatedModel !== requestModel) {
-                    tracer.setModelSubstitution(requestModel, translatedModel);
+                    tracer.setModelSubstitution(requestModel, translatedModel, translatedProvider);
                 }
                 const terminalStatus = cancelled
                     ? 499
@@ -499,6 +513,12 @@ export async function handleTranslatedJsonRequest(args) {
                     : undefined,
                 toolCalls: streamResult.toolCalls,
             };
+            // Substitution BEFORE usage — see the streaming path for why: pricing
+            // happens inside setUsage()/recordMetrics(), so substituting afterwards
+            // bills the requested model instead of the one that served.
+            if (tracer && streamResult.model && streamResult.model !== requestModel) {
+                tracer.setModelSubstitution(requestModel, streamResult.model, attempt.provider);
+            }
             // Track usage and metrics
             const resolvedUsage = extractUsageFromStreamResult(streamResult.usage);
             tracer?.setUsage({
@@ -508,9 +528,6 @@ export async function handleTranslatedJsonRequest(args) {
                 cacheReadTokens: 0,
             });
             tracer?.recordMetrics();
-            if (tracer && streamResult.model && streamResult.model !== requestModel) {
-                tracer.setModelSubstitution(requestModel, streamResult.model);
-            }
             tracer?.end(200, Date.now() - requestStartTime);
             recordFinalSuccess(lastAttemptLabel, "translation");
             const traceCtx = tracer?.getTraceContext();

package/dist/rag/document/loaders.js

@@ -227,55 +227,83 @@ export class PDFLoader {
             source,
             pageRange: options?.pageRange,
         });
+        let PDFParse;
         try {
-            // Try to use pdf-parse if available
-            const pdfParse = await this.loadPdfParser();
-            const buffer = await readFile(source);
-            const data = await pdfParse(buffer);
+            PDFParse = await this.loadPdfParser();
+        }
+        catch (error) {
+            // pdf-parse genuinely isn't installed / doesn't expose a usable
+            // export — degrade gracefully rather than throwing.
+            logger.warn("[PDFLoader] pdf-parse not available, using fallback", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return new MDocument(`[PDF Document: ${basename(source)}]\n\nNote: PDF parsing requires the 'pdf-parse' package. Install it with:\n  npm install pdf-parse`, {
+                type: "pdf",
+                metadata: {
+                    source: basename(source),
+                    parseError: "pdf-parse not available",
+                    ...options?.metadata,
+                },
+            });
+        }
+        const buffer = await readFile(source);
+        const parser = new PDFParse({ data: buffer });
+        try {
+            const data = await parser.getText();
             const text = data.text;
             // Handle page range if specified
             if (options?.pageRange) {
-                const _pages = this.parsePageRange(options.pageRange, data.numpages);
+                const _pages = this.parsePageRange(options.pageRange, data.total);
                 // Note: pdf-parse doesn't support page selection directly
                 // This is a placeholder for more sophisticated page handling
                 logger.debug("[PDFLoader] Page range requested but not fully supported", {
                     pageRange: options.pageRange,
-                    totalPages: data.numpages,
+                    totalPages: data.total,
                 });
             }
             return new MDocument(text, {
                 type: "pdf",
                 metadata: {
                     source: basename(source),
-                    pageCount: data.numpages,
-                    info: data.info,
+                    pageCount: data.total,
                     ...options?.metadata,
                 },
             });
         }
         catch (error) {
-            // Fallback: Return placeholder document
-            logger.warn("[PDFLoader] pdf-parse not available, using fallback", {
-                error: error instanceof Error ? error.message : String(error),
+            // pdf-parse IS installed and loaded fine, but failed on this
+            // specific file (corrupt PDF, password-protected, unsupported
+            // structure, etc.). Keep this distinct from the "not installed"
+            // fallback above — both surface as a placeholder document, but the
+            // message, parseError value, and log level differ so a genuine
+            // parse failure is never mistaken for a missing dependency.
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error("[PDFLoader] pdf-parse failed to parse PDF", {
+                source,
+                error: message,
             });
-            return new MDocument(`[PDF Document: ${basename(source)}]\n\nNote: PDF parsing requires the 'pdf-parse' package. Install it with:\n  npm install pdf-parse`, {
+            return new MDocument(`[PDF Document: ${basename(source)}]\n\nNote: PDF parsing failed for this file: ${message}`, {
                 type: "pdf",
                 metadata: {
                     source: basename(source),
-                    parseError: "pdf-parse not available",
+                    parseError: `pdf-parse failed: ${message}`,
                     ...options?.metadata,
                 },
             });
         }
+        finally {
+            await parser.destroy();
+        }
     }
     canHandle(source) {
         const ext = extname(source).toLowerCase();
         return ext === ".pdf";
     }
     async loadPdfParser() {
-        // pdf-parse is an optional dependency — resolve it dynamically and
-        // validate at runtime that it exposes a callable parser (either the
-        // module itself or its default export) instead of blindly asserting.
+        // pdf-parse v2 exports a `PDFParse` class (`new PDFParse({ data }).getText()`)
+        // instead of v1's bare callable — resolve it dynamically and validate at
+        // runtime that the export shape is actually present instead of blindly
+        // asserting.
         let pdfParseModule;
         try {
             pdfParseModule = await import("pdf-parse");
@@ -283,15 +311,15 @@ export class PDFLoader {
         catch {
             throw new Error("pdf-parse module not available");
         }
-        const candidate = (typeof pdfParseModule === "object" &&
+        const candidate = typeof pdfParseModule === "object" &&
             pdfParseModule !== null &&
-            "default" in pdfParseModule
-            ? pdfParseModule.default
-            : undefined) || pdfParseModule;
+            "PDFParse" in pdfParseModule
+            ? pdfParseModule.PDFParse
+            : undefined;
         if (typeof candidate !== "function") {
             // Outside the try/catch so this message isn't swallowed by the
             // module-not-available rethrow.
-            throw new Error("pdf-parse module does not export a parse function");
+            throw new Error("pdf-parse module does not export a PDFParse class");
         }
         return candidate;
     }

package/dist/server/abstract/baseServerAdapter.d.ts

@@ -65,6 +65,19 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
      * Called when drain timeout expires and forceClose is true
      */
     protected abstract forceCloseConnections(): Promise<void>;
+    /**
+     * Import an optional framework dependency (express/fastify/koa and their
+     * plugins), converting a missing package into a {@link MissingDependencyError}
+     * instead of letting the framework's `Cannot find package` propagate raw.
+     *
+     * Delegates to {@link tryImport} for the actual resolution and message
+     * formatting, then re-wraps only the "package genuinely absent" case — the
+     * one `tryImport` signals by attaching the loader's own module-not-found
+     * error as `cause` — into the adapter-specific error type. Any other
+     * failure (installed but broken, non-package specifier) passes through
+     * unchanged, matching `tryImport`'s own contract.
+     */
+    protected importFrameworkDependency<T>(pkg: string, framework: string): Promise<T>;
     /**
      * Initialize the server adapter
      * Sets up routes, middleware, and framework

package/dist/server/abstract/baseServerAdapter.js

@@ -7,7 +7,8 @@ import { EventEmitter } from "events";
 import { getMetricsAggregator, SpanSerializer, SpanStatus, SpanType, } from "../../observability/index.js";
 import { withTimeout } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
-import { DrainTimeoutError, InvalidLifecycleStateError, ShutdownTimeoutError, } from "../errors.js";
+import { tryImport } from "../../utils/tryImport.js";
+import { DrainTimeoutError, InvalidLifecycleStateError, MissingDependencyError, ShutdownTimeoutError, } from "../errors.js";
 /**
  * Abstract base class for server adapters
  * Provides common functionality and defines the interface for framework-specific implementations
@@ -94,6 +95,29 @@ export class BaseServerAdapter extends EventEmitter {
     // ============================================
     // Common Methods (Shared Implementation)
     // ============================================
+    /**
+     * Import an optional framework dependency (express/fastify/koa and their
+     * plugins), converting a missing package into a {@link MissingDependencyError}
+     * instead of letting the framework's `Cannot find package` propagate raw.
+     *
+     * Delegates to {@link tryImport} for the actual resolution and message
+     * formatting, then re-wraps only the "package genuinely absent" case — the
+     * one `tryImport` signals by attaching the loader's own module-not-found
+     * error as `cause` — into the adapter-specific error type. Any other
+     * failure (installed but broken, non-package specifier) passes through
+     * unchanged, matching `tryImport`'s own contract.
+     */
+    async importFrameworkDependency(pkg, framework) {
+        try {
+            return await tryImport(pkg, `${framework} server adapter`);
+        }
+        catch (error) {
+            if (error instanceof Error && isModuleNotFoundCause(error.cause)) {
+                throw new MissingDependencyError(pkg, framework, `pnpm add ${pkg}`);
+            }
+            throw error;
+        }
+    }
     /**
      * Initialize the server adapter
      * Sets up routes, middleware, and framework
@@ -572,3 +596,17 @@ export class BaseServerAdapter extends EventEmitter {
         return { ...this.config };
     }
 }
+/**
+ * True when `cause` is the module loader's own "package not found" error —
+ * the shape `tryImport` attaches as `cause` exactly when it decides the
+ * package is genuinely missing (see `isMissingModule` in `tryImport.ts`).
+ * Anything else (installed-but-broken, no cause at all) is not our case to
+ * convert into a {@link MissingDependencyError}.
+ */
+function isModuleNotFoundCause(cause) {
+    if (!(cause instanceof Error)) {
+        return false;
+    }
+    const code = cause.code;
+    return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+}

package/dist/server/adapters/expressAdapter.js

@@ -32,7 +32,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
             return;
         }
         // Dynamic import to avoid loading if not used (ESM-compatible)
-        const expressModule = await import("express");
+        const expressModule = await this.importFrameworkDependency("express", "Express");
         const express = expressModule.default;
         this.app = express();
         // Body parsing
@@ -45,7 +45,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
         }
         // CORS
         if (this.config.cors.enabled) {
-            const corsModule = await import("cors");
+            const corsModule = await this.importFrameworkDependency("cors", "Express");
             const cors = corsModule.default;
             this.app.use(cors({
                 origin: this.config.cors.origins,
@@ -57,7 +57,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
         }
         // Rate limiting
         if (this.config.rateLimit.enabled) {
-            const rateLimitModule = await import("express-rate-limit");
+            const rateLimitModule = await this.importFrameworkDependency("express-rate-limit", "Express");
             const rateLimit = rateLimitModule.default;
             const windowMs = this.config.rateLimit.windowMs;
             const limiter = rateLimit({
@@ -118,8 +118,18 @@ export class ExpressServerAdapter extends BaseServerAdapter {
      * Override initialize to ensure async framework setup
      */
     async initialize() {
-        // Initialize Express asynchronously first
-        await this.initializeFrameworkAsync();
+        // Initialize Express asynchronously first. This runs before
+        // super.initialize()'s try/catch even starts, so a failure here (e.g. the
+        // "express" package is not installed) must be caught here too — otherwise
+        // it propagates with lifecycleState left at "uninitialized" instead of
+        // "error".
+        try {
+            await this.initializeFrameworkAsync();
+        }
+        catch (error) {
+            this.lifecycleState = "error";
+            throw error;
+        }
         // Then call base class initialize
         await super.initialize();
     }

package/dist/server/adapters/fastifyAdapter.js

@@ -34,7 +34,7 @@ export class FastifyServerAdapter extends BaseServerAdapter {
             return;
         }
         // Dynamic import to avoid loading if not used
-        const fastifyModule = await import("fastify");
+        const fastifyModule = await this.importFrameworkDependency("fastify", "Fastify");
         const Fastify = fastifyModule.default;
         this.app = Fastify({
             logger: this.config.logging.enabled
@@ -48,7 +48,7 @@ export class FastifyServerAdapter extends BaseServerAdapter {
         });
         // Register CORS plugin if enabled
         if (this.config.cors.enabled) {
-            const corsModule = await import("@fastify/cors");
+            const corsModule = await this.importFrameworkDependency("@fastify/cors", "Fastify");
             await this.app.register(corsModule.default, {
                 origin: this.config.cors.origins,
                 methods: this.config.cors.methods,
@@ -59,7 +59,7 @@ export class FastifyServerAdapter extends BaseServerAdapter {
         }
         // Register rate limiting plugin if enabled
         if (this.config.rateLimit.enabled) {
-            const rateLimitModule = await import("@fastify/rate-limit");
+            const rateLimitModule = await this.importFrameworkDependency("@fastify/rate-limit", "Fastify");
             const windowMs = this.config.rateLimit.windowMs;
             await this.app.register(rateLimitModule.default, {
                 max: this.config.rateLimit.maxRequests,
@@ -166,8 +166,18 @@ export class FastifyServerAdapter extends BaseServerAdapter {
      * Override initialize to ensure async framework setup
      */
     async initialize() {
-        // Initialize Fastify asynchronously first
-        await this.initializeFrameworkAsync();
+        // Initialize Fastify asynchronously first. This runs before
+        // super.initialize()'s try/catch even starts, so a failure here (e.g. the
+        // "fastify" package is not installed) must be caught here too — otherwise
+        // it propagates with lifecycleState left at "uninitialized" instead of
+        // "error".
+        try {
+            await this.initializeFrameworkAsync();
+        }
+        catch (error) {
+            this.lifecycleState = "error";
+            throw error;
+        }
         // Then call base class initialize
         await super.initialize();
     }

package/dist/server/adapters/koaAdapter.js

@@ -38,8 +38,8 @@ export class KoaServerAdapter extends BaseServerAdapter {
             return;
         }
         // Dynamic imports to avoid loading if not used
-        const KoaModule = await import("koa");
-        const RouterModule = await import("@koa/router");
+        const KoaModule = await this.importFrameworkDependency("koa", "Koa");
+        const RouterModule = await this.importFrameworkDependency("@koa/router", "Koa");
         const Koa = KoaModule.default;
         const Router = RouterModule.default;
         this.app = new Koa();
@@ -85,7 +85,7 @@ export class KoaServerAdapter extends BaseServerAdapter {
         });
         // CORS middleware
         if (this.config.cors.enabled) {
-            const corsModule = await import("@koa/cors");
+            const corsModule = await this.importFrameworkDependency("@koa/cors", "Koa");
             const cors = corsModule.default;
             this.app.use(cors({
                 origin: (ctx) => {
@@ -103,7 +103,7 @@ export class KoaServerAdapter extends BaseServerAdapter {
         }
         // Body parsing middleware
         if (this.config.bodyParser.enabled) {
-            const bodyParserModule = await import("koa-bodyparser");
+            const bodyParserModule = await this.importFrameworkDependency("koa-bodyparser", "Koa");
             const bodyParser = bodyParserModule.default;
             this.app.use(bodyParser({
                 jsonLimit: this.config.bodyParser.jsonLimit,
@@ -200,8 +200,18 @@ export class KoaServerAdapter extends BaseServerAdapter {
      * Override initialize to ensure async framework setup
      */
     async initialize() {
-        // Initialize Koa asynchronously first
-        await this.initializeFrameworkAsync();
+        // Initialize Koa asynchronously first. This runs before
+        // super.initialize()'s try/catch even starts, so a failure here (e.g. the
+        // "koa" package is not installed) must be caught here too — otherwise it
+        // propagates with lifecycleState left at "uninitialized" instead of
+        // "error".
+        try {
+            await this.initializeFrameworkAsync();
+        }
+        catch (error) {
+            this.lifecycleState = "error";
+            throw error;
+        }
         // Then call base class initialize
         await super.initialize();
     }

package/dist/server/routes/codexProxyRoutes.js

@@ -21,6 +21,7 @@ import { tokenStore } from "../../auth/tokenStore.js";
 import { CODEX_ORIGINATOR, CODEX_RESPONSES_URL, CODEX_USER_AGENT, codexTokenNeedsRefresh, isPermanentCodexRefreshFailure, refreshCodexToken, resolveCodexAccountId, } from "../../auth/codexOAuth.js";
 import { clearAccountCooldown, loadAccountCooldowns, saveAccountCooldown, } from "../../proxy/accountCooldown.js";
 import { loadAccountQuotas, saveAccountQuota, } from "../../proxy/accountQuota.js";
+import { createCodexUsageTap } from "../../proxy/codexUsage.js";
 import { CODEX_ACCOUNT_PREFIX, parseCodexRateLimitHeaders, } from "../../proxy/codexAccountUsage.js";
 import { logRequest } from "../../proxy/requestLogger.js";
 import { parseRetryAfterMs } from "../../proxy/routingPolicy.js";
@@ -340,7 +341,34 @@ async function handleCodexResponsesRequest(ctx) {
                     connection: "keep-alive",
                     ...(ctx.responseHeaders ?? {}),
                 };
-                return new Response(upstream.body, {
+                // Tap the relay for token usage. The log above is written first and
+                // unconditionally so a request is never lost when a client hangs up
+                // mid-stream; this emits a second record for the same requestId
+                // carrying the counts, which proxyAnalysis merges. If the stream shape
+                // is not recognised, usage resolves null and nothing extra is written —
+                // i.e. exactly the previous behaviour.
+                if (!upstream.body) {
+                    return new Response(upstream.body, {
+                        status: upstream.status,
+                        headers,
+                    });
+                }
+                const { stream: usageTap, usage: usageSeen } = createCodexUsageTap();
+                usageSeen
+                    .then((usage) => {
+                    if (!usage) {
+                        return;
+                    }
+                    return writeLog(account.label, upstream.status, {
+                        provider: "openai",
+                        inputTokens: usage.inputTokens,
+                        outputTokens: usage.outputTokens,
+                        cacheReadTokens: usage.cacheReadTokens,
+                        cacheCreationTokens: usage.cacheCreationTokens,
+                    });
+                })
+                    .catch(() => undefined);
+                return new Response(upstream.body.pipeThrough(usageTap), {
                     status: upstream.status,
                     headers,
                 });

package/dist/server/routes/openaiProxyRoutes.js

@@ -335,6 +335,11 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                             toolCount: Object.keys(parsed.tools).length,
                             clientApp: "openai-compat",
                             userAgent: ctx.headers["user-agent"] ?? "",
+                            // Without this the tracer defaults to "anthropic" and every
+                            // non-Anthropic model prices to $0 (the anthropic table has no
+                            // _default), while a claude-* alias routed elsewhere prices at
+                            // Claude rates. Both are wrong in opposite directions.
+                            provider: targetProvider ?? "openai-compatible",
                         }, ctx.headers);
                         tracer.setMode("full");
                     }

package/dist/types/generate.d.ts

@@ -379,6 +379,13 @@ export type GenerateOptions = {
      * with `stopReason: "stalled"`. Catches wedged tools and hung model calls
      * that a whole-turn deadline would let run to the bitter end.
      * Unset = disabled.
+     *
+     * Enforced by the native Vertex loops (Gemini + Claude) ONLY. Unlike
+     * `turnTimeoutMs`, the AI-SDK loop path does not implement stall detection,
+     * so setting this on any other provider has no effect — the turn runs until
+     * it finishes, times out some other way, or the caller aborts. The narrower
+     * scope is stated here because the option itself is accepted everywhere:
+     * without this note a caller would reasonably read silence as coverage.
      */
     stallTimeoutMs?: number;
     /**