@juspay/neurolink 12.30.0 → 12.30.1

package/CHANGELOG.md

@@ -1,8 +1,8 @@
-## [12.30.0](https://github.com/juspay/neurolink/compare/v12.29.2...v12.30.0) (2026-09-26)
+## [12.30.1](https://github.com/juspay/neurolink/compare/v12.30.0...v12.30.1) (2026-09-26)
 
-### Features
+### Bug Fixes
 
-- **(video):** honour videoOptions end to end, timestamp keyframes, transcribe speech ([ab037cc](https://github.com/juspay/neurolink/commit/ab037cc1ecce885c9a4bd64f6ca020021f24a038)), closes [#1720](https://github.com/juspay/neurolink/issues/1720) [#478](https://github.com/juspay/neurolink/issues/478) [#460](https://github.com/juspay/neurolink/issues/460) [#433](https://github.com/juspay/neurolink/issues/433) [#433](https://github.com/juspay/neurolink/issues/433) [#460](https://github.com/juspay/neurolink/issues/460)
+- **(proxy):** stop Grok's config gaining a second catalog on every start ([a92dd0b](https://github.com/juspay/neurolink/commit/a92dd0b93ff6bda3522d870a72436dbf6ae2bbe8))
 
 ## [11.2.3](https://github.com/juspay/neurolink/compare/v11.2.2...v11.2.3) (2026-08-19)
 

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

@@ -8,6 +8,7 @@ import { homedir } from "os";
 import { join } from "path";
 import { logger } from "../../utils/logger.js";
 import { writeFileAtomic } from "./snapshot.js";
+import { dottedTableIds, findDuplicateTable, ownedLineCount, readStringValue, splitTomlSections, } from "./tomlSections.js";
 //
 // Points the Codex CLI at the proxy by managing `~/.codex/config.toml`:
 //   - appends a marker-delimited `[model_providers.neurolink]` table
@@ -28,18 +29,67 @@ function getCodexSnapshotPath() {
 }
 const CODEX_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
 const CODEX_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const CODEX_MANAGED_COMMENT_LINES = new Set([
+    CODEX_BLOCK_BEGIN,
+    CODEX_BLOCK_END,
+]);
+const CODEX_PROVIDER_ID = "neurolink";
+const CODEX_PROVIDER_NAME = "NeuroLink Proxy";
 const CODEX_PROVIDER_LINE_RE = /^[ \t]*model_provider[ \t]*=.*$/m;
 const CODEX_MODEL_LINE_RE = /^[ \t]*model[ \t]*=.*$/m;
-/** Strip any previously-managed block + our injected provider line. */
-function stripCodexManagedConfig(text) {
-    const blockRe = new RegExp(`\\n?${escapeRegExp(CODEX_BLOCK_BEGIN)}[\\s\\S]*?${escapeRegExp(CODEX_BLOCK_END)}\\n?`, "g");
-    let out = text.replace(blockRe, "\n");
-    // Remove our injected selector line (only the exact "neurolink" one).
-    out = out.replace(/^[ \t]*model_provider[ \t]*=[ \t]*"neurolink"[ \t]*$\n?/m, "");
-    return out;
+const CODEX_MANAGED_SELECTOR_RE = /^[ \t]*model_provider[ \t]*=[ \t]*"neurolink"[ \t]*$\n?/m;
+/**
+ * What of a Codex config.toml the proxy owns, found by content rather than
+ * by the block markers. Codex's own saves keep comments (measured on
+ * codex-cli 0.155.1), but a hand edit or another tool need not, and a
+ * marker-only writer then appended a second `[model_providers.neurolink]`,
+ * which Codex cannot parse. The proxy's provider is that table carrying the
+ * name the proxy writes, with any sub-tables under it. `foreign` is set when
+ * a `neurolink` provider exists that the proxy did not write: another name, a
+ * dotted-key or array definition, or sub-tables with no provider table, which
+ * the proxy never writes. Writing ours beside it would declare the table twice
+ * or adopt the user's keys. `remainder` keeps every byte the proxy does not
+ * own, including comments the user wrote after its table.
+ */
+function inspectCodexConfig(text) {
+    const sections = splitTomlSections(text);
+    const isProvider = (section) => section.path !== null &&
+        section.path.length >= 2 &&
+        section.path[0] === "model_providers" &&
+        section.path[1] === CODEX_PROVIDER_ID;
+    const tables = sections.filter((section) => isProvider(section) && !section.arrayTable && section.path?.length === 2);
+    const ours = (section) => readStringValue(section, "name") === CODEX_PROVIDER_NAME;
+    const foreign = tables.some((table) => !ours(table)) ||
+        (tables.length === 0 && sections.some(isProvider)) ||
+        sections.some((section) => isProvider(section) && section.arrayTable) ||
+        dottedTableIds(sections, "model_providers").includes(CODEX_PROVIDER_ID);
+    const owned = sections.map((section) => isProvider(section) &&
+        !section.arrayTable &&
+        (section.path?.length === 2 ? ours(section) : !foreign));
+    const managedBaseUrls = [
+        ...new Set(sections.flatMap((section, index) => {
+            const url = owned[index]
+                ? readStringValue(section, "base_url")
+                : undefined;
+            return url === undefined ? [] : [url];
+        })),
+    ];
+    const remainder = sections
+        .flatMap((section, index) => owned[index]
+        ? section.lines.slice(ownedLineCount(section, CODEX_MANAGED_COMMENT_LINES))
+        : section.lines)
+        .filter((line) => !CODEX_MANAGED_COMMENT_LINES.has(line.trim()))
+        .join("");
+    return { remainder, managedBaseUrls, foreign };
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Remove the selector the proxy injected. Only the preamble holds top-level
+ * keys: a profile's own `model_provider = "neurolink"` is the user's.
+ */
+function stripCodexSelector(text) {
+    return editTomlPreamble(text, (preamble) => CODEX_MANAGED_SELECTOR_RE.test(preamble)
+        ? preamble.replace(CODEX_MANAGED_SELECTOR_RE, "")
+        : null);
 }
 /**
  * Apply a top-level TOML key edit, confined to the document preamble.
@@ -60,8 +110,8 @@ function editTomlPreamble(text, edit) {
 function buildCodexProviderBlock(baseUrl) {
     return [
         CODEX_BLOCK_BEGIN,
-        "[model_providers.neurolink]",
-        'name = "NeuroLink Proxy"',
+        `[model_providers.${CODEX_PROVIDER_ID}]`,
+        `name = "${CODEX_PROVIDER_NAME}"`,
         `base_url = "${baseUrl}/backend-api/codex"`,
         'wire_api = "responses"',
         "requires_openai_auth = true",
@@ -77,6 +127,37 @@ export async function setCodexProxySettings(baseUrl) {
             return false;
         }
         const original = fs.readFileSync(getCodexConfigPath(), "utf8");
+        const inspected = inspectCodexConfig(original);
+        if (inspected.foreign) {
+            logger.warn("[proxy] Codex: config.toml already defines a neurolink provider the proxy did not write; leaving it untouched");
+            return false;
+        }
+        let text = stripCodexSelector(inspected.remainder);
+        // Set the selector: replace an existing top-level model_provider or insert
+        // one right after the top-level `model = ...` line (stays before any table).
+        let selectorPlaced = false;
+        text = editTomlPreamble(text, (preamble) => {
+            if (CODEX_PROVIDER_LINE_RE.test(preamble)) {
+                selectorPlaced = true;
+                return preamble.replace(CODEX_PROVIDER_LINE_RE, 'model_provider = "neurolink"');
+            }
+            if (CODEX_MODEL_LINE_RE.test(preamble)) {
+                selectorPlaced = true;
+                return preamble.replace(CODEX_MODEL_LINE_RE, (line) => `${line}\nmodel_provider = "neurolink"`);
+            }
+            return null;
+        });
+        if (!selectorPlaced) {
+            text = `model_provider = "neurolink"\n${text}`;
+        }
+        const next = `${text.replace(/\s*$/, "\n")}\n${buildCodexProviderBlock(baseUrl)}`;
+        // Codex will not load a config that declares a table twice. Writing into
+        // one would only bury the user's own error under ours.
+        const duplicate = findDuplicateTable(next);
+        if (duplicate !== undefined) {
+            logger.warn(`[proxy] Codex: config.toml declares [${duplicate}] more than once; leaving it untouched`);
+            return false;
+        }
         // Snapshot the user's original selector once (survives crashes/restarts).
         if (!fs.existsSync(getCodexSnapshotPath())) {
             // Same preamble boundary the edit paths use. Matching document-wide would
@@ -95,26 +176,11 @@ export async function setCodexProxySettings(baseUrl) {
             fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
             await writeFileAtomic(getCodexSnapshotPath(), JSON.stringify({ originalProviderLine }, null, 2), 0o600);
         }
-        let text = stripCodexManagedConfig(original);
-        // Set the selector: replace an existing top-level model_provider or insert
-        // one right after the top-level `model = ...` line (stays before any table).
-        let selectorPlaced = false;
-        text = editTomlPreamble(text, (preamble) => {
-            if (CODEX_PROVIDER_LINE_RE.test(preamble)) {
-                selectorPlaced = true;
-                return preamble.replace(CODEX_PROVIDER_LINE_RE, 'model_provider = "neurolink"');
-            }
-            if (CODEX_MODEL_LINE_RE.test(preamble)) {
-                selectorPlaced = true;
-                return preamble.replace(CODEX_MODEL_LINE_RE, (line) => `${line}\nmodel_provider = "neurolink"`);
-            }
-            return null;
-        });
-        if (!selectorPlaced) {
-            text = `model_provider = "neurolink"\n${text}`;
+        // Every proxy start applies. Rewriting a file that already matches only
+        // widens the window for racing Codex's own saves.
+        if (next !== original) {
+            await writeFileAtomic(getCodexConfigPath(), next);
         }
-        const trimmed = text.replace(/\s*$/, "\n");
-        await writeFileAtomic(getCodexConfigPath(), `${trimmed}\n${buildCodexProviderBlock(baseUrl)}`);
         return true;
     }
     catch (error) {
@@ -129,19 +195,23 @@ export async function clearCodexProxySettings(expectedBaseUrl) {
             return false;
         }
         const original = fs.readFileSync(getCodexConfigPath(), "utf8");
-        // The managed block records its owner in `base_url`. Without this check a
-        // second proxy shutting down on another port would strip the block that the
-        // still-running proxy installed, and restore the snapshot selector on top —
-        // silently taking Codex off the live proxy. Mirrors the Claude and OpenCode
-        // clear paths.
-        if (expectedBaseUrl) {
-            const ownerMatch = original.match(new RegExp(`${escapeRegExp(CODEX_BLOCK_BEGIN)}[\\s\\S]*?base_url\\s*=\\s*"([^"]*)"`));
-            if (ownerMatch &&
-                ownerMatch[1] !== `${expectedBaseUrl}/backend-api/codex`) {
-                return false;
-            }
+        const inspected = inspectCodexConfig(original);
+        // Apply refuses such a config, so the selector pointing at the user's own
+        // provider is theirs as well.
+        if (inspected.foreign) {
+            return false;
+        }
+        // The managed table records its owner in `base_url`. Without this check a
+        // second proxy shutting down on another port would strip the table that
+        // the still-running proxy installed, and restore the snapshot selector on
+        // top — silently taking Codex off the live proxy. Mirrors the Claude and
+        // OpenCode clear paths.
+        if (expectedBaseUrl &&
+            inspected.managedBaseUrls.length > 0 &&
+            !inspected.managedBaseUrls.includes(`${expectedBaseUrl}/backend-api/codex`)) {
+            return false;
         }
-        let text = stripCodexManagedConfig(original);
+        let text = stripCodexSelector(inspected.remainder);
         // Restore the user's original selector line if we snapshotted one.
         let restored = null;
         if (fs.existsSync(getCodexSnapshotPath())) {

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

@@ -18,6 +18,16 @@
  * Adaptive thinking: Grok's global `default_reasoning_effort = "xhigh"`
  * becomes Anthropic `thinking.type = "adaptive"`. Haiku 4.5 rejects that
  * with 400. Only Claude Opus/Sonnet 4.6 and 5.x keep reasoning enabled.
+ *
+ * Ownership is decided by content, never by the block markers alone. Grok
+ * rewrites config.toml on its own saves (`/settings`, `grok mcp add`, ...)
+ * through a serializer that drops every comment, the markers included, and
+ * splits the inline `extra_headers` into a `[model.<id>.extra_headers]`
+ * sub-table (measured on Grok Build 1.0.40). A marker-only writer then kept
+ * the unmarked tables and appended a second copy of every id on the next
+ * proxy start, and TOML rejects a table declared twice, so Grok would not
+ * start. What marks an entry as ours is the placeholder key, a credential
+ * only the proxy accepts, and that survives Grok's rewrite.
  */
 import type { CliGrokProxyModelSpec, CliProxyClientApplyOptions, CliProxyClientConfigurator, ModelMapping } from "../../types/index.js";
 declare function getGrokConfigDir(): string;
@@ -26,7 +36,11 @@ declare function getGrokSnapshotPath(): string;
 declare function classifyGrokProxyModel(id: string, mapping?: ModelMapping): CliGrokProxyModelSpec;
 declare function loadRoutedModelIds(configPath?: string): Promise<string[]>;
 declare function catalogModelIds(configPath?: string): Promise<string[]>;
-declare function buildGrokManagedBlock(baseUrl: string, configPath?: string): Promise<string>;
+/**
+ * `userModelIds` are ids the user defines themselves. Writing the proxy's
+ * entry beside theirs would declare the table twice, so theirs wins.
+ */
+declare function buildGrokManagedBlock(baseUrl: string, configPath?: string, userModelIds?: ReadonlySet<string>): Promise<string>;
 export declare function setGrokProxySettings(baseUrl: string, options?: CliProxyClientApplyOptions): Promise<boolean>;
 export declare function clearGrokProxySettings(expectedBaseUrl?: string): Promise<boolean>;
 export declare const grokConfigurator: CliProxyClientConfigurator;

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

@@ -18,6 +18,16 @@
  * Adaptive thinking: Grok's global `default_reasoning_effort = "xhigh"`
  * becomes Anthropic `thinking.type = "adaptive"`. Haiku 4.5 rejects that
  * with 400. Only Claude Opus/Sonnet 4.6 and 5.x keep reasoning enabled.
+ *
+ * Ownership is decided by content, never by the block markers alone. Grok
+ * rewrites config.toml on its own saves (`/settings`, `grok mcp add`, ...)
+ * through a serializer that drops every comment, the markers included, and
+ * splits the inline `extra_headers` into a `[model.<id>.extra_headers]`
+ * sub-table (measured on Grok Build 1.0.40). A marker-only writer then kept
+ * the unmarked tables and appended a second copy of every id on the next
+ * proxy start, and TOML rejects a table declared twice, so Grok would not
+ * start. What marks an entry as ours is the placeholder key, a credential
+ * only the proxy accepts, and that survives Grok's rewrite.
  */
 import { readFileSync } from "fs";
 import { homedir } from "os";
@@ -26,9 +36,19 @@ import { logger } from "../../utils/logger.js";
 import { getContextWindowSize } from "../../constants/contextWindows.js";
 import { DEFAULT_PROXY_MODEL_IDS } from "../../constants/proxyModels.js";
 import { defaultProxyConfigPath, parseProxyConfigString, } from "../../proxy/proxyConfig.js";
-import { isUsableSnapshot, shouldCaptureSnapshot, writeFileAtomic, } from "./snapshot.js";
+import { isUsableSnapshot, resolveSymlinkTarget, shouldCaptureSnapshot, writeFileAtomic, } from "./snapshot.js";
+import { dottedTableIds, findDuplicateTable, inlineTablePairs, maskTomlStrings, maskedStringValue, ownedLineCount, parseMaskedAssignment, readStringValue, splitTomlSections, tomlCodeLines, } from "./tomlSections.js";
 const GROK_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
 const GROK_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const GROK_BLOCK_NOTES = [
+    "# Proxy catalog. Built-in grok-4.6 / grok-4.5 stay on xAI.",
+    "# context_window is Grok's compaction limit and must be <= upstream.",
+];
+const GROK_MANAGED_COMMENT_LINES = new Set([
+    GROK_BLOCK_BEGIN,
+    GROK_BLOCK_END,
+    ...GROK_BLOCK_NOTES,
+]);
 const PLACEHOLDER_KEY = "neurolink-proxy";
 const ANTHROPIC_VERSION = "2023-06-01";
 function getGrokConfigDir() {
@@ -43,9 +63,6 @@ function getGrokConfigPath() {
 function getGrokSnapshotPath() {
     return join(homedir(), ".neurolink", "grok-proxy-snapshot.json");
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function tomlKey(id) {
     return /^[A-Za-z0-9_-]+$/.test(id) ? id : JSON.stringify(id);
 }
@@ -172,28 +189,148 @@ function buildGrokModelBlock(spec, baseUrl) {
     }
     return lines.join("\n");
 }
-async function buildGrokManagedBlock(baseUrl, configPath) {
-    const specs = await catalogGrokSpecs(configPath);
-    const body = specs
+/**
+ * `userModelIds` are ids the user defines themselves. Writing the proxy's
+ * entry beside theirs would declare the table twice, so theirs wins.
+ */
+async function buildGrokManagedBlock(baseUrl, configPath, userModelIds = new Set()) {
+    const catalog = await catalogGrokSpecs(configPath);
+    for (const spec of catalog) {
+        if (userModelIds.has(spec.id)) {
+            logger.debug(`[proxy] Grok: config.toml already defines [model.${tomlKey(spec.id)}]; keeping it and skipping the proxy's entry`);
+        }
+    }
+    const body = catalog
+        .filter((spec) => !userModelIds.has(spec.id))
         .map((spec) => buildGrokModelBlock(spec, baseUrl))
         .join("\n\n");
     return [
         GROK_BLOCK_BEGIN,
-        "# Proxy catalog. Built-in grok-4.6 / grok-4.5 stay on xAI.",
-        "# context_window is Grok's compaction limit and must be <= upstream.",
+        ...GROK_BLOCK_NOTES,
         "",
         body,
         GROK_BLOCK_END,
         "",
     ].join("\n");
 }
-function stripGrokManagedBlock(text) {
-    const blockRe = new RegExp(`\\n?${escapeRegExp(GROK_BLOCK_BEGIN)}[\\s\\S]*?${escapeRegExp(GROK_BLOCK_END)}\\n?`, "g");
-    return text.replace(blockRe, "\n");
+function modelEntryId(section) {
+    return section.path !== null &&
+        section.path.length >= 2 &&
+        section.path[0] === "model"
+        ? section.path[1]
+        : null;
+}
+/** Where a model entry carries the placeholder key, as a path within it. */
+const PLACEHOLDER_KEY_PATHS = [
+    ["api_key"],
+    ["extra_headers", "x-api-key"],
+];
+function isPlaceholderKey(path, value) {
+    return (value === PLACEHOLDER_KEY &&
+        PLACEHOLDER_KEY_PATHS.some((keyPath) => keyPath.length === path.length &&
+            keyPath.every((part, index) => path[index] === part)));
+}
+/**
+ * Whether a section of a model entry sends the placeholder key: `api_key` on
+ * the model, or `x-api-key` in its `extra_headers`, spelled as a plain key, a
+ * dotted key, an inline table or the sub-table Grok's own save writes. The
+ * full key path must match, so a user's `legacy.api_key` is not the proxy's.
+ */
+function sectionSendsPlaceholderKey(section) {
+    const prefix = section.path?.slice(2) ?? [];
+    return tomlCodeLines(section).some(({ line, statement }) => {
+        if (!statement) {
+            return false;
+        }
+        const { masked, strings } = maskTomlStrings(line);
+        const assignment = parseMaskedAssignment(masked, strings);
+        if (!assignment) {
+            return false;
+        }
+        const path = [...prefix, ...assignment.path];
+        return (isPlaceholderKey(path, maskedStringValue(assignment.value, strings)) ||
+            inlineTablePairs(assignment.value, strings).some((pair) => isPlaceholderKey([...path, ...pair.path], maskedStringValue(pair.value, strings))));
+    });
 }
-function extractManagedBaseUrl(text) {
-    const match = text.match(new RegExp(`${escapeRegExp(GROK_BLOCK_BEGIN)}[\\s\\S]*?base_url\\s*=\\s*"([^"]*)"`));
-    return match?.[1];
+/**
+ * Which parts of a Grok config.toml the proxy owns.
+ *
+ * A model entry is a `[model.<id>]` table plus its `[model.<id>.*]`
+ * sub-tables, wherever they sit: Grok's save keeps them together, hand edits
+ * need not. It is the proxy's when it sends the placeholder key and is either
+ * in the current catalog or still carries the exact name the proxy gave it,
+ * which covers entries a later catalog dropped. A user's own model behind the
+ * proxy, under their own name, is theirs. Keys and values are read as TOML,
+ * never as raw text, so a string that merely mentions the placeholder cannot
+ * make a user's table look like the proxy's. `remainder` is the text with
+ * owned entries and the managed comment lines removed and every other byte
+ * kept, so a missing, orphaned or doubled marker cannot make an apply delete
+ * the user's content or leave an old copy of the catalog behind.
+ */
+function inspectGrokConfig(text, catalogIds) {
+    const sections = splitTomlSections(text);
+    // Models the user defines without a [model.<id>] table of their own.
+    const definedElsewhere = new Set([
+        ...dottedTableIds(sections, "model"),
+        ...sections.flatMap((section) => {
+            const id = section.arrayTable ? modelEntryId(section) : null;
+            return id !== null && section.path?.length === 2 ? [id] : [];
+        }),
+    ]);
+    const ids = sections.map((section) => section.arrayTable ? null : modelEntryId(section));
+    const isModelTable = (index) => ids[index] !== null && sections[index].path?.length === 2;
+    const tableFor = (index) => {
+        if (ids[index] === null || isModelTable(index)) {
+            return index;
+        }
+        const sameModel = (candidate) => isModelTable(candidate) && ids[candidate] === ids[index];
+        const before = sections.findLastIndex((_, candidate) => candidate < index && sameModel(candidate));
+        const after = sections.findIndex((_, candidate) => candidate > index && sameModel(candidate));
+        return before !== -1 ? before : after !== -1 ? after : index;
+    };
+    const entryOf = sections.map((_, index) => tableFor(index));
+    const ownedEntries = new Set(entryOf.filter((entry) => {
+        const id = ids[entry];
+        if (id === null) {
+            return false;
+        }
+        const sendsPlaceholder = sections.some((section, index) => entryOf[index] === entry &&
+            ids[index] !== null &&
+            sectionSendsPlaceholderKey(section));
+        if (!sendsPlaceholder) {
+            return false;
+        }
+        // A sub-table left without its table carries no name to check; it is
+        // the proxy's unless the model is defined some other way.
+        if (!isModelTable(entry)) {
+            return !definedElsewhere.has(id);
+        }
+        return (catalogIds.has(id) ||
+            readStringValue(sections[entry], "name") === displayNameFor(id));
+    }));
+    const owned = sections.map((_, index) => ids[index] !== null && ownedEntries.has(entryOf[index]));
+    const userModelIds = new Set([
+        ...definedElsewhere,
+        ...sections.flatMap((section, index) => {
+            const id = modelEntryId(section);
+            return id !== null && !owned[index] ? [id] : [];
+        }),
+    ]);
+    const managedBaseUrls = [
+        ...new Set(sections.flatMap((section, index) => {
+            const url = owned[index]
+                ? readStringValue(section, "base_url")
+                : undefined;
+            return url === undefined ? [] : [url];
+        })),
+    ];
+    const remainder = sections
+        .flatMap((section, index) => owned[index]
+        ? section.lines.slice(ownedLineCount(section, GROK_MANAGED_COMMENT_LINES))
+        : section.lines)
+        .filter((line) => !GROK_MANAGED_COMMENT_LINES.has(line.trim()))
+        .join("");
+    return { remainder, managedBaseUrls, userModelIds };
 }
 async function readGrokSnapshot() {
     const fs = await import("fs");
@@ -250,11 +387,26 @@ export async function setGrokProxySettings(baseUrl, options) {
                 : original.indexOf(GROK_BLOCK_END) + GROK_BLOCK_END.length)
             : undefined
         : undefined;
+    const inspected = original === null
+        ? null
+        : inspectGrokConfig(original, new Set(await catalogModelIds(options?.configPath)));
+    const block = await buildGrokManagedBlock(baseUrl, options?.configPath, inspected?.userModelIds);
+    const remainder = inspected?.remainder ?? "";
+    const next = remainder.trim().length === 0
+        ? block
+        : `${remainder.replace(/\s*$/, "\n")}\n${block}`;
+    // Grok refuses to load or save a config it cannot parse. Writing into one
+    // would only bury the user's own error under ours.
+    const duplicate = findDuplicateTable(next);
+    if (duplicate !== undefined) {
+        logger.warn(`[proxy] Grok: config.toml declares [${duplicate}] more than once; leaving it untouched`);
+        return false;
+    }
     if (existingSnapshot === null ||
         shouldCaptureSnapshot({
             hasSnapshot: existingSnapshot !== null,
             written: existingSnapshot?.writtenBaseUrl,
-            current: extractManagedBaseUrl(original ?? "") ?? currentBlock,
+            current: inspected?.managedBaseUrls[0] ?? currentBlock,
         })) {
         fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
         await writeFileAtomic(getGrokSnapshotPath(), JSON.stringify({
@@ -262,12 +414,11 @@ export async function setGrokProxySettings(baseUrl, options) {
             writtenBaseUrl: baseUrl,
         }, null, 2), 0o600);
     }
-    const withoutBlock = original ? stripGrokManagedBlock(original) : "";
-    const trimmed = withoutBlock.replace(/\s*$/, "\n");
-    const next = `${trimmed}\n${await buildGrokManagedBlock(baseUrl, options?.configPath)}`;
-    await writeFileAtomic(getGrokConfigPath(), next.startsWith("\n") && original === null
-        ? next.replace(/^\n+/, "")
-        : next, original === null ? 0o600 : undefined);
+    // Every proxy start applies; an update starts one. Rewriting a file that
+    // already matches only widens the window for racing Grok's own saves.
+    if (next !== original) {
+        await writeFileAtomic(getGrokConfigPath(), next, original === null ? 0o600 : undefined);
+    }
     return true;
 }
 export async function clearGrokProxySettings(expectedBaseUrl) {
@@ -279,13 +430,16 @@ export async function clearGrokProxySettings(expectedBaseUrl) {
     catch {
         return false;
     }
-    if (!current.includes(GROK_BLOCK_BEGIN)) {
+    const inspected = inspectGrokConfig(current, new Set(await catalogModelIds()));
+    if (inspected.remainder === current) {
         return false;
     }
-    const configuredUrl = extractManagedBaseUrl(current);
+    // Another proxy's block is left alone. One entry the user repointed does
+    // not make the rest foreign, whichever entry happens to come first.
+    const configuredUrls = inspected.managedBaseUrls;
     if (expectedBaseUrl &&
-        configuredUrl !== undefined &&
-        configuredUrl !== expectedBaseUrl) {
+        configuredUrls.length > 0 &&
+        !configuredUrls.includes(expectedBaseUrl)) {
         logger.debug("[proxy] Grok clear: base URL is not the one we wrote, leaving it intact");
         return false;
     }
@@ -294,9 +448,13 @@ export async function clearGrokProxySettings(expectedBaseUrl) {
         logger.warn("[proxy] Grok clear: no usable snapshot, leaving config.toml untouched rather than stripping a block we cannot prove we own");
         return false;
     }
-    const remainder = stripGrokManagedBlock(current).replace(/\s*$/, "\n");
+    const remainder = inspected.remainder.replace(/\s*$/, "\n");
     if (!snapshot.originalExisted && remainder.trim().length === 0) {
-        fs.rmSync(getGrokConfigPath(), { force: true });
+        // Apply wrote through a symlink the user already had, so the link stays
+        // and the file apply created behind it goes.
+        fs.rmSync(await resolveSymlinkTarget(getGrokConfigPath()), {
+            force: true,
+        });
     }
     else {
         await writeFileAtomic(getGrokConfigPath(), remainder);

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

@@ -63,6 +63,11 @@ export declare function isProxyOwnedValue(args: {
     written: unknown;
     current: unknown;
 }): boolean;
+/**
+ * The path a chain of symlinks finally names, which need not exist. A path
+ * that is not a link comes back unchanged.
+ */
+export declare function resolveSymlinkTarget(filePath: string): Promise<string>;
 /**
  * Replace a file's contents without ever exposing a partial one.
  *
@@ -112,5 +117,12 @@ export declare function isProxyOwnedValue(args: {
  * is NOT atomic. Moving the temp file to `os.tmpdir()` would look like a
  * tidy-up and would quietly restore the exact window this function exists to
  * close, on Windows only, where nobody here would see it.
+ *
+ * A config kept in a dotfiles repository is often a symlink into it, a setup
+ * Grok documents and its own writer honours. A rename over the link would
+ * replace the link with a regular file and leave the repository's copy stale,
+ * so the write lands on the end of the link chain instead, which need not
+ * exist yet. The temp file is that target's sibling, so the rename stays
+ * atomic.
  */
 export declare function writeFileAtomic(filePath: string, contents: string, mode?: number): Promise<void>;

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

@@ -113,6 +113,31 @@ export function isProxyOwnedValue(args) {
     }
     return valuesMatch(args.current, args.written);
 }
+/**
+ * The path a chain of symlinks finally names, which need not exist. A path
+ * that is not a link comes back unchanged.
+ */
+export async function resolveSymlinkTarget(filePath) {
+    const fs = await import("fs");
+    const { dirname, resolve } = await import("path");
+    let target = filePath;
+    for (let hops = 0;; hops += 1) {
+        let isLink;
+        try {
+            isLink = fs.lstatSync(target).isSymbolicLink();
+        }
+        catch {
+            isLink = false;
+        }
+        if (!isLink) {
+            return target;
+        }
+        if (hops === 40) {
+            throw new Error(`${filePath}: too many levels of symbolic links`);
+        }
+        target = resolve(dirname(target), fs.readlinkSync(target));
+    }
+}
 /** Distinguishes concurrent writers within one process. */
 let atomicWriteCounter = 0;
 /**
@@ -164,12 +189,20 @@ let atomicWriteCounter = 0;
  * is NOT atomic. Moving the temp file to `os.tmpdir()` would look like a
  * tidy-up and would quietly restore the exact window this function exists to
  * close, on Windows only, where nobody here would see it.
+ *
+ * A config kept in a dotfiles repository is often a symlink into it, a setup
+ * Grok documents and its own writer honours. A rename over the link would
+ * replace the link with a regular file and leave the repository's copy stale,
+ * so the write lands on the end of the link chain instead, which need not
+ * exist yet. The temp file is that target's sibling, so the rename stays
+ * atomic.
  */
 export async function writeFileAtomic(filePath, contents, mode) {
     const fs = await import("fs");
     const { dirname, join, basename } = await import("path");
+    const target = await resolveSymlinkTarget(filePath);
     atomicWriteCounter += 1;
-    const tempPath = join(dirname(filePath), `.${basename(filePath)}.neurolink-${process.pid}-${atomicWriteCounter}.tmp`);
+    const tempPath = join(dirname(target), `.${basename(target)}.neurolink-${process.pid}-${atomicWriteCounter}.tmp`);
     // Which step failed changes what the user should do about it: a failed write
     // is usually a missing directory or a full disk and the config is untouched,
     // while a failed rename is a locked destination and the config is intact but
@@ -180,7 +213,7 @@ export async function writeFileAtomic(filePath, contents, mode) {
     let effectiveMode = mode;
     if (effectiveMode === undefined) {
         try {
-            effectiveMode = fs.statSync(filePath).mode & 0o777;
+            effectiveMode = fs.statSync(target).mode & 0o777;
         }
         catch {
             effectiveMode = 0o600;
@@ -192,12 +225,12 @@ export async function writeFileAtomic(filePath, contents, mode) {
         // caller sees an ENOENT naming a path it never asked to write. Creating
         // the directory first makes a first-run write behave like the plain
         // writeFileSync it replaced.
-        fs.mkdirSync(dirname(filePath), { recursive: true });
+        fs.mkdirSync(dirname(target), { recursive: true });
         fs.writeFileSync(tempPath, contents, { mode: effectiveMode });
         stage = "chmod";
         fs.chmodSync(tempPath, effectiveMode);
         stage = "rename";
-        fs.renameSync(tempPath, filePath);
+        fs.renameSync(tempPath, target);
     }
     catch (error) {
         // Never leave scratch in the user's config directory.

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

@@ -0,0 +1,74 @@
+/**
+ * Line-level TOML reading for the proxy's client-config writers.
+ *
+ * Grok and Codex keep their settings in TOML files the user and the CLI
+ * itself also edit, and the writers must find what the proxy wrote there
+ * without trusting its comment markers: Grok's own save drops every comment.
+ * No TOML parser is a dependency, and a parse-and-serialize round trip would
+ * reformat the user's file anyway, so this reads just enough structure to
+ * edit text in place: table headers, strings, keys and assignments. Every
+ * line keeps its own terminator, so text a writer does not own round-trips
+ * byte for byte.
+ */
+import type { CliTomlSection } from "../../types/index.js";
+export declare function splitTomlSections(text: string): CliTomlSection[];
+/**
+ * A line of TOML with every string replaced by `@<n>@` and any comment
+ * dropped, so text inside a string can never read as a key or an assignment.
+ * `strings[n]` is the decoded value. `@` cannot occur outside a string in
+ * valid TOML.
+ */
+export declare function maskTomlStrings(line: string): {
+    masked: string;
+    strings: string[];
+};
+export declare function parseMaskedAssignment(masked: string, strings: readonly string[]): {
+    path: string[];
+    value: string;
+} | null;
+/**
+ * The string a masked value starts with. Only the start counts, so a value
+ * with damage after it (a literal `\n` left by a bad paste) is still read.
+ */
+export declare function maskedStringValue(value: string, strings: readonly string[]): string | undefined;
+/** The pairs directly inside a one-line inline table. */
+export declare function inlineTablePairs(value: string, strings: readonly string[]): {
+    path: string[];
+    value: string;
+}[];
+/** The dotted key a statement assigns, and its value when that is a string. */
+export declare function readTomlAssignment(line: string): {
+    path: string[];
+    value: string | undefined;
+} | null;
+/**
+ * The lines of a section that are TOML rather than the inside of a
+ * multi-line string; `statement` marks those that start a key/value pair
+ * rather than continue an array or inline table.
+ */
+export declare function tomlCodeLines(section: CliTomlSection): {
+    line: string;
+    statement: boolean;
+}[];
+export declare function readStringValue(section: CliTomlSection, key: string): string | undefined;
+/**
+ * Names of the `<parent>.<name>` tables defined by dotted keys instead of a
+ * `[<parent>.<name>]` header: `claude-opus-4-6.base_url = ...` under
+ * `[model]`, or `model.claude-opus-4-6.base_url = ...` before the first
+ * header.
+ */
+export declare function dottedTableIds(sections: readonly CliTomlSection[], parent: string): string[];
+/**
+ * How many of an owned section's lines are the writer's. Comments after its
+ * last key belong to what follows, so a note the user wrote above their own
+ * next table survives. `managedLines` are the writer's own comment lines,
+ * which are dropped wherever they sit.
+ */
+export declare function ownedLineCount(section: CliTomlSection, managedLines: ReadonlySet<string>): number;
+/**
+ * A table declared twice is a TOML error, and neither Grok nor Codex will
+ * start on one.
+ * Each `[[array]]` element opens a fresh scope for everything under it, so
+ * `[mcp_servers.env]` under two elements is not a repeat.
+ */
+export declare function findDuplicateTable(text: string): string | undefined;

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

@@ -0,0 +1,365 @@
+/**
+ * Line-level TOML reading for the proxy's client-config writers.
+ *
+ * Grok and Codex keep their settings in TOML files the user and the CLI
+ * itself also edit, and the writers must find what the proxy wrote there
+ * without trusting its comment markers: Grok's own save drops every comment.
+ * No TOML parser is a dependency, and a parse-and-serialize round trip would
+ * reformat the user's file anyway, so this reads just enough structure to
+ * edit text in place: table headers, strings, keys and assignments. Every
+ * line keeps its own terminator, so text a writer does not own round-trips
+ * byte for byte.
+ */
+function splitLinesKeepingEnds(text) {
+    return text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+function readTomlKey(text) {
+    const bare = text.match(/^[A-Za-z0-9_-]+/);
+    if (bare) {
+        return { value: bare[0], length: bare[0].length };
+    }
+    const basic = text.match(/^"(?:[^"\\]|\\.)*"/);
+    if (basic) {
+        let value;
+        try {
+            value = JSON.parse(basic[0]);
+        }
+        catch {
+            value = undefined;
+        }
+        return {
+            value: typeof value === "string" ? value : basic[0].slice(1, -1),
+            length: basic[0].length,
+        };
+    }
+    const literal = text.match(/^'[^']*'/);
+    if (literal) {
+        return { value: literal[0].slice(1, -1), length: literal[0].length };
+    }
+    return null;
+}
+function parseTomlTableHeader(line) {
+    const text = line.trim();
+    if (!text.startsWith("[")) {
+        return null;
+    }
+    const arrayTable = text.startsWith("[[");
+    const path = [];
+    let rest = text.slice(arrayTable ? 2 : 1);
+    for (;;) {
+        rest = rest.trimStart();
+        const key = readTomlKey(rest);
+        if (key === null) {
+            return null;
+        }
+        path.push(key.value);
+        rest = rest.slice(key.length).trimStart();
+        if (!rest.startsWith(".")) {
+            break;
+        }
+        rest = rest.slice(1);
+    }
+    const close = arrayTable ? "]]" : "]";
+    if (!rest.startsWith(close)) {
+        return null;
+    }
+    const tail = rest.slice(close.length).trim();
+    return tail.length === 0 || tail.startsWith("#")
+        ? { path, arrayTable }
+        : null;
+}
+function advanceTomlScan(line, state) {
+    let { multiline, depth } = state;
+    let i = 0;
+    while (i < line.length) {
+        if (multiline !== null) {
+            if (multiline === '"""' && line[i] === "\\") {
+                i += 2;
+            }
+            else if (line.startsWith(multiline, i)) {
+                // Up to two quotes of content may sit against the closing delimiter.
+                const quote = multiline[0];
+                i += 3;
+                while (line[i] === quote) {
+                    i += 1;
+                }
+                multiline = null;
+            }
+            else {
+                i += 1;
+            }
+            continue;
+        }
+        const ch = line[i];
+        if (ch === "#") {
+            break;
+        }
+        if (line.startsWith('"""', i) || line.startsWith("'''", i)) {
+            multiline = line.startsWith('"""', i) ? '"""' : "'''";
+            i += 3;
+        }
+        else if (ch === '"') {
+            i += 1;
+            while (i < line.length && line[i] !== '"') {
+                i += line[i] === "\\" ? 2 : 1;
+            }
+            i += 1;
+        }
+        else if (ch === "'") {
+            const end = line.indexOf("'", i + 1);
+            i = end === -1 ? line.length : end + 1;
+        }
+        else {
+            if (ch === "[" || ch === "{") {
+                depth += 1;
+            }
+            else if (ch === "]" || ch === "}") {
+                depth = Math.max(0, depth - 1);
+            }
+            i += 1;
+        }
+    }
+    return { multiline, depth };
+}
+export function splitTomlSections(text) {
+    const sections = [];
+    let current = { path: null, arrayTable: false, lines: [] };
+    let state = { multiline: null, depth: 0 };
+    for (const line of splitLinesKeepingEnds(text)) {
+        const header = state.multiline === null && state.depth === 0
+            ? parseTomlTableHeader(line)
+            : null;
+        if (header) {
+            sections.push(current);
+            current = { ...header, lines: [line] };
+            continue;
+        }
+        current.lines.push(line);
+        state = advanceTomlScan(line, state);
+    }
+    sections.push(current);
+    return sections;
+}
+function decodeBasicString(inner) {
+    try {
+        const value = JSON.parse(`"${inner}"`);
+        return typeof value === "string" ? value : inner;
+    }
+    catch {
+        return inner;
+    }
+}
+/**
+ * A line of TOML with every string replaced by `@<n>@` and any comment
+ * dropped, so text inside a string can never read as a key or an assignment.
+ * `strings[n]` is the decoded value. `@` cannot occur outside a string in
+ * valid TOML.
+ */
+export function maskTomlStrings(line) {
+    const strings = [];
+    let masked = "";
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === "#") {
+            break;
+        }
+        const triple = line.startsWith('"""', i)
+            ? '"""'
+            : line.startsWith("'''", i)
+                ? "'''"
+                : null;
+        if (triple !== null || ch === '"' || ch === "'") {
+            const delimiter = triple ?? ch;
+            let end = i + delimiter.length;
+            while (end < line.length && !line.startsWith(delimiter, end)) {
+                end += delimiter.startsWith('"') && line[end] === "\\" ? 2 : 1;
+            }
+            // Up to two quotes of content may sit against a triple closer.
+            for (let extra = 0; triple !== null &&
+                extra < 2 &&
+                line[end + delimiter.length] === delimiter[0]; extra += 1) {
+                end += 1;
+            }
+            const inner = line.slice(i + delimiter.length, Math.min(end, line.length));
+            strings.push(delimiter.startsWith("'") ? inner : decodeBasicString(inner));
+            masked += `@${strings.length - 1}@`;
+            i = end + delimiter.length;
+            continue;
+        }
+        masked += ch;
+        i += 1;
+    }
+    return { masked, strings };
+}
+const TOML_KEY_PART = String.raw `(?:[A-Za-z0-9_-]+|@\d+@)`;
+const TOML_ASSIGNMENT = new RegExp(String.raw `^\s*(${TOML_KEY_PART}(?:\s*\.\s*${TOML_KEY_PART})*)\s*=\s*(.*?)\s*$`);
+function unmaskKeyPart(part, strings) {
+    const token = part.match(/^@(\d+)@$/);
+    return token ? strings[Number(token[1])] : part;
+}
+export function parseMaskedAssignment(masked, strings) {
+    const match = masked.match(TOML_ASSIGNMENT);
+    return match
+        ? {
+            path: match[1]
+                .split(".")
+                .map((part) => unmaskKeyPart(part.trim(), strings)),
+            value: match[2],
+        }
+        : null;
+}
+/**
+ * The string a masked value starts with. Only the start counts, so a value
+ * with damage after it (a literal `\n` left by a bad paste) is still read.
+ */
+export function maskedStringValue(value, strings) {
+    const token = value.match(/^@(\d+)@/);
+    return token ? strings[Number(token[1])] : undefined;
+}
+/** The pairs directly inside a one-line inline table. */
+export function inlineTablePairs(value, strings) {
+    if (!value.startsWith("{") || !value.endsWith("}")) {
+        return [];
+    }
+    const parts = [];
+    let depth = 0;
+    let start = 1;
+    for (let i = 1; i < value.length - 1; i += 1) {
+        if (value[i] === "{" || value[i] === "[") {
+            depth += 1;
+        }
+        else if (value[i] === "}" || value[i] === "]") {
+            depth -= 1;
+        }
+        else if (value[i] === "," && depth === 0) {
+            parts.push(value.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(value.slice(start, value.length - 1));
+    return parts.flatMap((part) => {
+        const pair = parseMaskedAssignment(part, strings);
+        return pair ? [pair] : [];
+    });
+}
+/** The dotted key a statement assigns, and its value when that is a string. */
+export function readTomlAssignment(line) {
+    const { masked, strings } = maskTomlStrings(line);
+    const assignment = parseMaskedAssignment(masked, strings);
+    return assignment
+        ? {
+            path: assignment.path,
+            value: maskedStringValue(assignment.value, strings),
+        }
+        : null;
+}
+function isTomlContentLine(line) {
+    const text = line.trim();
+    return text.length > 0 && !text.startsWith("#");
+}
+/**
+ * The lines of a section that are TOML rather than the inside of a
+ * multi-line string; `statement` marks those that start a key/value pair
+ * rather than continue an array or inline table.
+ */
+export function tomlCodeLines(section) {
+    const code = [];
+    let state = { multiline: null, depth: 0 };
+    section.lines.forEach((line, index) => {
+        const isHeader = index === 0 && section.path !== null;
+        if (!isHeader && state.multiline === null) {
+            code.push({ line, statement: state.depth === 0 });
+        }
+        if (!isHeader) {
+            state = advanceTomlScan(line, state);
+        }
+    });
+    return code;
+}
+export function readStringValue(section, key) {
+    for (const { line, statement } of tomlCodeLines(section)) {
+        const assignment = statement ? readTomlAssignment(line) : null;
+        if (assignment?.path.length === 1 && assignment.path[0] === key) {
+            return assignment.value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Names of the `<parent>.<name>` tables defined by dotted keys instead of a
+ * `[<parent>.<name>]` header: `claude-opus-4-6.base_url = ...` under
+ * `[model]`, or `model.claude-opus-4-6.base_url = ...` before the first
+ * header.
+ */
+export function dottedTableIds(sections, parent) {
+    return sections.flatMap((section) => {
+        const underParent = !section.arrayTable &&
+            section.path?.length === 1 &&
+            section.path[0] === parent;
+        if (!underParent && section.path !== null) {
+            return [];
+        }
+        return tomlCodeLines(section).flatMap(({ line, statement }) => {
+            const path = statement ? readTomlAssignment(line)?.path : undefined;
+            if (!path) {
+                return [];
+            }
+            if (underParent) {
+                return [path[0]];
+            }
+            return path.length >= 2 && path[0] === parent ? [path[1]] : [];
+        });
+    });
+}
+/**
+ * How many of an owned section's lines are the writer's. Comments after its
+ * last key belong to what follows, so a note the user wrote above their own
+ * next table survives. `managedLines` are the writer's own comment lines,
+ * which are dropped wherever they sit.
+ */
+export function ownedLineCount(section, managedLines) {
+    const lastKey = section.lines.findLastIndex(isTomlContentLine);
+    const firstNote = section.lines.findIndex((line, index) => index > lastKey &&
+        line.trim().length > 0 &&
+        !managedLines.has(line.trim()));
+    return firstNote === -1 ? section.lines.length : firstNote;
+}
+/**
+ * A table declared twice is a TOML error, and neither Grok nor Codex will
+ * start on one.
+ * Each `[[array]]` element opens a fresh scope for everything under it, so
+ * `[mcp_servers.env]` under two elements is not a repeat.
+ */
+export function findDuplicateTable(text) {
+    const tables = new Map();
+    const arrays = new Map();
+    const isUnder = (candidate, prefix) => candidate.length > prefix.length &&
+        prefix.every((part, index) => candidate[index] === part);
+    for (const { path, arrayTable } of splitTomlSections(text)) {
+        if (path === null) {
+            continue;
+        }
+        const key = JSON.stringify(path);
+        if (arrayTable) {
+            if (tables.has(key)) {
+                return path.join(".");
+            }
+            for (const scope of [tables, arrays]) {
+                for (const [seenKey, seenPath] of scope) {
+                    if (isUnder(seenPath, path)) {
+                        scope.delete(seenKey);
+                    }
+                }
+            }
+            arrays.set(key, path);
+            continue;
+        }
+        if (tables.has(key) || arrays.has(key)) {
+            return path.join(".");
+        }
+        tables.set(key, path);
+    }
+    return undefined;
+}
+//# sourceMappingURL=tomlSections.js.map

package/dist/types/proxyClient.d.ts

@@ -29,8 +29,10 @@ export type CliProxyClientConfigurator = {
     /**
      * Point the CLI at the proxy. `proxyBaseUrl` is the bare proxy origin
      * (e.g. "http://127.0.0.1:55669"); the configurator appends whatever path
-     * suffix its CLI needs. Returns false when nothing was written, so callers
-     * never print a success message for work that did not happen.
+     * suffix its CLI needs. Returns false when the CLI is not left pointing at
+     * the proxy, so callers never print a success message for work that did
+     * not happen. A configurator whose file already matches may return true
+     * without rewriting it.
      */
     apply: (proxyBaseUrl: string, options?: CliProxyClientApplyOptions) => Promise<boolean>;
     /**
@@ -55,7 +57,10 @@ export type CliProxyClientConfigurator = {
 export type CliProxyClientApplyResult = {
     id: string;
     displayName: string;
-    /** True only when the configurator actually wrote configuration. */
+    /**
+     * True only when the CLI's configuration points at the proxy: written now,
+     * or already written and left as it was.
+     */
     applied: boolean;
     /**
      * Set when the write landed but is not yet in effect — see
@@ -110,6 +115,26 @@ export type CliGrokSnapshot = {
     originalExisted: boolean;
     writtenBaseUrl: string;
 };
+/**
+ * One header-delimited run of a client's TOML config. `path` is the parsed
+ * header key (`["model", "gemini-2.5-pro"]` for `[model."gemini-2.5-pro"]`),
+ * or null for the keys before the first header. `lines` keep their own
+ * terminators, so text the writer does not own round-trips byte for byte.
+ */
+export type CliTomlSection = {
+    path: readonly string[] | null;
+    arrayTable: boolean;
+    lines: readonly string[];
+};
+/**
+ * What a line of TOML leaves open for the next one: a multi-line string, or
+ * brackets of an array or inline table. A `[` that starts a line is a table
+ * header only when neither is open.
+ */
+export type CliTomlScanState = {
+    multiline: '"""' | "'''" | null;
+    depth: number;
+};
 /**
  * Snapshot of the user's pre-existing Gemini CLI `~/.gemini/.env`.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.30.0",
+  "version": "12.30.1",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {