@juspay/neurolink 12.14.7 → 12.14.9

package/dist/cli/commands/proxy.js

@@ -25,7 +25,8 @@ import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../proxy/workerLog.js";
 import { startRollingProxyServer } from "../../proxy/rollingProxyServer.js";
-import { startProxyRestartControl } from "../../proxy/restartControl.js";
+import { startProxyRestartControl, requestProxySupervisorTelemetry, } from "../../proxy/restartControl.js";
+import { getProxyProcessTelemetry } from "../../proxy/processTelemetry.js";
 import { isProxyAuxiliaryRequest } from "../../proxy/proxyRequestKind.js";
 import { spawnProxySocketWorker } from "../../proxy/rollingWorkerProcess.js";
 import { PROXY_ROLLING_SUPERVISOR_ENV, PROXY_SOCKET_WORKER_ENV, } from "../../proxy/rollingWorkerProtocol.js";
@@ -2076,6 +2077,10 @@ export async function createProxyStartApp(params) {
                 };
             })(),
             observability: {
+                process: getProxyProcessTelemetry(),
+                supervisor: supervisorState?.pid
+                    ? await requestProxySupervisorTelemetry(supervisorState.restartControl, supervisorState.pid)
+                    : { status: "not_applicable" },
                 lifecycle: getProxyLifecycleLoggerSnapshot(),
                 requestLogs: getRequestLoggerSnapshot(),
             },
