@juspay/neurolink 9.81.2 → 9.82.0

package/dist/cli/commands/proxy.js

@@ -17,6 +17,7 @@ import ora from "ora";
 import { buildProxyHealthResponse, createProxyReadinessState, markProxyReady, waitForProxyReadiness, } from "../../lib/proxy/proxyHealth.js";
 import { logger } from "../../lib/utils/logger.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
+import { configureProxyKeepAliveDispatcher } from "../../lib/proxy/proxyDispatcher.js";
 import { loadProxyEnvFile, resolveProxyEnvFile, } from "../../lib/proxy/proxyEnv.js";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
@@ -1285,6 +1286,10 @@ async function startProxyCommandHandler(argv) {
             await ensureProxyStartAllowed(spinner);
         }
         const loadedEnvFile = await loadProxyStartEnv(argv, spinner);
+        // Reuse upstream TCP connections (longer keep-alive + bounded pool) instead
+        // of opening a new flow per request — cuts outbound flow churn through host
+        // content-filters. Runs once, after env load so it can be tuned via env.
+        configureProxyKeepAliveDispatcher();
         const { neurolink, cleanupLogs } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
         const { proxyConfig, strategy, modelRouter, passthrough, primaryAccountKey, } = await loadProxyStartConfiguration(argv, spinner);
         if (spinner) {

package/dist/cli/factories/commandFactory.d.ts

@@ -35,8 +35,9 @@ export declare class CLICommandFactory {
     private static validateAnthropicSubscriptionOptions;
     private static handleOutput;
     /**
-     * Helper method to handle TTS audio file output
+     * Helper method to handle TTS audio file output and playback
      * Saves audio to file when --tts-output flag is provided
+     * Plays audio when --tts-play flag is provided
      */
     private static handleTTSOutput;
     /**

package/dist/cli/factories/commandFactory.js

@@ -20,6 +20,7 @@ import { handleError } from "../errorHandler.js";
 import { LoopSession } from "../loop/session.js";
 import { initializeCliParser } from "../parser.js";
 import { formatFileSize, saveAudioToFile } from "../utils/audioFileUtils.js";
+import { playAudio } from "../utils/audioPlayer.js";
 import { resolveFilePaths } from "../utils/pathResolver.js";
 import { animatedWrite } from "../utils/typewriter.js";
 import { createStreamAbortHandler } from "../utils/abortHandler.js";
@@ -1040,13 +1041,15 @@ export class CLICommandFactory {
         }
     }
     /**
-     * Helper method to handle TTS audio file output
+     * Helper method to handle TTS audio file output and playback
      * Saves audio to file when --tts-output flag is provided
+     * Plays audio when --tts-play flag is provided
      */
     static async handleTTSOutput(result, options) {
-        // Check if --tts-output flag is provided
         const ttsOutputPath = options.ttsOutput;
-        if (!ttsOutputPath) {
+        const shouldPlay = options.ttsPlay;
+        // Nothing to do if neither save nor play is requested
+        if (!ttsOutputPath && !shouldPlay) {
             return;
         }
         // Extract audio from result with proper type checking
@@ -1061,20 +1064,36 @@ export class CLICommandFactory {
             }
             return;
         }
-        try {
-            // Save audio to file
-            const saveResult = await saveAudioToFile(audio, ttsOutputPath);
-            if (saveResult.success) {
-                if (!options.quiet) {
-                    logger.always(chalk.green(`🔊 Audio saved to: ${saveResult.path} (${formatFileSize(saveResult.size)})`));
+        // Save audio to file if --tts-output is provided
+        if (ttsOutputPath) {
+            try {
+                const saveResult = await saveAudioToFile(audio, ttsOutputPath);
+                if (saveResult.success) {
+                    if (!options.quiet) {
+                        logger.always(chalk.green(`🔊 Audio saved to: ${saveResult.path} (${formatFileSize(saveResult.size)})`));
+                    }
+                }
+                else {
+                    handleError(new Error(saveResult.error || "Failed to save audio file"), "TTS Output");
                 }
             }
-            else {
-                handleError(new Error(saveResult.error || "Failed to save audio file"), "TTS Output");
+            catch (error) {
+                handleError(error, "TTS Output");
             }
         }
-        catch (error) {
-            handleError(error, "TTS Output");
+        // Play audio if --tts-play is provided
+        if (shouldPlay) {
+            try {
+                if (!options.quiet) {
+                    logger.always(chalk.blue("Playing audio..."));
+                }
+                await playAudio(audio.buffer, audio.format);
+            }
+            catch (err) {
+                // Non-fatal: warn but don't crash
+                logger.always(chalk.yellow(`Audio playback failed: ${err.message}`));
+                logger.always(chalk.yellow("   Tip: Save the audio with --tts-output <file> and play manually."));
+            }
         }
     }
     /**
@@ -2898,15 +2917,16 @@ export class CLICommandFactory {
                 logger.always(`\nOutput saved to ${options.output}`);
             }
         }
-        // Handle TTS audio output if --tts-output is provided
+        // Handle TTS audio output/playback if --tts-output or --tts-play is provided
         // Note: For streaming, TTS audio is collected during the stream
         // and saved at the end if available
         const ttsOutputPath = options.ttsOutput;
-        if (ttsOutputPath) {
+        const shouldPlay = options.ttsPlay;
+        if (ttsOutputPath || shouldPlay) {
             // For now, streaming TTS output is not yet available
             // This will be enabled when the TTS streaming infrastructure is complete
             if (!options.quiet) {
-                logger.always(chalk.yellow("⚠️  TTS audio output for streaming is not yet available. Use 'generate' command for TTS output."));
+                logger.always(chalk.yellow("TTS audio for streaming is not yet available. Use 'generate' command for TTS output."));
             }
         }
         // Debug output for streaming

package/dist/cli/utils/audioPlayer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Audio playback utilities for CLI
+ *
+ * Provides functionality for playing TTS audio using platform-specific
+ * CLI tools with proper cleanup and error handling.
+ *
+ * @module cli/utils/audioPlayer
+ */
+import type { AudioFormat } from "../../lib/types/index.js";
+/**
+ * Get the file extension for an audio format
+ *
+ * @param format - Audio format
+ * @returns File extension string (e.g., "mp3", "wav")
+ */
+export declare function getAudioExtension(format: AudioFormat): string;
+/**
+ * Play audio from a buffer using platform-specific CLI tools
+ *
+ * Writes the buffer to a temporary file, plays it using the appropriate
+ * system audio player, and cleans up the temp file afterward.
+ *
+ * Supported platforms:
+ * - macOS: uses `afplay` (built-in, supports mp3/wav/aac/flac)
+ * - Linux: uses `paplay` for non-wav, `aplay` for wav
+ * - Windows: uses PowerShell SoundPlayer (wav) or WMPlayer.OCX (mp3)
+ *
+ * @param buffer - Audio data buffer
+ * @param format - Audio format (mp3, wav, ogg, opus)
+ * @throws Error if playback fails or platform is unsupported
+ *
+ * @example
+ * ```typescript
+ * await playAudio(audioBuffer, "mp3");
+ * ```
+ */
+export declare function playAudio(buffer: Buffer, format: AudioFormat): Promise<void>;

package/dist/cli/utils/audioPlayer.js

@@ -0,0 +1,138 @@
+/**
+ * Audio playback utilities for CLI
+ *
+ * Provides functionality for playing TTS audio using platform-specific
+ * CLI tools with proper cleanup and error handling.
+ *
+ * @module cli/utils/audioPlayer
+ */
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/**
+ * Get the file extension for an audio format
+ *
+ * @param format - Audio format
+ * @returns File extension string (e.g., "mp3", "wav")
+ */
+export function getAudioExtension(format) {
+    switch (format) {
+        case "mp3":
+            return "mp3";
+        case "wav":
+            return "wav";
+        case "ogg":
+            return "ogg";
+        case "opus":
+            return "opus";
+        default:
+            return "mp3";
+    }
+}
+/**
+ * Get the platform-specific audio player command and arguments
+ *
+ * @param filePath - Path to the audio file
+ * @param format - Audio format
+ * @returns Object with command and args for execFile
+ */
+function getPlayerCommand(filePath, format) {
+    const platform = process.platform;
+    switch (platform) {
+        case "darwin":
+            return { command: "afplay", args: [filePath] };
+        case "linux":
+            if (format === "wav") {
+                return { command: "aplay", args: [filePath] };
+            }
+            return { command: "paplay", args: [filePath] };
+        case "win32":
+            if (format === "wav") {
+                return {
+                    command: "powershell",
+                    args: [
+                        "-NoProfile",
+                        "-Command",
+                        `(New-Object System.Media.SoundPlayer '${filePath}').PlaySync()`,
+                    ],
+                };
+            }
+            return {
+                command: "powershell",
+                args: [
+                    "-NoProfile",
+                    "-Command",
+                    `$player = New-Object -ComObject WMPlayer.OCX; $player.URL = '${filePath}'; $player.controls.play(); Start-Sleep -Seconds 1; while ($player.playState -eq 3) { Start-Sleep -Milliseconds 100 }; $player.close()`,
+                ],
+            };
+        default:
+            throw new Error(`Unsupported platform: ${platform}. Audio playback is supported on macOS, Linux, and Windows.`);
+    }
+}
+/**
+ * Play audio from a buffer using platform-specific CLI tools
+ *
+ * Writes the buffer to a temporary file, plays it using the appropriate
+ * system audio player, and cleans up the temp file afterward.
+ *
+ * Supported platforms:
+ * - macOS: uses `afplay` (built-in, supports mp3/wav/aac/flac)
+ * - Linux: uses `paplay` for non-wav, `aplay` for wav
+ * - Windows: uses PowerShell SoundPlayer (wav) or WMPlayer.OCX (mp3)
+ *
+ * @param buffer - Audio data buffer
+ * @param format - Audio format (mp3, wav, ogg, opus)
+ * @throws Error if playback fails or platform is unsupported
+ *
+ * @example
+ * ```typescript
+ * await playAudio(audioBuffer, "mp3");
+ * ```
+ */
+export async function playAudio(buffer, format) {
+    const ext = getAudioExtension(format);
+    const tempFile = path.join(os.tmpdir(), `nl-tts-${Date.now()}.${ext}`);
+    try {
+        // Write audio buffer to temp file
+        await fs.promises.writeFile(tempFile, buffer);
+        const { command, args } = getPlayerCommand(tempFile, format);
+        try {
+            await execFileAsync(command, args);
+        }
+        catch (execError) {
+            const err = execError;
+            // Handle binary not found
+            if (err.code === "ENOENT") {
+                if (process.platform === "linux" && command === "paplay") {
+                    // Fallback to aplay on Linux
+                    try {
+                        await execFileAsync("aplay", [tempFile]);
+                        return;
+                    }
+                    catch (fallbackError) {
+                        const fbErr = fallbackError;
+                        if (fbErr.code === "ENOENT") {
+                            throw new Error("Neither paplay nor aplay found. Install PulseAudio (paplay) or ALSA (aplay) for audio playback.", { cause: fallbackError });
+                        }
+                        throw fallbackError;
+                    }
+                }
+                throw new Error(`Audio player '${command}' not found. Ensure it is installed and available in PATH.`, { cause: execError });
+            }
+            throw execError;
+        }
+    }
+    finally {
+        // Always clean up temp file
+        try {
+            await fs.promises.unlink(tempFile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+//# sourceMappingURL=audioPlayer.js.map

package/dist/constants/contextWindows.js

@@ -154,6 +154,8 @@ export const MODEL_CONTEXT_WINDOWS = {
     },
     anthropic: {
         _default: 200_000,
+        // Claude 5 (mid 2026) — 1M context window
+        "claude-sonnet-5": 1_000_000,
         // Claude 4.6 (Feb 2026) — 1M context window
         "claude-opus-4-6": 1_000_000,
         "claude-sonnet-4-6": 1_000_000,
@@ -243,6 +245,7 @@ export const MODEL_CONTEXT_WINDOWS = {
     vertex: {
         _default: 1_048_576,
         // Claude on Vertex
+        "claude-sonnet-5": 1_000_000,
         "claude-opus-4-6": 1_000_000,
         "claude-sonnet-4-6": 1_000_000,
         "claude-sonnet-4-5": 200_000,
@@ -252,6 +255,13 @@ export const MODEL_CONTEXT_WINDOWS = {
         "claude-sonnet-4-20250514": 200_000,
         "claude-opus-4-20250514": 200_000,
         "claude-opus-4": 200_000,
+        // Catch-all for UNKNOWN Claude models on Vertex (prefix match runs after
+        // the specific keys above). Without this, an unlisted Claude model falls
+        // to the Gemini-shaped _default (1,048,576) — ABOVE Anthropic's real 1M
+        // API cap — so the pre-dispatch budget check and the in-loop context
+        // guard both under-guard it (the claude-sonnet-5 1,005,647-token 400s).
+        // 200K is the conservative Anthropic floor; list real models explicitly.
+        "claude-": 200_000,
         // Gemini 3.1 on Vertex (all require -preview suffix)
         "gemini-3.1-pro-preview": 1_048_576,
         "gemini-3.1-flash-lite-preview": 1_048_576,

package/dist/core/constants.d.ts

@@ -36,6 +36,22 @@ export declare const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 300000;
  * a wrap-up nudge rides the next tool-result turn.
  */
 export declare const DEFAULT_WRAPUP_TIME_LEAD_MS = 120000;
+/**
+ * In-loop context guard threshold for native agentic loops: when the last
+ * model call's actual prompt size (provider-reported usage) plus the
+ * estimated growth from this step's tool results crosses this fraction of
+ * the model's context window, the loop stops calling tools and synthesizes a
+ * final answer instead of stepping into a provider 400 ("prompt is too
+ * long") that would destroy the whole turn's work.
+ */
+export declare const DEFAULT_CONTEXT_GUARD_RATIO = 0.85;
+/**
+ * Floor for the turn budget handed to the post-overflow recovery retry.
+ * The retry inherits the REMAINING `turnTimeoutMs` (whole-turn semantics —
+ * one generate() must not stack two full budgets), but never less than this,
+ * so a compacted retry still gets a workable window.
+ */
+export declare const MIN_RECOVERY_TURN_BUDGET_MS = 30000;
 export declare const TOOL_STORAGE_TIMEOUT_MS = 5000;
 export declare const STEP_LIMITS: {
     min: number;

package/dist/core/constants.js

@@ -122,6 +122,22 @@ export const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 300_000;
  * a wrap-up nudge rides the next tool-result turn.
  */
 export const DEFAULT_WRAPUP_TIME_LEAD_MS = 120_000;
+/**
+ * In-loop context guard threshold for native agentic loops: when the last
+ * model call's actual prompt size (provider-reported usage) plus the
+ * estimated growth from this step's tool results crosses this fraction of
+ * the model's context window, the loop stops calling tools and synthesizes a
+ * final answer instead of stepping into a provider 400 ("prompt is too
+ * long") that would destroy the whole turn's work.
+ */
+export const DEFAULT_CONTEXT_GUARD_RATIO = 0.85;
+/**
+ * Floor for the turn budget handed to the post-overflow recovery retry.
+ * The retry inherits the REMAINING `turnTimeoutMs` (whole-turn semantics —
+ * one generate() must not stack two full budgets), but never less than this,
+ * so a compacted retry still gets a workable window.
+ */
+export const MIN_RECOVERY_TURN_BUDGET_MS = 30_000;
 // Fire-and-forget tool storage writes (Redis). 5s is generous for a single
 // Redis write; if breached, the .catch logs a warning.
 export const TOOL_STORAGE_TIMEOUT_MS = 5000;

package/dist/core/modules/GenerationHandler.js

@@ -26,6 +26,7 @@ import { coerceJsonToSchema } from "../../utils/json/coerce.js";
 import { NoObjectGeneratedError } from "../../utils/generationErrors.js";
 import { Output, stepCountIs } from "../../utils/tool.js";
 import { generateText } from "../../utils/generation.js";
+import { extractSystemMessages } from "../../utils/systemMessages.js";
 const genTracer = tracers.generation;
 /**
  * Safely preview-serialize a value for debug logging.
@@ -105,9 +106,14 @@ export class GenerationHandler {
             }
         }
         const prepareStep = options.prepareStep;
+        // Hoist system-role messages into generateText's top-level `system` option
+        // rather than passing them inside `messages` (deprecated by the AI SDK,
+        // rejected in v7). See extractSystemMessages for the rationale. (#1024)
+        const { system, messages: nonSystemMessages } = extractSystemMessages(messages);
         return await generateText({
             model,
-            messages,
+            ...(system && { system }),
+            messages: nonSystemMessages,
             ...(shouldUseTools &&
                 Object.keys(toolsWithCache).length > 0 && { tools: toolsWithCache }),
             stopWhen: stepCountIs(options.maxSteps ?? DEFAULT_MAX_STEPS),

package/dist/core/modules/ToolsManager.d.ts

@@ -18,6 +18,11 @@ export declare class ToolsManager {
     /**
      * BZ-666: Wrap tool execute with output truncation to prevent
      * context overflow when large results flow into the AI SDK accumulator.
+     *
+     * Passes the AI-SDK second argument (execution options: abortSignal,
+     * toolCallId, messages) through to the inner execute — the native loops
+     * provide an abortSignal there, and dropping it at this wrapper made
+     * every tool uncancellable (deadline overshoot / ghost executions).
      */
     private wrapExecuteWithTruncation;
     /**

package/dist/core/modules/ToolsManager.js

@@ -7,6 +7,48 @@ import { getKeyCount } from "../../utils/transformationUtils.js";
 import { convertJsonSchemaToZod } from "../../utils/schemaConversion.js";
 import { generateToolOutputPreview } from "../../context/toolOutputLimits.js";
 import { tool as createAISDKTool, jsonSchema } from "../../utils/tool.js";
+/** Abort-shaped error so provider loops route it to their cancellation path. */
+function makeToolAbortError() {
+    const e = new Error("Tool execution aborted");
+    e.name = "AbortError";
+    return e;
+}
+/**
+ * Race a tool-execution promise against an AbortSignal so the calling loop
+ * observes a deadline/caller abort IMMEDIATELY instead of waiting for the
+ * tool to finish or its execution timeout to expire. The underlying call is
+ * not cancelled (bounded ghost execution — the same tradeoff as the tool
+ * timeout); real transport-level cancellation (executeExternalMCPTool → MCP
+ * client RequestOptions.signal) is tracked as a follow-up.
+ */
+function raceWithAbortSignal(promise, signal) {
+    if (signal.aborted) {
+        // Swallow the abandoned settlement so it can't become an unhandled
+        // rejection later.
+        promise.catch(() => {
+            // Swallow the abandoned settlement — it must never surface as an
+            // unhandled rejection after the race has already been decided.
+        });
+        return Promise.reject(makeToolAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            promise.catch(() => {
+                // Swallow the abandoned settlement — it must never surface as an
+                // unhandled rejection after the race has already been decided.
+            });
+            reject(makeToolAbortError());
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
 /**
  * ToolsManager class - Handles all tool management operations
  */
@@ -32,10 +74,24 @@ export class ToolsManager {
     /**
      * BZ-666: Wrap tool execute with output truncation to prevent
      * context overflow when large results flow into the AI SDK accumulator.
+     *
+     * Passes the AI-SDK second argument (execution options: abortSignal,
+     * toolCallId, messages) through to the inner execute — the native loops
+     * provide an abortSignal there, and dropping it at this wrapper made
+     * every tool uncancellable (deadline overshoot / ghost executions).
      */
     wrapExecuteWithTruncation(toolName, originalExecute) {
-        return async (params) => {
-            const result = await originalExecute(params);
+        return async (params, execOptions) => {
+            const signal = execOptions
+                ?.abortSignal;
+            const inner = originalExecute(params, execOptions);
+            // Inner executes that ignore the signal (external MCP / custom tools —
+            // the signal isn't plumbed to their transports yet) still return
+            // promptly on abort via the race; the loop's isAbortError handling
+            // treats the rejection as a cancellation, not a tool failure.
+            const result = signal && typeof signal.addEventListener === "function"
+                ? await raceWithAbortSignal(inner, signal)
+                : await inner;
             return this.truncateToolResult(toolName, result);
         };
     }
@@ -241,11 +297,11 @@ export class ToolsManager {
                 const guardedExecute = this.wrapExecuteWithTruncation(toolName, originalExecute);
                 tools[toolName] = {
                     ...directTool,
-                    execute: async (params) => {
+                    execute: async (params, execOptions) => {
                         const startTime = Date.now();
                         this.emitToolEvent("tool:start", toolName, { input: params });
                         try {
-                            const result = await guardedExecute(params);
+                            const result = await guardedExecute(params, execOptions);
                             this.emitToolEvent("tool:end", toolName, {
                                 result,
                                 success: true,
@@ -541,11 +597,11 @@ export class ToolsManager {
             return createAISDKTool({
                 description: tool.description || `External MCP tool ${tool.name}`,
                 inputSchema: finalSchema, // AI SDK v6 uses inputSchema (not parameters)
-                execute: async (params) => {
+                execute: async (params, execOptions) => {
                     const startTime = Date.now();
                     this.emitToolEvent("tool:start", tool.name, { input: params });
                     try {
-                        const result = await guardedExecute(params);
+                        const result = await guardedExecute(params, execOptions);
                         this.emitToolEvent("tool:end", tool.name, {
                             result,
                             success: true,

package/dist/index.d.ts

@@ -35,7 +35,12 @@ import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export { NeuroLinkConfigManager as ConfigManager } from "./config/configManager.js";
 export { BaseFactory, BaseRegistry, NeuroLinkFeatureError, createErrorFactory, withRetry, TypedEventEmitter, } from "./core/infrastructure/index.js";
-export { NeuroLinkClient, createClient, NeuroLinkApiError, NeuroLinkLanguageModel, NeuroLinkAIProvider, createNeuroLinkProvider, createNeuroLinkModel, createStreamingResponse, neurolink as neuroLinkAIInstance, createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamicAuthInterceptor, createLoggingInterceptor, createRetryInterceptor, createRateLimitInterceptor, createRequestTransformInterceptor, createResponseTransformInterceptor, createCacheInterceptor, createTimeoutInterceptor, createErrorHandlerInterceptor, composeMiddleware, conditionalMiddleware, SSEClient, WebSocketStreamingClient, createStreamingClient, createAsyncStream, collectStream, OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMiddleware, createTokenManagerMiddleware, createAuthWithRetryMiddleware, createMultiAuthMiddleware, OAuth2Error, OAuth2AuthError, TokenRefreshError, decodeJWTPayload, isJWTExpired, getJWTExpiry, getApiKeyFromEnv, ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/index.js";
+export { NeuroLinkClient, createClient, NeuroLinkApiError, } from "./client/httpClient.js";
+export { NeuroLinkLanguageModel, NeuroLinkProvider as NeuroLinkAIProvider, createNeuroLinkProvider, createNeuroLinkModel, createStreamingResponse, neurolink as neuroLinkAIInstance, } from "./client/aiSdkAdapter.js";
+export { createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamicAuthInterceptor, createLoggingInterceptor, createRetryInterceptor, createRateLimitInterceptor, createRequestTransformInterceptor, createResponseTransformInterceptor, createCacheInterceptor, createTimeoutInterceptor, createErrorHandlerInterceptor, composeMiddleware, conditionalMiddleware, } from "./client/interceptors.js";
+export { SSEClient, WebSocketStreamingClient, createStreamingClient, createAsyncStream, collectStream, } from "./client/streamingClient.js";
+export { OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMiddleware, createTokenManagerMiddleware, createAuthWithRetryMiddleware, createMultiAuthMiddleware, OAuth2Error, OAuth2AuthenticationError as OAuth2AuthError, TokenRefreshError, decodeJWTPayload, isJWTExpired, getJWTExpiry, getApiKeyFromEnv, } from "./client/auth.js";
+export { ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/errors.js";
 export { AIProviderName, BedrockModels, OpenAIModels, VertexModels, } from "./constants/enums.js";
 export { dynamicModelProvider } from "./core/dynamicModels.js";
 export { validateTool } from "./sdk/toolRegistration.js";

package/dist/index.js

@@ -41,20 +41,28 @@ export { BaseFactory, BaseRegistry, NeuroLinkFeatureError, createErrorFactory, w
 // ============================================================================
 // CLIENT SDK EXPORTS - Type-safe API access for browser and Node.js
 // Note: React hooks are NOT re-exported here. Import from '@juspay/neurolink/client'.
+// These re-exports intentionally bypass ./client/index.js: that barrel statically
+// re-exports ./reactHooks.js, so routing through it makes the ROOT import require
+// `react` (an optional peer dep) and crash react-less installs at import time.
 // ============================================================================
 export { 
 // HTTP Client
-NeuroLinkClient, createClient, NeuroLinkApiError, 
+NeuroLinkClient, createClient, NeuroLinkApiError, } from "./client/httpClient.js";
+export { 
 // AI SDK Adapter
-NeuroLinkLanguageModel, NeuroLinkAIProvider, createNeuroLinkProvider, createNeuroLinkModel, createStreamingResponse, neurolink as neuroLinkAIInstance, 
+NeuroLinkLanguageModel, NeuroLinkProvider as NeuroLinkAIProvider, createNeuroLinkProvider, createNeuroLinkModel, createStreamingResponse, neurolink as neuroLinkAIInstance, } from "./client/aiSdkAdapter.js";
+export { 
 // Interceptors
-createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamicAuthInterceptor, createLoggingInterceptor, createRetryInterceptor, createRateLimitInterceptor, createRequestTransformInterceptor, createResponseTransformInterceptor, createCacheInterceptor, createTimeoutInterceptor, createErrorHandlerInterceptor, composeMiddleware, conditionalMiddleware, 
+createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamicAuthInterceptor, createLoggingInterceptor, createRetryInterceptor, createRateLimitInterceptor, createRequestTransformInterceptor, createResponseTransformInterceptor, createCacheInterceptor, createTimeoutInterceptor, createErrorHandlerInterceptor, composeMiddleware, conditionalMiddleware, } from "./client/interceptors.js";
+export { 
 // Streaming Client
-SSEClient, WebSocketStreamingClient, createStreamingClient, createAsyncStream, collectStream, 
+SSEClient, WebSocketStreamingClient, createStreamingClient, createAsyncStream, collectStream, } from "./client/streamingClient.js";
+export { 
 // Authentication
-OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMiddleware, createTokenManagerMiddleware, createAuthWithRetryMiddleware, createMultiAuthMiddleware, OAuth2Error, OAuth2AuthError, TokenRefreshError, decodeJWTPayload, isJWTExpired, getJWTExpiry, getApiKeyFromEnv, 
+OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMiddleware, createTokenManagerMiddleware, createAuthWithRetryMiddleware, createMultiAuthMiddleware, OAuth2Error, OAuth2AuthenticationError as OAuth2AuthError, TokenRefreshError, decodeJWTPayload, isJWTExpired, getJWTExpiry, getApiKeyFromEnv, } from "./client/auth.js";
+export { 
 // Errors
-ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/index.js";
+ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/errors.js";
 export { AIProviderName, BedrockModels, OpenAIModels, VertexModels, } from "./constants/enums.js";
 // Dynamic Models exports
 export { dynamicModelProvider } from "./core/dynamicModels.js";

package/dist/lib/constants/contextWindows.js

@@ -154,6 +154,8 @@ export const MODEL_CONTEXT_WINDOWS = {
     },
     anthropic: {
         _default: 200_000,
+        // Claude 5 (mid 2026) — 1M context window
+        "claude-sonnet-5": 1_000_000,
         // Claude 4.6 (Feb 2026) — 1M context window
         "claude-opus-4-6": 1_000_000,
         "claude-sonnet-4-6": 1_000_000,
@@ -243,6 +245,7 @@ export const MODEL_CONTEXT_WINDOWS = {
     vertex: {
         _default: 1_048_576,
         // Claude on Vertex
+        "claude-sonnet-5": 1_000_000,
         "claude-opus-4-6": 1_000_000,
         "claude-sonnet-4-6": 1_000_000,
         "claude-sonnet-4-5": 200_000,
@@ -252,6 +255,13 @@ export const MODEL_CONTEXT_WINDOWS = {
         "claude-sonnet-4-20250514": 200_000,
         "claude-opus-4-20250514": 200_000,
         "claude-opus-4": 200_000,
+        // Catch-all for UNKNOWN Claude models on Vertex (prefix match runs after
+        // the specific keys above). Without this, an unlisted Claude model falls
+        // to the Gemini-shaped _default (1,048,576) — ABOVE Anthropic's real 1M
+        // API cap — so the pre-dispatch budget check and the in-loop context
+        // guard both under-guard it (the claude-sonnet-5 1,005,647-token 400s).
+        // 200K is the conservative Anthropic floor; list real models explicitly.
+        "claude-": 200_000,
         // Gemini 3.1 on Vertex (all require -preview suffix)
         "gemini-3.1-pro-preview": 1_048_576,
         "gemini-3.1-flash-lite-preview": 1_048_576,

package/dist/lib/core/constants.d.ts

@@ -36,6 +36,22 @@ export declare const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 300000;
  * a wrap-up nudge rides the next tool-result turn.
  */
 export declare const DEFAULT_WRAPUP_TIME_LEAD_MS = 120000;
+/**
+ * In-loop context guard threshold for native agentic loops: when the last
+ * model call's actual prompt size (provider-reported usage) plus the
+ * estimated growth from this step's tool results crosses this fraction of
+ * the model's context window, the loop stops calling tools and synthesizes a
+ * final answer instead of stepping into a provider 400 ("prompt is too
+ * long") that would destroy the whole turn's work.
+ */
+export declare const DEFAULT_CONTEXT_GUARD_RATIO = 0.85;
+/**
+ * Floor for the turn budget handed to the post-overflow recovery retry.
+ * The retry inherits the REMAINING `turnTimeoutMs` (whole-turn semantics —
+ * one generate() must not stack two full budgets), but never less than this,
+ * so a compacted retry still gets a workable window.
+ */
+export declare const MIN_RECOVERY_TURN_BUDGET_MS = 30000;
 export declare const TOOL_STORAGE_TIMEOUT_MS = 5000;
 export declare const STEP_LIMITS: {
     min: number;