lody 0.84.0 → 0.86.0

package/dist/grok-acp.js

@@ -1,5 +1,6 @@
 import { createInterface } from "node:readline";
-import { r as runtimeManifest } from "./chunks/runtime-manifest-Fr5DEH54.js";
+import { r as runtimeManifest } from "./chunks/runtime-manifest-ByWJfM07.js";
+import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
 import { spawn } from "node:child_process";
 const contract = runtimeManifest.privateWireContract;
 const PERMISSION_MODES = {
@@ -16,12 +17,17 @@ 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: () => ({}) }
+  billing: { contractKey: "billingRequest", params: () => ({}) },
+  rateLimits: { 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;
+const GROK_LODY_CAPABILITIES = {
+  usage: { version: 1 },
+  rateLimits: { version: 1, query: true }
+};
+const SEVEN_DAY_WINDOW_SECONDS = 7 * 24 * 60 * 60;
+const GROK_MODEL_SNAPSHOT_SETTLE_TIMEOUT_MS = 2e3;
 function logicalExtensionMethod(method) {
   return typeof method === "string" && method.startsWith("_") ? method.slice(1) : method;
 }
@@ -31,6 +37,9 @@ function wireExtensionMethod(method) {
 function extensionNotification(contractKey, params) {
   return { jsonrpc: "2.0", method: wireExtensionMethod(contract[contractKey]), params };
 }
+function lodyNotification(method, params) {
+  return { jsonrpc: "2.0", method, params };
+}
 function optionalNonnegativeNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
@@ -53,20 +62,18 @@ function billingUsagePercent(config, period) {
   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;
+function rateLimitsPayload(planName, window, now = Date.now()) {
   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 }
+    rateLimits: window ? [
+      {
+        limitId: "grok",
+        scope: { providerId: "grok" },
+        planName,
+        limitName: "Grok Build",
+        windows: [window]
+      }
+    ] : [],
+    fetchedAtEpochSeconds: Math.floor(now / 1e3)
   };
 }
 function normalizeUsageModel(usage, usageIsIncomplete) {
@@ -105,9 +112,9 @@ function normalizePromptUsage(promptUsage) {
     ...Object.keys(modelUsage).length ? { modelUsage } : {}
   };
 }
-function usageNotification(promptUsage) {
+function usageNotification(sessionId, promptUsage) {
   const params = normalizePromptUsage(promptUsage);
-  return params && extensionNotification("lodyUsageNotification", params);
+  return params && lodyNotification(LODY_EXTENSION_METHODS.sessionUsageUpdate, { sessionId, ...params });
 }
 function normalizeBillingRateLimits(billing) {
   if (!billing || typeof billing !== "object") return void 0;
@@ -121,20 +128,25 @@ function normalizeBillingRateLimits(billing) {
   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 measuredWindowDurationSeconds = Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs ? Math.round((endMs - startMs) / 1e3) : null;
+  const windowDurationSeconds = period?.type === contract.weeklyUsagePeriodType ? SEVEN_DAY_WINDOW_SECONDS : measuredWindowDurationSeconds;
+  const resetsAtEpochSeconds = Number.isFinite(endMs) ? Math.floor(endMs / 1e3) : 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;
+    if (!planName && windowDurationSeconds === null && resetsAtEpochSeconds === null)
+      return void 0;
     return rateLimitsPayload(planName, null);
   }
-  return rateLimitsPayload(planName, { usedPercent, windowDurationMins, resetsAt });
+  return rateLimitsPayload(planName, {
+    usedPercent,
+    windowDurationSeconds,
+    resetsAtEpochSeconds
+  });
 }
 function rateLimitsNotification(billing) {
   const params = normalizeBillingRateLimits(billing);
-  return params && extensionNotification("lodyRateLimitsNotification", params);
+  return params && lodyNotification(LODY_EXTENSION_METHODS.rateLimitsUpdate, params);
 }
 function contextUsageNotification(sessionId, context) {
   const size = nonnegativeNumber(context?.total);
@@ -184,6 +196,24 @@ function readReasoningEfforts(model) {
   if (!Array.isArray(raw)) return [];
   return raw.map((item) => typeof item === "string" ? item : item?.id ?? item?.reasoningEffort).filter((item) => typeof item === "string");
 }
+function readModelSnapshot(params) {
+  if (!params || typeof params !== "object" || !Array.isArray(params.availableModels)) {
+    return void 0;
+  }
+  if (params.availableModels.length === 0 || params.availableModels.some(
+    (model) => !model || typeof model !== "object" || typeof model.modelId !== "string"
+  )) {
+    return void 0;
+  }
+  const currentModelId = params.currentModelId;
+  if (typeof currentModelId !== "string" || !params.availableModels.some((model) => model.modelId === currentModelId)) {
+    return void 0;
+  }
+  return {
+    currentModelId,
+    availableModels: params.availableModels
+  };
+}
 function selectOption(id, name, description, currentValue, options, category) {
   return {
     id,
@@ -200,18 +230,147 @@ function permissionNotification(clientIdentifier, mode) {
   if (!mapped) return void 0;
   return extensionNotification("permissionNotification", { clientIdentifier, ...mapped });
 }
+function stripLodySessionConfig(meta) {
+  if (!meta || typeof meta !== "object") return meta;
+  const lody = meta.lody;
+  if (!lody || typeof lody !== "object" || !Object.hasOwn(lody, "sessionConfig")) return meta;
+  const { sessionConfig: _sessionConfig, ...remainingLody } = lody;
+  const { lody: _lody, ...remainingMeta } = meta;
+  return Object.keys(remainingLody).length > 0 ? { ...remainingMeta, lody: remainingLody } : remainingMeta;
+}
+function readLodySessionConfigOption(meta, configId) {
+  if (!meta || typeof meta !== "object") return void 0;
+  const sessionConfig = meta.lody?.sessionConfig;
+  if (!sessionConfig || typeof sessionConfig !== "object" || sessionConfig.version !== 1 || !sessionConfig.configOptionValues || typeof sessionConfig.configOptionValues !== "object") {
+    return void 0;
+  }
+  const value = sessionConfig.configOptionValues[configId];
+  return typeof value === "string" || typeof value === "boolean" ? value : void 0;
+}
+function translateSessionStart(message) {
+  const params = message.params ?? {};
+  const permissionMode = readLodySessionConfigOption(params._meta, "permission_mode");
+  const mapped = typeof permissionMode === "string" ? PERMISSION_MODES[permissionMode] : void 0;
+  if (!mapped) return { message, permissionMode: void 0, notification: void 0 };
+  const clientIdentifier = params._meta?.clientIdentifier;
+  const translated = {
+    ...message,
+    params: {
+      ...params,
+      _meta: {
+        ...stripLodySessionConfig(params._meta),
+        yoloMode: mapped.yolo_mode
+      }
+    }
+  };
+  return {
+    message: translated,
+    permissionMode,
+    notification: mapped.auto_mode && typeof clientIdentifier === "string" ? permissionNotification(clientIdentifier, permissionMode) : void 0
+  };
+}
 class GrokAcpCompatibilityProxy {
-  constructor() {
+  constructor({ deferSessionResponseUntilModelSnapshot = false } = {}) {
     this.sessions = /* @__PURE__ */ new Map();
     this.pending = /* @__PURE__ */ new Map();
+    this.pendingSessionResponses = /* @__PURE__ */ new Map();
+    this.clientVisibleSessions = /* @__PURE__ */ new Set();
+    this.latestModelSnapshot = void 0;
+    this.latestModelSnapshotFingerprint = void 0;
+    this.deferSessionResponseUntilModelSnapshot = deferSessionResponseUntilModelSnapshot;
     this.permissionModes = /* @__PURE__ */ new Map();
     this.nextInternalRequestId = Number.MAX_SAFE_INTEGER;
   }
-  internalRequest(kind, sessionId) {
+  applyModelSnapshot(state, snapshot) {
+    const previousModelId = state.currentModelId;
+    const previousReasoningEffort = state.reasoningEffort;
+    const currentModel = snapshot.availableModels.find(
+      (model) => model.modelId === snapshot.currentModelId
+    );
+    const reasoningEfforts = readReasoningEfforts(currentModel);
+    const metadataReasoningEffort = currentModel?._meta?.reasoningEffort ?? currentModel?._meta?.reasoning_effort;
+    state.currentModelId = snapshot.currentModelId;
+    state.models = snapshot.availableModels;
+    state.reasoningEfforts = reasoningEfforts;
+    state.reasoningEffort = previousModelId === snapshot.currentModelId && reasoningEfforts.includes(previousReasoningEffort) ? previousReasoningEffort : typeof metadataReasoningEffort === "string" && reasoningEfforts.includes(metadataReasoningEffort) ? metadataReasoningEffort : reasoningEfforts[0];
+  }
+  sessionResponseWithState(message, state) {
+    const models = typeof state.currentModelId === "string" && state.models.length > 0 ? {
+      currentModelId: state.currentModelId,
+      availableModels: state.models
+    } : message.result?.models;
+    return {
+      ...message,
+      result: {
+        ...message.result,
+        ...models ? { models } : {},
+        configOptions: this.configOptions(state)
+      }
+    };
+  }
+  exposePendingSessionResponse(id) {
+    const pending = this.pendingSessionResponses.get(id);
+    if (!pending) return { toRuntime: [], toClient: [] };
+    this.pendingSessionResponses.delete(id);
+    const state = this.sessions.get(pending.sessionId);
+    if (!state) return { toRuntime: [], toClient: [pending.message] };
+    this.clientVisibleSessions.add(pending.sessionId);
+    return {
+      toRuntime: [],
+      toClient: [this.sessionResponseWithState(pending.message, state)]
+    };
+  }
+  flushPendingSessionResponse(id) {
+    return this.exposePendingSessionResponse(id);
+  }
+  handleModelSnapshot(message) {
+    const snapshot = readModelSnapshot(message.params);
+    if (!snapshot) return { toRuntime: [], toClient: [message] };
+    const fingerprint = JSON.stringify(snapshot);
+    if (fingerprint === this.latestModelSnapshotFingerprint) {
+      return { toRuntime: [], toClient: [] };
+    }
+    this.latestModelSnapshot = snapshot;
+    this.latestModelSnapshotFingerprint = fingerprint;
+    for (const state of this.sessions.values()) {
+      this.applyModelSnapshot(state, snapshot);
+    }
+    const toClient = [];
+    const pendingSessionIds = /* @__PURE__ */ new Set();
+    const settledSessionResponseIds = [];
+    for (const id of [...this.pendingSessionResponses.keys()]) {
+      const pending = this.pendingSessionResponses.get(id);
+      if (pending) pendingSessionIds.add(pending.sessionId);
+      toClient.push(...this.exposePendingSessionResponse(id).toClient);
+      settledSessionResponseIds.push(id);
+    }
+    for (const sessionId of this.clientVisibleSessions) {
+      if (pendingSessionIds.has(sessionId)) continue;
+      const state = this.sessions.get(sessionId);
+      if (!state) continue;
+      toClient.push({
+        jsonrpc: "2.0",
+        method: "session/update",
+        params: {
+          sessionId,
+          update: {
+            sessionUpdate: "config_option_update",
+            configOptions: this.configOptions(state)
+          }
+        }
+      });
+    }
+    return {
+      toRuntime: [],
+      toClient,
+      ...settledSessionResponseIds.length > 0 ? { settledSessionResponseIds } : {}
+    };
+  }
+  internalRequest(kind, sessionId, responseId) {
     while (this.pending.has(this.nextInternalRequestId)) this.nextInternalRequestId -= 1;
     const id = this.nextInternalRequestId;
     this.nextInternalRequestId -= 1;
-    this.pending.set(id, { kind, sessionId });
+    this.pending.set(id, { kind, sessionId, responseId });
     const { contractKey, params } = INTERNAL_REQUESTS[kind];
     return {
       jsonrpc: "2.0",
@@ -228,7 +387,7 @@ class GrokAcpCompatibilityProxy {
     return this.usageRefreshRequests(state.sessionId);
   }
   usageForPrompt(state, promptId, promptUsage) {
-    const notification = usageNotification(promptUsage);
+    const notification = usageNotification(state.sessionId, promptUsage);
     if (!notification) return void 0;
     if (!rememberPrompt(state.usagePromptIds, promptId)) return void 0;
     return notification;
@@ -236,8 +395,22 @@ class GrokAcpCompatibilityProxy {
   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") {
+    if (message.method === "initialize" && message.id !== void 0) {
+      this.pending.set(message.id, { kind: "initialize" });
+      return { toRuntime: [message], toClient: [] };
+    }
+    if (message.method === LODY_EXTENSION_METHODS.rateLimitsGet) {
+      return {
+        toRuntime: [this.internalRequest("rateLimits", void 0, message.id)],
+        toClient: []
+      };
+    }
+    if (message.method === "session/new" || message.method === "session/load" || message.method === "session/resume" || message.method === "session/fork") {
       const clientIdentifier = params._meta?.clientIdentifier;
+      const translated2 = translateSessionStart(message);
+      if (translated2.permissionMode && typeof clientIdentifier === "string") {
+        this.permissionModes.set(clientIdentifier, translated2.permissionMode);
+      }
       if (message.id !== void 0) {
         this.pending.set(message.id, {
           kind: "session",
@@ -246,7 +419,10 @@ class GrokAcpCompatibilityProxy {
           clientIdentifier
         });
       }
-      return { toRuntime: [message], toClient: [] };
+      return {
+        toRuntime: translated2.notification ? [translated2.notification, translated2.message] : [translated2.message],
+        toClient: []
+      };
     }
     if (message.method === "session/prompt") {
       if (message.id !== void 0) {
@@ -358,27 +534,68 @@ class GrokAcpCompatibilityProxy {
       };
     }
     if (pending.kind === "billing") {
-      const notification = message.error ? extensionNotification("lodyRateLimitsNotification", rateLimitsPayload(null, null)) : rateLimitsNotification(unwrapExtensionResult(message.result));
+      const notification = message.error ? lodyNotification(LODY_EXTENSION_METHODS.rateLimitsUpdate, rateLimitsPayload(null, null)) : rateLimitsNotification(unwrapExtensionResult(message.result));
       return {
         toRuntime: [],
         toClient: notification ? [notification] : []
       };
     }
+    if (pending.kind === "rateLimits") {
+      const result = message.error ? rateLimitsPayload(null, null) : normalizeBillingRateLimits(unwrapExtensionResult(message.result)) ?? rateLimitsPayload(null, null);
+      return {
+        toRuntime: [],
+        toClient: [{ jsonrpc: "2.0", id: pending.responseId, result }]
+      };
+    }
+    if (pending.kind === "initialize") {
+      if (message.error) return { toRuntime: [], toClient: [message] };
+      const result = message.result ?? {};
+      const agentCapabilities = result.agentCapabilities ?? {};
+      return {
+        toRuntime: [],
+        toClient: [
+          {
+            ...message,
+            result: {
+              ...result,
+              agentCapabilities: {
+                ...agentCapabilities,
+                _meta: {
+                  ...agentCapabilities._meta ?? {},
+                  lody: GROK_LODY_CAPABILITIES
+                }
+              }
+            }
+          }
+        ]
+      };
+    }
     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);
+      if (this.latestModelSnapshot) {
+        this.applyModelSnapshot(state2, this.latestModelSnapshot);
+      }
       this.sessions.set(sessionId, state2);
+      const sessionResponse = this.sessionResponseWithState(message, state2);
+      if (this.deferSessionResponseUntilModelSnapshot && !this.latestModelSnapshot && message.id !== void 0) {
+        this.pendingSessionResponses.set(message.id, {
+          message: sessionResponse,
+          sessionId
+        });
+        return {
+          toRuntime: this.usageRefreshRequests(sessionId),
+          toClient: [],
+          deferredSessionResponseIds: [message.id]
+        };
+      }
+      this.clientVisibleSessions.add(sessionId);
       return {
         toRuntime: this.usageRefreshRequests(sessionId),
-        toClient: [
-          {
-            ...message,
-            result: { ...result, configOptions: this.configOptions(state2) }
-          }
-        ]
+        toClient: [sessionResponse]
       };
     }
     if (pending.kind === "prompt") {
@@ -410,11 +627,14 @@ class GrokAcpCompatibilityProxy {
   }
   handleRuntimeMethod(message) {
     const passthrough = { toRuntime: [], toClient: [message] };
+    const logicalMethod = logicalExtensionMethod(message.method);
+    if (logicalMethod === contract.modelsUpdateNotification) {
+      return this.handleModelSnapshot(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;
@@ -565,16 +785,36 @@ if (!grokPath) {
   process.exit(1);
 }
 const child = spawnGrokRuntime(grokPath);
-const proxy = new GrokAcpCompatibilityProxy();
+const proxy = new GrokAcpCompatibilityProxy({
+  deferSessionResponseUntilModelSnapshot: true
+});
+const deferredResponseTimers = /* @__PURE__ */ new Map();
 function write(stream, message) {
   stream.write(`${JSON.stringify(message)}
 `);
 }
+function dispatch(output) {
+  for (const id of output.settledSessionResponseIds ?? []) {
+    const timer = deferredResponseTimers.get(id);
+    if (timer) clearTimeout(timer);
+    deferredResponseTimers.delete(id);
+  }
+  for (const message of output.toRuntime) write(child.stdin, message);
+  for (const message of output.toClient) write(process.stdout, message);
+  for (const id of output.deferredSessionResponseIds ?? []) {
+    const existingTimer = deferredResponseTimers.get(id);
+    if (existingTimer) clearTimeout(existingTimer);
+    const timer = setTimeout(() => {
+      deferredResponseTimers.delete(id);
+      dispatch(proxy.flushPendingSessionResponse(id));
+    }, GROK_MODEL_SNAPSHOT_SETTLE_TIMEOUT_MS);
+    deferredResponseTimers.set(id, timer);
+    timer.unref();
+  }
+}
 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);
+    dispatch(proxy.handleClient(JSON.parse(line)));
   } catch (error) {
     console.error(
       `Invalid ACP client message: ${error instanceof Error ? error.message : String(error)}`
@@ -583,9 +823,7 @@ createInterface({ input: process.stdin }).on("line", (line) => {
 });
 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);
+    dispatch(proxy.handleRuntime(JSON.parse(line)));
   } catch (error) {
     console.error(
       `Invalid Grok runtime message: ${error instanceof Error ? error.message : String(error)}`