@@ -2893,6 +2898,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         restartControl = await startProxyRestartControl({
             stateDir: join(homedir(), ".neurolink"),
             server: rollingServer,
+            getTelemetry: getProxyProcessTelemetry,
             log: (message) => logger.warn(message),
             isUpdatePending: () => !!rollingReplacement || !!loadUpdateState()?.pendingRestartVersion,
             getInstalledVersion: async () => {

package/dist/index.d.ts

@@ -46,6 +46,7 @@ export { createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamic
 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 { BaseError, ProviderError, AuthenticationError, AuthorizationError, NetworkError, RateLimitError, InvalidModelError, } from "./types/index.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

@@ -73,6 +73,17 @@ OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMi
 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/errors.js";
+// The SDK-side error hierarchy `classifyProviderError()` actually throws
+// (as opposed to the unrelated `Client*` REST-client errors above). These
+// already reach consumers transitively through `export * from
+// "./types/index.js"` below, but that makes them public by accident of the
+// types barrel's shape — a future reshuffle of that barrel could drop them
+// silently. Exporting them here, explicitly, by name, makes the guarantee
+// intentional: `catch (e) { if (e instanceof RateLimitError) ... }` against
+// `@juspay/neurolink` is a supported, stable pattern, not an implementation
+// detail a caller happened to be able to reach. Imported from the barrel
+// (never the specific `types/errors.js` file) per Critical Rule 13.
+export { BaseError, ProviderError, AuthenticationError, AuthorizationError, NetworkError, RateLimitError, InvalidModelError, } from "./types/index.js";
 export { AIProviderName, BedrockModels, OpenAIModels, VertexModels, } from "./constants/enums.js";
 // Dynamic Models exports
 export { dynamicModelProvider } from "./core/dynamicModels.js";

package/dist/mcp/servers/aiProviders/aiAnalysisTools.js

@@ -185,41 +185,54 @@ const _benchmarkProviderPerformanceTool = {
             ];
             const benchmarkResults = [];
             for (const providerName of providersToTest) {
-                const provider = await AIProviderFactory.createProvider(providerName);
-                if (!provider) {
+                try {
+                    const provider = await AIProviderFactory.createProvider(providerName);
+                    if (!provider) {
+                        benchmarkResults.push({
+                            provider: providerName,
+                            error: "Failed to create provider.",
+                        });
+                        continue;
+                    }
+                    let totalLatency = 0, totalTokens = 0, successfulTests = 0;
+                    for (const prompt of testPrompts) {
+                        for (let i = 0; i < typedParams.iterations; i++) {
+                            const testStartTime = Date.now();
+                            const result = await provider.generate({
+                                prompt: prompt,
+                                maxTokens: typedParams.maxTokens,
+                            });
+                            if (result && result.usage) {
+                                totalLatency += Date.now() - testStartTime;
+                                totalTokens += result.usage.total || 0;
+                                successfulTests++;
+                            }
+                        }
+                    }
                     benchmarkResults.push({
                         provider: providerName,
-                        error: "Failed to create provider.",
+                        metrics: {
+                            avgLatency: successfulTests > 0
+                                ? Math.round(totalLatency / successfulTests)
+                                : 0,
+                            total: totalTokens,
+                            successRate: (successfulTests /
+                                (testPrompts.length * typedParams.iterations)) *
+                                100,
+                        },
                     });
-                    continue;
                 }
-                let totalLatency = 0, totalTokens = 0, successfulTests = 0;
-                for (const prompt of testPrompts) {
-                    for (let i = 0; i < typedParams.iterations; i++) {
-                        const testStartTime = Date.now();
-                        const result = await provider.generate({
-                            prompt: prompt,
-                            maxTokens: typedParams.maxTokens,
-                        });
-                        if (result && result.usage) {
-                            totalLatency += Date.now() - testStartTime;
-                            totalTokens += result.usage.total || 0;
-                            successfulTests++;
-                        }
-                    }
+                catch (providerError) {
+                    // A single provider's failure (network, auth, rate-limit, etc.)
+                    // must not abort the whole benchmark — record it and keep testing
+                    // the remaining providers, mirroring the null-provider branch above.
+                    benchmarkResults.push({
+                        provider: providerName,
+                        error: providerError instanceof Error
+                            ? providerError.message
+                            : String(providerError),
+                    });
                 }
-                benchmarkResults.push({
-                    provider: providerName,
-                    metrics: {
-                        avgLatency: successfulTests > 0
-                            ? Math.round(totalLatency / successfulTests)
-                            : 0,
-                        total: totalTokens,
-                        successRate: (successfulTests /
-                            (testPrompts.length * typedParams.iterations)) *
-                            100,
-                    },
-                });
             }
             const executionTime = Date.now() - startTime;
             return {

package/dist/neurolink.d.ts

@@ -1648,7 +1648,10 @@ export declare class NeuroLink {
      */
     testProvider(providerName: string): Promise<boolean>;
     /**
-     * Internal method to test provider connection with minimal generation call
+     * Internal method to test provider connection with minimal generation call.
+     * `signal` lets a caller (getProviderStatus's per-provider race) cancel the
+     * underlying request once it has already lost the race against its
+     * timeout, instead of leaving it running unobserved.
      */
     private testProviderConnection;
     /**

package/dist/neurolink.js

@@ -6490,6 +6490,14 @@ Current user's request: ${currentInput}`;
         if (lastError instanceof ContextBudgetExceededError) {
             throw lastError;
         }
+        // A single-candidate list (an explicit provider, or
+        // disableInternalFallback) never actually tried "all providers" —
+        // naming the one provider that failed is clearer than the generic
+        // multi-provider wording. The multi-provider prefix is left untouched
+        // so existing message-matching suites keep passing.
+        if (providersToTry.length === 1) {
+            throw new Error(`Provider ${providersToTry[0]} failed: ${lastError?.message || "Unknown error"}`);
+        }
         throw new Error(`Failed to generate text with all providers. Last error: ${lastError?.message || "Unknown error"}`);
     }
     /**
@@ -10863,13 +10871,36 @@ Current user's request: ${currentInput}`;
                         };
                     }
                 }
-                // Test other providers with actual generation call
+                // Test other providers with actual generation call. The losing
+                // side of the race is aborted in `finally` below — previously the
+                // timeout promise alone rejected while the still-running
+                // testProviderConnection() call (and the provider request inside
+                // it) kept executing to completion unobserved, wasting quota and
+                // holding the connection open past the 5s status check.
                 const testTimeout = 5000;
-                const testPromise = this.testProviderConnection(providerName);
+                const abortController = new AbortController();
+                const testPromise = this.testProviderConnection(providerName, abortController.signal);
+                let timeoutHandle;
                 const timeoutPromise = new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error("Provider test timeout (5s)")), testTimeout);
+                    timeoutHandle = setTimeout(() => {
+                        reject(new Error("Provider test timeout (5s)"));
+                    }, testTimeout);
                 });
-                await Promise.race([testPromise, timeoutPromise]);
+                try {
+                    await Promise.race([testPromise, timeoutPromise]);
+                }
+                finally {
+                    // Runs on both outcomes: clears the timer so it can't fire after
+                    // a fast success, and aborts the signal so a timed-out
+                    // generate() call stops instead of finishing unobserved.
+                    clearTimeout(timeoutHandle);
+                    // The aborted generate() resolves/rejects after the race is
+                    // decided; swallow that settlement so it can't surface as an
+                    // unhandledRejection, mirroring raceWithAbort's handling of the
+                    // losing side.
+                    testPromise.catch(() => undefined);
+                    abortController.abort();
+                }
                 return {
                     provider: providerName,
                     status: "working",
@@ -10919,15 +10950,19 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Internal method to test provider connection with minimal generation call
+     * Internal method to test provider connection with minimal generation call.
+     * `signal` lets a caller (getProviderStatus's per-provider race) cancel the
+     * underlying request once it has already lost the race against its
+     * timeout, instead of leaving it running unobserved.
      */
-    async testProviderConnection(providerName) {
+    async testProviderConnection(providerName, signal) {
         const { AIProviderFactory } = await import("./core/factory.js");
         const provider = await AIProviderFactory.createProvider(providerName, null);
         await provider.generate({
             prompt: "test",
             maxTokens: 1,
             disableTools: true,
+            abortSignal: signal,
         });
     }
     /**

package/dist/providers/azureOpenai.js

@@ -172,7 +172,7 @@ export class AzureOpenAIProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "azure", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // New overridable hooks (provided by the base-enhancement branch)

package/dist/providers/catalog/loader.d.ts

@@ -2,5 +2,5 @@ import type { OpenAICompatCatalogEntry, ProviderCatalogJson, ProviderConfigOptio
 export declare function catalogCredentialsKey(entry: ProviderCatalogJson): string;
 export declare function catalogEnvVar(entry: ProviderCatalogJson, kind: "apiKey" | "baseURL" | "model"): string;
 export declare function buildCatalogConfigOptions(entry: ProviderCatalogJson): ProviderConfigOptions;
-export declare function getCatalogJsonEntries(): ProviderCatalogJson[];
+export declare function getCatalogJsonEntries(): readonly ProviderCatalogJson[];
 export declare function buildCatalogEntries(): OpenAICompatCatalogEntry[];

package/dist/providers/catalog/loader.js

@@ -70,8 +70,37 @@ function buildErrorRules(entry) {
     });
     return [...bespoke, ...DEFAULT_ERROR_RULES];
 }
+// Recursively freezes a value in place and returns it. Used only on a
+// structuredClone()d graph below — never on CATALOG_JSON_ENTRIES itself —
+// so this never touches the module-level singleton.
+function deepFreeze(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            deepFreeze(item);
+        }
+        return Object.freeze(value);
+    }
+    if (value !== null && typeof value === "object") {
+        for (const key of Object.keys(value)) {
+            deepFreeze(value[key]);
+        }
+        return Object.freeze(value);
+    }
+    return value;
+}
+// Returns a deep clone of the catalog graph, frozen at every level, never
+// the module-level singleton by reference or anything sharing its nested
+// objects/arrays — CATALOG_JSON_ENTRIES is reused on every call, so handing
+// out (a shallow copy of) the live array would let any one caller's
+// mutation corrupt catalog state for the rest of the process, and freezing
+// only the outer array left `entry.aliases`, `entry.models.fallbacks`,
+// `entry.models.catalog` etc. shared and mutable despite the `readonly`
+// return type. structuredClone() first (so the frozen graph never aliases
+// CATALOG_JSON_ENTRIES's own objects), then deepFreeze() the clone. All
+// current callers only .find/.map/.flatMap/.filter/iterate, so this is
+// behavior-preserving for them.
 export function getCatalogJsonEntries() {
-    return CATALOG_JSON_ENTRIES;
+    return deepFreeze(structuredClone(CATALOG_JSON_ENTRIES));
 }
 export function buildCatalogEntries() {
     return CATALOG_JSON_ENTRIES.map((entry) => {

package/dist/providers/cohere.js

@@ -87,7 +87,7 @@ export class CohereProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "cohere", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     async validateConfiguration() {
         return (typeof this.config.apiKey === "string" &&

package/dist/providers/deepseek.js

@@ -89,7 +89,7 @@ export class DeepSeekProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "deepseek", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // Optional hooks — provider-specific quirks

package/dist/providers/googleAiStudio/client.js

@@ -1289,12 +1289,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
             ...options,
             tools: baseTools,
         };
-        // Check for tools + JSON schema conflict (Gemini limitation)
+        // Check for tools + JSON schema conflict, via the shared predicate (same
+        // gate executeStream() and executeNativeGemini3Generate() use) so this
+        // path also honors isGeminiProvider/isNativeAnthropicProvider instead of
+        // hand-rolling its own tools+schema condition.
         const wantsJsonOutput = options.output?.format === "json" || options.schema;
-        if (wantsJsonOutput &&
-            mergedOptions.tools &&
-            Object.keys(mergedOptions.tools).length > 0 &&
-            !mergedOptions.disableTools) {
+        const exclusionInForce = isToolsSchemaExclusionInForce(this.providerName, modelName, !mergedOptions.disableTools, Object.keys(mergedOptions.tools ?? {}).length);
+        if (wantsJsonOutput && exclusionInForce) {
             logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
             mergedOptions = { ...mergedOptions, disableTools: true, tools: {} };
         }

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

@@ -138,32 +138,6 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * this purpose.
      */
     private resolveExpressApiKey;
-    /**
-     * Convert one AI-SDK tool into a Vertex Gemini function declaration.
-     * Single source for the pre-loop snapshot AND the mid-turn discovery
-     * refresh, so tools hydrated by search_tools get the exact same schema
-     * treatment (inline, typed, additionalProperties stripped).
-     */
-    private buildGeminiFunctionDeclaration;
-    /**
-     * Mid-turn tool sync for the native Gemini loops. `search_tools` hydrates
-     * discovered tools into the live `options.tools` record between steps, but
-     * the loop's declarations + executeMap are a pre-loop snapshot — without
-     * this refresh, a tool discovered this turn stays invisible to the rest of
-     * the turn and every call to it dies as TOOL_NOT_FOUND. Mutates the
-     * declaration array in place (the request config holds it by reference)
-     * and clears breaker strikes accrued while the tool was still deferred.
-     */
-    private refreshGeminiToolDeclarations;
-    /**
-     * Dispatch-miss recovery for the native Gemini loops: the model called a
-     * name missing from the executeMap snapshot. Re-read the live record (a
-     * tool hydrated by search_tools in this very step batch) or auto-hydrate a
-     * deferred catalog tool the model called directly by its advertised name.
-     * Returns the dedup-wrapped executor, or undefined when the name is
-     * genuinely unknown — callers keep TOOL_NOT_FOUND for that case.
-     */
-    private resolveGeminiToolOnMiss;
     /**
      * Convert one AI-SDK tool into an Anthropic (Claude-on-Vertex) tool
      * declaration. Single source for the pre-loop snapshot AND the mid-turn
@@ -174,18 +148,25 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     private buildAnthropicToolDeclaration;
     /**
-     * Mid-turn tool sync for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of refreshGeminiToolDeclarations. Claude only calls tools
+     * Mid-turn tool sync for the Claude-on-Vertex loops. Claude only calls tools
      * present in the request's `tools` array, so without this per-step refresh
      * a tool discovered via search_tools is unreachable for the rest of the
      * turn. Mutates the array in place (requestParams holds it by reference).
      */
     private refreshAnthropicToolDeclarations;
     /**
-     * Dispatch-miss recovery for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of resolveGeminiToolOnMiss.
+     * Dispatch-miss recovery for the Claude-on-Vertex loops.
      */
     private resolveAnthropicToolOnMiss;
+    /**
+     * Build the synthetic `final_result` tool used to force structured output
+     * on Claude-on-Vertex. Anthropic has no native responseSchema, so a schema
+     * is instead enforced by requiring the model to call this tool with
+     * matching arguments. Single source for the non-streaming and streaming
+     * paths — both previously built this object independently from their own
+     * schema variable, byte-identical apart from that variable's name.
+     */
+    private buildFinalResultTool;
     /**
      * Execute stream using native @google/genai SDK for Gemini 3 models on Vertex AI
      * This bypasses @ai-sdk/google-vertex to properly handle thought_signature