@juspay/neurolink 11.22.5 → 11.23.1

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

@@ -52,6 +52,18 @@ export declare class LiteLLMProvider extends OpenAIChatCompletionsProvider {
     protected getDefaultModel(): string;
     protected getFallbackModelName(): string;
     protected getFallbackModels(): string[];
+    /**
+     * generate() rides the SSE wire for LiteLLM: deployments commonly sit
+     * behind proxies/tunnels (e.g. Cloudflare, which 524s an origin that is
+     * silent for ~100s), and a non-streaming completion from a slow model
+     * sends nothing until it is fully done. Streaming keeps bytes flowing for
+     * the whole generation while the base class aggregates into the same
+     * complete result — structuredData coercion, tool calls, stopReason,
+     * usage and the JSON damage flags are unchanged for callers.
+     * Escape hatch: NEUROLINK_LITELLM_SSE_GENERATE=false restores the plain
+     * JSON wire.
+     */
+    protected useStreamingWireForGenerate(): boolean;
     /**
      * Gemini 2.5 models on LiteLLM have a known compatibility issue with
      * `max_tokens` — strip it before the wire body is built. Applies to

package/dist/providers/litellm/client.js

@@ -248,6 +248,20 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
             "google/gemini-2.5-flash",
         ]);
     }
+    /**
+     * generate() rides the SSE wire for LiteLLM: deployments commonly sit
+     * behind proxies/tunnels (e.g. Cloudflare, which 524s an origin that is
+     * silent for ~100s), and a non-streaming completion from a slow model
+     * sends nothing until it is fully done. Streaming keeps bytes flowing for
+     * the whole generation while the base class aggregates into the same
+     * complete result — structuredData coercion, tool calls, stopReason,
+     * usage and the JSON damage flags are unchanged for callers.
+     * Escape hatch: NEUROLINK_LITELLM_SSE_GENERATE=false restores the plain
+     * JSON wire.
+     */
+    useStreamingWireForGenerate() {
+        return process.env.NEUROLINK_LITELLM_SSE_GENERATE !== "false";
+    }
     /**
      * Gemini 2.5 models on LiteLLM have a known compatibility issue with
      * `max_tokens` — strip it before the wire body is built. Applies to

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -77,6 +77,19 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * (OpenAI, Azure OpenAI) override this to false.
      */
     protected suppressResponseFormatWithTools(): boolean;
+    /**
+     * When true, `doGenerate` puts `stream: true` on the wire and aggregates
+     * the SSE stream into the SAME complete result the JSON wire returns —
+     * callers still get one awaited result with structuredData coercion, tool
+     * calls, finish reason and usage intact. Bytes then flow continuously, so
+     * proxy/tunnel idle limits (e.g. Cloudflare's ~100s 524 on tunneled
+     * gateways) cannot kill a slow completion, and the request timeout is
+     * re-armed on every chunk (idle semantics) instead of capping total
+     * duration. Default false: some OpenAI-compatible backends mishandle
+     * `stream_options` or omit usage on streams, so each provider opts in
+     * deliberately. LiteLLM overrides this to true.
+     */
+    protected useStreamingWireForGenerate(): boolean;
     /**
      * Hook to adjust the fully-built wire request body before it is sent, on
      * both the streaming and non-streaming paths. Default identity. Override for

package/dist/providers/openaiChatCompletionsBase.js

@@ -108,6 +108,21 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     suppressResponseFormatWithTools() {
         return true;
     }
+    /**
+     * When true, `doGenerate` puts `stream: true` on the wire and aggregates
+     * the SSE stream into the SAME complete result the JSON wire returns —
+     * callers still get one awaited result with structuredData coercion, tool
+     * calls, finish reason and usage intact. Bytes then flow continuously, so
+     * proxy/tunnel idle limits (e.g. Cloudflare's ~100s 524 on tunneled
+     * gateways) cannot kill a slow completion, and the request timeout is
+     * re-armed on every chunk (idle semantics) instead of capping total
+     * duration. Default false: some OpenAI-compatible backends mishandle
+     * `stream_options` or omit usage on streams, so each provider opts in
+     * deliberately. LiteLLM overrides this to true.
+     */
+    useStreamingWireForGenerate() {
+        return false;
+    }
     /**
      * Hook to adjust the fully-built wire request body before it is sent, on
      * both the streaming and non-streaming paths. Default identity. Override for
@@ -387,6 +402,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const correctBodyAfterContextOverflow = this.correctBodyAfterContextOverflow.bind(this);
         const resolveWireMaxTokens = this.resolveWireMaxTokens.bind(this);
         const suppressResponseFormatWithTools = this.suppressResponseFormatWithTools.bind(this);
+        const useStreamingWireForGenerate = this.useStreamingWireForGenerate.bind(this);
         const getTimeoutForOptions = (opts) => this.getTimeout((opts ?? {}));
         return {
             specificationVersion: "v3",
@@ -414,6 +430,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // Fit max_tokens to the runtime-discovered output ceiling and
                 // context window (no-op when nothing was discovered).
                 const wireMaxTokens = resolveWireMaxTokens(modelId, options.maxOutputTokens, baseMessages, wireTools);
+                // SSE wire for generate (opt-in per provider): stream on the wire,
+                // aggregate below into the same complete response the JSON wire
+                // yields. See useStreamingWireForGenerate.
+                const sseWire = useStreamingWireForGenerate();
                 const body = ensureJsonWordInBody(adjustRequestBody(buildBody({
                     modelId,
                     messages: baseMessages,
@@ -432,7 +452,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                             toolChoice: v3ToolChoiceToOpenAI(options.toolChoice, wireNameMaps?.toWire),
                         }
                         : {}),
-                    streaming: false,
+                    streaming: sseWire,
                     ...(responseFormat ? { responseFormat } : {}),
                 }), modelId));
                 // Per-step timeout: the AI-SDK V3 call options never carry `timeout`,
@@ -451,6 +471,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // this step's listeners the moment the request settles.
                 const { signal: composedSignal, dispose: disposeComposedSignal } = composeAbortSignalsScoped(options.abortSignal, timeoutController?.controller.signal);
                 let json;
+                // Whether the response we end up consuming is SSE. Starts as the
+                // provider's wire preference; the 400 fallback below can flip it
+                // when a backend rejects `stream`/`stream_options` outright.
+                let wireIsStreaming = sseWire;
                 try {
                     let res = await fetchImpl(url, {
                         method: "POST",
@@ -474,14 +498,26 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         // attempt, so the configured timeout caps the overall call —
                         // matching the streaming path, which reuses its composed signal
                         // for the retry.
-                        const retryBody = res.status === 400
+                        const typedErr = apiErr;
+                        let retryBody = res.status === 400
                             ? (() => {
-                                const typedErr = apiErr;
                                 const overflowCorrected = correctBodyAfterContextOverflow(body, typedErr);
                                 return (adjustBodyAfter400(overflowCorrected ?? body, typedErr) ??
                                     overflowCorrected);
                             })()
                             : undefined;
+                        // SSE-wire net: a backend that rejects streaming itself (the 400
+                        // names `stream`/`stream_options`) gets ONE retry on the plain
+                        // JSON wire. Gated on the error text so a genuine bad request
+                        // isn't replayed just to fail identically a second time.
+                        if (!retryBody &&
+                            sseWire &&
+                            res.status === 400 &&
+                            /stream/i.test(typedErr.responseBody ?? "")) {
+                            const { stream: _stream, stream_options: _streamOptions, ...jsonWireBody } = body;
+                            retryBody = jsonWireBody;
+                            wireIsStreaming = false;
+                        }
                         if (!retryBody) {
                             throw apiErr;
                         }
@@ -502,7 +538,59 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     // after cleanup(), so a response whose headers arrived but whose
                     // body stalled mid-transfer was bounded by nothing but the caller's
                     // outer wall-clock.
-                    json = (await res.json());
+                    if (wireIsStreaming) {
+                        if (!res.body) {
+                            throw new Error(`${providerName}: streaming generate response had no body`);
+                        }
+                        // Idle-timeout semantics: every raw chunk re-arms the timeout,
+                        // so the configured window bounds silence, not total duration —
+                        // the whole point of the SSE wire is that a slow-but-alive
+                        // completion keeps the connection (and the timer) fed.
+                        const monitored = timeoutController
+                            ? res.body.pipeThrough(new TransformStream({
+                                transform(chunk, controller) {
+                                    timeoutController.reset();
+                                    controller.enqueue(chunk);
+                                },
+                            }))
+                            : res.body;
+                        const sse = await parseSSEStream(monitored, () => { });
+                        // Re-shape the aggregate into the JSON-wire response so every
+                        // line below this point (content parts, finish-reason mapping,
+                        // usage clamping, response metadata) is shared verbatim between
+                        // the two wires and cannot drift.
+                        json = {
+                            ...(sse.id ? { id: sse.id } : {}),
+                            ...(sse.model ? { model: sse.model } : {}),
+                            choices: [
+                                {
+                                    index: 0,
+                                    message: {
+                                        role: "assistant",
+                                        content: sse.text.length > 0 ? sse.text : null,
+                                        ...(sse.reasoning ? { reasoning: sse.reasoning } : {}),
+                                        ...(sse.toolCalls.size > 0
+                                            ? {
+                                                tool_calls: [...sse.toolCalls.values()].map((tc) => ({
+                                                    id: tc.id,
+                                                    type: "function",
+                                                    function: {
+                                                        name: tc.name,
+                                                        arguments: tc.argsBuffered,
+                                                    },
+                                                })),
+                                            }
+                                            : {}),
+                                    },
+                                    finish_reason: sse.finishReason ?? "stop",
+                                },
+                            ],
+                            ...(sse.usage ? { usage: sse.usage } : {}),
+                        };
+                    }
+                    else {
+                        json = (await res.json());
+                    }
                 }
                 finally {
                     timeoutController?.cleanup();

package/dist/providers/openaiChatCompletionsClient.js

@@ -531,6 +531,12 @@ export const parseSSEStream = async (body, onTextDelta, onReasoningDelta) => {
         if (chunk.usage) {
             result.usage = chunk.usage;
         }
+        if (chunk.id && !result.id) {
+            result.id = chunk.id;
+        }
+        if (chunk.model && !result.model) {
+            result.model = chunk.model;
+        }
         const choice = chunk.choices?.[0];
         if (!choice) {
             return;

package/dist/rag/ChunkerFactory.d.ts

@@ -37,13 +37,23 @@ export declare class ChunkerFactory extends BaseFactory<Chunker, ChunkerConfig>
      */
     createChunker(strategyOrAlias: string, config?: ChunkerConfig): Promise<Chunker>;
     /**
-     * Get metadata for a chunker
+     * Get metadata for a chunker.
+     *
+     * Awaits registration first. `metadataMap` and the alias map are populated by
+     * `registerAll()`, which only runs via the async `ensureInitialized()` — and
+     * the only place that awaited it was `create()`. So on a fresh process this
+     * returned `undefined` for every strategy until something happened to build a
+     * chunker first, and returned real metadata after. Order-dependent, silent,
+     * and `undefined` rather than a throw.
+     *
+     * `createChunker()` and `getAvailableStrategies()` were already async for
+     * exactly this reason; these readers were the ones that had not caught up.
      */
-    getChunkerMetadata(strategyOrAlias: string): ChunkerMetadata | undefined;
+    getChunkerMetadata(strategyOrAlias: string): Promise<ChunkerMetadata | undefined>;
     /**
      * Get default configuration for a chunker
      */
-    getDefaultConfig(strategyOrAlias: string): ChunkerConfig | undefined;
+    getDefaultConfig(strategyOrAlias: string): Promise<ChunkerConfig | undefined>;
     /**
      * Get available chunking strategies (not including aliases)
      */
@@ -51,19 +61,19 @@ export declare class ChunkerFactory extends BaseFactory<Chunker, ChunkerConfig>
     /**
      * Get all aliases mapped to their strategies
      */
-    getStrategyAliases(): Map<string, string>;
+    getStrategyAliases(): Promise<Map<string, string>>;
     /**
      * Check if a strategy exists
      */
-    hasStrategy(strategyOrAlias: string): boolean;
+    hasStrategy(strategyOrAlias: string): Promise<boolean>;
     /**
      * Get chunkers suitable for a use case
      */
-    getChunkersForUseCase(useCase: string): ChunkingStrategy[];
+    getChunkersForUseCase(useCase: string): Promise<ChunkingStrategy[]>;
     /**
      * Get all chunker metadata
      */
-    getAllMetadata(): Map<string, ChunkerMetadata>;
+    getAllMetadata(): Promise<Map<string, ChunkerMetadata>>;
     /**
      * Clear factory and metadata
      */
@@ -84,8 +94,8 @@ export declare function getAvailableStrategies(): Promise<ChunkingStrategy[]>;
 /**
  * Convenience function to get chunker metadata
  */
-export declare function getChunkerMetadata(strategyOrAlias: string): ChunkerMetadata | undefined;
+export declare function getChunkerMetadata(strategyOrAlias: string): Promise<ChunkerMetadata | undefined>;
 /**
  * Convenience function to get default config
  */
-export declare function getDefaultConfig(strategyOrAlias: string): ChunkerConfig | undefined;
+export declare function getDefaultConfig(strategyOrAlias: string): Promise<ChunkerConfig | undefined>;

package/dist/rag/ChunkerFactory.js

@@ -229,17 +229,28 @@ export class ChunkerFactory extends BaseFactory {
         }
     }
     /**
-     * Get metadata for a chunker
+     * Get metadata for a chunker.
+     *
+     * Awaits registration first. `metadataMap` and the alias map are populated by
+     * `registerAll()`, which only runs via the async `ensureInitialized()` — and
+     * the only place that awaited it was `create()`. So on a fresh process this
+     * returned `undefined` for every strategy until something happened to build a
+     * chunker first, and returned real metadata after. Order-dependent, silent,
+     * and `undefined` rather than a throw.
+     *
+     * `createChunker()` and `getAvailableStrategies()` were already async for
+     * exactly this reason; these readers were the ones that had not caught up.
      */
