@juspay/neurolink 10.4.1 → 10.4.3

package/dist/lib/types/proxy.d.ts

@@ -1121,6 +1121,7 @@ export type ProxyAnalysisAccount = {
     unclassifiedRateLimits: number;
 };
 /** Offline report generated from proxy request, attempt, and lifecycle logs. */
+export type ProxyAnalysisStreamName = "lifecycle" | "requests" | "attempts" | "debug";
 export type ProxyAnalysisReport = {
     generatedAt: string;
     since: string;
@@ -1129,6 +1130,7 @@ export type ProxyAnalysisReport = {
         lifecycle: number;
         requests: number;
         attempts: number;
+        debug: number;
     };
     coverage: {
         lifecycle: boolean;
@@ -1143,6 +1145,20 @@ export type ProxyAnalysisReport = {
         unsupportedLifecycleLines: number;
         lifecycleSequenceGaps: number;
         lifecycleSequenceDuplicates: number;
+        streams: Record<ProxyAnalysisStreamName, {
+            observedFrom: string | null;
+            observedTo: string | null;
+            startsAtOrBeforeRequestedWindow: boolean;
+        }>;
+        bodyArtifacts: {
+            capturesIndexed: number;
+            artifactsReferenced: number;
+            artifactsPresent: number;
+            artifactsMissing: number;
+            invalidPaths: number;
+            writeFailures: number;
+            truncatedCaptures: number;
+        };
     };
     lifecycle: {
         accepted: number;
@@ -1392,6 +1408,7 @@ export type StoredBodyArtifact = {
     storedFileBytes?: number;
     redactedBody?: string;
     bodyTruncated?: boolean;
+    bodyWriteFailed?: boolean;
 };
 /** File the proxy logger tracks for rotation and cleanup. */
 export type ManagedLogFile = {
@@ -1653,6 +1670,11 @@ export type ProxyWorkerStatusMessage = {
     generation: number;
     pid: number;
     socketId: string;
+} | {
+    type: "proxy-worker:replacement-requested";
+    generation: number;
+    pid: number;
+    reason: "environment";
 };
 export type ProxyWorkerSocketMessage = {
     type: "proxy-worker:socket";
@@ -1661,6 +1683,8 @@ export type ProxyWorkerSocketMessage = {
 };
 export type ProxyWorkerIpcMessage = ProxyWorkerControlMessage | ProxyWorkerStatusMessage | ProxyWorkerSocketMessage;
 export type TransferableProxySocket = Pick<import("node:net").Socket, "destroy" | "end" | "pause" | "resume" | "once">;
+/** A transferred socket whose temporary handoff listeners can be detached. */
+export type DetachableTransferableProxySocket = TransferableProxySocket & Pick<import("node:net").Socket, "off">;
 export type RollingWorkerHandle = {
     pid: number;
     sendControl: (message: ProxyWorkerControlMessage) => void;
@@ -1714,6 +1738,11 @@ export type RollingWorkerSupervisorOptions = {
     socketQueueTimeoutMs?: number;
     shutdownTimeoutMs?: number;
     onStateChange?: (snapshot: RollingWorkerSupervisorSnapshot) => void;
+    onReplacementRequested?: (request: {
+        generation: number;
+        pid: number;
+        reason: "environment";
+    }) => void;
     log?: (message: string) => void;
 };
 export type RollingProxyServerOptions = {
@@ -1854,6 +1883,7 @@ export type ProxyRuntimeConfigReloadResult = {
     applied: boolean;
     changed: boolean;
     generation: number;
+    environmentChanged?: boolean;
     error?: string;
 };
 /** Safe runtime configuration diagnostics exposed through proxy status. */
@@ -1933,7 +1963,7 @@ export type StatusStats = {
         transientRateLimits?: number;
         quotaRateLimits?: number;
         cooling: boolean;
-        status?: "active" | "cooling" | "disabled" | "excluded" | "removed";
+        status?: "active" | "cooling" | "disabled" | "excluded" | "removed" | "unattributed";
     }[];
     persistence?: ProxyStatsPersistenceStatus;
 };

package/dist/lib/types/toolResolution.d.ts

@@ -8,6 +8,7 @@
  * `BaseProvider` that every generate/stream path passes through.
  */
 import type { ToolConfig } from "./config.js";
+import type { Tool } from "./tools.js";
 /**
  * The resolved, merged tool policy for one request. Produced by
  * `resolveToolPolicy()` (src/lib/tools/toolPolicy.ts) and consumed by
@@ -71,3 +72,12 @@ export type DeferredToolIndexEntry = {
     /** Originating MCP server id, when known. */
     serverId?: string;
 };
+/**
+ * Resolver attached (under a symbol key, invisible to enumeration) to the
+ * hot tool record by `partitionToolsForDiscovery`. Given a deferred tool's
+ * name it hydrates that tool into the record, persists the session pin, and
+ * returns it — `undefined` when the name is not in the deferred catalog.
+ * Native agent loops call it on a dispatch miss so a model that calls a
+ * cataloged tool directly (without `search_tools` first) still succeeds.
+ */
+export type DeferredToolResolver = (name: string) => Tool | undefined;

package/dist/providers/anthropic.js

@@ -15,6 +15,7 @@ import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../utils/pricing.js";
+import { resolveDeferredTool } from "../tools/toolDiscovery.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -1400,6 +1401,18 @@ export class AnthropicProvider extends BaseProvider {
             let totalCacheWrite = 0;
             let lastStop = null;
             for (let step = 0; step < maxSteps; step++) {
+                // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
+                // new tools into toolsRecord between steps; Claude only calls tools
+                // declared in the request, so advertise them now (`params` below
+                // rebuilds from anthropicTools every step).
+                if (anthropicTools) {
+                    const declared = new Set(anthropicTools.map((t) => t.name));
+                    const hydrated = Object.fromEntries(Object.entries(toolsRecord).filter(([name]) => !declared.has(name)));
+                    if (Object.keys(hydrated).length > 0) {
+                        anthropicTools.push(...(toolsToAnthropic(hydrated) ?? []));
+                        logger.info(`[Anthropic] ${Object.keys(hydrated).length} tool(s) hydrated mid-turn via discovery: ${Object.keys(hydrated).join(", ")}`);
+                    }
+                }
                 // Prompt-cache parity with the native Vertex+Claude path — rolling
                 // history breakpoints, re-applied per step so the stable prefix
                 // stays byte-identical while the breakpoint follows the growing
@@ -1566,7 +1579,11 @@ export class AnthropicProvider extends BaseProvider {
                         args,
                     });
                     toolsUsed.push(acc.name);
-                    const tool = toolsRecord[acc.name];
+                    // Live record lookup, then deferred-catalog auto-hydration: with
+                    // tools.discovery on, the model may call a cataloged tool it never
+                    // loaded via search_tools — a real tool, not a hallucination.
+                    const tool = (toolsRecord[acc.name] ??
+                        resolveDeferredTool(toolsRecord, acc.name));
                     try {
                         if (!tool?.execute) {
                             throw new Error(`Tool not found: ${acc.name}`);

package/dist/providers/googleAiStudio.js

@@ -10,7 +10,7 @@ import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../
 import { withTimeout } from "../utils/async/index.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
-import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, DedupExecuteMap, } from "./googleNativeGemini3.js";
+import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "./googleNativeGemini3.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
@@ -523,10 +523,12 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 let toolsConfig;
                 let executeMap = new DedupExecuteMap();
                 let originalNameMap = new Map();
+                let declarationsResult;
                 if (options.tools &&
                     Object.keys(options.tools).length > 0 &&
                     !options.disableTools) {
                     const result = buildNativeToolDeclarations(options.tools);
+                    declarationsResult = result;
                     toolsConfig = result.toolsConfig;
                     executeMap = result.executeMap;
                     originalNameMap = result.originalNameMap;
@@ -597,6 +599,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     : new Error("Request aborted");
                             }
                             step++;
+                            // Mid-turn discovery sync: advertise tools hydrated into the
+                            // live record by search_tools during the previous step.
+                            if (declarationsResult) {
+                                refreshNativeToolDeclarations(options.tools, declarationsResult);
+                            }
                             logger.debug(`[GoogleAIStudio] Native SDK step ${step}/${maxSteps}`);
                             try {
                                 const rawStream = await client.models.generateContentStream({
@@ -640,6 +647,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     abortSignal: composedSignal,
                                     originalNameMap,
                                     toolExecutions,
+                                    liveTools: options.tools,
+                                    declarations: declarationsResult,
                                 });
                                 // Persist this step's tool calls/results into conversation
                                 // memory. Without this, tool_call / tool_result rows never
@@ -810,11 +819,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 let toolsConfig;
                 let executeMap = new DedupExecuteMap();
                 let originalNameMap = new Map();
+                let declarationsResult;
                 const shouldUseTools = !options.disableTools;
                 if (shouldUseTools) {
                     const tools = options.tools || {};
                     if (Object.keys(tools).length > 0) {
                         const result = buildNativeToolDeclarations(tools);
+                        declarationsResult = result;
                         toolsConfig = result.toolsConfig;
                         executeMap = result.executeMap;
                         originalNameMap = result.originalNameMap;
@@ -856,6 +867,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             : new Error("Request aborted");
                     }
                     step++;
+                    // Mid-turn discovery sync — see the stream twin.
+                    if (declarationsResult) {
+                        refreshNativeToolDeclarations(options.tools, declarationsResult);
+                    }
                     logger.debug(`[GoogleAIStudio] Native SDK generate step ${step}/${maxSteps}`);
                     try {
                         const stream = await client.models.generateContentStream({
@@ -894,6 +909,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             toolExecutions,
                             abortSignal: composedSignal,
                             originalNameMap,
+                            liveTools: options.tools,
+                            declarations: declarationsResult,
                         });
                         // Persist this step's tool calls/results into conversation memory.
                         const stepToolCalls = allToolCalls.slice(toolCallsBefore);

package/dist/providers/googleNativeGemini3.d.ts

@@ -82,7 +82,16 @@ export declare function normalizeToolsForJsonSchemaProvider(tools: Record<string
  *
  * This handles both Zod schemas and plain JSON Schema objects for tool parameters.
  */
-export declare function buildNativeToolDeclarations(tools: Record<string, Tool>): NativeToolDeclarationsResult;
+export declare function buildNativeToolDeclarations(tools: Record<string, Tool>, reservedNames?: ReadonlySet<string>): NativeToolDeclarationsResult;
+/**
+ * Mid-turn tool sync for the native Gemini loops that build their snapshot
+ * via buildNativeToolDeclarations. `search_tools` (tools.discovery) hydrates
+ * discovered tools into the live record between steps; without this refresh
+ * they stay invisible to the rest of the turn and every call dies as
+ * TOOL_NOT_FOUND. Mutates the snapshot in place — the request config holds
+ * `toolsConfig` by reference — and returns true when anything was added.
+ */
+export declare function refreshNativeToolDeclarations(liveTools: Record<string, Tool> | undefined, current: NativeToolDeclarationsResult): boolean;
 /**
  * Build the native @google/genai config object shared by stream and generate.
  *
@@ -217,6 +226,15 @@ export declare function executeNativeToolCalls(logLabel: string, stepFunctionCal
     }>;
     abortSignal?: AbortSignal;
     originalNameMap?: Map<string, string>;
+    /**
+     * Live tool record + declaration snapshot for mid-turn discovery: on a
+     * dispatch miss the executor re-resolves against `liveTools` (hydrated
+     * by search_tools, or auto-hydrated from the deferred catalog) and syncs
+     * `declarations` in place. `declarations.executeMap` must be the same
+     * map passed as the `executeMap` argument (true at every call site).
+     */
+    liveTools?: Record<string, Tool>;
+    declarations?: NativeToolDeclarationsResult;
 }): Promise<NativeFunctionResponse[]>;
 /**
  * Handle maxSteps termination by producing a final answer when the model was

package/dist/providers/googleNativeGemini3.js

@@ -15,6 +15,7 @@ import { DEFAULT_CONTEXT_GUARD_RATIO, DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIE
 import { logger } from "../utils/logger.js";
 import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
+import { resolveLiveTool } from "../tools/toolDiscovery.js";
 import { jsonSchema as aiJsonSchema, tool as createAISDKTool, } from "../utils/tool.js";
 // ── Functions ──
 /** Stable, key-order-independent serialization of tool args for the dedup key. */
@@ -367,7 +368,7 @@ export function normalizeToolsForJsonSchemaProvider(tools) {
  *
  * This handles both Zod schemas and plain JSON Schema objects for tool parameters.
  */
-export function buildNativeToolDeclarations(tools) {
+export function buildNativeToolDeclarations(tools, reservedNames) {
     const functionDeclarations = [];
     const executeMap = new DedupExecuteMap();
     const skippedTools = [];
@@ -380,8 +381,10 @@ export function buildNativeToolDeclarations(tools) {
     // execute are still pushed to functionDeclarations). The originalNameMap
     // lets the calling stream loop translate Google-returned function-call
     // names back to the consumer-facing identifier so the sanitization is
-    // transport-only.
-    const usedNames = new Set();
+    // transport-only. `reservedNames` seeds the collision set so a mid-turn
+    // refresh (see refreshNativeToolDeclarations) never re-issues a safe name
+    // already assigned by the pre-loop snapshot.
+    const usedNames = new Set(reservedNames ?? []);
     const originalNameMap = new Map();
     for (const [name, tool] of Object.entries(tools)) {
         try {
@@ -442,6 +445,36 @@ export function buildNativeToolDeclarations(tools) {
         originalNameMap,
     };
 }
+/**
+ * Mid-turn tool sync for the native Gemini loops that build their snapshot
+ * via buildNativeToolDeclarations. `search_tools` (tools.discovery) hydrates
+ * discovered tools into the live record between steps; without this refresh
+ * they stay invisible to the rest of the turn and every call dies as
+ * TOOL_NOT_FOUND. Mutates the snapshot in place — the request config holds
+ * `toolsConfig` by reference — and returns true when anything was added.
+ */
+export function refreshNativeToolDeclarations(liveTools, current) {
+    if (!liveTools) {
+        return false;
+    }
+    const declaredOriginals = new Set(current.originalNameMap.values());
+    const missing = Object.entries(liveTools).filter(([name]) => !declaredOriginals.has(name));
+    if (missing.length === 0) {
+        return false;
+    }
+    const built = buildNativeToolDeclarations(Object.fromEntries(missing), new Set(current.originalNameMap.keys()));
+    current.toolsConfig[0].functionDeclarations.push(...built.toolsConfig[0].functionDeclarations);
+    for (const [safeName, originalName] of built.originalNameMap) {
+        current.originalNameMap.set(safeName, originalName);
+    }
+    for (const [safeName, execute] of built.executeMap) {
+        current.executeMap.set(safeName, execute);
+    }
+    logger.info(`[buildNativeToolDeclarations] ${missing.length} tool(s) hydrated mid-turn via discovery: ${missing
+        .map(([name]) => name)
+        .join(", ")}`);
+    return true;
+}
 /**
  * Build the native @google/genai config object shared by stream and generate.
  *
@@ -795,7 +828,31 @@ export async function executeNativeToolCalls(logLabel, stepFunctionCalls, execut
             });
             continue;
         }
-        const execute = executeMap.get(call.name);
+        let execute = executeMap.get(call.name);
+        if (!execute && options?.declarations) {
+            // Snapshot miss: the tool may have been hydrated into the live record
+            // by search_tools within this very step batch, or the model called a
+            // deferred catalog tool directly by its advertised name.
+            const liveTool = resolveLiveTool(options.liveTools, exposedName);
+            if (liveTool?.execute) {
+                refreshNativeToolDeclarations(options.liveTools, options.declarations);
+                // NOT_FOUND strikes accrued while the tool was deferred are snapshot
+                // artifacts, not real failures — reset so the breaker starts clean.
+                failedTools.delete(call.name);
+                // The refresh registered the executor under its Google-safe name —
+                // resolve it for this dispatch (later calls use the declared name).
+                for (const [safeName, originalName] of options.declarations
+                    .originalNameMap) {
+                    if (originalName === exposedName) {
+                        execute = executeMap.get(safeName);
+                        break;
+                    }
+                }
+                if (execute) {
+                    logger.info(`${logLabel} Tool "${exposedName}" resolved mid-turn via discovery — executing.`);
+                }
+            }
+        }
         if (execute) {
             try {
                 // AI SDK Tool execute requires (args, options) - provide minimal options

package/dist/providers/googleVertex.d.ts

@@ -152,6 +152,54 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Create @google/genai client configured for Vertex AI
      */
     private createVertexGenAIClient;
+    /**
+     * 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
+     * discovery refresh — Anthropic validates input_schema as JSON Schema
+     * draft 2020-12 and rejects OpenAPI-3 dialect (`nullable: true`), so this
+     * uses the default JSON Schema target, matching the direct anthropic
+     * provider. The Gemini paths keep "openApi3".
+     */
+    private buildAnthropicToolDeclaration;
+    /**
+     * Mid-turn tool sync for the Claude-on-Vertex loops — the Anthropic
+     * counterpart of refreshGeminiToolDeclarations. 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.
+     */
+    private resolveAnthropicToolOnMiss;
     /**
      * 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