@ycodium-ai/agent-grok 0.2.3252 → 0.2.3265

package/dist/index.js

@@ -159,6 +159,9 @@ var GROK_CARD = {
 
 // src/grokInstance.ts
 import * as NodeCrypto3 from "node:crypto";
+import {
+  raceAbort as raceAbort2
+} from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle as nodeStreamsFromHandle2 } from "@ycodium-ai/plugin-api/process-stdin";
 
 // ../../packages/ycodium-acp-executor/src/executor.ts
@@ -25191,11 +25194,15 @@ function createAcpConnection(options) {
     });
   };
   const close = (error62) => shutdown(error62 ?? new AcpConnectionClosedError());
+  const abandonPending = (error62) => {
+    rejectPending(error62);
+  };
   return {
     request,
     begin,
     notify,
     awaitInboundIdle,
+    abandonPending,
     close,
     closed
   };
@@ -25661,10 +25668,11 @@ function createExecutorPrompt({
   const prompt = async (input2) => {
     failIfPromptUnavailable();
     const started = requireStarted();
+    let sessionId = started.sessionId;
     let record3;
     const settle2 = (rest) => settleTurn({
       expectedGeneration: started.generation,
-      expectedSessionId: started.sessionId,
+      expectedSessionId: sessionId,
       record: record3,
       ...rest
     });
@@ -25748,12 +25756,32 @@ function createExecutorPrompt({
       const queuedTurnId = turnId;
       const isStale = () => interruptedTurnIds.has(queuedTurnId) || input2.expectedActiveTurnId !== void 0 && shared.activeTurnId !== queuedTurnId;
       if (!isStale()) {
-        shared.modelSelectionState = await applyRequestedModel({
-          state: shared.modelSelectionState,
-          acpSessionId: started.sessionId,
-          requestedModelId: input2.requestedModelId,
-          expectedGeneration: started.generation
-        });
+        try {
+          const applied = await applyRequestedModel({
+            state: shared.modelSelectionState,
+            acpSessionId: sessionId,
+            setup: shared.startResult?.sessionSetupResult ?? {},
+            requestedModelId: input2.requestedModelId,
+            expectedGeneration: started.generation
+          });
+          shared.modelSelectionState = applied.state;
+          sessionId = applied.sessionId;
+          record3.sessionId = applied.sessionId;
+        } catch (error62) {
+          const failureCategory = readAcpFailureCategory(error62);
+          if (failureCategory === "model-unavailable") {
+            const errorMessage = error62 instanceof Error && error62.message.trim().length > 0 ? error62.message : "Requested model is not in this agent's catalog. This turn was not sent.";
+            settle2({
+              turnId,
+              stopReason: "error",
+              state: "failed",
+              errorMessage,
+              failureCategory
+            });
+            throw error62 instanceof Error ? withFailureCategory(error62, failureCategory) : error62;
+          }
+          throw error62;
+        }
       }
       failIfDisposed();
       if (isStale()) {
@@ -25764,7 +25792,7 @@ function createExecutorPrompt({
       let written = false;
       try {
         response = await sendPromptRpc(
-          started.sessionId,
+          sessionId,
           promptParts,
           () => {
             written = true;
@@ -25814,7 +25842,7 @@ function createExecutorPrompt({
     if (hooks.readContextWindow !== void 0) {
       try {
         contextWindow = await hooks.readContextWindow({
-          sessionId: started.sessionId,
+          sessionId,
           promptResponse: response
         }) ?? void 0;
       } catch {
@@ -26457,6 +26485,56 @@ function acpInitializePayload(clientInfo, overrides) {
   };
 }
 
+// ../../packages/ycodium-acp-executor/src/refreshDeadline.ts
+var MODEL_CATALOG_REFRESH_TIMEOUT_MS = 9e4;
+
+// ../../packages/ycodium-acp-executor/src/model-send.ts
+function judgeRequestedModel(input2) {
+  const requested = normalizeModelId(input2.requestedModelId);
+  const current = input2.state.currentModelId;
+  if (requested === void 0 || requested === current) return { kind: "keep" };
+  const hasCatalog = input2.state.advertisedModelValues.length > 0;
+  const hasCurrent = current !== void 0;
+  if (!hasCatalog && !hasCurrent) return { kind: "keep" };
+  const canSwitch = input2.state.strategy === "session/set_model" && input2.state.sessionModelsAdvertised || input2.state.strategy === "config-option" && input2.state.modelConfigId !== void 0;
+  const value = hasCatalog ? matchAdvertisedModelValue(requested, input2.state.advertisedModelValues) : void 0;
+  if (value !== void 0 && value === current) return { kind: "keep" };
+  if (value !== void 0 && canSwitch) return { kind: "switch", value };
+  return input2.refreshed ? { kind: "unavailable" } : { kind: "refresh" };
+}
+function modelUnavailableError(requestedModelId, currentModelId) {
+  const current = currentModelId ?? "its own model";
+  return withFailureCategory(
+    new Error(
+      `Requested model "${requestedModelId}" is not in this agent's catalog; it is on "${current}". This turn was not sent. Refresh the model list in this agent's settings and try again.`
+    ),
+    "model-unavailable"
+  );
+}
+var ModelCatalogRefreshTimeoutError = class extends Error {
+  constructor() {
+    super("model catalog refresh timed out");
+    this.name = "ModelCatalogRefreshTimeoutError";
+  }
+};
+function modelRefreshTimedOutError(requestedModelId) {
+  return withFailureCategory(
+    new Error(
+      `Refreshing this agent's model list timed out, so this turn was not sent. Requested model "${requestedModelId}".`
+    ),
+    "model-unavailable"
+  );
+}
+function modelRefreshFailedError(requestedModelId, error62) {
+  const detail = error62 instanceof Error && error62.message.trim().length > 0 ? error62.message : "the model list could not be read";
+  return withFailureCategory(
+    new Error(
+      `Refreshing this agent's model list failed (${detail}), so this turn was not sent. Requested model "${requestedModelId}".`
+    ),
+    "model-unavailable"
+  );
+}
+
 // ../../packages/ycodium-acp-executor/src/runtime-mode.ts
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -26487,43 +26565,131 @@ function createExecutorSession({
   failIfDisposed,
   shared
 }) {
-  const applyRequestedModel = async (input2) => {
-    const requestedModelId = normalizeModelId(input2.requestedModelId);
-    if (requestedModelId === void 0 || requestedModelId === input2.state.currentModelId || input2.state.strategy === "session/set_model" && !input2.state.sessionModelsAdvertised || input2.state.strategy === "config-option" && input2.state.modelConfigId === void 0) {
-      return input2.state;
-    }
-    const value = matchAdvertisedModelValue(requestedModelId, input2.state.advertisedModelValues);
-    if (value === void 0) {
-      if (requestedModelId !== shared.lastUnmatchedModelId) {
-        shared.lastUnmatchedModelId = requestedModelId;
-        options.log?.info("requested model is not in the agent catalog; keeping its own model", {
-          requestedModelId,
-          currentModelId: input2.state.currentModelId,
-          advertisedModelValues: input2.state.advertisedModelValues
-        });
-      }
-      return input2.state;
+  const openFreshSession = async (expectedGeneration) => {
+    const initialized = shared.initializeResult;
+    if (initialized === void 0) {
+      throw new Error("no handshake");
     }
-    if (value === input2.state.currentModelId) {
-      return input2.state;
+    const mcpServers = filterMcpServersByAgentCapabilities(
+      options.mcpServers ?? [],
+      initialized.agentCapabilities
+    );
+    const additionalDirectories = options.additionalDirectories !== void 0 && options.additionalDirectories.length > 0 ? { additionalDirectories: options.additionalDirectories } : {};
+    const created = await connection.request("session/new", {
+      cwd: options.cwd,
+      mcpServers,
+      ...additionalDirectories
+    });
+    if (!isLive(expectedGeneration)) {
+      throw new AcpExecutorDisposedError();
     }
+    if (created.sessionId === void 0 || created.sessionId.length === 0) {
+      throw new Error("session/new did not return a session id");
+    }
+    return { sessionId: created.sessionId, setup: created };
+  };
+  const switchModel = async (input2) => {
     let configOptions = input2.state.configOptions;
     if (input2.state.strategy === "config-option") {
       const switched = await connection.request(
         "session/set_config_option",
-        { sessionId: input2.acpSessionId, configId: input2.state.modelConfigId, value }
+        { sessionId: input2.sessionId, configId: input2.state.modelConfigId, value: input2.value }
       );
       configOptions = switched?.configOptions ?? configOptions;
     } else {
       await connection.request("session/set_model", {
-        sessionId: input2.acpSessionId,
-        modelId: value
+        sessionId: input2.sessionId,
+        modelId: input2.value
       });
     }
     if (!isLive(input2.expectedGeneration)) {
       throw new AcpExecutorDisposedError();
     }
-    return { ...input2.state, currentModelId: value, configOptions };
+    return { ...input2.state, currentModelId: input2.value, configOptions };
+  };
+  const adoptReopenedSession = (applied) => {
+    if (shared.sessionId === void 0 && shared.startResult === void 0) return;
+    const setup = applied.setup;
+    shared.sessionId = applied.sessionId;
+    shared.modelSelectionState = applied.state;
+    shared.modeState = parseSessionModeState(setup);
+    if (shared.startResult !== void 0) {
+      shared.startResult = {
+        ...shared.startResult,
+        sessionId: applied.sessionId,
+        sessionSetupResult: setup,
+        modelConfigId: extractModelConfigId(setup),
+        modelId: applied.state.currentModelId
+      };
+    }
+  };
+  const applyRequestedModel = async (input2) => {
+    async function applyOnce(state, sessionId, setup, refreshed) {
+      const requestedModelId = normalizeModelId(input2.requestedModelId) ?? "";
+      const judgment = judgeRequestedModel({
+        state,
+        requestedModelId: input2.requestedModelId,
+        refreshed
+      });
+      if (judgment.kind === "keep") return { state, sessionId, setup };
+      if (judgment.kind === "unavailable") {
+        throw modelUnavailableError(requestedModelId, state.currentModelId);
+      }
+      if (judgment.kind === "switch") {
+        return {
+          state: await switchModel({
+            state,
+            sessionId,
+            value: judgment.value,
+            expectedGeneration: input2.expectedGeneration
+          }),
+          sessionId,
+          setup
+        };
+      }
+      return refreshAndRejudge(requestedModelId);
+    }
+    async function refreshAndRejudge(requestedModelId) {
+      const timeoutMs = options.modelCatalogRefreshTimeoutMs ?? MODEL_CATALOG_REFRESH_TIMEOUT_MS;
+      let timedOut = false;
+      const timeoutError = new ModelCatalogRefreshTimeoutError();
+      let timer;
+      const work = (async () => {
+        await options.refreshCatalogForSend?.();
+        if (timedOut) throw timeoutError;
+        const reopened = await openFreshSession(input2.expectedGeneration);
+        if (timedOut) throw timeoutError;
+        const next = modelSelectionStateFromSetup(reopened.setup);
+        const applied = await applyOnce(next, reopened.sessionId, reopened.setup, true);
+        if (timedOut) throw timeoutError;
+        adoptReopenedSession(applied);
+        return applied;
+      })();
+      void work.then(
+        () => void 0,
+        () => void 0
+      );
+      const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          timedOut = true;
+          connection.abandonPending(timeoutError);
+          reject(timeoutError);
+        }, timeoutMs);
+      });
+      try {
+        return await Promise.race([work, deadline]);
+      } catch (error62) {
+        if (error62 instanceof AcpExecutorDisposedError) throw error62;
+        if (timedOut || error62 instanceof ModelCatalogRefreshTimeoutError) {
+          throw modelRefreshTimedOutError(requestedModelId);
+        }
+        if (readAcpFailureCategory(error62) === "model-unavailable") throw error62;
+        throw modelRefreshFailedError(requestedModelId, error62);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    }
+    return applyOnce(input2.state, input2.acpSessionId, input2.setup, false);
   };
   const startOnce = async (expectedGeneration) => {
     const initializePayload = acpInitializePayload(options.clientInfo, options.clientCapabilities);
@@ -26592,12 +26758,17 @@ function createExecutorSession({
         categories: unhandledCategories
       });
     }
-    const nextModelSelectionState = await applyRequestedModel({
-      state: modelSelectionStateFromSetup(setup),
+    const openedSetup = setup;
+    const appliedModel = await applyRequestedModel({
+      state: modelSelectionStateFromSetup(openedSetup),
       acpSessionId: nextSessionId,
+      setup: openedSetup,
       requestedModelId: options.requestedModelId,
       expectedGeneration
     });
+    nextSessionId = appliedModel.sessionId;
+    setup = appliedModel.setup;
+    const nextModelSelectionState = appliedModel.state;
     await applyRequestedEffort({
       connection,
       log: options.log,
@@ -27132,7 +27303,6 @@ function createAcpExecutor(options) {
       currentModelId: void 0,
       advertisedModelValues: []
     },
-    lastUnmatchedModelId: void 0,
     initializeResult: void 0,
     startResult: void 0,
     startInFlight: void 0,
@@ -28696,7 +28866,8 @@ var runGrokInspect = async (input2) => {
     args: GROK_INSPECT_ARGS,
     cwd,
     owner: { bindingId: host.bindingId },
-    ...Object.keys(env).length > 0 ? { env } : {}
+    ...Object.keys(env).length > 0 ? { env } : {},
+    ...input2.signal === void 0 ? {} : { signal: input2.signal }
   });
   const run = await collectProbeProcess(handle, {
     timeoutMs: INSPECT_TIMEOUT_MS,
@@ -28782,10 +28953,21 @@ function grokOpenCommands(session) {
   };
 }
 
+// src/modelCacheRefresh.ts
+import * as NodeFS4 from "node:fs";
+import * as NodePath6 from "node:path";
+import {
+  ExecutorSpawnAbortedError as ExecutorSpawnAbortedError2,
+  ExecutorSpawnRefusedError as ExecutorSpawnRefusedError2,
+  throwIfExecutorSpawnAborted
+} from "@ycodium-ai/plugin-api/executor";
+
 // src/probeModels.ts
 import {
   describeExecutorSpawnFailure,
-  ExecutorSpawnRefusedError
+  ExecutorSpawnAbortedError,
+  ExecutorSpawnRefusedError,
+  raceAbort
 } from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
 var PROBE_REQUEST_TIMEOUT_MS = 2e4;
@@ -28809,21 +28991,27 @@ async function probeGrokModels(input2) {
       args: tokenizeLaunchArgs(recipe.launchArgs),
       cwd: process.cwd(),
       owner: { bindingId: host.bindingId },
-      ...Object.keys(env).length > 0 ? { env } : {}
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...input2.signal === void 0 ? {} : { signal: input2.signal }
     });
   } catch (error62) {
-    if (error62 instanceof ExecutorSpawnRefusedError) throw error62;
+    if (error62 instanceof ExecutorSpawnRefusedError || error62 instanceof ExecutorSpawnAbortedError) {
+      throw error62;
+    }
     return { kind: "not-started", ...describeExecutorSpawnFailure(error62) };
   }
   let handshake;
   try {
     const { readable, writable } = nodeStreamsFromHandle(handle);
-    handshake = await openAcpProbeHandshake({
-      readable,
-      writable,
-      clientInfo: GROK_CLIENT_INFO,
-      requestTimeoutMs: PROBE_REQUEST_TIMEOUT_MS
-    });
+    handshake = await raceAbort(
+      openAcpProbeHandshake({
+        readable,
+        writable,
+        clientInfo: GROK_CLIENT_INFO,
+        requestTimeoutMs: PROBE_REQUEST_TIMEOUT_MS
+      }),
+      input2.signal
+    );
     return { kind: "answered", models: grokProbeModels(handshake.initializeResult) };
   } catch (error62) {
     return { kind: "failed", detail: failureDetail(error62) };
@@ -28833,34 +29021,195 @@ async function probeGrokModels(input2) {
   }
 }
 async function probeGrokVersion(input2) {
-  const { recipe, host, env } = input2;
+  const { recipe, host, env, signal } = input2;
   return probeCliVersion({
     spawn: () => host.process.spawn({
       program: recipe.binaryPath,
       args: ["--version"],
       owner: { bindingId: host.bindingId },
-      ...Object.keys(env).length > 0 ? { env } : {}
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...signal === void 0 ? {} : { signal }
     }),
     timeoutMs: PROBE_REQUEST_TIMEOUT_MS
   });
 }
 
+// src/modelCacheRefresh.ts
+var GROK_MODEL_CACHE_FILE = "models_cache.json";
+var GROK_MODEL_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var GROK_MODELS_COMMAND_TIMEOUT_MS = 6e4;
+function grokModelCachePath(accountHome) {
+  return NodePath6.join(accountHome, GROK_MODEL_CACHE_FILE);
+}
+function readGrokModelCacheMtimeMs(accountHome) {
+  try {
+    return NodeFS4.statSync(grokModelCachePath(accountHome)).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function grokModelCacheNeedsRefresh(input2) {
+  if (input2.force) return true;
+  if (input2.cacheMtimeMs === null) return true;
+  if (input2.nowMs - input2.cacheMtimeMs > GROK_MODEL_CACHE_MAX_AGE_MS) return true;
+  return input2.lastSeenCliVersion !== null && input2.cliVersion !== null && input2.cliVersion !== input2.lastSeenCliVersion;
+}
+async function drain(stream) {
+  for await (const chunk of stream) {
+    void chunk;
+  }
+}
+async function runGrokModelsCommand(input2) {
+  const { recipe, host, env } = input2;
+  throwIfExecutorSpawnAborted(input2.signal);
+  let handle;
+  try {
+    handle = await host.process.spawn({
+      program: recipe.binaryPath,
+      args: ["models"],
+      cwd: process.cwd(),
+      owner: { bindingId: host.bindingId },
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...input2.signal === void 0 ? {} : { signal: input2.signal }
+    });
+  } catch (error62) {
+    if (error62 instanceof ExecutorSpawnAbortedError2) throw error62;
+    host.log.warn("grok models could not be started; keeping the previous model list", {
+      detail: error62 instanceof ExecutorSpawnRefusedError2 ? "process limit" : String(error62)
+    });
+    return false;
+  }
+  const finished = Promise.all([drain(handle.stdout), drain(handle.stderr), handle.exited]).then(
+    ([, , code]) => code
+  );
+  let timer;
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2("timeout"), GROK_MODELS_COMMAND_TIMEOUT_MS);
+    timer.unref?.();
+  });
+  try {
+    const outcome = await Promise.race([finished, timeout]);
+    if (outcome === "timeout") {
+      finished.catch(() => void 0);
+      host.log.warn("grok models timed out; keeping the previous model list", {
+        timeoutMs: GROK_MODELS_COMMAND_TIMEOUT_MS
+      });
+      return false;
+    }
+    if (outcome !== 0) {
+      host.log.warn("grok models exited non-zero; keeping the previous model list", {
+        exitCode: outcome
+      });
+      return false;
+    }
+    return true;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    await handle.kill("SIGTERM").catch(() => void 0);
+  }
+}
+var modelsCommandSlots = /* @__PURE__ */ new Map();
+function runCoalescedModelsCommand(cachePath, force, run) {
+  const existing = modelsCommandSlots.get(cachePath);
+  if (existing !== void 0) {
+    if (force && existing.followUp === void 0) {
+      const followUp = existing.current.then(
+        () => run(),
+        () => run()
+      );
+      existing.followUp = followUp;
+      void followUp.finally(() => {
+        if (modelsCommandSlots.get(cachePath)?.followUp === followUp) {
+          modelsCommandSlots.delete(cachePath);
+        }
+      });
+      return followUp;
+    }
+    return existing.followUp ?? existing.current;
+  }
+  const current = run();
+  const slot = { current };
+  modelsCommandSlots.set(cachePath, slot);
+  void current.finally(() => {
+    if (slot.followUp !== void 0) return;
+    if (modelsCommandSlots.get(cachePath) === slot) modelsCommandSlots.delete(cachePath);
+  });
+  return current;
+}
+function createGrokModelCatalog(input2) {
+  let lastSeenCliVersion = null;
+  let skipUnforced = false;
+  const nowMs = input2.nowMs ?? (() => Date.now());
+  const readCliVersion = (signal) => {
+    if (input2.recipe.binaryPath.length === 0) return Promise.resolve(null);
+    return probeGrokVersion({
+      recipe: input2.recipe,
+      host: input2.host,
+      env: input2.spawnEnv(),
+      ...signal === void 0 ? {} : { signal }
+    });
+  };
+  const refreshModelCatalog = async (request) => {
+    try {
+      const cliVersion = request.cliVersion !== void 0 ? request.cliVersion : await readCliVersion();
+      if (!request.force && skipUnforced) {
+        skipUnforced = false;
+        if (cliVersion !== null) lastSeenCliVersion = cliVersion;
+        return;
+      }
+      const needs = grokModelCacheNeedsRefresh({
+        cacheMtimeMs: readGrokModelCacheMtimeMs(input2.accountHome()),
+        nowMs: nowMs(),
+        lastSeenCliVersion,
+        cliVersion,
+        force: request.force
+      });
+      let commandOk = true;
+      if (needs) {
+        commandOk = await runCoalescedModelsCommand(
+          grokModelCachePath(input2.accountHome()),
+          request.force,
+          () => runGrokModelsCommand({
+            recipe: input2.recipe,
+            host: input2.host,
+            env: input2.spawnEnv(),
+            ...request.signal === void 0 ? {} : { signal: request.signal }
+          })
+        );
+      }
+      if (cliVersion !== null) lastSeenCliVersion = cliVersion;
+      if (request.force && request.armProbeSkip === true) skipUnforced = true;
+      if (!commandOk && request.surfaceErrors === true) {
+        throw new Error("grok models failed");
+      }
+    } catch (error62) {
+      if (error62 instanceof ExecutorSpawnAbortedError2) throw error62;
+      if (request.surfaceErrors === true) throw error62;
+      input2.host.log.warn("grok model cache refresh failed; keeping the previous model list", {
+        detail: error62 instanceof Error ? error62.message : String(error62)
+      });
+    }
+  };
+  const refreshForSend = () => refreshModelCatalog({ force: true, surfaceErrors: true });
+  return { readCliVersion, refreshModelCatalog, refreshForSend };
+}
+
 // src/grokHome.ts
 import * as NodeCrypto2 from "node:crypto";
 import * as NodeOS3 from "node:os";
-import * as NodePath6 from "node:path";
+import * as NodePath7 from "node:path";
 import { mergeLaunchEnv } from "@ycodium-ai/plugin-api/executor";
 function expandHomePath(value) {
   if (value === "~") return NodeOS3.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return NodePath6.join(NodeOS3.homedir(), value.slice(2));
+    return NodePath7.join(NodeOS3.homedir(), value.slice(2));
   }
   return value;
 }
 function resolveGrokHomePath(value) {
   const trimmed3 = value.trim();
-  if (trimmed3.length === 0) return NodePath6.join(NodeOS3.homedir(), ".grok");
-  return NodePath6.resolve(expandHomePath(trimmed3));
+  if (trimmed3.length === 0) return NodePath7.join(NodeOS3.homedir(), ".grok");
+  return NodePath7.resolve(expandHomePath(trimmed3));
 }
 function probeGrokAccount(accountPath) {
   const resolved = resolveGrokHomePath(accountPath);
@@ -28879,12 +29228,12 @@ function grokContinuationKey(recipe) {
 function resolveAccountHomePath(recipe, configuredHome) {
   const fromEnvironment = recipe.environment["GROK_HOME"]?.trim();
   if (fromEnvironment !== void 0 && fromEnvironment.length > 0) {
-    return NodePath6.resolve(expandHomePath(fromEnvironment));
+    return NodePath7.resolve(expandHomePath(fromEnvironment));
   }
   return resolveGrokHomePath(configuredHome);
 }
 function absentPath() {
-  return NodePath6.join(
+  return NodePath7.join(
     NodeOS3.tmpdir(),
     `ycodium-grok-no-auth-${NodeCrypto2.randomUUID()}`,
     "auth.json"
@@ -29012,7 +29361,22 @@ var createGrokInstance = (config2, host) => {
         return { status: "unknown" };
     }
   };
-  const probe = async () => {
+  const spawnEnv = () => {
+    const configuredHome = recipe.homePath;
+    return buildSpawnEnv(
+      recipe,
+      resolveGrokHomePath(configuredHome),
+      configuredHome.trim().length > 0
+    );
+  };
+  const modelCatalog = createGrokModelCatalog({
+    recipe,
+    host,
+    spawnEnv,
+    accountHome: () => resolveAccountHomePath(recipe, recipe.homePath)
+  });
+  const probe = async (signal) => {
+    if (signal?.aborted) throw new Error("aborted");
     if (recipe.binaryPath.length === 0) {
       return {
         installed: false,
@@ -29022,17 +29386,35 @@ var createGrokInstance = (config2, host) => {
         detail: "Grok program path is not configured"
       };
     }
-    const configuredHome = recipe.homePath;
-    const env = buildSpawnEnv(
-      recipe,
-      resolveGrokHomePath(configuredHome),
-      configuredHome.trim().length > 0
+    const env = spawnEnv();
+    const version2 = await raceAbort2(modelCatalog.readCliVersion(signal), signal);
+    if (signal?.aborted) throw new Error("aborted");
+    await raceAbort2(
+      modelCatalog.refreshModelCatalog({
+        force: false,
+        cliVersion: version2,
+        ...signal === void 0 ? {} : { signal }
+      }),
+      signal
+    );
+    if (signal?.aborted) throw new Error("aborted");
+    const [outcome, skills] = await raceAbort2(
+      Promise.all([
+        probeGrokModels({
+          recipe,
+          host,
+          env,
+          ...signal === void 0 ? {} : { signal }
+        }),
+        probeGrokSkills({
+          recipe,
+          host,
+          env,
+          ...signal === void 0 ? {} : { signal }
+        })
+      ]),
+      signal
     );
-    const [outcome, version2, skills] = await Promise.all([
-      probeGrokModels({ recipe, host, env }),
-      probeGrokVersion({ recipe, host, env }),
-      probeGrokSkills({ recipe, host, env })
-    ]);
     if (outcome.kind !== "answered") {
       return {
         installed: outcome.kind === "failed",
@@ -29057,21 +29439,18 @@ var createGrokInstance = (config2, host) => {
   };
   const instance = {
     probe,
+    readCliVersion: () => modelCatalog.readCliVersion(),
+    refreshModelCatalog: ({ force }) => modelCatalog.refreshModelCatalog({ force, armProbeSkip: force }),
     // 项目里的技能：探测在 home 下跑 inspect 只看得到整机的；这里在项目目录里再跑一次。
     workspaceInventory: ({ cwd }) => {
       if (recipe.binaryPath.length === 0) {
         return Promise.reject(new Error("Grok program path is not configured"));
       }
-      const configuredHome = recipe.homePath;
       return inspectGrokWorkspace({
         recipe,
         host,
         cwd,
-        env: buildSpawnEnv(
-          recipe,
-          resolveGrokHomePath(configuredHome),
-          configuredHome.trim().length > 0
-        )
+        env: spawnEnv()
       });
     },
     // 有意不处理 input.readOnlyDirectories：grok 的 read_file 在每一档都不弹审批、
@@ -29090,12 +29469,7 @@ var createGrokInstance = (config2, host) => {
         if (disposed) throw new Error("instance disposed");
         throwIfStartAborted(signal);
       }
-      const configuredHome = recipe.homePath;
-      const env = buildSpawnEnv(
-        recipe,
-        resolveGrokHomePath(configuredHome),
-        configuredHome.trim().length > 0
-      );
+      const env = spawnEnv();
       const effort = modelSelectionStringOption(input2.modelSelection, GROK_REASONING_OPTION_ID);
       const baseArgs = tokenizeLaunchArgs(recipe.launchArgs);
       const insertAt = baseArgs.length <= 1 ? baseArgs.length : baseArgs.length - 1;
@@ -29185,6 +29559,7 @@ var createGrokInstance = (config2, host) => {
           }
         },
         ...requestedModelId === void 0 ? {} : { requestedModelId },
+        refreshCatalogForSend: () => modelCatalog.refreshForSend(),
         ...input2.bindingGeneration === void 0 ? {} : { originBindingGeneration: input2.bindingGeneration },
         // 内置编排那一条排第一，后面跟用户在插件中心配的；缺了这一栏，
         // `mcp__ycodium__*` 整套工具（浏览器等）在这只手的会话里都不存在。
@@ -29401,7 +29776,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-grok",
-  apiVersion: 29,
+  apiVersion: 31,
   executors,
   activate(ctx) {
     ctx.log.info("grok executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-grok",
-  "version": "0.2.3252",
+  "version": "0.2.3265",
   "description": "Grok executor: grok CLI over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "ycodium-acp-executor": "0.2.3252",
-    "@ycodium-ai/plugin-api": "0.2.3252",
+    "@ycodium-ai/plugin-api": "0.2.3265",
+    "ycodium-acp-executor": "0.2.3265",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {