@juspay/neurolink 11.11.7 → 11.13.0

package/dist/cli/commands/proxy.js

@@ -3993,6 +3993,46 @@ export const proxyInstallCommand = {
         console.info(chalk.gray(`  Remove: neurolink proxy uninstall`));
     },
 };
+/**
+ * Put every auto-configured CLI back the way it was, using the URL recorded in
+ * the proxy's own state file.
+ *
+ * `proxy uninstall` is the one moment where "the proxy is going away for good"
+ * is unambiguous, and it is the only place this can be done for a
+ * launchd-managed service: the shutdown path restores on SIGINT only, and both
+ * `launchctl unload` and this command stop the supervisor with SIGTERM. Without
+ * this, uninstalling left all five clients pointing at a socket that no longer
+ * answers, with nothing to say why.
+ *
+ * Must run before `clearProxyState()` — the state file is what tells us which
+ * URL the clients were given, and the restore helpers deliberately refuse to
+ * touch a URL they did not write.
+ */
+async function restoreClientsOnUninstall() {
+    let state = null;
+    try {
+        state = loadProxyState();
+    }
+    catch {
+        // An unreadable state file is not a reason to abort an uninstall.
+    }
+    if (!state?.port) {
+        // Nothing recorded, so we cannot prove which URL the configs carry.
+        return;
+    }
+    // 0.0.0.0 is a bind address, never a reachable one; clients were handed
+    // localhost, so that is what restore has to match on.
+    const host = state.host === "0.0.0.0" ? "localhost" : (state.host ?? "localhost");
+    const results = await restoreAllClients(`http://${host}:${state.port}`);
+    for (const result of results) {
+        if (result.restored) {
+            console.info(chalk.green(`\u2713 Restored ${result.displayName} settings`));
+        }
+        else if (result.error) {
+            logger.debug(`[proxy] ${result.id} restore failed during uninstall: ${result.error.message}`);
+        }
+    }
+}
 export const proxyUninstallCommand = {
     command: "uninstall",
     describe: "Remove proxy background service",
@@ -4008,6 +4048,7 @@ export const proxyUninstallCommand = {
                 console.info(chalk.red("A proxy supervisor is still running and could not be stopped; leaving its state intact. Stop it manually and retry."));
                 process.exit(1);
             }
+            await restoreClientsOnUninstall();
             clearProxyState();
             clearProxySupervisorState();
             console.info(chalk.yellow("No proxy service installed."));
@@ -4029,6 +4070,7 @@ export const proxyUninstallCommand = {
             process.exit(1);
         }
         unlinkSync(PLIST_PATH);
+        await restoreClientsOnUninstall();
         clearProxyState();
         clearProxySupervisorState();
         console.info(chalk.green(`✓ Plist removed from ${PLIST_PATH}`));

package/dist/cli/commands/proxyAnalyze.js

@@ -81,7 +81,16 @@ function printAnalysis(report) {
     logger.always(chalk.bold("  Cache"));
     if (report.coverage.cacheUsage) {
         logger.always(`    Usage records: ${report.cache.requestsWithUsage}, cache-read requests: ${report.cache.requestsWithCacheRead}, hit rate: ${report.cache.requestHitRate === null ? "-" : `${(report.cache.requestHitRate * 100).toFixed(1)}%`}`);
-        logger.always(`    Tokens: ${report.cache.cacheReadTokens} read, ${report.cache.cacheCreationTokens} created, ${report.cache.inputTokens} input`);
+        logger.always(`    Tokens: ${report.cache.cacheReadTokens} read, ${report.cache.cacheCreationTokens} created, ${report.cache.inputTokens} input, ${report.cache.outputTokens} output`);
+        logger.always(report.cache.requestsPriced > 0
+            ? `    Estimated cost: $${report.cache.estimatedCostUsd.toFixed(4)} across ${report.cache.requestsPriced} priced request(s)`
+            : "    Estimated cost: unavailable (no request carried a priceable model)");
+        if (report.cache.requestsPricedByPrefix > 0) {
+            logger.always(chalk.yellow(`    ⚠ ${report.cache.requestsPricedByPrefix} request(s) priced by name-prefix fallback, not an exact rate: ${report.cache.modelsPricedByPrefix.join(", ")}`));
+        }
+        if (report.cache.requestsUnpriced > 0) {
+            logger.always(chalk.yellow(`    ⚠ ${report.cache.requestsUnpriced} request(s) had usage but no pricing row: ${report.cache.unpricedModels.join(", ")}`));
+        }
     }
     else {
         logger.always(chalk.yellow("    Cache usage: unavailable"));

package/dist/cli/proxy-clients/claudeCode.js

@@ -8,6 +8,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { logger } from "../../lib/utils/logger.js";
+import { isProxyOwnedValue, shouldCaptureSnapshot } from "./snapshot.js";
 /**
  * Resolved per call rather than at module load so `detect()` and `apply()`
  * agree when HOME changes — under test, and on the `--dev` isolation path.
@@ -20,6 +21,13 @@ function getClaudeSettingsPath() {
 }
 /** Keys we manage in Claude Code's settings.env */
 const PROXY_MANAGED_KEYS = ["ANTHROPIC_BASE_URL", "ENABLE_TOOL_SEARCH"];
+/** The user's values for those keys, as they were before the proxy first ran. */
+const CLAUDE_ORIGINAL_KEY = "__proxy_original_env";
+/**
+ * The values this writer last wrote. Lets apply() tell its own values from ones
+ * the user substituted while the proxy was not running.
+ */
+const CLAUDE_WRITTEN_KEY = "__proxy_written_env";
 export async function setClaudeProxySettings(baseUrl) {
     const fs = await import("fs");
     let settings = {};
@@ -31,18 +39,30 @@ export async function setClaudeProxySettings(baseUrl) {
     }
     const env = (settings.env ?? {});
     // Preserve original values so clearClaudeProxySettings can restore them.
-    // Only snapshot once — subsequent calls should not overwrite the snapshot.
-    const originals = (settings
-        .__proxy_original_env ?? {});
+    // A repeat apply() must not overwrite the snapshot with the proxy's own
+    // values — but a value the user set while the proxy was gone must replace
+    // it. See shouldCaptureSnapshot.
+    const originals = (settings[CLAUDE_ORIGINAL_KEY] ?? {});
+    const written = (settings[CLAUDE_WRITTEN_KEY] ??
+        {});
     for (const key of PROXY_MANAGED_KEYS) {
-        if (!(key in originals)) {
-            originals[key] = key in env ? env[key] : null;
+        const current = key in env ? env[key] : undefined;
+        if (shouldCaptureSnapshot({
+            hasSnapshot: key in originals,
+            written: written[key],
+            current,
+        })) {
+            originals[key] = current ?? null;
         }
     }
-    settings.__proxy_original_env = originals;
+    settings[CLAUDE_ORIGINAL_KEY] = originals;
     env.ANTHROPIC_BASE_URL = baseUrl;
     env.ENABLE_TOOL_SEARCH = "true";
     settings.env = env;
+    settings[CLAUDE_WRITTEN_KEY] = {
+        ANTHROPIC_BASE_URL: baseUrl,
+        ENABLE_TOOL_SEARCH: "true",
+    };
     fs.writeFileSync(getClaudeSettingsPath(), JSON.stringify(settings, null, 2));
 }
 export async function clearClaudeProxySettings(expectedBaseUrl) {
@@ -64,7 +84,7 @@ export async function clearClaudeProxySettings(expectedBaseUrl) {
         // User switched to a different proxy URL; do not clobber.
         return false;
     }
-    if (!("__proxy_original_env" in settings)) {
+    if (!(CLAUDE_ORIGINAL_KEY in settings)) {
         // No snapshot means we cannot prove these keys are ours. Without this
         // guard the loop below reads every managed key as "did not exist before"
         // and deletes it — wiping a real user value. Leaving a stale proxy URL
@@ -76,9 +96,20 @@ export async function clearClaudeProxySettings(expectedBaseUrl) {
     const hadBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string";
     const hadToolSearch = env.ENABLE_TOOL_SEARCH === "true";
     // Restore original values if they were saved, otherwise delete the keys
-    const originals = (settings
-        .__proxy_original_env ?? {});
+    const originals = (settings[CLAUDE_ORIGINAL_KEY] ?? {});
+    // Only restore keys we can prove are ours. A user who kept the proxy's base
+    // URL but changed one of the other managed values made a deliberate edit;
+    // reverting it to the snapshot — or deleting it, when the snapshot says the
+    // key was absent — would silently undo them.
+    const writtenValues = (settings[CLAUDE_WRITTEN_KEY] ?? {});
     for (const key of PROXY_MANAGED_KEYS) {
+        if (!isProxyOwnedValue({
+            written: writtenValues[key],
+            current: key in env ? env[key] : undefined,
+        })) {
+            logger.debug(`[proxy] Claude clear: ${key} was edited after the proxy wrote it, leaving it intact`);
+            continue;
+        }
         const original = originals[key];
         if (original !== undefined && original !== null) {
             // Restore the value that existed before the proxy was started
@@ -89,7 +120,8 @@ export async function clearClaudeProxySettings(expectedBaseUrl) {
             delete env[key];
         }
     }
-    delete settings.__proxy_original_env;
+    delete settings[CLAUDE_ORIGINAL_KEY];
+    delete settings[CLAUDE_WRITTEN_KEY];
     if (Object.keys(env).length === 0) {
         delete settings.env;
     }

package/dist/cli/proxy-clients/openCode.js

@@ -7,6 +7,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { logger } from "../../lib/utils/logger.js";
+import { cloneForSnapshot, isProxyOwnedValue, shouldCaptureSnapshot, } from "./snapshot.js";
 function getOpenCodeConfigDir() {
     // OpenCode resolves this with the unmodified `xdg-basedir` package —
     // `XDG_CONFIG_HOME || ~/.config` — on every platform, macOS included. There
@@ -28,6 +29,11 @@ function getOpenCodeConfigPath() {
  * Mirrors the Claude pattern (`__proxy_original_env` inside Claude's settings).
  */
 const OPENCODE_ORIGINAL_KEY = "__proxy_original_neurolink";
+/**
+ * What this writer last wrote into provider.neurolink. Lets apply() tell its
+ * own block from one the user substituted while the proxy was not running.
+ */
+const OPENCODE_WRITTEN_KEY = "__proxy_written_neurolink";
 export async function setOpenCodeProxySettings(baseUrl, proxyKey) {
     const fs = await import("fs");
     const configDir = getOpenCodeConfigDir();
@@ -49,18 +55,20 @@ export async function setOpenCodeProxySettings(baseUrl, proxyKey) {
         config = { provider: {} };
     }
     const provider = (config.provider ?? {});
-    // Persist a snapshot of the user's pre-existing provider.neurolink — but
-    // only the first time we touch the file. Subsequent set() calls must NOT
-    // overwrite the snapshot (otherwise after the proxy writes its own block,
-    // the next set() would store the proxy's block as the "original" and
-    // permanently lose the user's real config on the next clear()).
-    if (!(OPENCODE_ORIGINAL_KEY in config)) {
+    // Persist a snapshot of the user's pre-existing provider.neurolink. Repeat
+    // apply() calls must not overwrite it with the proxy's own block — but a
+    // block the user wrote while the proxy was gone must replace it. See
+    // shouldCaptureSnapshot.
+    const currentBlock = "neurolink" in provider ? provider.neurolink : undefined;
+    if (shouldCaptureSnapshot({
+        hasSnapshot: OPENCODE_ORIGINAL_KEY in config,
+        written: config[OPENCODE_WRITTEN_KEY],
+        current: currentBlock,
+    })) {
         config[OPENCODE_ORIGINAL_KEY] =
-            "neurolink" in provider
-                ? JSON.parse(JSON.stringify(provider.neurolink))
-                : null;
+            currentBlock === undefined ? null : cloneForSnapshot(currentBlock);
     }
-    provider.neurolink = {
+    const block = {
         id: "neurolink",
         name: "NeuroLink Proxy",
         npm: "@ai-sdk/openai-compatible",
@@ -71,6 +79,8 @@ export async function setOpenCodeProxySettings(baseUrl, proxyKey) {
             apiKey: proxyKey || "neurolink-proxy",
         },
     };
+    provider.neurolink = block;
+    config[OPENCODE_WRITTEN_KEY] = cloneForSnapshot(block);
     config.provider = provider;
     fs.writeFileSync(getOpenCodeConfigPath(), JSON.stringify(config, null, 2));
     return true;
@@ -105,15 +115,27 @@ export async function clearOpenCodeProxySettings(expectedBaseUrl) {
     // explicitly had no entry before — never on an "undefined" snapshot, since
     // that would mean the snapshot was lost and we cannot prove the entry is ours.
     if (OPENCODE_ORIGINAL_KEY in config) {
-        const snapshot = config[OPENCODE_ORIGINAL_KEY];
-        if (snapshot === null) {
-            // User had no provider.neurolink before the proxy started — safe to remove.
-            delete provider.neurolink;
+        // Only restore what we can prove is ours. The base-URL check above lets
+        // through a block still pointing at the proxy that the user has edited
+        // beside the URL; reverting that discards a deliberate change.
+        if (isProxyOwnedValue({
+            written: config[OPENCODE_WRITTEN_KEY],
+            current: existing,
+        })) {
+            const snapshot = config[OPENCODE_ORIGINAL_KEY];
+            if (snapshot === null) {
+                // User had no provider.neurolink before the proxy started — safe to remove.
+                delete provider.neurolink;
+            }
+            else {
+                provider.neurolink = snapshot;
+            }
         }
         else {
-            provider.neurolink = snapshot;
+            logger.debug("[proxy] OpenCode clear: provider.neurolink was edited after the proxy wrote it, leaving it intact");
         }
         delete config[OPENCODE_ORIGINAL_KEY];
+        delete config[OPENCODE_WRITTEN_KEY];
     }
     else {
         // No snapshot present — refuse to delete to avoid destroying a config

package/dist/cli/proxy-clients/qwenCode.js

@@ -20,6 +20,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { logger } from "../../lib/utils/logger.js";
+import { cloneForSnapshot, isProxyOwnedValue, shouldCaptureSnapshot, } from "./snapshot.js";
 /**
  * Resolved per call rather than at module load so `detect()` and `apply()`
  * agree when HOME changes — under test, and on the `--dev` isolation path.
@@ -37,6 +38,12 @@ function getQwenSettingsPath() {
  * the same approach the Claude and OpenCode writers take.
  */
 const QWEN_ORIGINAL_KEY = "__proxy_original_qwen_auth";
+/**
+ * The auth block this writer last wrote. Lets apply() tell its own block from
+ * one the user substituted while the proxy was not running — which for Qwen
+ * carries a real API key.
+ */
+const QWEN_WRITTEN_KEY = "__proxy_written_qwen_auth";
 function readQwenSettings(fs) {
     try {
         const parsed = JSON.parse(fs.readFileSync(getQwenSettingsPath(), "utf8"));
@@ -61,18 +68,25 @@ export async function setQwenProxySettings(baseUrl, proxyKey) {
     const settings = readQwenSettings(fs) ?? {};
     const security = (settings.security ?? {});
     const auth = (security.auth ?? {});
-    // Snapshot only on first touch. A second apply() must not overwrite the
-    // snapshot with our own block, which would lose the user's real config on
-    // the next restore.
-    if (!(QWEN_ORIGINAL_KEY in settings)) {
+    // A repeat apply() must not overwrite the snapshot with our own block, which
+    // would lose the user's real config on the next restore — but a block the
+    // user wrote while the proxy was gone must replace it. See
+    // shouldCaptureSnapshot.
+    const currentAuth = "auth" in security ? security.auth : undefined;
+    if (shouldCaptureSnapshot({
+        hasSnapshot: QWEN_ORIGINAL_KEY in settings,
+        written: settings[QWEN_WRITTEN_KEY],
+        current: currentAuth,
+    })) {
         settings[QWEN_ORIGINAL_KEY] =
-            "auth" in security ? JSON.parse(JSON.stringify(auth)) : null;
+            currentAuth === undefined ? null : cloneForSnapshot(currentAuth);
     }
     auth.selectedType = "openai";
     auth.baseUrl = baseUrl;
     auth.apiKey = proxyKey || "neurolink-proxy";
     security.auth = auth;
     settings.security = security;
+    settings[QWEN_WRITTEN_KEY] = cloneForSnapshot(auth);
     fs.writeFileSync(getQwenSettingsPath(), JSON.stringify(settings, null, 2));
     return true;
 }
@@ -100,14 +114,24 @@ export async function clearQwenProxySettings(expectedBaseUrl) {
         logger.debug("[proxy] Qwen clear: no original-auth snapshot found, leaving security.auth intact");
         return false;
     }
-    const snapshot = settings[QWEN_ORIGINAL_KEY];
-    if (snapshot === null) {
-        delete security.auth;
+    // Only restore what we can prove is ours. The base-URL check above lets
+    // through a block still pointing at the proxy whose key the user rotated
+    // beside it — overwriting that would destroy a live credential. Our
+    // bookkeeping keys go either way, so a stale sentinel cannot outlive us.
+    if (isProxyOwnedValue({ written: settings[QWEN_WRITTEN_KEY], current: auth })) {
+        const snapshot = settings[QWEN_ORIGINAL_KEY];
+        if (snapshot === null) {
+            delete security.auth;
+        }
+        else {
+            security.auth = snapshot;
+        }
     }
     else {
-        security.auth = snapshot;
+        logger.debug("[proxy] Qwen clear: security.auth was edited after the proxy wrote it, leaving it intact");
     }
     delete settings[QWEN_ORIGINAL_KEY];
+    delete settings[QWEN_WRITTEN_KEY];
     settings.security = security;
     fs.writeFileSync(getQwenSettingsPath(), JSON.stringify(settings, null, 2));
     return true;

package/dist/cli/proxy-clients/registry.js

@@ -1,3 +1,4 @@
+import { logger } from "../../lib/utils/logger.js";
 import { claudeCodeConfigurator } from "./claudeCode.js";
 import { openCodeConfigurator } from "./openCode.js";
 import { codexConfigurator } from "./codex.js";
@@ -34,11 +35,16 @@ export async function applyAllClients(proxyBaseUrl) {
             results.push({ id: client.id, displayName: client.displayName, applied });
         }
         catch (error) {
+            const wrapped = error instanceof Error ? error : new Error(String(error));
+            // The result already carries the id, but a caller is free to ignore it.
+            // Naming the client here means a path-resolution failure (a HOME that
+            // moved, a directory that vanished mid-run) is never fully silent.
+            logger.debug(`[proxy] ${client.id} apply failed: ${wrapped.message}`);
             results.push({
                 id: client.id,
                 displayName: client.displayName,
                 applied: false,
-                error: error instanceof Error ? error : new Error(String(error)),
+                error: wrapped,
             });
         }
     }
@@ -56,11 +62,13 @@ export async function restoreAllClients(proxyBaseUrl) {
             });
         }
         catch (error) {
+            const wrapped = error instanceof Error ? error : new Error(String(error));
+            logger.debug(`[proxy] ${client.id} restore failed: ${wrapped.message}`);
             results.push({
                 id: client.id,
                 displayName: client.displayName,
                 restored: false,
-                error: error instanceof Error ? error : new Error(String(error)),
+                error: wrapped,
             });
         }
     }

package/dist/cli/proxy-clients/snapshot.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared snapshot bookkeeping for the JSON-file configurators.
+ *
+ * Every writer that edits a user's config in place has to answer one question
+ * on each apply(): is the value sitting in the file right now the one *we* put
+ * there, or one the user put there?
+ *
+ * Snapshotting only on first touch is not enough. The sentinel is persisted in
+ * the user's file so a restore survives a crash, which means it also survives
+ * an unclean kill where no restore ever ran. If the user then edits the block
+ * by hand — reasonably, since the proxy is gone — a presence-only guard keeps
+ * the stale snapshot, apply() overwrites their edit, and the next restore
+ * writes the stale value back over it. For Qwen that value is a live API key.
+ *
+ * So each writer also records what it wrote. A current value that still matches
+ * the recorded write is ours and the snapshot stands; anything else is the
+ * user's and must be re-snapshotted before we overwrite it.
+ */
+/**
+ * Whether apply() should record `current` as the user's original value.
+ *
+ * - No snapshot yet: record one. This is the first touch.
+ * - Snapshot present but no record of what we wrote: leave it alone. The file
+ *   was written by a version that predates the write-record, so we cannot tell
+ *   ours from the user's and the safe move is the old behaviour.
+ * - Snapshot present and the current value is exactly what we wrote: leave it
+ *   alone. This is the repeat-apply case the first-touch guard exists for.
+ * - Snapshot present and the current value is *not* what we wrote: re-record.
+ *   The user replaced it while the proxy was not running.
+ */
+export declare function shouldCaptureSnapshot(args: {
+    hasSnapshot: boolean;
+    written: unknown;
+    current: unknown;
+}): boolean;
+/** Deep copy through JSON, so a snapshot cannot alias the object it describes. */
+export declare function cloneForSnapshot<T>(value: T): T;
+/**
+ * Whether the value currently in the file is the one this writer put there.
+ *
+ * Restore uses this as its licence to act. A base-URL check alone catches a
+ * user who repointed the client elsewhere, but not one who kept the proxy URL
+ * and changed something beside it — a rotated key, an added field. Reverting
+ * those to the snapshot destroys a deliberate edit; for Qwen it destroys a
+ * credential. No record of what we wrote (a config from before this existed)
+ * means we cannot prove ownership either way, so the caller keeps its previous
+ * behaviour rather than refusing every restore.
+ */
+export declare function isProxyOwnedValue(args: {
+    written: unknown;
+    current: unknown;
+}): boolean;

package/dist/cli/proxy-clients/snapshot.js

@@ -0,0 +1,98 @@
+/**
+ * Shared snapshot bookkeeping for the JSON-file configurators.
+ *
+ * Every writer that edits a user's config in place has to answer one question
+ * on each apply(): is the value sitting in the file right now the one *we* put
+ * there, or one the user put there?
+ *
+ * Snapshotting only on first touch is not enough. The sentinel is persisted in
+ * the user's file so a restore survives a crash, which means it also survives
+ * an unclean kill where no restore ever ran. If the user then edits the block
+ * by hand — reasonably, since the proxy is gone — a presence-only guard keeps
+ * the stale snapshot, apply() overwrites their edit, and the next restore
+ * writes the stale value back over it. For Qwen that value is a live API key.
+ *
+ * So each writer also records what it wrote. A current value that still matches
+ * the recorded write is ours and the snapshot stands; anything else is the
+ * user's and must be re-snapshotted before we overwrite it.
+ */
+/**
+ * Structural equality, insensitive to object key order.
+ *
+ * Comparing serialised JSON would be simpler but wrong: `JSON.stringify` is not
+ * canonical, so anything that rewrites the user's config — a formatter, an
+ * editor's "sort keys", another tool round-tripping the file — reorders keys and
+ * makes our own block look like the user's. The writer would then snapshot the
+ * proxy block as the "original" and restore it over the real config later.
+ *
+ * `undefined` is only ever equal to itself: absent is not the same as present.
+ */
+function valuesMatch(current, written) {
+    if (current === undefined || written === undefined) {
+        return current === written;
+    }
+    if (current === null || written === null) {
+        return current === written;
+    }
+    if (typeof current !== "object" || typeof written !== "object") {
+        return current === written;
+    }
+    if (Array.isArray(current) || Array.isArray(written)) {
+        if (!Array.isArray(current) || !Array.isArray(written)) {
+            return false;
+        }
+        return (current.length === written.length &&
+            current.every((item, index) => valuesMatch(item, written[index])));
+    }
+    const a = current;
+    const b = written;
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length) {
+        return false;
+    }
+    return aKeys.every((key) => Object.prototype.hasOwnProperty.call(b, key) &&
+        valuesMatch(a[key], b[key]));
+}
+/**
+ * Whether apply() should record `current` as the user's original value.
+ *
+ * - No snapshot yet: record one. This is the first touch.
+ * - Snapshot present but no record of what we wrote: leave it alone. The file
+ *   was written by a version that predates the write-record, so we cannot tell
+ *   ours from the user's and the safe move is the old behaviour.
+ * - Snapshot present and the current value is exactly what we wrote: leave it
+ *   alone. This is the repeat-apply case the first-touch guard exists for.
+ * - Snapshot present and the current value is *not* what we wrote: re-record.
+ *   The user replaced it while the proxy was not running.
+ */
+export function shouldCaptureSnapshot(args) {
+    if (!args.hasSnapshot) {
+        return true;
+    }
+    if (args.written === undefined) {
+        return false;
+    }
+    return !valuesMatch(args.current, args.written);
+}
+/** Deep copy through JSON, so a snapshot cannot alias the object it describes. */
+export function cloneForSnapshot(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Whether the value currently in the file is the one this writer put there.
+ *
+ * Restore uses this as its licence to act. A base-URL check alone catches a
+ * user who repointed the client elsewhere, but not one who kept the proxy URL
+ * and changed something beside it — a rotated key, an added field. Reverting
+ * those to the snapshot destroys a deliberate edit; for Qwen it destroys a
+ * credential. No record of what we wrote (a config from before this existed)
+ * means we cannot prove ownership either way, so the caller keeps its previous
+ * behaviour rather than refusing every restore.
+ */
+export function isProxyOwnedValue(args) {
+    if (args.written === undefined) {
+        return true;
+    }
+    return valuesMatch(args.current, args.written);
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/lib/providers/googleAiStudio/client.js

@@ -20,7 +20,7 @@ import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js
 import { buildGeminiResponseSchema, buildNativeConfig, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, } from "../googleNativeGemini3/index.js";
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
-import { createProxyFetch } from "../../proxy/proxyFetch.js";
+import { warnGoogleSdkIgnoresProxy } from "../../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -38,16 +38,19 @@ async function createGoogleGenAIClient(apiKey, baseURL) {
         });
     }
     const Ctor = ctor;
-    // Include httpOptions with proxy fetch for corporate network support.
+    // httpOptions carries the endpoint override and nothing else. It used to
+    // also pass a proxy fetch, which the SDK silently ignored — see
+    // warnGoogleSdkIgnoresProxy for why that is not fixable here.
+    //
     // baseUrl is only included when resolved — verified against
     // @google/genai's ApiClient (dist/node/index.cjs) that it falls back to
     // its own default whenever httpOptions.baseUrl is undefined, so omitting
     // the key and passing `baseUrl: undefined` behave identically; the key is
     // still omitted outright for a cleaner outbound config object.
+    warnGoogleSdkIgnoresProxy("GoogleAIStudio");
     return new Ctor({
         apiKey,
         httpOptions: {
-            fetch: createProxyFetch(),
             ...(baseURL ? { baseUrl: baseURL } : {}),
         },
     });

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

@@ -54,6 +54,27 @@ export declare const resolveVertexLocation: (modelName: string | undefined, conf
 export declare class GoogleVertexProvider extends BaseProvider {
     private projectId;
     private location;
+    /**
+     * Vertex AI Express Mode credentials.
+     *
+     * Vertex supports two authentication modes. The long-standing one pairs a
+     * project and location with Application Default Credentials, which makes
+     * the SDK mint an OAuth token through google-auth-library before every
+     * request. Express Mode instead authenticates with an API key alone.
+     *
+     * Express is used only when an apiKey is supplied WITHOUT an explicit
+     * project or location, so existing ADC callers — including those already
+     * passing an apiKey alongside a project — keep exactly the behaviour they
+     * have today.
+     */
+    private expressApiKey?;
+    /**
+     * Optional endpoint override, mirroring AI Studio's
+     * `credentials.googleAiStudio.baseURL`: per-request credential first, then
+     * the environment, then unset so the SDK applies its own default. Blank
+     * values count as unset so an empty override cannot clobber that default.
+     */
+    private baseURL?;
     private registeredTools;
     private toolContext;
     private static modelConfigCache;
@@ -105,6 +126,18 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Create @google/genai client configured for Vertex AI
      */
     private createVertexGenAIClient;
+    /** Endpoint override: credential, then environment, then unset. */
+    private resolveBaseURL;
+    /**
+     * Express Mode key, if this provider should use it.
+     *
+     * Deliberately NOT read from GOOGLE_API_KEY: that variable is already set
+     * by callers who also configure a project, and treating it as an Express
+     * opt-in would silently switch their authentication mode. Express is opted
+     * into per request, or through GOOGLE_VERTEX_API_KEY which exists only for
+     * 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