@juspay/neurolink 10.4.1 → 10.4.3

package/dist/cli/commands/proxy.d.ts

@@ -22,7 +22,7 @@ import { ProxyRuntimeConfigStore } from "../../lib/proxy/runtimeConfig.js";
  *   string) recorded when the supervisor we expect at `pid` was launched.
  *   When provided, this is cross-checked against `pid`'s actual OS-reported
  *   start time (see {@link getProcessStartTime}) — the args match alone
- *   ("neurolink" + "proxy" both present) is not airtight, since an
+ *   (the `neurolink proxy start` command is present) is not airtight, since an
  *   unrelated process (e.g. a shell running this very test suite, or a
  *   coincidentally-named script) could match it too. A pid recycled by such
  *   a process would have a start time far from the recorded supervisor

package/dist/cli/commands/proxy.js

@@ -187,7 +187,7 @@ async function getProcessStartTime(pid) {
  *   string) recorded when the supervisor we expect at `pid` was launched.
  *   When provided, this is cross-checked against `pid`'s actual OS-reported
  *   start time (see {@link getProcessStartTime}) — the args match alone
- *   ("neurolink" + "proxy" both present) is not airtight, since an
+ *   (the `neurolink proxy start` command is present) is not airtight, since an
  *   unrelated process (e.g. a shell running this very test suite, or a
  *   coincidentally-named script) could match it too. A pid recycled by such
  *   a process would have a start time far from the recorded supervisor
@@ -215,9 +215,9 @@ export async function processLooksLikeProxySupervisor(pid, expectedStartTimeIso)
     // "neurolink", an editor with a neurolink file open) would match, and a
     // stale/recycled pid running such a process could then be SIGTERM'd/
     // SIGKILL'd by `ensureSupervisorStoppedBeforeClear` during uninstall.
