@juspay/neurolink 12.47.3 → 12.47.5

package/dist/core/loopEngine.js

@@ -366,7 +366,7 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                     // The caller's span, when it passes one. withProviderRetry writes
                     // gen_ai.provider.total_attempts here, so a loop that threaded a
                     // span before it moved onto this engine keeps emitting it.
-                    options.span, `${adapter.providerLabel}.step`);
+                    options.span, `${adapter.providerLabel}.step`, undefined, internalAbort.signal);
                 }
                 catch (err) {
                     throw err instanceof PostEmissionStepError ? err.cause : err;

package/dist/localUsage/copilotCliReader.js

@@ -125,7 +125,7 @@ export async function createCopilotCliReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: dbPath,
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/localUsage/cursorReader.js

@@ -375,7 +375,7 @@ export async function createCursorReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: chatsRoot(),
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/localUsage/hermesReader.js

@@ -318,7 +318,7 @@ export async function createHermesReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: hermesHome(),
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/localUsage/openCodeReader.js

@@ -80,10 +80,11 @@ export async function createOpenCodeReader() {
             const errors = [];
             const models = new Set();
             const dbPath = databasePath();
-            // `node:sqlite` is built in from Node 22 but still flagged experimental,
-            // so it can be absent or change shape. Imported lazily and behind a
-            // try/catch: a runtime without it must degrade to a reported failure for
-            // this one reader, not take down a scan of all the others.
+            // `node:sqlite` arrived in Node 22.5.0 behind `--experimental-sqlite`, was
+            // unflagged in 22.13.0 and is still marked experimental, so it can be
+            // absent or change shape. Imported lazily and behind a try/catch: a
+            // runtime without it must degrade to a reported failure for this one
+            // reader, not take down a scan of all the others.
             let DatabaseSync;
             try {
                 const sqlite = await import("node:sqlite");
@@ -102,7 +103,7 @@ export async function createOpenCodeReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: dbPath,
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/neurolink.d.ts

@@ -129,7 +129,7 @@ export declare class NeuroLink {
      * request dedup — BZ-664's actual goal — is untouched: the first
      * occurrence in a request may still be served from cache. Request-scoped
      * like _disableToolCacheForCurrentRequest above (assigned a fresh Set at
-     * request start so the router's save/restore-by-reference pattern works).
+     * request start so `preservingTurnState`'s save/restore-by-reference works).
      */
     private _toolCacheKeysServedThisRequest;
     /** True only while a generate()/stream() turn is executing — the
@@ -1094,6 +1094,18 @@ export declare class NeuroLink {
      */
     private streamWithIterationFallback;
     private executeStreamRequest;
+    /**
+     * Runs an internal call that re-enters the public generate() (the tool-routing
+     * router, the classifier router) without ending the outer turn's tool-cache
+     * state. generate()'s own `finally` resets these fields, so the outer turn
+     * would otherwise lose its repeat-call cache bypass for every later tool
+     * call. Restored by reference: the nested call assigns a new Set rather than
+     * mutating the outer one.
+     *
+     * Covers one turn re-entering itself. Two concurrent turns on one instance
+     * still share these fields.
+     */
+    private preservingTurnState;
     /**
      * Pre-call tool routing for both stream() and generate() turns: runs the
      * router LLM once per turn and appends the unpicked servers' registered tool

package/dist/neurolink.js

@@ -433,7 +433,7 @@ export class NeuroLink {
      * request dedup — BZ-664's actual goal — is untouched: the first
      * occurrence in a request may still be served from cache. Request-scoped
      * like _disableToolCacheForCurrentRequest above (assigned a fresh Set at
-     * request start so the router's save/restore-by-reference pattern works).
+     * request start so `preservingTurnState`'s save/restore-by-reference works).
      */
     _toolCacheKeysServedThisRequest = new Set();
     /** True only while a generate()/stream() turn is executing — the
@@ -994,9 +994,9 @@ export class NeuroLink {
         // generate() (marked so it never recursively re-routes). Fails open.
         this.classifierRouter = config?.classifierRouter?.enabled
             ? new ClassifierRouter(config.classifierRouter, {
-                generate: (genOptions) => this.generate({
+                generate: (genOptions) => this.preservingTurnState(() => this.generate({
                     ...genOptions,
-                }),
+                })),
                 // Fail-open by construction: tryDecide returns null rather than
                 // throwing, so an absent or broken decision provider leaves routing
                 // exactly as it was.
@@ -7265,6 +7265,30 @@ Current user's request: ${currentInput}`;
             throw error;
         }
     }
+    /**
+     * Runs an internal call that re-enters the public generate() (the tool-routing
+     * router, the classifier router) without ending the outer turn's tool-cache
+     * state. generate()'s own `finally` resets these fields, so the outer turn
+     * would otherwise lose its repeat-call cache bypass for every later tool
+     * call. Restored by reference: the nested call assigns a new Set rather than
+     * mutating the outer one.
+     *
+     * Covers one turn re-entering itself. Two concurrent turns on one instance
+     * still share these fields.
+     */
+    async preservingTurnState(run) {
+        const disableToolCache = this._disableToolCacheForCurrentRequest;
+        const keysServed = this._toolCacheKeysServedThisRequest;
+        const turnActive = this._generationTurnActive;
+        try {
+            return await run();
+        }
+        finally {
+            this._disableToolCacheForCurrentRequest = disableToolCache;
+            this._toolCacheKeysServedThisRequest = keysServed;
+            this._generationTurnActive = turnActive;
+        }
+    }
     /**
      * Pre-call tool routing for both stream() and generate() turns: runs the
      * router LLM once per turn and appends the unpicked servers' registered tool
@@ -7420,104 +7444,92 @@ Current user's request: ${currentInput}`;
                     return;
                 }
             }
-            // The router call below re-enters the public generate(), whose finally
-            // block resets _disableToolCacheForCurrentRequest to false. That flag is
-            // turn-scoped (set at the top of this turn) and read by the main tool
-            // execution path that runs after routing, so save it before the router
-            // call and restore it afterward to keep the turn's cache setting intact.
-            const cacheDisabledForCurrentRequest = this._disableToolCacheForCurrentRequest;
             let routedExcludeTools;
             let resolvedDecision;
-            try {
-                // Intercept the decision so we can store it in the cache.
-                const captureDecision = (decision) => {
-                    resolvedDecision = decision;
-                    emitDecision(decision);
-                };
-                // --- ITEM B: build the embedFn for the L2 embedding fast-path ---
-                // The vector cache is persisted at the NeuroLink instance level so
-                // tool embedding vectors are computed once and reused across turns
-                // (Finding 1 fix). It is cleared by setToolRoutingServers() when the
-                // catalog changes so stale vectors are never used after an update.
-                let routingEmbedFn;
-                const embeddingCfg = routingConfig.embedding;
-                if (embeddingCfg?.enabled === true) {
-                    try {
-                        // Resolve the embedding provider: use the explicitly configured one
-                        // if present, otherwise fall back to the stream/generate call's
-                        // provider. The factory call is wrapped in try/catch so a provider
-                        // that doesn't support embedMany (it throws at call time, not
-                        // construction time) fails open when routingEmbedFn is invoked.
-                        const embProviderName = embeddingCfg.provider ??
-                            (options.provider && options.provider !== "auto"
-                                ? options.provider
-                                : undefined) ??
-                            routingConfig.routerModel?.provider;
-                        if (embProviderName) {
-                            const embProvider = await AIProviderFactory.createProvider(embProviderName, embeddingCfg.model, true, this, undefined, this.resolveCredentials(options.credentials));
-                            // Bind embedMany with the configured model (may be undefined —
-                            // the provider uses its default embedding model in that case).
-                            routingEmbedFn = (texts) => withTimeout(embProvider.embedMany(texts, embeddingCfg.model), embeddingCfg.timeoutMs ?? 10000);
-                            // Lazy-init the persistent vector cache for this instance.
-                            // Subsequent turns reuse the same Map so text→vector lookups
-                            // already populated from earlier turns are served from memory.
-                            if (!this.toolRoutingVectorCache) {
-                                this.toolRoutingVectorCache = new Map();
-                            }
+            // Intercept the decision so we can store it in the cache.
+            const captureDecision = (decision) => {
+                resolvedDecision = decision;
+                emitDecision(decision);
+            };
+            // --- ITEM B: build the embedFn for the L2 embedding fast-path ---
+            // The vector cache is persisted at the NeuroLink instance level so
+            // tool embedding vectors are computed once and reused across turns
+            // (Finding 1 fix). It is cleared by setToolRoutingServers() when the
+            // catalog changes so stale vectors are never used after an update.
+            let routingEmbedFn;
+            const embeddingCfg = routingConfig.embedding;
+            if (embeddingCfg?.enabled === true) {
+                try {
+                    // Resolve the embedding provider: use the explicitly configured one
+                    // if present, otherwise fall back to the stream/generate call's
+                    // provider. The factory call is wrapped in try/catch so a provider
+                    // that doesn't support embedMany (it throws at call time, not
+                    // construction time) fails open when routingEmbedFn is invoked.
+                    const embProviderName = embeddingCfg.provider ??
+                        (options.provider && options.provider !== "auto"
+                            ? options.provider
+                            : undefined) ??
+                        routingConfig.routerModel?.provider;
+                    if (embProviderName) {
+                        const embProvider = await AIProviderFactory.createProvider(embProviderName, embeddingCfg.model, true, this, undefined, this.resolveCredentials(options.credentials));
+                        // Bind embedMany with the configured model (may be undefined —
+                        // the provider uses its default embedding model in that case).
+                        routingEmbedFn = (texts) => withTimeout(embProvider.embedMany(texts, embeddingCfg.model), embeddingCfg.timeoutMs ?? 10000);
+                        // Lazy-init the persistent vector cache for this instance.
+                        // Subsequent turns reuse the same Map so text→vector lookups
+                        // already populated from earlier turns are served from memory.
+                        if (!this.toolRoutingVectorCache) {
+                            this.toolRoutingVectorCache = new Map();
                         }
                     }
-                    catch (embSetupError) {
-                        logger.debug("[ToolRouting] Embedding provider setup failed, L2 path disabled for this turn", {
-                            error: embSetupError instanceof Error
-                                ? embSetupError.message
-                                : String(embSetupError),
-                        });
-                        // routingEmbedFn remains undefined — fast-path is skipped.
-                    }
                 }
-                routedExcludeTools = await resolveToolRoutingExclusions({
-                    catalog,
-                    alwaysIncludeServerIds: routingConfig.alwaysIncludeServerIds ?? [],
-                    userQuery: routingQuery,
-                    routerPromptPrefix: routingConfig.routerPromptPrefix,
-                    routerModel: {
-                        provider: routingConfig.routerModel?.provider ??
-                            options.provider,
-                        model: routingConfig.routerModel?.model ?? options.model,
-                        region: routingConfig.routerModel?.region ?? options.region,
-                        temperature: routingConfig.routerModel?.temperature,
-                    },
-                    timeoutMs: routingConfig.timeoutMs ?? DEFAULT_TOOL_ROUTING_TIMEOUT_MS,
-                    // Forward the abort signal so a cancelled turn aborts the router
-                    // call promptly instead of waiting out the routing timeout.
-                    generateFn: (generateOptions) => this.generate({
-                        ...generateOptions,
-                        abortSignal: options.abortSignal,
-                    }),
-                    // Calibrated per-server routing when a decision provider is
-                    // configured. tryDecide returns null without one, so the resolver
-                    // falls straight through to the generative router as before.
-                    decideFn: (decisionOptions) => this.tryDecide({
-                        ...decisionOptions,
-                        signal: options.abortSignal,
-                    }),
-                    decisionMinDropConfidence: routingConfig.minDropConfidence,
-                    emitDecision: captureDecision,
-                    // L2 / ITEM D — only populated when embedding is configured.
-                    embedFn: routingEmbedFn,
-                    embeddingConfig: embeddingCfg,
-                    granularity: routingConfig.granularity ?? "server",
-                    // Pass the persistent vector cache so tool embeddings are reused
-                    // across turns (Finding 1).
-                    embeddingVectorCache: routingEmbedFn !== undefined
-                        ? this.toolRoutingVectorCache
-                        : undefined,
-                });
-            }
-            finally {
-                this._disableToolCacheForCurrentRequest =
-                    cacheDisabledForCurrentRequest;
-            }
+                catch (embSetupError) {
+                    logger.debug("[ToolRouting] Embedding provider setup failed, L2 path disabled for this turn", {
+                        error: embSetupError instanceof Error
+                            ? embSetupError.message
+                            : String(embSetupError),
+                    });
+                    // routingEmbedFn remains undefined — fast-path is skipped.
+                }
+            }
+            routedExcludeTools = await resolveToolRoutingExclusions({
+                catalog,
+                alwaysIncludeServerIds: routingConfig.alwaysIncludeServerIds ?? [],
+                userQuery: routingQuery,
+                routerPromptPrefix: routingConfig.routerPromptPrefix,
+                routerModel: {
+                    provider: routingConfig.routerModel?.provider ??
+                        options.provider,
+                    model: routingConfig.routerModel?.model ?? options.model,
+                    region: routingConfig.routerModel?.region ?? options.region,
+                    temperature: routingConfig.routerModel?.temperature,
+                },
+                timeoutMs: routingConfig.timeoutMs ?? DEFAULT_TOOL_ROUTING_TIMEOUT_MS,
+                // Forward the abort signal so a cancelled turn aborts the router
+                // call promptly instead of waiting out the routing timeout.
+                generateFn: (generateOptions) => this.preservingTurnState(() => this.generate({
+                    ...generateOptions,
+                    abortSignal: options.abortSignal,
+                })),
+                // Calibrated per-server routing when a decision provider is
+                // configured. tryDecide returns null without one, so the resolver
+                // falls straight through to the generative router as before.
+                decideFn: (decisionOptions) => this.tryDecide({
+                    ...decisionOptions,
+                    signal: options.abortSignal,
+                }),
+                decisionMinDropConfidence: routingConfig.minDropConfidence,
+                emitDecision: captureDecision,
+                // L2 / ITEM D — only populated when embedding is configured.
+                embedFn: routingEmbedFn,
+                embeddingConfig: embeddingCfg,
+                granularity: routingConfig.granularity ?? "server",
+                // Pass the persistent vector cache so tool embeddings are reused
+                // across turns (Finding 1).
+                embeddingVectorCache: routingEmbedFn !== undefined
+                    ? this.toolRoutingVectorCache
+                    : undefined,
+            });
             // Aborted during the router call — skip applying now-stale exclusions;
             // the main generation path enforces the abort itself.
             if (options.abortSignal?.aborted) {
@@ -7986,6 +7998,20 @@ Current user's request: ${currentInput}`;
                         yield* incrementalFallback;
                     }
                     ttsResolver?.(streamedTTSResult);
+                    // `streamState.finishReason` starts as a "stop" placeholder, before a
+                    // single chunk exists. A provider that records how the turn really
+                    // ended in metadata (a token-limit cut, a content filter, a step cap
+                    // that left tool calls pending) has that adopted here, once the drain
+                    // is done. Only the three unified values count: a raw vendor string
+                    // or "stop" leaves the graded reason alone, and a fallback's own
+                    // value is never overwritten.
+                    const drainedFinishReason = mcpStreamOutcome.metadata?.finishReason;
+                    if (!metadata.fallbackAttempted &&
+                        (drainedFinishReason === "length" ||
+                            drainedFinishReason === "tool-calls" ||
+                            drainedFinishReason === "content-filter")) {
+                        streamState.finishReason = drainedFinishReason;
+                    }
                     resolvedUsage = mcpStreamOutcome.usage;
                     if (!resolvedUsage && mcpStreamOutcome.analytics) {
                         try {
@@ -8176,8 +8202,19 @@ Current user's request: ${currentInput}`;
                 }
             })();
             const streamResult = await this.processStreamResult(processedStream, enhancedOptions, factoryResult);
-            streamResult.finishReason =
+            streamState.finishReason =
                 streamState.finishReason || streamResult.finishReason;
+            // Live, like toolCalls/toolResults below: the reason a stream ends with is
+            // only known after it drains, so a plain copy would stay the creation-time
+            // placeholder for every truncated or capped turn.
+            Object.defineProperty(streamResult, "finishReason", {
+                enumerable: true,
+                configurable: true,
+                get: () => streamState.finishReason,
+                set: (value) => {
+                    streamState.finishReason = value;
+                },
+            });
             // #1819 / E1b: a top-level cross-provider fallback (handleStreamFallback,
             // inside `processedStream` above) only reassigns
             // `streamState.toolCalls`/`toolResults` once the caller starts draining
@@ -9207,13 +9244,18 @@ Current user's request: ${currentInput}`;
         if (toolResultsDescriptor) {
             Object.defineProperty(response, "toolResults", toolResultsDescriptor);
         }
+        const finishReasonDescriptor = Object.getOwnPropertyDescriptor(streamResult, "finishReason");
+        if (finishReasonDescriptor) {
+            Object.defineProperty(response, "finishReason", finishReasonDescriptor);
+        }
         if (!source) {
             return response;
         }
         // NeuroLink grades the turn's terminal state itself (a normalized
         // finishReason, stopReason for aborts and time limits), so those fields
-        // stay plain values here. Copying the provider's getter for them would
-        // report the raw vendor reason, e.g. Anthropic's end_turn, instead.
+        // keep NeuroLink's own value here (finishReason through the descriptor
+        // copied above). Copying the provider's getter for them would report the
+        // raw vendor reason, e.g. Anthropic's end_turn, instead.
         //
         // toolCalls/toolResults are excluded for a different reason: `source`
         // (the PRIMARY provider's own result) may itself define them as live

package/dist/processors/media/VideoProcessor.js

@@ -445,7 +445,10 @@ export class VideoProcessor extends BaseFileProcessor {
                         metadata = this.buildMetadata(probeResult.data, buffer.length);
                     }
                 }
-                if (!metadata) {
+                // mediabunny reports a duration of 0 for a clip it can open but not
+                // time, and ffprobe's "N/A" parses to NaN: neither is a missing
+                // result, so both take the ffmpeg fallback.
+                if (!metadata || !(metadata.duration > 0)) {
                     // ffmpeg-static ships ffmpeg only, so a host that relies on it has
                     // no ffprobe. Without a duration no frame timestamps can be chosen.
                     const ffmpegProbe = await this.probeVideoWithFfmpeg(tempVideoPath);
@@ -456,7 +459,9 @@ export class VideoProcessor extends BaseFileProcessor {
                         // Nothing downstream reports this: an empty duration selects no
                         // frames, the request still succeeds, and the model is simply
                         // told nothing about the video.
-                        logger.warn(`[NEUROLINK] No metadata could be read for ${filename} (mediabunny, ffprobe and ffmpeg all failed), so no keyframes will be extracted: ${ffmpegProbe.error}`);
+                        logger.warn(metadata
+                            ? `[NEUROLINK] No positive duration could be read for ${filename} (the first reader gave none and ffmpeg could not supply one), so frame times cannot be chosen: ${ffmpegProbe.error}`
+                            : `[NEUROLINK] No metadata could be read for ${filename} (mediabunny, ffprobe and ffmpeg all failed), so no keyframes will be extracted: ${ffmpegProbe.error}`);
                     }
                 }
                 if (!metadata) {

package/dist/providers/amazonSagemaker.js

@@ -242,7 +242,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             ...(options.toolTimeoutMs !== undefined
                 ? { toolTimeoutMs: options.toolTimeoutMs }
                 : {}),
-            runStep: (call) => withProviderRetry(call, undefined, "sagemaker generate").catch((err) => {
+            runStep: (call) => withProviderRetry(call, undefined, "sagemaker generate", undefined, options.abortSignal).catch((err) => {
                 throw this.handleProviderError(err);
             }),
         }, toolExecutionSummaries);

package/dist/providers/anthropic/client.js

@@ -1623,7 +1623,7 @@ export class AnthropicProvider extends BaseProvider {
             ...(options.toolTimeoutMs !== undefined
                 ? { toolTimeoutMs: options.toolTimeoutMs }
                 : {}),
-            runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, "anthropic generate").catch((err) => {
+            runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, "anthropic generate", undefined, options.abortSignal).catch((err) => {
                 throw this.handleProviderError(err);
             }),
         }, toolExecutionSummaries);

package/dist/providers/nvidiaNim/client.js

@@ -270,7 +270,9 @@ export class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
                 message: "NVIDIA NIM rate limit exceeded",
             },
             {
-                match: (ctx) => /404|model_not_found/.test(ctx.message),
+                // NIM answers most of its roster with a 404 whose text ("Function …
+                // not found for account …") names no model, so the status decides.
+                match: (ctx) => ctx.statusCode === 404 || /404|model_not_found/.test(ctx.message),
                 errorClass: InvalidModelError,
                 message: () => `NVIDIA NIM model '${this.modelName}' not available. Browse the catalog at https://build.nvidia.com/models`,
             },

package/dist/providers/openaiChatCompletionsBase.js

@@ -99,6 +99,28 @@ const resolveAgainstSchema = (text, schema) => {
     const scalar = recoverScalarRoot(text, schema);
     return scalar.kind === "accepted" ? scalar.value : undefined;
 };
+/**
+ * The one place a finish reason becomes the unified spelling. Accepts the wire's
+ * `finish_reason` (`tool_calls`, `content_filter`) and the unified spelling a
+ * middleware's own finish part already carries (`tool-calls`, `content-filter`),
+ * since both reach the stream path. Anything else, including `stop`, `error` and
+ * an absent value, reads as `stop`.
+ */
+const toUnifiedFinishReason = (reason) => {
+    switch (reason) {
+        case "length":
+            return "length";
+        case "tool_calls":
+        case "function_call":
+        case "tool-calls":
+            return "tool-calls";
+        case "content_filter":
+        case "content-filter":
+            return "content-filter";
+        default:
+            return "stop";
+    }
+};
 // Pull one native chunk at a time and forward cancellation to its iterator.
 const chunksToV3Stream = (source, completion, cancel) => {
     const iterator = source[Symbol.asyncIterator]();
@@ -774,13 +796,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     });
                 }
                 const rawFinish = choice?.finish_reason;
-                const unified = rawFinish === "length"
-                    ? "length"
-                    : rawFinish === "tool_calls" || rawFinish === "function_call"
-                        ? "tool-calls"
-                        : rawFinish === "content_filter"
-                            ? "content-filter"
-                            : "stop";
+                const unified = toUnifiedFinishReason(rawFinish);
                 return {
                     content,
                     finishReason: { unified, raw: rawFinish ?? "stop" },
@@ -989,7 +1005,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // supplied around each call: without them a 429 surfaces as a raw
                 // upstream string instead of a RateLimitError, and a throttle is
                 // never retried.
-                runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`).catch((err) => {
+                runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`, undefined, options.abortSignal).catch((err) => {
                     throw this.handleProviderError(err);
                 }),
             }, toolExecutionSummaries);
@@ -1839,7 +1855,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 if (!loopPromise) {
                     resolveFinish("stop");
                 }
-                streamMetadata.rawFinishReason = await finishPromise;
+                const rawFinishReason = await finishPromise;
+                streamMetadata.rawFinishReason = rawFinishReason;
                 // Structured output for a `stream({ schema })` turn. Runs HERE —
                 // after the stream is fully drained — so a tool-free re-ask (when the
                 // streamed answer isn't already schema-valid) never reaches
@@ -1884,9 +1901,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // Only reached once the structured-output re-ask above (when there
                 // was one) has resolved without throwing. A caller abort during that
                 // re-ask rejects `resolveStreamStructuredData` and skips this line
-                // entirely, so `metadata.finishReason` never claims "stop" for a
+                // entirely, so `metadata.finishReason` never claims a finish for a
                 // turn that actually failed after the wire stream itself finished.
-                streamMetadata.finishReason = "stop";
+                // The reason is the turn's own (a token-limit cut reads "length"), not
+                // a blanket "stop" for every stream that drained without throwing.
+                streamMetadata.finishReason = toUnifiedFinishReason(rawFinishReason);
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
                 // Pipeline B (ContextEnricher) surfaces a WARNING-level Langfuse
@@ -2188,7 +2207,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         };
         let res;
         try {
-            res = await withProviderRetry(doFetch, trace.getActiveSpan() ?? undefined, `${this.providerName} stream`);
+            res = await withProviderRetry(doFetch, trace.getActiveSpan() ?? undefined, `${this.providerName} stream`, undefined, args.abortSignal);
         }
         catch (err) {
             // The one-shot 400 context-overflow fallback lives outside

package/dist/proxy/proxyConfig.js

@@ -241,6 +241,10 @@ function kebabToCamelRoutingKey(kebabKey) {
  * *because* one of the spellings was explicitly `null` — never merely
  * because both were absent — so callers can warn once per null key without
  * warning on ordinary omission.
+ *
+ * `account-allowlist` is the one key whose `null` `validateProxyConfig`
+ * rejects before this runs, so for it the `null` branch is only reachable
+ * through a direct `parseRoutingConfig` call.
  */
 function readLegacyRoutingKey(routing, kebabKey) {
     const camelKey = kebabToCamelRoutingKey(kebabKey);
@@ -313,6 +317,13 @@ export function validateProxyConfig(config) {
                 }
             });
         }