-    getChunkerMetadata(strategyOrAlias) {
+    async getChunkerMetadata(strategyOrAlias) {
+        await this.ensureInitialized();
         const resolvedName = this.resolveName(strategyOrAlias);
         return this.metadataMap.get(resolvedName);
     }
     /**
      * Get default configuration for a chunker
      */
-    getDefaultConfig(strategyOrAlias) {
-        const metadata = this.getChunkerMetadata(strategyOrAlias);
+    async getDefaultConfig(strategyOrAlias) {
+        const metadata = await this.getChunkerMetadata(strategyOrAlias);
         return metadata?.defaultConfig;
     }
     /**
@@ -252,20 +263,23 @@ export class ChunkerFactory extends BaseFactory {
     /**
      * Get all aliases mapped to their strategies
      */
-    getStrategyAliases() {
+    async getStrategyAliases() {
+        await this.ensureInitialized();
         return this.getAliases();
     }
     /**
      * Check if a strategy exists
      */
-    hasStrategy(strategyOrAlias) {
+    async hasStrategy(strategyOrAlias) {
+        await this.ensureInitialized();
         const resolved = this.resolveName(strategyOrAlias);
         return this.has(resolved);
     }
     /**
      * Get chunkers suitable for a use case
      */
-    getChunkersForUseCase(useCase) {
+    async getChunkersForUseCase(useCase) {
+        await this.ensureInitialized();
         const matches = [];
         const useCaseLower = useCase.toLowerCase();
         for (const [strategy, metadata] of this.metadataMap) {
@@ -279,7 +293,8 @@ export class ChunkerFactory extends BaseFactory {
     /**
      * Get all chunker metadata
      */
-    getAllMetadata() {
+    async getAllMetadata() {
+        await this.ensureInitialized();
         return new Map(this.metadataMap);
     }
     /**

package/dist/rag/reranker/RerankerFactory.d.ts

@@ -64,11 +64,11 @@ export declare class RerankerFactory extends BaseFactory<Reranker, RerankerConfi
     /**
      * Get metadata for a reranker
      */
-    getRerankerMetadata(typeOrAlias: string): RerankerMetadata | undefined;
+    getRerankerMetadata(typeOrAlias: string): Promise<RerankerMetadata | undefined>;
     /**
      * Get default configuration for a reranker
      */
-    getDefaultConfig(typeOrAlias: string): Partial<RerankerConfig> | undefined;
+    getDefaultConfig(typeOrAlias: string): Promise<Partial<RerankerConfig> | undefined>;
     /**
      * Get available reranker types (not including aliases)
      */
@@ -76,27 +76,27 @@ export declare class RerankerFactory extends BaseFactory<Reranker, RerankerConfi
     /**
      * Get all aliases mapped to their types
      */
-    getTypeAliases(): Map<string, string>;
+    getTypeAliases(): Promise<Map<string, string>>;
     /**
      * Check if a type exists
      */
-    hasType(typeOrAlias: string): boolean;
+    hasType(typeOrAlias: string): Promise<boolean>;
     /**
      * Get rerankers suitable for a use case
      */
-    getRerankersForUseCase(useCase: string): RerankerType[];
+    getRerankersForUseCase(useCase: string): Promise<RerankerType[]>;
     /**
      * Get rerankers that don't require external APIs
      */
-    getLocalRerankers(): RerankerType[];
+    getLocalRerankers(): Promise<RerankerType[]>;
     /**
      * Get rerankers that don't require AI models
      */
-    getModelFreeRerankers(): RerankerType[];
+    getModelFreeRerankers(): Promise<RerankerType[]>;
     /**
      * Get all reranker metadata
      */
-    getAllMetadata(): Map<RerankerType, RerankerMetadata>;
+    getAllMetadata(): Promise<Map<RerankerType, RerankerMetadata>>;
     /**
      * Clear factory and metadata
      */
@@ -117,8 +117,8 @@ export declare function getAvailableRerankerTypes(): Promise<RerankerType[]>;
 /**
  * Convenience function to get reranker metadata
  */
-export declare function getRerankerMetadata(typeOrAlias: string): RerankerMetadata | undefined;
+export declare function getRerankerMetadata(typeOrAlias: string): Promise<RerankerMetadata | undefined>;
 /**
  * Convenience function to get default config
  */
-export declare function getRerankerDefaultConfig(typeOrAlias: string): Partial<RerankerConfig> | undefined;
+export declare function getRerankerDefaultConfig(typeOrAlias: string): Promise<Partial<RerankerConfig> | undefined>;

package/dist/rag/reranker/RerankerFactory.js

@@ -316,15 +316,16 @@ export class RerankerFactory extends BaseFactory {
     /**
      * Get metadata for a reranker
      */
-    getRerankerMetadata(typeOrAlias) {
+    async getRerankerMetadata(typeOrAlias) {
+        await this.ensureInitialized();
         const resolvedName = this.resolveName(typeOrAlias);
         return this.metadataMap.get(resolvedName);
     }
     /**
      * Get default configuration for a reranker
      */
-    getDefaultConfig(typeOrAlias) {
-        const metadata = this.getRerankerMetadata(typeOrAlias);
+    async getDefaultConfig(typeOrAlias) {
+        const metadata = await this.getRerankerMetadata(typeOrAlias);
         return metadata?.defaultConfig;
     }
     /**
@@ -337,20 +338,23 @@ export class RerankerFactory extends BaseFactory {
     /**
      * Get all aliases mapped to their types
      */
-    getTypeAliases() {
+    async getTypeAliases() {
+        await this.ensureInitialized();
         return this.getAliases();
     }
     /**
      * Check if a type exists
      */
-    hasType(typeOrAlias) {
+    async hasType(typeOrAlias) {
+        await this.ensureInitialized();
         const resolved = this.resolveName(typeOrAlias);
         return this.has(resolved);
     }
     /**
      * Get rerankers suitable for a use case
      */
-    getRerankersForUseCase(useCase) {
+    async getRerankersForUseCase(useCase) {
+        await this.ensureInitialized();
         const matches = [];
         const useCaseLower = useCase.toLowerCase();
         for (const [type, metadata] of this.metadataMap) {
@@ -364,7 +368,8 @@ export class RerankerFactory extends BaseFactory {
     /**
      * Get rerankers that don't require external APIs
      */
-    getLocalRerankers() {
+    async getLocalRerankers() {
+        await this.ensureInitialized();
         const matches = [];
         for (const [type, metadata] of this.metadataMap) {
             if (!metadata.requiresExternalAPI) {
@@ -376,7 +381,8 @@ export class RerankerFactory extends BaseFactory {
     /**
      * Get rerankers that don't require AI models
      */
-    getModelFreeRerankers() {
+    async getModelFreeRerankers() {
+        await this.ensureInitialized();
         const matches = [];
         for (const [type, metadata] of this.metadataMap) {
             if (!metadata.requiresModel) {
@@ -388,7 +394,8 @@ export class RerankerFactory extends BaseFactory {
     /**
      * Get all reranker metadata
      */
-    getAllMetadata() {
+    async getAllMetadata() {
+        await this.ensureInitialized();
         return new Map(this.metadataMap);
     }
     /**

package/dist/types/openaiCompatible.d.ts

@@ -199,6 +199,10 @@ export type OpenAICompatSSEResult = {
     }>;
     finishReason: "stop" | "length" | "tool_calls" | "function_call" | "content_filter" | null;
     usage?: OpenAICompatUsage;
+    /** Response id from the first stream chunk that carried one. */
+    id?: string;
+    /** Served model from the first stream chunk that carried one. */
+    model?: string;
 };
 export type OpenAICompatStreamChunk = {
     content: string;

package/dist/utils/timeout.d.ts

@@ -116,6 +116,13 @@ export declare function withStreamingTimeout<T>(generator: AsyncGenerator<T>, ti
 export declare function createTimeoutController(timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): {
     controller: AbortController;
     cleanup: () => void;
+    /**
+     * Re-arm the timeout window from now. Streaming consumers call this on
+     * every chunk so the timeout bounds *idle* time rather than total
+     * duration — a slow-but-alive upstream is not killed mid-generation.
+     * No-op once the controller has already aborted.
+     */
+    reset: () => void;
     timeoutMs: number;
 } | null;
 /**

package/dist/utils/timeout.js

@@ -313,7 +313,7 @@ export function createTimeoutController(timeout, provider, operation) {
         return null;
     }
     const controller = new AbortController();
-    const timer = setTimeout(() => {
+    const fire = () => {
         // NOTE: we cannot stamp the AI SDK's ai.streamText/ai.generateText span
         // from here — the setTimeout callback runs in the async context captured
         // at schedule time, which is BEFORE the AI SDK span exists. Instead we
@@ -321,11 +321,19 @@ export function createTimeoutController(timeout, provider, operation) {
         // wrapper, which sets span.status = ERROR + message. ContextEnricher's
         // SpanStatusCode.ERROR branch then surfaces level=ERROR + status_message.
         controller.abort(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
-    }, timeoutMs);
+    };
+    let timer = setTimeout(fire, timeoutMs);
     const cleanup = () => {
         clearTimeout(timer);
     };
-    return { controller, cleanup, timeoutMs };
+    const reset = () => {
+        if (controller.signal.aborted) {
+            return;
+        }
+        clearTimeout(timer);
+        timer = setTimeout(fire, timeoutMs);
+    };
+    return { controller, cleanup, reset, timeoutMs };
 }
 /**
  * Compose an external abort signal with a timeout controller's signal.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.22.5",
+  "version": "11.23.1",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {