@juspay/neurolink 12.12.16 → 12.14.0

package/dist/cli/commands/proxy.js

@@ -11,13 +11,14 @@
  */
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import chalk from "chalk";
 import ora from "ora";
 import { buildProxyHealthResponse, createProxyReadinessState, markProxyDrainingForUpdate, markProxyReady, resumeProxyConnections, waitForProxyReadiness, } from "../../proxy/proxyHealth.js";
 import { logger } from "../../utils/logger.js";
 import { applyAllClients, restoreAllClients, } from "../proxy-clients/registry.js";
+import { resolveProxyConfigPath } from "../../proxy/proxyConfig.js";
 import { redactUrlsInText, sanitizeForLog, } from "../../utils/logSanitize.js";
 import { withTimeout } from "../../utils/async/withTimeout.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
@@ -2696,7 +2697,9 @@ async function startProxyRuntime(params) {
         logger.always(`  ${chalk.bold("Env File:")}   ${chalk.cyan(params.loadedEnvFile)}`);
     }
     if (!isDev) {
-        for (const result of await applyAllClients(url)) {
+        for (const result of await applyAllClients(url, {
+            configPath: params.configPath,
+        })) {
             if (result.error) {
                 // Visible, not debug-level. A client whose config could not be written
                 // will keep talking to its own upstream, which looks like the proxy
@@ -2953,9 +2956,7 @@ async function startProxyCommandHandler(argv) {
         // content-filters. Runs once, after env load so it can be tuned via env.
         configureProxyKeepAliveDispatcher();
         const { neurolink, logsDir } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
-        const configPath = argv.config
-            ? resolve(argv.config)
-            : join(homedir(), ".neurolink", "proxy-config.yaml");
+        const configPath = resolveProxyConfigPath(argv.config);
         const runtimeConfigStore = await ProxyRuntimeConfigStore.create({
             configPath,
             configRequired: Boolean(argv.config),
@@ -3012,6 +3013,7 @@ async function startProxyCommandHandler(argv) {
             passthrough,
             logsDir,
             runtimeConfigStore,
+            configPath,
         });
     }
     catch (error) {
@@ -4174,7 +4176,9 @@ export const proxySetupCommand = {
             const nextStep = stepNum + 1;
             console.info(chalk.blue(`\nStep ${nextStep}:`) + " Configuring Claude Code...");
             const url = `http://127.0.0.1:${port}`;
-            for (const result of await applyAllClients(url)) {
+            for (const result of await applyAllClients(url, {
+                configPath: resolveProxyConfigPath(argv.config),
+            })) {
                 if (result.error) {
                     console.info(chalk.yellow(`  ⚠ Could not auto-configure ${result.displayName}: ${result.error.message}`));
                     // Claude Code is the one client whose manual fallback is a single
@@ -4364,9 +4368,7 @@ export const proxyInstallCommand = {
         });
         const envFile = envResolution.path;
         const explicitConfig = argv.config;
-        const configPath = explicitConfig
-            ? resolve(explicitConfig)
-            : join(homedir(), ".neurolink", "proxy-config.yaml");
+        const configPath = resolveProxyConfigPath(explicitConfig);
         if (explicitConfig && !existsSync(configPath)) {
             console.info(chalk.red(`Proxy config file not found: ${configPath}`));
             process.exit(1);

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

@@ -0,0 +1,45 @@
+/**
+ * Grok Build client configurator.
+ *
+ * Grok Build (`grok`, xAI's terminal agent) is a Codex-shaped TOML client
+ * that speaks three wire formats. Built-in `grok-4.6` / `grok-4.5` stay on
+ * xAI (`cli-chat-proxy.grok.com`, Responses API, 500k window). This writer
+ * does not remap those. It adds the proxy's advertised catalog as extra
+ * picker entries so Grok can send Claude traffic through `/v1/messages`
+ * (passthrough) and Gemini/OpenAI traffic through `/v1/chat/completions`
+ * (translation), each with a `context_window` that Grok's own compaction
+ * will honour — the proxy does not truncate.
+ *
+ * Snapshot lives in `~/.neurolink/`, following Codex, never inside
+ * `config.toml`. Grok's TOML parser is not a closed schema, but putting
+ * bookkeeping keys in the user's file is how OpenCode was bricked, and new
+ * writers do not rely on tolerance.
+ *
+ * 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.
+ */
+import type { CliGrokProxyModelSpec, CliProxyClientApplyOptions, CliProxyClientConfigurator, ModelMapping } from "../../types/index.js";
+declare function getGrokConfigDir(): string;
+declare function getGrokConfigPath(): string;
+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>;
+export declare function setGrokProxySettings(baseUrl: string, options?: CliProxyClientApplyOptions): Promise<boolean>;
+export declare function clearGrokProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+export declare const grokConfigurator: CliProxyClientConfigurator;
+/** Test-only export (CLAUDE.md rule 15 determinism exception). See openCode.ts. */
+export declare const __grokTestHooks: {
+    getGrokConfigDir: typeof getGrokConfigDir;
+    getGrokConfigPath: typeof getGrokConfigPath;
+    getGrokSnapshotPath: typeof getGrokSnapshotPath;
+    setGrokProxySettings: typeof setGrokProxySettings;
+    clearGrokProxySettings: typeof clearGrokProxySettings;
+    classifyGrokProxyModel: typeof classifyGrokProxyModel;
+    loadRoutedModelIds: typeof loadRoutedModelIds;
+    catalogModelIds: typeof catalogModelIds;
+    buildGrokManagedBlock: typeof buildGrokManagedBlock;
+};
+export {};

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

@@ -0,0 +1,342 @@
+/**
+ * Grok Build client configurator.
+ *
+ * Grok Build (`grok`, xAI's terminal agent) is a Codex-shaped TOML client
+ * that speaks three wire formats. Built-in `grok-4.6` / `grok-4.5` stay on
+ * xAI (`cli-chat-proxy.grok.com`, Responses API, 500k window). This writer
+ * does not remap those. It adds the proxy's advertised catalog as extra
+ * picker entries so Grok can send Claude traffic through `/v1/messages`
+ * (passthrough) and Gemini/OpenAI traffic through `/v1/chat/completions`
+ * (translation), each with a `context_window` that Grok's own compaction
+ * will honour — the proxy does not truncate.
+ *
+ * Snapshot lives in `~/.neurolink/`, following Codex, never inside
+ * `config.toml`. Grok's TOML parser is not a closed schema, but putting
+ * bookkeeping keys in the user's file is how OpenCode was bricked, and new
+ * writers do not rely on tolerance.
+ *
+ * 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.
+ */
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+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";
+const GROK_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
+const GROK_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const PLACEHOLDER_KEY = "neurolink-proxy";
+const ANTHROPIC_VERSION = "2023-06-01";
+function getGrokConfigDir() {
+    const env = process.env.GROK_HOME;
+    return env !== undefined && env.trim().length > 0
+        ? env.trim()
+        : join(homedir(), ".grok");
+}
+function getGrokConfigPath() {
+    return join(getGrokConfigDir(), "config.toml");
+}
+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);
+}
+function displayNameFor(id) {
+    const base = id.replace(/-\d{8}$/, "");
+    const pretty = base
+        .split("-")
+        .map((part) => /^\d/.test(part) ? part : part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ")
+        .replace(/(\d) (\d)/g, "$1.$2");
+    return `${pretty} (NeuroLink)`;
+}
+function providerForModelId(id) {
+    if (id.startsWith("claude-")) {
+        return "anthropic";
+    }
+    if (id.startsWith("gemini-")) {
+        return "vertex";
+    }
+    return "openai";
+}
+function providerFromMapping(provider, fallbackId) {
+    const normalized = provider.trim().toLowerCase();
+    if (normalized === "anthropic" || normalized === "claude") {
+        return "anthropic";
+    }
+    if (normalized === "openai") {
+        return "openai";
+    }
+    if (normalized === "vertex" ||
+        normalized === "google" ||
+        normalized === "google-ai" ||
+        normalized === "gemini") {
+        return "vertex";
+    }
+    return providerForModelId(fallbackId);
+}
+function isMissingFileError(error) {
+    if (!error || typeof error !== "object" || !("code" in error)) {
+        return false;
+    }
+    return error.code === "ENOENT";
+}
+/**
+ * Anthropic `thinking.type = "adaptive"` is what Grok emits for `xhigh`.
+ * Measured: Haiku 4.5 returns 400 "adaptive thinking is not supported".
+ * Opus/Sonnet 4.6 and the 5-series accept it.
+ */
+function supportsAdaptiveThinking(id) {
+    return (/^claude-(opus|sonnet)-4-6$/.test(id) || /^claude-(opus|sonnet)-5/.test(id));
+}
+function classifyGrokProxyModel(id, mapping) {
+    const classifyId = mapping && mapping.to.trim().length > 0 ? mapping.to.trim() : id;
+    const provider = mapping
+        ? providerFromMapping(mapping.provider, classifyId)
+        : providerForModelId(id);
+    const windowProvider = mapping && mapping.provider.trim().length > 0
+        ? mapping.provider.trim()
+        : provider;
+    const apiBackend = provider === "anthropic" ? "messages" : "chat_completions";
+    const contextWindow = getContextWindowSize(windowProvider, classifyId);
+    return {
+        id,
+        name: displayNameFor(id),
+        apiBackend,
+        contextWindow,
+        maxCompletionTokens: contextWindow >= 1_000_000 ? 16_384 : 8_192,
+        supportsReasoningEffort: supportsAdaptiveThinking(classifyId),
+    };
+}
+async function loadRoutedMappings(configPath) {
+    const resolvedPath = configPath ?? defaultProxyConfigPath();
+    try {
+        const config = await parseProxyConfigString(readFileSync(resolvedPath, "utf8"));
+        return (config.routing?.modelMappings ?? []).filter((mapping) => mapping.from.trim().length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+async function loadRoutedModelIds(configPath) {
+    return (await loadRoutedMappings(configPath)).map((mapping) => mapping.from.trim());
+}
+async function catalogGrokSpecs(configPath) {
+    const seen = new Set();
+    const specs = [];
+    const routed = await loadRoutedMappings(configPath);
+    const routedByFrom = new Map(routed.map((mapping) => [mapping.from.trim(), mapping]));
+    for (const id of [
+        ...DEFAULT_PROXY_MODEL_IDS,
+        ...routed.map((mapping) => mapping.from.trim()),
+    ]) {
+        if (id.startsWith("grok-") || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        specs.push(classifyGrokProxyModel(id, routedByFrom.get(id)));
+    }
+    return specs;
+}
+async function catalogModelIds(configPath) {
+    return (await catalogGrokSpecs(configPath)).map((spec) => spec.id);
+}
+function buildGrokModelBlock(spec, baseUrl) {
+    const lines = [
+        `[model.${tomlKey(spec.id)}]`,
+        `model = ${JSON.stringify(spec.id)}`,
+        `name = ${JSON.stringify(spec.name)}`,
+        `base_url = ${JSON.stringify(baseUrl)}`,
+        `api_backend = ${JSON.stringify(spec.apiBackend)}`,
+        `context_window = ${spec.contextWindow}`,
+        `auto_compact_threshold_percent = 80`,
+        `max_completion_tokens = ${spec.maxCompletionTokens}`,
+        `supports_backend_search = false`,
+    ];
+    if (!spec.supportsReasoningEffort) {
+        lines.push("supports_reasoning_effort = false");
+    }
+    if (spec.apiBackend === "messages") {
+        lines.push(`extra_headers = { "x-api-key" = ${JSON.stringify(PLACEHOLDER_KEY)}, "anthropic-version" = ${JSON.stringify(ANTHROPIC_VERSION)} }`);
+    }
+    else {
+        lines.push(`api_key = ${JSON.stringify(PLACEHOLDER_KEY)}`);
+    }
+    return lines.join("\n");
+}
+async function buildGrokManagedBlock(baseUrl, configPath) {
+    const specs = await catalogGrokSpecs(configPath);
+    const body = specs
+        .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.",
+        "",
+        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 extractManagedBaseUrl(text) {
+    const match = text.match(new RegExp(`${escapeRegExp(GROK_BLOCK_BEGIN)}[\\s\\S]*?base_url\\s*=\\s*"([^"]*)"`));
+    return match?.[1];
+}
+async function readGrokSnapshot() {
+    const fs = await import("fs");
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(getGrokSnapshotPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!isUsableSnapshot(parsed, "originalExisted")) {
+        logger.debug("[proxy] Grok: ignoring a malformed snapshot rather than treating it as empty");
+        return null;
+    }
+    const record = parsed;
+    const originalExisted = record.originalExisted;
+    const writtenBaseUrl = record.writtenBaseUrl;
+    if (typeof originalExisted !== "boolean") {
+        return null;
+    }
+    if (typeof writtenBaseUrl !== "string") {
+        return null;
+    }
+    return { originalExisted, writtenBaseUrl };
+}
+export async function setGrokProxySettings(baseUrl, options) {
+    const fs = await import("fs");
+    try {
+        fs.accessSync(getGrokConfigDir());
+    }
+    catch {
+        return false;
+    }
+    let original;
+    try {
+        original = fs.readFileSync(getGrokConfigPath(), "utf8");
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            logger.warn("[proxy] Grok: unable to read config.toml; leaving it untouched");
+            return false;
+        }
+        original = null;
+    }
+    const existingSnapshot = await readGrokSnapshot();
+    if (existingSnapshot === null && fs.existsSync(getGrokSnapshotPath())) {
+        logger.warn("[proxy] Grok: snapshot file is unreadable; leaving config.toml untouched rather than overwriting with no way back");
+        return false;
+    }
+    const currentBlock = original
+        ? original.includes(GROK_BLOCK_BEGIN)
+            ? original.slice(original.indexOf(GROK_BLOCK_BEGIN), original.indexOf(GROK_BLOCK_END) === -1
+                ? original.length
+                : original.indexOf(GROK_BLOCK_END) + GROK_BLOCK_END.length)
+            : undefined
+        : undefined;
+    if (existingSnapshot === null ||
+        shouldCaptureSnapshot({
+            hasSnapshot: existingSnapshot !== null,
+            written: existingSnapshot?.writtenBaseUrl,
+            current: extractManagedBaseUrl(original ?? "") ?? currentBlock,
+        })) {
+        fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
+        await writeFileAtomic(getGrokSnapshotPath(), JSON.stringify({
+            originalExisted: existingSnapshot?.originalExisted ?? original !== null,
+            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);
+    return true;
+}
+export async function clearGrokProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    let current;
+    try {
+        current = fs.readFileSync(getGrokConfigPath(), "utf8");
+    }
+    catch {
+        return false;
+    }
+    if (!current.includes(GROK_BLOCK_BEGIN)) {
+        return false;
+    }
+    const configuredUrl = extractManagedBaseUrl(current);
+    if (expectedBaseUrl &&
+        configuredUrl !== undefined &&
+        configuredUrl !== expectedBaseUrl) {
+        logger.debug("[proxy] Grok clear: base URL is not the one we wrote, leaving it intact");
+        return false;
+    }
+    const snapshot = await readGrokSnapshot();
+    if (snapshot === null) {
+        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");
+    if (!snapshot.originalExisted && remainder.trim().length === 0) {
+        fs.rmSync(getGrokConfigPath(), { force: true });
+    }
+    else {
+        await writeFileAtomic(getGrokConfigPath(), remainder);
+    }
+    try {
+        fs.rmSync(getGrokSnapshotPath(), { force: true });
+    }
+    catch {
+        // next apply overwrites
+    }
+    return true;
+}
+export const grokConfigurator = {
+    id: "grok",
+    displayName: "Grok Build",
+    detect: async () => {
+        const fs = await import("fs");
+        try {
+            fs.accessSync(getGrokConfigDir());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    // Grok appends `/messages` or `/chat/completions` to `base_url`, so it
+    // takes the `/v1` door rather than the proxy root.
+    apply: (proxyBaseUrl, options) => setGrokProxySettings(`${proxyBaseUrl}/v1`, options),
+    restore: (proxyBaseUrl) => clearGrokProxySettings(`${proxyBaseUrl}/v1`),
+};
+/** Test-only export (CLAUDE.md rule 15 determinism exception). See openCode.ts. */
+export const __grokTestHooks = {
+    getGrokConfigDir,
+    getGrokConfigPath,
+    getGrokSnapshotPath,
+    setGrokProxySettings,
+    clearGrokProxySettings,
+    classifyGrokProxyModel,
+    loadRoutedModelIds,
+    catalogModelIds,
+    buildGrokManagedBlock,
+};
+//# sourceMappingURL=grok.js.map

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

@@ -1,4 +1,4 @@
-import type { CliProxyClientApplyResult, CliProxyClientConfigurator, CliProxyClientRestoreResult } from "../../types/index.js";
+import type { CliProxyClientApplyOptions, CliProxyClientApplyResult, CliProxyClientConfigurator, CliProxyClientRestoreResult } from "../../types/index.js";
 /**
  * Every CLI the proxy auto-configures, in apply order.
  *
@@ -14,6 +14,6 @@ export declare const PROXY_CLIENT_CONFIGURATORS: readonly CliProxyClientConfigur
  * how loudly to report — the daemon-start path logs failures at debug level
  * while the setup wizard prints a visible warning.
  */
-export declare function applyAllClients(proxyBaseUrl: string): Promise<CliProxyClientApplyResult[]>;
+export declare function applyAllClients(proxyBaseUrl: string, options?: CliProxyClientApplyOptions): Promise<CliProxyClientApplyResult[]>;
 /** Restore every client's previous configuration. See applyAllClients. */
 export declare function restoreAllClients(proxyBaseUrl: string): Promise<CliProxyClientRestoreResult[]>;

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

@@ -5,6 +5,7 @@ import { codexConfigurator } from "./codex.js";
 import { qwenCodeConfigurator } from "./qwenCode.js";
 import { copilotConfigurator } from "./copilot.js";
 import { geminiConfigurator } from "./gemini.js";
+import { grokConfigurator } from "./grok.js";
 /**
  * Every CLI the proxy auto-configures, in apply order.
  *
@@ -18,6 +19,7 @@ export const PROXY_CLIENT_CONFIGURATORS = [
     qwenCodeConfigurator,
     copilotConfigurator,
     geminiConfigurator,
+    grokConfigurator,
 ];
 /**
  * Point every detected client at the proxy.
@@ -27,12 +29,12 @@ export const PROXY_CLIENT_CONFIGURATORS = [
  * how loudly to report — the daemon-start path logs failures at debug level
  * while the setup wizard prints a visible warning.
  */
-export async function applyAllClients(proxyBaseUrl) {
+export async function applyAllClients(proxyBaseUrl, options) {
     const results = [];
     for (const client of PROXY_CLIENT_CONFIGURATORS) {
         try {
             const applied = (await client.detect())
-                ? await client.apply(proxyBaseUrl)
+                ? await client.apply(proxyBaseUrl, options)
                 : false;
             // Only ask for a note when something was actually written: a note on a
             // client that was skipped would read as an instruction to act on a

package/dist/constants/proxyModels.d.ts

@@ -1,7 +1,7 @@
 /**
  * Model IDs the proxy advertises when no routing config narrows the list.
  *
- * Two consumers need the same answer and must not drift apart:
+ * Three consumers need the same answer and must not drift apart:
  *
  *   - `proxyTranslationEngine` serves them from `GET /v1/models`.
  *   - The OpenCode client configurator writes them into `provider.neurolink.
@@ -9,6 +9,12 @@
  *     It does not call `/v1/models`, so an empty map means every model id is
  *     unknown and `opencode run` fails with `ProviderModelNotFoundError`
  *     before a request is ever made.
+ *   - The Grok Build configurator writes the same ids (plus any
+ *     `routing.model-mappings` in the active proxy config — default
+ *     `~/.neurolink/proxy-config.yaml`, or the path passed to `--config`)
+ *     into `~/.grok/config.toml` as `[model.<id>]` entries, with
+ *     `api_backend` and `context_window` so Grok's compaction matches the
+ *     upstream. Built-in grok-* ids are skipped.
  *
  * Format matches the IDs used throughout `src/lib/models/` and
  * `src/lib/constants/` (e.g. `claude-3-5-haiku-20241022`, not

package/dist/constants/proxyModels.js

@@ -1,7 +1,7 @@
 /**
  * Model IDs the proxy advertises when no routing config narrows the list.
  *
- * Two consumers need the same answer and must not drift apart:
+ * Three consumers need the same answer and must not drift apart:
  *
  *   - `proxyTranslationEngine` serves them from `GET /v1/models`.
  *   - The OpenCode client configurator writes them into `provider.neurolink.
@@ -9,6 +9,12 @@
  *     It does not call `/v1/models`, so an empty map means every model id is
  *     unknown and `opencode run` fails with `ProviderModelNotFoundError`
  *     before a request is ever made.
+ *   - The Grok Build configurator writes the same ids (plus any
+ *     `routing.model-mappings` in the active proxy config — default
+ *     `~/.neurolink/proxy-config.yaml`, or the path passed to `--config`)
+ *     into `~/.grok/config.toml` as `[model.<id>]` entries, with
+ *     `api_backend` and `context_window` so Grok's compaction matches the
+ *     upstream. Built-in grok-* ids are skipped.
  *
  * Format matches the IDs used throughout `src/lib/models/` and
  * `src/lib/constants/` (e.g. `claude-3-5-haiku-20241022`, not

package/dist/core/baseProvider.d.ts

@@ -41,6 +41,16 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns the current model's registered capability, or true when unknown
      */
     supportsTools(): boolean;
+    /**
+     * Whether this provider implements the opt-in `executionControl` contract.
+     *
+     * Default false, and that default is load-bearing: a provider that has not
+     * implemented the contract must REJECT it, not ignore it. Silently dropping
+     * a caller-set execution policy is invisible until a long turn dies at a
+     * ceiling its owner believed had been removed. Overridden only where the
+     * control is genuinely honoured end to end.
+     */
+    supportsExecutionControl(): boolean;
     /**
      * Apply the shared tool gate and optionally report registry-backed
      * suppression at the request entry point.

package/dist/core/baseProvider.js

@@ -46,6 +46,7 @@ import { TelemetryHandler } from "./modules/TelemetryHandler.js";
 import { ToolsManager } from "./modules/ToolsManager.js";
 import { Utilities } from "./modules/Utilities.js";
 import { generateOnceNative } from "../utils/nativeSingleShot.js";
+import { validateExecutionControl } from "../utils/parameterValidation.js";
 import { extractTokenUsage } from "../utils/tokenUtils.js";
 /**
  * Read the consumer-facing lifecycle callbacks buried inside a request's
@@ -182,6 +183,18 @@ export class BaseProvider {
     supportsTools() {
         return modelSupports("functionCalling", this.providerName, this.modelName);
     }
+    /**
+     * Whether this provider implements the opt-in `executionControl` contract.
+     *
+     * Default false, and that default is load-bearing: a provider that has not
+     * implemented the contract must REJECT it, not ignore it. Silently dropping
+     * a caller-set execution policy is invisible until a long turn dies at a
+     * ceiling its owner believed had been removed. Overridden only where the
+     * control is genuinely honoured end to end.
+     */
+    supportsExecutionControl() {
+        return false;
+    }
     /**
      * Apply the shared tool gate and optionally report registry-backed
      * suppression at the request entry point.
@@ -211,6 +224,14 @@ export class BaseProvider {
         // maxTokens (getSafeMaxTokens consults the discovered output ceiling).
         await this.ensureModelLimits();
         let options = this.normalizeStreamOptions(optionsOrPrompt);
+        // Before anything else, and before a single byte leaves the process: an
+        // execution policy this provider cannot honour is an error, and a policy
+        // whose shape could be read two ways is an error. Both are silent bugs at
+        // the point they would otherwise matter.
+        validateExecutionControl(options.executionControl, this.providerName, this.supportsExecutionControl(), {
+            turnTimeoutMs: options.turnTimeoutMs,
+            toolTimeoutMs: options.toolTimeoutMs,
+        });
         logger.info(`Starting stream`, {
             provider: this.providerName,
             hasTools: !options.disableTools && this.supportsTools(),

package/dist/core/constants.d.ts

@@ -27,9 +27,22 @@ export declare const DEFAULT_GEMINI_STREAM_TIMEOUT_MS = 300000;
  * Default per-tool-execution timeout for native agentic loops. A tool that
  * exceeds it fails with an error tool_result and costs one step — the turn
  * continues instead of hanging on a wedged tool. Override per call with
- * `toolTimeoutMs`.
+ * `toolTimeoutMs`, or remove the bound entirely with `toolTimeoutMs: null`.
  */
 export declare const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 300000;
+/**
+ * Resolve a caller's `toolTimeoutMs` into the bound a loop should actually
+ * apply: a number of milliseconds, or `null` for no bound at all.
+ *
+ * The three-way distinction is the whole point, and `??` cannot express it:
+ * `undefined` means "no opinion, take the default", while `null` is a stated
+ * choice to run tools unbounded — the pre-existing behaviour of the loops that
+ * never had a per-tool timer, and the only way to say it, since a finite
+ * number is always a ceiling and `Infinity` silently desugars to `setTimeout`'s
+ * ~24.9-day cap. Every loop resolves it through here so `null` cannot come to
+ * mean "the default" on one provider and "unbounded" on another.
+ */
+export declare function resolveToolTimeoutMs(toolTimeoutMs: number | null | undefined): number | null;
 /**
  * Default wrap-up lead applied when `turnTimeoutMs` is set but
  * `wrapupTimeLeadMs` is not: with less than this much turn time remaining,

package/dist/core/constants.js

@@ -122,9 +122,26 @@ export const DEFAULT_GEMINI_STREAM_TIMEOUT_MS = 300_000;
  * Default per-tool-execution timeout for native agentic loops. A tool that
  * exceeds it fails with an error tool_result and costs one step — the turn
  * continues instead of hanging on a wedged tool. Override per call with
- * `toolTimeoutMs`.
+ * `toolTimeoutMs`, or remove the bound entirely with `toolTimeoutMs: null`.
  */
 export const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 300_000;
+/**
+ * Resolve a caller's `toolTimeoutMs` into the bound a loop should actually
+ * apply: a number of milliseconds, or `null` for no bound at all.
+ *
+ * The three-way distinction is the whole point, and `??` cannot express it:
+ * `undefined` means "no opinion, take the default", while `null` is a stated
+ * choice to run tools unbounded — the pre-existing behaviour of the loops that
+ * never had a per-tool timer, and the only way to say it, since a finite
+ * number is always a ceiling and `Infinity` silently desugars to `setTimeout`'s
+ * ~24.9-day cap. Every loop resolves it through here so `null` cannot come to
+ * mean "the default" on one provider and "unbounded" on another.
+ */
+export function resolveToolTimeoutMs(toolTimeoutMs) {
+    return toolTimeoutMs === null
+        ? null
+        : (toolTimeoutMs ?? DEFAULT_TOOL_EXECUTION_TIMEOUT_MS);
+}
 /**
  * Default wrap-up lead applied when `turnTimeoutMs` is set but
  * `wrapupTimeLeadMs` is not: with less than this much turn time remaining,