-    // Require the actual proxy-supervisor invocation — both "neurolink" AND
-    // the "proxy" subcommand present in args.
-    if (!(/neurolink/i.test(args) && /\bproxy\b/i.test(args))) {
+    // Require the actual proxy-supervisor invocation. Commands such as
+    // `neurolink proxy status` must never be mistaken for the listener owner.
+    if (!/\bneurolink(?:-proxy)?\b.*\bproxy\s+start\b/i.test(args)) {
         return false;
     }
     if (!expectedStartTimeIso) {
@@ -1556,6 +1556,80 @@ export async function createProxyStartApp(params) {
         });
         const primaryAccount = await resolveStatusPrimaryAccount(activeProxyConfig);
         const activeUpdaterPid = supervisorState?.updaterPid ?? runtimeState?.updaterPid;
+        const accountRows = Object.values(stats.accounts).map((account) => {
+            const normalizedKey = normalizeAnthropicAccountKey(account.label);
+            const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
+            const accountKey = storedAccountKeys.has(normalizedKey)
+                ? normalizedKey
+                : isLegacyAccount
+                    ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                    : account.label === "env"
+                        ? ENV_ANTHROPIC_ACCOUNT_KEY
+                        : normalizedKey;
+            const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
+            const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
+            const accountStatus = disabledAccountKeys.has(accountKey)
+                ? "disabled"
+                : !isAccountAllowed(accountKey, activeAccountAllowlist)
+                    ? "excluded"
+                    : accountInventoryLoaded && account.type === "oauth" && !isStored
+                        ? "removed"
+                        : cooling
+                            ? "cooling"
+                            : "active";
+            return {
+                label: account.label,
+                type: account.type,
+                attempts: account.attemptCount,
+                requests: account.successCount + account.errorCount,
+                success: account.successCount,
+                errors: account.errorCount,
+                attemptErrors: account.attemptErrorCount,
+                rateLimits: account.rateLimitCount,
+                transientRateLimits: account.transientRateLimitCount,
+                quotaRateLimits: account.quotaRateLimitCount,
+                cooling,
+                status: accountStatus,
+            };
+        });
+        const attributed = accountRows.reduce((total, account) => ({
+            attempts: total.attempts + (account.attempts ?? 0),
+            requests: total.requests + (account.requests ?? 0),
+            success: total.success + (account.success ?? 0),
+            errors: total.errors + (account.errors ?? 0),
+            attemptErrors: total.attemptErrors + (account.attemptErrors ?? 0),
+            rateLimits: total.rateLimits + (account.rateLimits ?? 0),
+            transientRateLimits: total.transientRateLimits + (account.transientRateLimits ?? 0),
+            quotaRateLimits: total.quotaRateLimits + (account.quotaRateLimits ?? 0),
+        }), {
+            attempts: 0,
+            requests: 0,
+            success: 0,
+            errors: 0,
+            attemptErrors: 0,
+            rateLimits: 0,
+            transientRateLimits: 0,
+            quotaRateLimits: 0,
+        });
+        const unattributed = {
+            attempts: Math.max(0, stats.totalAttempts - attributed.attempts),
+            requests: Math.max(0, stats.totalRequests - attributed.requests),
+            success: Math.max(0, stats.totalSuccess - attributed.success),
+            errors: Math.max(0, stats.totalErrors - attributed.errors),
+            attemptErrors: Math.max(0, stats.totalAttemptErrors - attributed.attemptErrors),
+            rateLimits: Math.max(0, stats.totalRateLimits - attributed.rateLimits),
+            transientRateLimits: Math.max(0, stats.totalTransientRateLimits - attributed.transientRateLimits),
+            quotaRateLimits: Math.max(0, stats.totalQuotaRateLimits - attributed.quotaRateLimits),
+        };
+        if (Object.values(unattributed).some((count) => count > 0)) {
+            accountRows.push({
+                label: "unattributed",
+                type: "internal",
+                ...unattributed,
+                cooling: false,
+                status: "unattributed",
+            });
+        }
         return c.json({
             status: "running",
             ready: health.ready,
@@ -1578,42 +1652,7 @@ export async function createProxyStartApp(params) {
                 totalRateLimits: stats.totalRateLimits,
                 totalTransientRateLimits: stats.totalTransientRateLimits,
                 totalQuotaRateLimits: stats.totalQuotaRateLimits,
-                accounts: Object.values(stats.accounts).map((account) => {
-                    const normalizedKey = normalizeAnthropicAccountKey(account.label);
-                    const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
-                    const accountKey = storedAccountKeys.has(normalizedKey)
-                        ? normalizedKey
-                        : isLegacyAccount
-                            ? LEGACY_ANTHROPIC_ACCOUNT_KEY
-                            : account.label === "env"
-                                ? ENV_ANTHROPIC_ACCOUNT_KEY
-                                : normalizedKey;
-                    const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
-                    const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
-                    const accountStatus = disabledAccountKeys.has(accountKey)
-                        ? "disabled"
-                        : !isAccountAllowed(accountKey, activeAccountAllowlist)
-                            ? "excluded"
-                            : accountInventoryLoaded && account.type === "oauth" && !isStored
-                                ? "removed"
-                                : cooling
-                                    ? "cooling"
-                                    : "active";
-                    return {
-                        label: account.label,
-                        type: account.type,
-                        attempts: account.attemptCount,
-                        requests: account.successCount + account.errorCount,
-                        success: account.successCount,
-                        errors: account.errorCount,
-                        attemptErrors: account.attemptErrorCount,
-                        rateLimits: account.rateLimitCount,
-                        transientRateLimits: account.transientRateLimitCount,
-                        quotaRateLimits: account.quotaRateLimitCount,
-                        cooling,
-                        status: accountStatus,
-                    };
-                }),
+                accounts: accountRows,
                 primaryAccount,
                 persistence: getUsageStatsPersistenceStatus(),
             },
@@ -1930,9 +1969,11 @@ function registerProxyShutdownHandlers(params) {
             }
         }
         const usageStatsFlush = import("../../lib/proxy/usageStats.js").then(({ flushUsageStats }) => flushUsageStats());
-        const [usageStatsFlushResult, lifecycleFlushResult] = await Promise.allSettled([
+        const requestLogsFlush = import("../../lib/proxy/requestLogger.js").then(({ flushRequestLogs }) => flushRequestLogs());
+        const [usageStatsFlushResult, lifecycleFlushResult, requestLogsFlushResult,] = await Promise.allSettled([
             withTimeout(usageStatsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy usage statistics during shutdown"),
             withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown"),
+            withTimeout(requestLogsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy request logs during shutdown"),
         ]);
         if (usageStatsFlushResult.status === "rejected") {
             const error = usageStatsFlushResult.reason;
@@ -1942,6 +1983,10 @@ function registerProxyShutdownHandlers(params) {
             const error = lifecycleFlushResult.reason;
             logger.debug(`[proxy] lifecycle metadata flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
+        if (requestLogsFlushResult.status === "rejected") {
+            const error = requestLogsFlushResult.reason;
+            logger.warn(`[proxy] request log flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
+        }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../lib/services/server/ai/observability/instrumentation.js");
             await flushOpenTelemetry();
@@ -2136,8 +2181,27 @@ async function startProxyRuntime(params) {
     let stopRuntimeConfig;
     if (params.runtimeConfigStore) {
         const runtimeConfigStore = params.runtimeConfigStore;
-        const unsubscribeReload = runtimeConfigStore.subscribeReload(() => {
-            persistRuntimeConfig(runtimeConfigStore.getSnapshot());
+        const unsubscribeReload = runtimeConfigStore.subscribeReload((result) => {
+            const snapshot = runtimeConfigStore.getSnapshot();
+            persistRuntimeConfig(snapshot);
+            if (socketWorker &&
+                result.applied &&
+                result.changed &&
+                result.environmentChanged &&
+                process.connected &&
+                process.send) {
+                try {
+                    process.send({
+                        type: "proxy-worker:replacement-requested",
+                        generation: getProxyWorkerGeneration(),
+                        pid: process.pid,
+                        reason: "environment",
+                    });
+                }
+                catch (error) {
+                    logger.warn(`[proxy] failed to request environment replacement: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
         });
         const reloadOnSighup = () => {
             void runtimeConfigStore.reload("sighup");
@@ -2646,20 +2710,23 @@ export const proxyStatusCommand = {
                             supervisorState.rolling.active?.pid === state?.pid)
                     : true);
             if ((state || supervisorState) && (servingWorker || supervisorRunning)) {
-                const activeHost = state?.host ?? supervisorState?.host ?? null;
-                const activePort = state?.port ?? supervisorState?.port ?? null;
+                const servingState = servingWorker ? state : null;
+                const activeHost = servingState?.host ?? supervisorState?.host ?? null;
+                const activePort = servingState?.port ?? supervisorState?.port ?? null;
                 status.running = true;
                 status.pid = servingWorker && state ? state.pid : null;
                 status.port = activePort;
                 status.host = activeHost;
-                status.mode = state
-                    ? state.passthrough
+                status.mode = servingState
+                    ? servingState.passthrough
                         ? "passthrough"
                         : "full"
                     : null;
-                status.strategy = state?.strategy ?? null;
+                status.strategy = servingState?.strategy ?? null;
                 status.startTime =
-                    state?.startTime ?? supervisorState?.startTime ?? null;
+                    (supervisorRunning ? supervisorState?.startTime : null) ??
+                        servingState?.startTime ??
+                        null;
                 status.uptime = status.startTime
                     ? Date.now() - new Date(status.startTime).getTime()
                     : null;
@@ -2667,17 +2734,18 @@ export const proxyStatusCommand = {
                     activeHost && activePort
                         ? `http://${activeHost === "0.0.0.0" ? "localhost" : activeHost}:${activePort}`
                         : null;
-                status.envFile = state?.envFile ?? null;
-                status.fallbackChain = state?.fallbackChain ?? null;
-                status.accountAllowlist = state?.accountAllowlist ?? null;
-                status.configGeneration = state?.configGeneration ?? null;
-                status.configLoadedAt = state?.configLoadedAt ?? null;
-                status.lastConfigReloadError = state?.lastConfigReloadError ?? null;
+                status.envFile = servingState?.envFile ?? null;
+                status.fallbackChain = servingState?.fallbackChain ?? null;
+                status.accountAllowlist = servingState?.accountAllowlist ?? null;
+                status.configGeneration = servingState?.configGeneration ?? null;
+                status.configLoadedAt = servingState?.configLoadedAt ?? null;
+                status.lastConfigReloadError =
+                    servingState?.lastConfigReloadError ?? null;
                 status.supervisorPid = supervisorPid ?? null;
                 status.supervisorRunning = supervisorRunning;
                 status.rolling = supervisorState?.rolling ?? null;
                 status.updaterPid =
-                    supervisorState?.updaterPid ?? state?.updaterPid ?? null;
+                    supervisorState?.updaterPid ?? servingState?.updaterPid ?? null;
                 status.updaterRunning = status.updaterPid
                     ? isProcessRunning(status.updaterPid)
                     : false;

package/dist/cli/commands/proxyAnalyze.js

@@ -11,7 +11,7 @@ function printAnalysis(report) {
     logger.always(chalk.gray("=".repeat(50)));
     logger.always(`  Since:       ${chalk.cyan(report.since)}`);
     logger.always(`  Logs:        ${chalk.cyan(report.logsDir)}`);
-    logger.always(`  Files:       ${report.files.requests} request, ${report.files.attempts} attempt, ${report.files.lifecycle} lifecycle`);
+    logger.always(`  Files:       ${report.files.requests} request, ${report.files.attempts} attempt, ${report.files.lifecycle} lifecycle, ${report.files.debug} debug`);
     logger.always("");
     logger.always(chalk.bold("  Reliability"));
     logger.always(report.coverage.finalRequests
@@ -68,6 +68,15 @@ function printAnalysis(report) {
     logger.always("");
     logger.always(chalk.bold("  Data Quality"));
     logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates`);
+    for (const [stream, range] of Object.entries(report.dataQuality.streams)) {
+        if (range.observedFrom) {
+            logger.always(`    ${stream}: ${range.observedFrom} to ${range.observedTo}${range.startsAtOrBeforeRequestedWindow ? "" : chalk.yellow(" (starts after requested window)")}`);
+        }
+    }
+    const artifacts = report.dataQuality.bodyArtifacts;
+    if (artifacts.capturesIndexed > 0) {
+        logger.always(`    Body artifacts: ${artifacts.artifactsPresent}/${artifacts.artifactsReferenced} present, ${artifacts.artifactsMissing} missing, ${artifacts.writeFailures} write failures, ${artifacts.invalidPaths} invalid paths, ${artifacts.truncatedCaptures} truncated captures`);
+    }
     if (report.accounts.length > 0) {
         logger.always("");
         logger.always(chalk.bold("  Accounts"));

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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