@juspay/neurolink 11.25.4 → 11.26.1

package/dist/core/baseProvider.d.ts

@@ -72,6 +72,11 @@ export declare abstract class BaseProvider implements AIProvider {
      * that supplied `onError`).
      */
     private fireLifecycleErrorCallback;
+    /**
+     * Build the fake-stream output and apply the same incremental TTS wrapper
+     * used by the standard NeuroLink stream path.
+     */
+    private createFakeStreamingOutput;
     /**
      * Execute fake streaming - extracted method for reusability
      */

package/dist/core/baseProvider.js

@@ -1,6 +1,6 @@
 import { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { directAgentTools } from "../agent/directTools.js";
-import { isImageGenerationModel } from "../core/constants.js";
+import { isImageGenerationModel } from "./constants.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { modelSupports } from "../models/modelRegistry.js";
 import { ATTR, tracers } from "../telemetry/index.js";
@@ -13,6 +13,7 @@ import { duckTypedStatusCode, extractRetryAfterMsFromError, } from "../utils/pro
 import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "../utils/lifecycleTimeout.js";
 import { logger } from "../utils/logger.js";
+import { interleaveTTSStream } from "../utils/ttsStream.js";
 import { TimeoutError as AsyncTimeoutError, withTimeoutFn, } from "../utils/async/withTimeout.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
@@ -486,6 +487,61 @@ export class BaseProvider {
             logger.warn("[lifecycle] onError callback error:", e);
         }
     }
+    /**
+     * Build the fake-stream output and apply the same incremental TTS wrapper
+     * used by the standard NeuroLink stream path.
+     */
+    createFakeStreamingOutput(result, options, onTTSComplete) {
+        const incrementalTTS = options.tts?.enabled === true;
+        const source = (async function* () {
+            if (result?.content) {
+                const words = result.content.split(/(\s+)/);
+                let buffer = "";
+                for (let i = 0; i < words.length; i++) {
+                    buffer += words[i];
+                    const shouldYield = i === words.length - 1 ||
+                        buffer.length > 50 ||
+                        /[.!?;,]\s*$/.test(buffer);
+                    if (shouldYield && buffer.trim()) {
+                        yield { content: buffer };
+                        buffer = "";
+                        await new Promise((resolve) => {
+                            setTimeout(resolve, Math.random() * 9 + 1);
+                        });
+                    }
+                }
+                if (buffer.trim()) {
+                    yield { content: buffer };
+                }
+            }
+            if (result?.imageOutput) {
+                yield { type: "image", imageOutput: result.imageOutput };
+            }
+            if (result?.audio && !incrementalTTS) {
+                yield {
+                    type: "tts_audio",
+                    audio: {
+                        data: result.audio.buffer,
+                        format: result.audio.format,
+                        index: 0,
+                        isFinal: true,
+                        cumulativeSize: result.audio.size,
+                        voice: result.audio.voice,
+                        sampleRate: result.audio.sampleRate,
+                    },
+                };
+            }
+        })();
+        if (!incrementalTTS || !options.tts) {
+            return source;
+        }
+        return interleaveTTSStream({
+            stream: source,
+            provider: options.tts.provider ?? options.provider ?? this.providerName,
+            options: options.tts,
+            onComplete: onTTSComplete,
+        });
+    }
     /**
      * Execute fake streaming - extracted method for reusability
      */