+        // A `null` allowlist must not read as "unset": a reload that loses a
+        // restriction this way would silently open the proxy to every account.
+        // Checked per spelling, before the legacy read coalesces them.
+        if (routing["account-allowlist"] === null ||
+            routing[kebabToCamelRoutingKey("account-allowlist")] === null) {
+            errors.push("routing.account-allowlist must be an array of non-empty strings (null is not allowed; omit the key to remove the restriction)");
+        }
         const rawAccountAllowlist = readLegacyRoutingKey(routing, "account-allowlist").value;
         if (rawAccountAllowlist !== undefined) {
             if (!Array.isArray(rawAccountAllowlist)) {

package/dist/types/model.d.ts

@@ -272,9 +272,9 @@ export type ModelRoutingOptions = {
 /**
  * A single model's metadata inside a provider's manifest. This is the one
  * canonical shape every model-metadata consumer (context windows, pricing,
- * MODEL_REGISTRY, vision capability, output-token ceilings) is intended to
- * migrate onto — this PR is purely additive and does not yet move any
- * consumer over.
+ * MODEL_REGISTRY, vision capability, output-token ceilings) reads from —
+ * contextWindows.ts, pricing.ts, modelRegistry.ts, providerImageAdapter.ts and
+ * core/constants.ts.
  *
  * `pricingPerMTok` is optional by design: a model with no verified price
  * (e.g. a just-announced model pricing.ts hasn't priced yet) must not report
@@ -311,9 +311,10 @@ export type ProviderModelManifestEntry = {
      * forward verbatim for the ids that already had a MODEL_REGISTRY entry
      * before this migration. Absent for every id that never had one — those
      * get performance/useCases/category derived mechanically instead (see
-     * Task 9's buildModelRegistryFromManifests). Never populate this for a
-     * genuinely new model: mechanical derivation is the correct default, and
-     * a fabricated "curated" value would be worse than an honestly-derived one.
+     * buildManifestDerivedEntries in src/lib/models/modelRegistry.ts). Never
+     * populate this for a genuinely new model: mechanical derivation is the
+     * correct default, and a fabricated "curated" value would be worse than an
+     * honestly-derived one.
      */
     curated?: {
         performance?: ModelPerformance;

package/dist/types/providers.d.ts

@@ -2408,7 +2408,14 @@ export type ProviderDescriptor = {
      * checks to its own server (TypeSafe). See {@link DecisionLimits}.
      */
     decisionLimits?: DecisionLimits;
-    /** Ascending priority (1 = tried first) in the auto-select fallback chain used by getBestProvider(). Undefined = not part of the auto-select chain. */
+    /**
+     * Ascending priority (1 = tried first) in the auto-select fallback chain
+     * used by getBestProvider(). Undefined = not part of the auto-select chain.
+     *
+     * Priorities favor local and self-hosted deployments first to avoid an
+     * external dependency during fallback, then cloud providers according to
+     * reliability, feature set and model coverage.
+     */
     autoSelectPriority?: number;
     /** Format-validation regex sourced from providerConfig.ts's API_KEY_FORMATS, when one exists for this provider. */
     apiKeyFormatPattern?: RegExp;