lody 0.77.2 → 0.78.0

package/dist/chunks/{directory-handle-BBQKxZ5F.js → directory-handle-OPjjCl3O.js}

@@ -487,8 +487,10 @@ const normalizeCodeCollabFileIndexSignalValue = (value) => {
   return value.v === 1 && isNonNegativeInteger(value.r) ? { v: 1, r: value.r } : void 0;
 };
 const isCodeCollabFileIndexSignalKey = (key) => key.length === 1 && key[0] === CODE_COLLAB_FILE_INDEX_SIGNAL_KEY[0];
-function readCodeCollabFileIndexFromFlock(flock) {
+const isCorruptedCodeCollabWorkspacePath = (workspacePath) => workspacePath.includes("\uFFFD");
+function scanCodeCollabFileIndexFlock(flock) {
   const fileIndex = {};
+  const corruptedPaths = [];
   for (const row of flock.scan()) {
     if (row.value === void 0) {
       continue;
@@ -497,13 +499,17 @@ function readCodeCollabFileIndexFromFlock(flock) {
     if (typeof workspacePath !== "string" || workspacePath.length === 0 || extra.length > 0) {
       continue;
     }
+    if (isCorruptedCodeCollabWorkspacePath(workspacePath)) {
+      corruptedPaths.push(workspacePath);
+      continue;
+    }
     const parsed = normalizeCodeCollabFileIndexValue(row.value);
     if (!parsed) {
       continue;
     }
     fileIndex[workspacePath] = parsed;
   }
-  return fileIndex;
+  return { fileIndex, corruptedPaths };
 }
 function readCodeCollabFileIndexSignalFromFlock(flock) {
   for (const row of flock.scan()) {
@@ -531,8 +537,12 @@ function writeCodeCollabFileIndexSignalToFlock(flock, revision, nowMs) {
   return true;
 }
 function writeCodeCollabFileIndexToFlock(flock, next, nowMs) {
-  const previous = readCodeCollabFileIndexFromFlock(flock);
+  const { fileIndex: previous, corruptedPaths } = scanCodeCollabFileIndexFlock(flock);
   let changed = false;
+  for (const workspacePath of corruptedPaths) {
+    flock.delete(codeCollabFileIndexKeyForWorkspacePath(workspacePath), nowMs);
+    changed = true;
+  }
   for (const workspacePath of Object.keys(previous)) {
     if (Object.prototype.hasOwnProperty.call(next, workspacePath)) {
       continue;

package/dist/chunks/{review-viewer-C1f8pVKg.js → review-viewer-Bgp2Thsg.js}

@@ -49,11 +49,12 @@ import "node:worker_threads";
 import "node:url";
 import "node:console";
 import "node:dns";
-import "./directory-handle-BBQKxZ5F.js";
+import "./directory-handle-OPjjCl3O.js";
 import "./diff-line-counts-bmGB_T-n.js";
 import "./package-qnDHmQq4.js";
 import "node:string_decoder";
 import "node:stream/promises";
+import "./runtime-manifest-Fr5DEH54.js";
 import "async_hooks";
 import "module";
 import "./diff-worker-task-8tVIjLTu.js";
@@ -75,7 +76,7 @@ let __tla = Promise.all([
     }
   })()
 ]).then(async () => {
-  const reviewViewerVersion = "0.77.2";
+  const reviewViewerVersion = "0.78.0";
   const reviewViewerSha256 = "41b6ffd0acff2c355e190b604776a89138f9598a1772d09390a6d5af514e71bb";
   const reviewViewerFileName = "standalone.html";
   const DEFAULT_CDN_BASES = [

package/dist/chunks/runtime-manifest-Fr5DEH54.js

@@ -0,0 +1,9 @@
+const officialRuntime = { "version": "1.0.0" };
+const privateWireContract = { "permissionNotification": "x.ai/yolo_mode_changed", "sessionConfigMeta": "x.ai/sessionConfig", "sessionNotification": "x.ai/session_notification", "sessionUpdateNotification": "x.ai/session/update", "turnCompletedUpdate": "turn_completed", "sessionInfoRequest": "x.ai/session/info", "billingRequest": "x.ai/billing", "weeklyUsagePeriodType": "USAGE_PERIOD_TYPE_WEEKLY", "lodyUsageNotification": "acp_ext:session_usage_update", "lodyRateLimitsNotification": "acp_ext:session_rate_limits", "reasoningEffortMeta": "reasoningEffort", "autoPermissionMode": true };
+const runtimeManifest = {
+  officialRuntime,
+  privateWireContract
+};
+export {
+  runtimeManifest as r
+};

package/dist/file-index-scan-worker.js

@@ -1,6 +1,6 @@
 import { opendir } from "node:fs/promises";
 import path__default from "node:path";
-import { x as buildCodeCollabFileIndexState, D as scanGitDirectoryEntries, F as joinWorkspacePath, G as isInsideGitWorktree, A as computeAllChanges, H as pathSegmentComparisonKey, E as closeDirectoryQuietly } from "./chunks/directory-handle-BBQKxZ5F.js";
+import { x as buildCodeCollabFileIndexState, D as scanGitDirectoryEntries, F as joinWorkspacePath, G as isInsideGitWorktree, A as computeAllChanges, H as pathSegmentComparisonKey, E as closeDirectoryQuietly } from "./chunks/directory-handle-OPjjCl3O.js";
 import "./chunks/schemas-Du3qLZPS.js";
 import "node:child_process";
 import "node:util";

package/dist/grok-acp.js

@@ -0,0 +1,599 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { r as runtimeManifest } from "./chunks/runtime-manifest-Fr5DEH54.js";
+const contract = runtimeManifest.privateWireContract;
+const PERMISSION_MODES = {
+  ask: { permission_mode: "ask", yolo_mode: false, auto_mode: false },
+  auto: { permission_mode: "auto", yolo_mode: false, auto_mode: true },
+  "always-approve": {
+    permission_mode: "always-approve",
+    yolo_mode: true,
+    auto_mode: false
+  }
+};
+const INTERACTION_TO_RUNTIME = { agent: "default", plan: "plan" };
+const INTERACTION_FROM_RUNTIME = { default: "agent", plan: "plan", ask: "plan" };
+const LEGACY_INTERACTION_ALIASES = { ask: "plan" };
+const INTERNAL_REQUESTS = {
+  context: { contractKey: "sessionInfoRequest", params: (sessionId) => ({ sessionId }) },
+  billing: { contractKey: "billingRequest", params: () => ({}) }
+};
+const USD_TICKS_PER_USD = 1e10;
+const MAX_TRACKED_PROMPTS = 256;
+const FIVE_HOUR_WINDOW_MINS = 5 * 60;
+const SEVEN_DAY_WINDOW_MINS = 7 * 24 * 60;
+function logicalExtensionMethod(method) {
+  return typeof method === "string" && method.startsWith("_") ? method.slice(1) : method;
+}
+function wireExtensionMethod(method) {
+  return `_${method}`;
+}
+function extensionNotification(contractKey, params) {
+  return { jsonrpc: "2.0", method: wireExtensionMethod(contract[contractKey]), params };
+}
+function optionalNonnegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function nonnegativeNumber(value) {
+  return optionalNonnegativeNumber(value) ?? 0;
+}
+function optionalAmount(value) {
+  return optionalNonnegativeNumber(value?.val ?? value);
+}
+function billingUsagePercent(config, period) {
+  const fallback = period === config.currentPeriod ? config : {};
+  const explicit = optionalNonnegativeNumber(period.creditUsagePercent) ?? optionalNonnegativeNumber(fallback.creditUsagePercent);
+  if (explicit !== void 0) return explicit;
+  const limit = optionalAmount(period.monthlyLimit ?? fallback.monthlyLimit);
+  const used = optionalAmount(
+    period.totalUsed ?? period.includedUsed ?? period.used ?? fallback.totalUsed ?? fallback.used
+  );
+  if (limit && used !== void 0) return used / limit * 100;
+  const hasOfficialZeroUsage = config.isUnifiedBillingUser === true && config.currentPeriod?.type === contract.weeklyUsagePeriodType && optionalAmount(config.onDemandCap) === 0 && optionalAmount(config.onDemandUsed) === 0 && optionalAmount(config.prepaidBalance) === 0;
+  if (hasOfficialZeroUsage) return 0;
+  return void 0;
+}
+function rateLimitsPayload(planName, window) {
+  const isFiveHour = window?.windowDurationMins === FIVE_HOUR_WINDOW_MINS;
+  const isSevenDay = window?.windowDurationMins === SEVEN_DAY_WINDOW_MINS;
+  return {
+    schemaVersion: 2,
+    planName,
+    limitName: "Grok Build",
+    limitId: "grok",
+    windows: window ? [window] : [],
+    fiveHour: isFiveHour ? window.usedPercent : null,
+    sevenDay: isSevenDay ? window.usedPercent : null,
+    fiveHourResetAt: isFiveHour ? window.resetsAt : null,
+    sevenDayResetAt: isSevenDay ? window.resetsAt : null,
+    ...window ? {} : { apiUnavailable: true }
+  };
+}
+function normalizeUsageModel(usage, usageIsIncomplete) {
+  const inputTokens = nonnegativeNumber(usage?.inputTokens);
+  const outputTokens = nonnegativeNumber(usage?.outputTokens);
+  const cacheReadInputTokens = nonnegativeNumber(usage?.cachedReadTokens);
+  const cacheCreationInputTokens = nonnegativeNumber(usage?.cacheCreationTokens);
+  const reasoningOutputTokens = nonnegativeNumber(usage?.reasoningTokens);
+  const costUsdTicks = optionalNonnegativeNumber(usage?.costUsdTicks);
+  const hasTrustworthyCost = !usageIsIncomplete && usage?.costIsPartial !== true && costUsdTicks !== void 0;
+  return {
+    // Grok's ACP totals include cache buckets in inputTokens and reasoning in
+    // outputTokens. Lody stores disjoint buckets and adds them for reporting.
+    inputTokens: Math.max(0, inputTokens - cacheReadInputTokens - cacheCreationInputTokens),
+    outputTokens: Math.max(0, outputTokens - reasoningOutputTokens),
+    cacheReadInputTokens,
+    cacheCreationInputTokens,
+    reasoningOutputTokens,
+    ...hasTrustworthyCost ? { costUSD: costUsdTicks / USD_TICKS_PER_USD } : {}
+  };
+}
+function normalizePromptUsage(promptUsage) {
+  if (!promptUsage || typeof promptUsage !== "object") return void 0;
+  const usageIsIncomplete = promptUsage.usageIsIncomplete === true;
+  const usage = normalizeUsageModel(promptUsage, usageIsIncomplete);
+  const modelUsage = {};
+  if (promptUsage.modelUsage && typeof promptUsage.modelUsage === "object") {
+    for (const [modelId, model] of Object.entries(promptUsage.modelUsage)) {
+      if (model && typeof model === "object") {
+        modelUsage[modelId] = normalizeUsageModel(model, usageIsIncomplete);
+      }
+    }
+  }
+  return {
+    usage,
+    ...Object.keys(modelUsage).length ? { modelUsage } : {}
+  };
+}
+function usageNotification(promptUsage) {
+  const params = normalizePromptUsage(promptUsage);
+  return params && extensionNotification("lodyUsageNotification", params);
+}
+function normalizeBillingRateLimits(billing) {
+  if (!billing || typeof billing !== "object") return void 0;
+  const config = billing.config;
+  if (!config || typeof config !== "object") return void 0;
+  const latestHistory = Array.isArray(config.history) ? config.history.at(-1) : void 0;
+  const period = config.currentPeriod ?? latestHistory ?? config;
+  let usedPercent = billingUsagePercent(config, period);
+  if (usedPercent !== void 0) usedPercent = Math.min(100, usedPercent);
+  const start = period?.start ?? period?.billingPeriodStart ?? config.billingPeriodStart;
+  const end = period?.end ?? period?.billingPeriodEnd ?? config.billingPeriodEnd;
+  const startMs = typeof start === "string" ? Date.parse(start) : Number.NaN;
+  const endMs = typeof end === "string" ? Date.parse(end) : Number.NaN;
+  const measuredWindowDurationMins = Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs ? Math.round((endMs - startMs) / 6e4) : null;
+  const windowDurationMins = period?.type === contract.weeklyUsagePeriodType ? SEVEN_DAY_WINDOW_MINS : measuredWindowDurationMins;
+  const resetsAt = Number.isFinite(endMs) ? endMs : null;
+  const tier = billing.subscriptionTier ?? billing.subscription_tier;
+  const planName = typeof tier === "string" && tier.trim() ? tier : null;
+  if (usedPercent === void 0) {
+    if (!planName && windowDurationMins === null && resetsAt === null) return void 0;
+    return rateLimitsPayload(planName, null);
+  }
+  return rateLimitsPayload(planName, { usedPercent, windowDurationMins, resetsAt });
+}
+function rateLimitsNotification(billing) {
+  const params = normalizeBillingRateLimits(billing);
+  return params && extensionNotification("lodyRateLimitsNotification", params);
+}
+function contextUsageNotification(sessionId, context) {
+  const size = nonnegativeNumber(context?.total);
+  const used = nonnegativeNumber(context?.used);
+  if (size <= 0) return void 0;
+  return {
+    jsonrpc: "2.0",
+    method: "session/update",
+    params: {
+      sessionId,
+      update: { sessionUpdate: "usage_update", size, used }
+    }
+  };
+}
+function unwrapExtensionResult(result) {
+  if (!result || typeof result !== "object") return result;
+  return Object.prototype.hasOwnProperty.call(result, "result") ? result.result : result;
+}
+function rememberPrompt(set, promptId) {
+  if (!promptId) return true;
+  if (set.has(promptId)) return false;
+  set.add(promptId);
+  if (set.size > MAX_TRACKED_PROMPTS) {
+    set.delete(set.values().next().value);
+  }
+  return true;
+}
+function errorResponse(id, message) {
+  return { jsonrpc: "2.0", id, error: { code: -32602, message } };
+}
+function unsupportedConfigOption(id, configId) {
+  return {
+    toRuntime: [],
+    toClient: [errorResponse(id, `Unsupported Grok config option: ${configId}`)]
+  };
+}
+function optionName(value) {
+  if (value === "xhigh") return "X-High";
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function legacyOptions(result) {
+  const options = result?._meta?.[contract.sessionConfigMeta]?.options;
+  return Array.isArray(options) ? options : [];
+}
+function readReasoningEfforts(model) {
+  const raw = model?._meta?.reasoningEfforts ?? model?._meta?.reasoning_efforts;
+  if (!Array.isArray(raw)) return [];
+  return raw.map((item) => typeof item === "string" ? item : item?.id ?? item?.reasoningEffort).filter((item) => typeof item === "string");
+}
+function selectOption(id, name, description, currentValue, options, category) {
+  return {
+    id,
+    name,
+    description,
+    category,
+    type: "select",
+    currentValue,
+    options
+  };
+}
+function permissionNotification(clientIdentifier, mode) {
+  const mapped = PERMISSION_MODES[mode];
+  if (!mapped) return void 0;
+  return extensionNotification("permissionNotification", { clientIdentifier, ...mapped });
+}
+class GrokAcpCompatibilityProxy {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.permissionModes = /* @__PURE__ */ new Map();
+    this.nextInternalRequestId = Number.MAX_SAFE_INTEGER;
+  }
+  internalRequest(kind, sessionId) {
+    while (this.pending.has(this.nextInternalRequestId)) this.nextInternalRequestId -= 1;
+    const id = this.nextInternalRequestId;
+    this.nextInternalRequestId -= 1;
+    this.pending.set(id, { kind, sessionId });
+    const { contractKey, params } = INTERNAL_REQUESTS[kind];
+    return {
+      jsonrpc: "2.0",
+      id,
+      method: wireExtensionMethod(contract[contractKey]),
+      params: params(sessionId)
+    };
+  }
+  usageRefreshRequests(sessionId) {
+    return [this.internalRequest("context", sessionId), this.internalRequest("billing", sessionId)];
+  }
+  usageRefreshRequestsForPrompt(state, promptId) {
+    if (!rememberPrompt(state.usageRefreshPromptIds, promptId)) return [];
+    return this.usageRefreshRequests(state.sessionId);
+  }
+  usageForPrompt(state, promptId, promptUsage) {
+    const notification = usageNotification(promptUsage);
+    if (!notification) return void 0;
+    if (!rememberPrompt(state.usagePromptIds, promptId)) return void 0;
+    return notification;
+  }
+  handleClient(message) {
+    if (!message || typeof message !== "object") return { toRuntime: [message], toClient: [] };
+    const params = message.params ?? {};
+    if (message.method === "session/new" || message.method === "session/load" || message.method === "session/resume") {
+      const clientIdentifier = params._meta?.clientIdentifier;
+      if (message.id !== void 0) {
+        this.pending.set(message.id, {
+          kind: "session",
+          method: message.method,
+          sessionId: params.sessionId,
+          clientIdentifier
+        });
+      }
+      return { toRuntime: [message], toClient: [] };
+    }
+    if (message.method === "session/prompt") {
+      if (message.id !== void 0) {
+        this.pending.set(message.id, {
+          kind: "prompt",
+          sessionId: params.sessionId
+        });
+      }
+      return { toRuntime: [message], toClient: [] };
+    }
+    if (message.method !== "session/set_config_option") {
+      return { toRuntime: [message], toClient: [] };
+    }
+    const { sessionId, configId, value } = params;
+    const state = this.sessions.get(sessionId);
+    if (!state || typeof value !== "string") {
+      return {
+        toRuntime: [],
+        toClient: [errorResponse(message.id, "Unknown Grok session or invalid config value")]
+      };
+    }
+    if (configId === "permission_mode") {
+      const notification = permissionNotification(state.clientIdentifier, value);
+      if (!notification || !state.clientIdentifier) {
+        return {
+          toRuntime: [],
+          toClient: [
+            errorResponse(
+              message.id,
+              "Grok permission mode requires the current Lody clientIdentifier"
+            )
+          ]
+        };
+      }
+      this.permissionModes.set(state.clientIdentifier, value);
+      return {
+        toRuntime: [notification],
+        toClient: [
+          {
+            jsonrpc: "2.0",
+            id: message.id,
+            result: { configOptions: this.configOptions(state) }
+          }
+        ]
+      };
+    }
+    let translated;
+    let effectiveValue = value;
+    if (configId === "reasoning_effort") {
+      if (!state.currentModelId || !state.reasoningEfforts.includes(value)) {
+        return {
+          toRuntime: [],
+          toClient: [errorResponse(message.id, "Unsupported Grok reasoning effort")]
+        };
+      }
+      translated = {
+        jsonrpc: "2.0",
+        id: message.id,
+        method: "session/set_model",
+        params: {
+          sessionId,
+          modelId: state.currentModelId,
+          _meta: {
+            [contract.reasoningEffortMeta]: value
+          }
+        }
+      };
+    } else if (configId === "model") {
+      translated = {
+        jsonrpc: "2.0",
+        id: message.id,
+        method: "session/set_model",
+        params: { sessionId, modelId: value }
+      };
+    } else if (configId === "interaction_mode") {
+      effectiveValue = LEGACY_INTERACTION_ALIASES[value] ?? value;
+      const modeId = INTERACTION_TO_RUNTIME[effectiveValue];
+      if (!modeId) return unsupportedConfigOption(message.id, configId);
+      translated = {
+        jsonrpc: "2.0",
+        id: message.id,
+        method: "session/set_mode",
+        params: { sessionId, modeId }
+      };
+    } else {
+      return unsupportedConfigOption(message.id, configId);
+    }
+    this.pending.set(message.id, {
+      kind: "config",
+      sessionId,
+      configId,
+      value: effectiveValue
+    });
+    return { toRuntime: [translated], toClient: [] };
+  }
+  handleRuntime(message) {
+    if (!message || typeof message !== "object") return { toRuntime: [], toClient: [message] };
+    if (typeof message.method === "string") return this.handleRuntimeMethod(message);
+    const pending = this.pending.get(message.id);
+    if (!pending) return { toRuntime: [], toClient: [message] };
+    this.pending.delete(message.id);
+    if (pending.kind === "context") {
+      if (message.error) return { toRuntime: [], toClient: [] };
+      const sessionInfo = unwrapExtensionResult(message.result);
+      const contextNotification = contextUsageNotification(pending.sessionId, sessionInfo?.context);
+      return {
+        toRuntime: [],
+        toClient: contextNotification ? [contextNotification] : []
+      };
+    }
+    if (pending.kind === "billing") {
+      const notification = message.error ? extensionNotification("lodyRateLimitsNotification", rateLimitsPayload(null, null)) : rateLimitsNotification(unwrapExtensionResult(message.result));
+      return {
+        toRuntime: [],
+        toClient: notification ? [notification] : []
+      };
+    }
+    if (message.error) return { toRuntime: [], toClient: [message] };
+    if (pending.kind === "session") {
+      const result = message.result ?? {};
+      const sessionId = result.sessionId ?? pending.sessionId;
+      if (!sessionId) return { toRuntime: [], toClient: [message] };
+      const state2 = this.stateFromSessionResponse(sessionId, pending.clientIdentifier, result);
+      this.sessions.set(sessionId, state2);
+      return {
+        toRuntime: this.usageRefreshRequests(sessionId),
+        toClient: [
+          {
+            ...message,
+            result: { ...result, configOptions: this.configOptions(state2) }
+          }
+        ]
+      };
+    }
+    if (pending.kind === "prompt") {
+      const state2 = this.sessions.get(pending.sessionId);
+      if (!state2) return { toRuntime: [], toClient: [message] };
+      const meta = message.result?._meta;
+      const promptId = meta?.promptId ?? meta?.requestId;
+      const usage = this.usageForPrompt(state2, promptId, meta?.usage);
+      return {
+        toRuntime: this.usageRefreshRequestsForPrompt(state2, promptId),
+        toClient: usage ? [message, usage] : [message]
+      };
+    }
+    const state = this.sessions.get(pending.sessionId);
+    if (!state) return { toRuntime: [], toClient: [message] };
+    if (pending.configId === "model") state.currentModelId = pending.value;
+    if (pending.configId === "reasoning_effort") state.reasoningEffort = pending.value;
+    if (pending.configId === "interaction_mode") state.interactionMode = pending.value;
+    return {
+      toRuntime: [],
+      toClient: [
+        {
+          jsonrpc: "2.0",
+          id: message.id,
+          result: { configOptions: this.configOptions(state) }
+        }
+      ]
+    };
+  }
+  handleRuntimeMethod(message) {
+    const passthrough = { toRuntime: [], toClient: [message] };
+    const sessionId = message.params?.sessionId;
+    const update = message.params?.update;
+    const state = this.sessions.get(sessionId);
+    if (!state) return passthrough;
+    const logicalMethod = logicalExtensionMethod(message.method);
+    if (logicalMethod === contract.sessionUpdateNotification && update?.sessionUpdate === contract.turnCompletedUpdate) {
+      if (message.params?._meta?.isReplay === true) return passthrough;
+      const promptId = update.prompt_id ?? update.promptId;
+      const usage = this.usageForPrompt(state, promptId, update.usage);
+      return {
+        toRuntime: this.usageRefreshRequestsForPrompt(state, promptId),
+        toClient: usage ? [message, usage] : [message]
+      };
+    }
+    if (message.method === "session/update" && update?.sessionUpdate === "current_mode_update") {
+      const interactionMode = INTERACTION_FROM_RUNTIME[update.currentModeId];
+      if (interactionMode) state.interactionMode = interactionMode;
+      return passthrough;
+    }
+    if (logicalMethod === contract.sessionNotification && update?.sessionUpdate === "model_changed") {
+      const modelId = update.model_id ?? update.modelId;
+      const reasoningEffort = update.reasoning_effort ?? update.reasoningEffort;
+      if (typeof modelId === "string") state.currentModelId = modelId;
+      if (typeof reasoningEffort === "string") state.reasoningEffort = reasoningEffort;
+      return {
+        toRuntime: [this.internalRequest("context", sessionId)],
+        toClient: [message]
+      };
+    }
+    return passthrough;
+  }
+  stateFromSessionResponse(sessionId, clientIdentifier, result) {
+    const old = this.sessions.get(sessionId);
+    const legacy = legacyOptions(result);
+    const legacyModels = legacy.filter((option) => option.category === "model");
+    const legacyEfforts = legacy.filter((option) => option.category === "mode");
+    const availableModels = result.models?.availableModels ?? [];
+    const currentModelId = result.models?.currentModelId ?? legacyModels.find((option) => option.selected)?.id ?? old?.currentModelId;
+    const currentModel = availableModels.find((model) => model.modelId === currentModelId);
+    const metadataEfforts = readReasoningEfforts(currentModel);
+    const reasoningEfforts = metadataEfforts.length ? metadataEfforts : legacyEfforts.map((option) => option.id);
+    return {
+      sessionId,
+      clientIdentifier: clientIdentifier ?? old?.clientIdentifier,
+      interactionMode: INTERACTION_FROM_RUNTIME[result.modes?.currentModeId] ?? old?.interactionMode ?? "agent",
+      currentModelId,
+      models: availableModels.length ? availableModels : legacyModels.map((option) => ({
+        modelId: option.id,
+        name: option.label,
+        description: option.description
+      })),
+      reasoningEfforts,
+      reasoningEffort: legacyEfforts.find((option) => option.selected)?.id ?? old?.reasoningEffort ?? reasoningEfforts[0],
+      usagePromptIds: old?.usagePromptIds ?? /* @__PURE__ */ new Set(),
+      usageRefreshPromptIds: old?.usageRefreshPromptIds ?? /* @__PURE__ */ new Set()
+    };
+  }
+  configOptions(state) {
+    const modes = [
+      {
+        value: "agent",
+        name: "Agent",
+        description: "Use tools and make changes when needed"
+      },
+      {
+        value: "plan",
+        name: "Plan",
+        description: "Plan without modifying the workspace"
+      }
+    ];
+    const permissions = [
+      {
+        value: "ask",
+        name: "Ask Every Time",
+        description: "Request approval for protected actions"
+      },
+      {
+        value: "always-approve",
+        name: "Always Approve",
+        description: "Approve protected actions automatically"
+      }
+    ];
+    {
+      permissions.splice(1, 0, {
+        value: "auto",
+        name: "Auto",
+        description: "Let Grok decide when approval is required"
+      });
+    }
+    const options = [
+      selectOption(
+        "interaction_mode",
+        "Interaction Mode",
+        "Controls how Grok works",
+        state.interactionMode,
+        modes,
+        "mode"
+      ),
+      selectOption(
+        "permission_mode",
+        "Permission Mode",
+        "Controls protected tool approvals",
+        this.permissionModes.get(state.clientIdentifier) ?? "ask",
+        permissions,
+        "_permission"
+      )
+    ];
+    if (state.currentModelId) {
+      options.push(
+        selectOption(
+          "model",
+          "Model",
+          "Select the model used for this session",
+          state.currentModelId,
+          state.models.map((model) => ({
+            value: model.modelId,
+            name: model.name || model.modelId,
+            description: model.description ?? null
+          })),
+          "model"
+        )
+      );
+    }
+    if (state.reasoningEfforts.length && state.reasoningEffort) {
+      options.push(
+        selectOption(
+          "reasoning_effort",
+          "Reasoning Effort",
+          "Controls how much reasoning the model performs",
+          state.reasoningEffort,
+          state.reasoningEfforts.map((value) => ({
+            value,
+            name: optionName(value),
+            description: null
+          })),
+          "thought_level"
+        )
+      );
+    }
+    return options;
+  }
+}
+const grokPath = process.env.GROK_PATH;
+if (!grokPath) {
+  console.error("GROK_PATH must point to the official Grok runtime");
+  process.exit(1);
+}
+const child = spawn(grokPath, ["agent", "stdio"], {
+  env: { ...process.env, GROK_DISABLE_AUTOUPDATER: "1" },
+  stdio: ["pipe", "pipe", "inherit"]
+});
+const proxy = new GrokAcpCompatibilityProxy();
+function write(stream, message) {
+  stream.write(`${JSON.stringify(message)}
+`);
+}
+createInterface({ input: process.stdin }).on("line", (line) => {
+  try {
+    const output = proxy.handleClient(JSON.parse(line));
+    for (const message of output.toRuntime) write(child.stdin, message);
+    for (const message of output.toClient) write(process.stdout, message);
+  } catch (error) {
+    console.error(
+      `Invalid ACP client message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+});
+createInterface({ input: child.stdout }).on("line", (line) => {
+  try {
+    const output = proxy.handleRuntime(JSON.parse(line));
+    for (const message of output.toRuntime) write(child.stdin, message);
+    for (const message of output.toClient) write(process.stdout, message);
+  } catch (error) {
+    console.error(
+      `Invalid Grok runtime message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+});
+process.stdin.on("end", () => child.stdin.end());
+child.on("error", (error) => {
+  console.error(`Failed to launch official Grok runtime: ${error.message}`);
+  process.exitCode = 1;
+});
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  else process.exitCode = code ?? 1;
+});