@@ -525,10 +581,10 @@ export class BaseProvider {
                 skipToolPromptInjection: options.skipToolPromptInjection,
                 timeout: options.timeout,
                 stt: options.stt,
-                // Forward TTS options too — without this, the fake-streaming fallback
-                // path silently drops `tts` and the resulting StreamResult never
-                // produces a `tts_audio` chunk even when synthesis was requested.
-                tts: options.tts,
+                // Streaming TTS is synthesized incrementally by
+                // createFakeStreamingOutput; do not let generate() perform a duplicate
+                // input- or whole-response synthesis first.
+                tts: options.tts?.enabled ? undefined : options.tts,
             };
             logger.debug(`Calling generate for fake streaming`, {
                 provider: this.providerName,
@@ -545,58 +601,45 @@ export class BaseProvider {
                 hasImageOutput: !!result?.imageOutput,
                 timestamp: Date.now(),
             });
-            // Create a synthetic stream from the generate result that simulates progressive delivery
-            return {
-                stream: (async function* () {
-                    if (result?.content) {
-                        // Split content into words for more natural streaming
-                        const words = result.content.split(/(\s+)/); // Keep whitespace
-                        let buffer = "";
-                        for (let i = 0; i < words.length; i++) {
-                            buffer += words[i];
-                            // Yield chunks of roughly 5-10 words or at punctuation
-                            const shouldYield = i === words.length - 1 || // Last word
-                                buffer.length > 50 || // Buffer getting long
-                                /[.!?;,]\s*$/.test(buffer); // End of sentence/clause
-                            if (shouldYield && buffer.trim()) {
-                                yield { content: buffer };
-                                buffer = "";
-                                // Small delay to simulate streaming (1-10ms)
-                                await new Promise((resolve) => {
-                                    setTimeout(resolve, Math.random() * 9 + 1);
-                                });
-                            }
+            const incrementalTTS = options.tts?.enabled === true;
+            const ttsProvider = options.tts?.provider ?? options.provider ?? this.providerName;
+            const ttsStartedAt = Date.now();
+            let resolveAudio;
+            let audioSettled = false;
+            const audio = incrementalTTS
+                ? new Promise((resolve) => {
+                    resolveAudio = resolve;
+                }).catch(() => undefined)
+                : undefined;
+            const ttsMetadata = incrementalTTS
+                ? {
+                    attempted: TTSProcessor.supports(ttsProvider),
+                    success: false,
+                }
+                : result?.ttsMetadata;
+            const onTTSComplete = incrementalTTS
+                ? (ttsResult, error) => {
+                    if (audioSettled) {
+                        return;
+                    }
+                    audioSettled = true;
+                    if (ttsMetadata) {
+                        ttsMetadata.success =
+                            error === undefined && ttsResult !== undefined;
+                        if (error) {
+                            ttsMetadata.error = error;
                         }
-                        // Yield all remaining content
-                        if (buffer.trim()) {
-                            yield { content: buffer };
+                        else {
+                            delete ttsMetadata.error;
                         }
+                        ttsMetadata.latency = Date.now() - ttsStartedAt;
                     }
-                    // 🔧 CRITICAL FIX: Yield image output if present
-                    if (result?.imageOutput) {
-                        yield {
-                            type: "image",
-                            imageOutput: result.imageOutput,
-                        };
-                    }
-                    // Yield synthesized audio so callers using stream() with tts.enabled
-                    // still receive a tts_audio chunk on the fake-streaming fallback
-                    // path (matches the discriminator used by the real streaming path).
-                    if (result?.audio) {
-                        yield {
-                            type: "tts_audio",
-                            audio: {
-                                data: result.audio.buffer,
-                                format: result.audio.format,
-                                index: 0,
-                                isFinal: true,
-                                cumulativeSize: result.audio.size,
-                                voice: result.audio.voice,
-                                sampleRate: result.audio.sampleRate,
-                            },
-                        };
-                    }
-                })(),
+                    resolveAudio?.(ttsResult);
+                }
+                : undefined;
+            // Create a synthetic stream from the generate result that simulates progressive delivery
+            return {
+                stream: this.createFakeStreamingOutput(result, options, onTTSComplete),
                 usage: result?.usage,
                 provider: result?.provider,
                 model: result?.model,
@@ -618,6 +661,8 @@ export class BaseProvider {
                 // 🔧 FIX: Include analytics and evaluation from generate result
                 analytics: result?.analytics,
                 evaluation: result?.evaluation,
+                audio,
+                ttsMetadata,
             };
         }
         catch (error) {

package/dist/factories/providerDescriptors.js

@@ -11,6 +11,8 @@ import { API_KEY_FORMATS } from "../utils/providerConfig.js";
 export const PROVIDER_DESCRIPTORS = [
     {
         name: AIProviderName.BEDROCK,
+        defaultHealthSweepPriority: 5,
+        autoSelectPreference: 7,
         aliases: ["aws"],
         credentialsKey: "bedrock",
         envVars: {
@@ -32,6 +34,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.OPENAI,
+        defaultHealthSweepPriority: 4,
+        autoSelectPreference: 3,
         aliases: ["gpt", "chatgpt"],
         credentialsKey: "openai",
         envVars: { apiKey: "OPENAI_API_KEY", baseURL: "OPENAI_BASE_URL" },
@@ -75,6 +79,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.VERTEX,
+        defaultHealthSweepPriority: 1,
+        autoSelectPreference: 5,
         aliases: ["googleVertex"],
         credentialsKey: "vertex",
         envVars: {
@@ -115,6 +121,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.ANTHROPIC,
+        defaultHealthSweepPriority: 3,
+        autoSelectPreference: 4,
         aliases: ["claude"],
         credentialsKey: "anthropic",
         envVars: {
@@ -137,6 +145,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.AZURE,
+        defaultHealthSweepPriority: 6,
+        autoSelectPreference: 8,
         aliases: ["azureOpenai"],
         credentialsKey: "azure",
         envVars: {
@@ -160,6 +170,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.GOOGLE_AI,
+        defaultHealthSweepPriority: 2,
+        autoSelectPreference: 6,
         aliases: ["googleAiStudio", "google", "gemini", "google-ai-studio"],
         credentialsKey: "googleAiStudio",
         envVars: {
@@ -202,6 +214,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.OLLAMA,
+        defaultHealthSweepPriority: 8,
+        autoSelectPreference: 2,
         aliases: ["local"],
         credentialsKey: "ollama",
         envVars: {
@@ -234,6 +248,8 @@ export const PROVIDER_DESCRIPTORS = [
     },
     {
         name: AIProviderName.LITELLM,
+        defaultHealthSweepPriority: 7,
+        autoSelectPreference: 1,
         aliases: [],
         credentialsKey: "litellm",
         envVars: {

package/dist/models/modelResolver.js

@@ -5,6 +5,22 @@
  */
 import { MODEL_REGISTRY, MODEL_ALIASES, USE_CASE_RECOMMENDATIONS, getAllModels, getModelById, getModelsByProvider, getAvailableProviders, calculateCost, formatModelForDisplay, } from "./modelRegistry.js";
 import { isNonNullObject } from "../utils/typeUtils.js";
+const MIN_FUZZY_QUERY_LENGTH = 4;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * True when `needle` appears in `haystack` at a real token boundary (hyphen,
+ * underscore, dot, slash, whitespace, or string start/end) — not merely as
+ * an arbitrary substring. Model ids use hyphens/dots ("gpt-4.1-mini");
+ * MODEL_REGISTRY .name fields use spaces ("GPT-4 Omni"), hence including
+ * \s in the boundary class.
+ */
+function includesAtWordBoundary(haystack, needle) {
+    const boundary = "(?:^|[-_./\\s])";
+    const pattern = new RegExp(`${boundary}${escapeRegExp(needle)}${boundary.replace("^|", "$|")}`);
+    return pattern.test(haystack);
+}
 /**
  * Model resolver class with advanced search and recommendation functionality
  */
@@ -23,25 +39,31 @@ export class ModelResolver {
             const resolvedId = MODEL_ALIASES[normalizedQuery];
             return MODEL_REGISTRY[resolvedId] || null;
         }
+        // Underspecified queries produce ambiguous, iteration-order-dependent
+        // matches (see Task 13 of the model metadata consolidation plan) — skip
+        // fuzzy matching entirely below this length.
+        if (normalizedQuery.length < MIN_FUZZY_QUERY_LENGTH) {
+            return null;
+        }
         // Fuzzy matching
         const allModels = getAllModels();
         // Try partial matching on ID
-        const idMatch = allModels.find((model) => model.id.toLowerCase().includes(normalizedQuery) ||
-            normalizedQuery.includes(model.id.toLowerCase()));
+        const idMatch = allModels.find((model) => includesAtWordBoundary(model.id.toLowerCase(), normalizedQuery) ||
+            includesAtWordBoundary(normalizedQuery, model.id.toLowerCase()));
         if (idMatch) {
             return idMatch;
         }
         // Try partial matching on name
-        const nameMatch = allModels.find((model) => model.name.toLowerCase().includes(normalizedQuery) ||
-            normalizedQuery.includes(model.name.toLowerCase()));
+        const nameMatch = allModels.find((model) => includesAtWordBoundary(model.name.toLowerCase(), normalizedQuery) ||
+            includesAtWordBoundary(normalizedQuery, model.name.toLowerCase()));
         if (nameMatch) {
             return nameMatch;
         }
         // Try provider-specific matching
         const providerMatch = allModels.find((model) => {
             const providerQuery = `${model.provider}-${normalizedQuery}`;
-            return (model.id.toLowerCase().includes(providerQuery) ||
-                model.name.toLowerCase().includes(normalizedQuery));
+            return (includesAtWordBoundary(model.id.toLowerCase(), providerQuery) ||
+                includesAtWordBoundary(model.name.toLowerCase(), normalizedQuery));
         });
         if (providerMatch) {
             return providerMatch;

package/dist/neurolink.d.ts

@@ -945,7 +945,9 @@ export declare class NeuroLink {
      *
      * // Consume the stream
      * for await (const chunk of result.stream) {
-     *   process.stdout.write(chunk.content);
+     *   if ("content" in chunk) {
+     *     process.stdout.write(chunk.content);
+     *   }
      * }
      *
      * // Advanced streaming with options
@@ -1031,25 +1033,10 @@ export declare class NeuroLink {
     private validateStreamRequestOptions;
     private maybeHandleWorkflowStreamRequest;
     private runStandardStreamRequest;
-    /**
-     * TTS Mode 2 synthesis helper for the stream() pipeline.
-     *
-     * m5 — extracted from runStandardStreamRequest so the surrounding generator
-     * stays under the max-lines-per-function lint budget. Behaviour preserved
-     * exactly:
-     * - When Mode 2 is enabled (`tts.enabled && tts.useAiResponse`) AND the
-     *   model produced non-empty content: synthesises one final audio buffer
-     *   and returns it as an `audioChunk` for the caller to `yield`. Resolves
-     *   `ttsResolver` with the `TTSResult`.
-     * - When Mode 2 is enabled but synthesis fails: logs a warning and resolves
-     *   `ttsResolver` with `undefined`.
-     * - When Mode 2 is requested but skipped (empty content / wrong mode):
-     *   resolves `ttsResolver` with `undefined` early so callers awaiting
-     *   `result.audio` unblock before the surrounding `finally` cleanup
-     *   completes (Issue 7 latency micro-opt — the finally block also resolves
-     *   defensively, so this is a redundant early signal, not a coverage fix).
-     */
-    private synthesizeStreamModeTwo;
+    /** Wrap one provider stream with incremental TTS synthesis. */
+    private createIncrementalTTSStream;
+    /** Prevent provider fallback streams from duplicating outer streaming TTS. */
+    private deferProviderStreamTTS;
     /**
      * Prepare stream options: initialize memory, MCP, retrieval, orchestration,
      * Ollama tool auto-disable, factory processing, and tool detection.