lody 0.91.0 → 0.92.0

package/dist/chunks/{index-BNIS69wD.js → index-Cy4lnlSp.js}

@@ -32600,7 +32600,47 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return {};
     }
     return {
-      configOptions: this.createSessionConfigOptions(sessionState)
+      configOptions: this.createSessionConfigOptions(sessionState),
+      ...this.createModelCapabilitiesMeta(sessionState)
+    };
+  }
+  /**
+   * Publishes what each model can do, not just what the current one can.
+   *
+   * `configOptions` is rebuilt per model — `fast-mode` appears only while the
+   * current model has a fast speed tier, and the effort list is that model's —
+   * so a client reading it learns nothing about any other model, and there is
+   * no ACP request that asks. This data is already in hand here, from the same
+   * `Model` objects those options are built from; dropping it forced clients to
+   * guess or to refuse selections that are perfectly valid.
+   *
+   * Self-declared and advisory: it describes this account's catalog at this
+   * moment, and the live session state remains the authority.
+   */
+  createModelCapabilitiesMeta(sessionState) {
+    const models = sessionState.availableModels;
+    if (models.length === 0) {
+      return {};
+    }
+    return {
+      _meta: {
+        lody: {
+          modelCapabilities: {
+            version: 1,
+            models: Object.fromEntries(
+              models.map((model) => [
+                model.id,
+                {
+                  effortValues: model.supportedReasoningEfforts.map(
+                    (effort) => effort.reasoningEffort
+                  ),
+                  fastMode: modelSupportsFast(model)
+                }
+              ])
+            )
+          }
+        }
+      }
     };
   }
   isSessionConfigEnabled() {

package/dist/chunks/{review-viewer-BxVOWMjT.js → review-viewer-CEr3NCEE.js}

@@ -80,7 +80,7 @@ let __tla = Promise.all([
     }
   })()
 ]).then(async () => {
-  const reviewViewerVersion = "0.91.0";
+  const reviewViewerVersion = "0.92.0";
   const reviewViewerSha256 = "dc9c7fc1dde49bb39c5fe86392d69219b469c0cab4fd492d8b562045e7f676e4";
   const reviewViewerFileName = "standalone.html";
   const DEFAULT_CDN_BASES = [

package/dist/claude-acp.js

@@ -41,7 +41,7 @@ import { isIPv4, isIPv6 } from "net";
 import { R as RequestError, a as CreateElicitationResponse, n as ndJsonStream, b as agent$1, m as methods } from "./chunks/acp-DBqkNziA.js";
 import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
 import { p as packageJson } from "./chunks/package-DlotPnLa.js";
-import { s as string, b as boolean, c as array } from "./chunks/schemas-Du3qLZPS.js";
+import { s as string, b as boolean, c as array, o as object, n as number, l as literal } from "./chunks/schemas-Du3qLZPS.js";
 import { WritableStream, ReadableStream as ReadableStream$1 } from "node:stream/web";
 (async () => {
   var One = Object.create;
@@ -68082,6 +68082,16 @@ ${content.text}
     }
     logger.error(`Unexpected case: ${valueAsString}`);
   }
+  const ScopedWeeklyLimitSchema = object({
+    kind: literal("weekly_scoped"),
+    percent: number(),
+    resets_at: string().nullish(),
+    scope: object({
+      model: object({
+        display_name: string().trim().min(1)
+      })
+    })
+  });
   const KEYCHAIN_TIMEOUT_MS = 5e3;
   const KEYCHAIN_BACKOFF_MS = 6e4;
   const defaultDeps = {
@@ -68130,6 +68140,22 @@ ${content.text}
           resetsAtEpochSeconds: sevenDayResetAt
         });
       }
+      if (Array.isArray(apiResponse.limits)) {
+        for (const rawLimit of apiResponse.limits) {
+          const parsed = ScopedWeeklyLimitSchema.safeParse(rawLimit);
+          if (!parsed.success) continue;
+          const limit = parsed.data;
+          const usedPercent = parseUtilization(limit.percent);
+          if (usedPercent === null) continue;
+          const window2 = {
+            label: limit.scope.model.display_name,
+            usedPercent,
+            windowDurationSeconds: 7 * 24 * 60 * 60,
+            resetsAtEpochSeconds: parseDate(limit.resets_at ?? void 0)
+          };
+          windows.push(window2);
+        }
+      }
       const result = {
         rateLimits: [
           {
@@ -72078,7 +72104,8 @@ ${explanation}` : fallbackSummary;
       return {
         sessionId,
         modes,
-        configOptions
+        configOptions,
+        ...buildModelCapabilitiesMeta(modelInfos)
       };
     }
     async enqueueProviderUpdate(config) {
@@ -72290,6 +72317,31 @@ ${explanation}` : fallbackSummary;
   function clientSupportsBooleanConfigOptions(clientCapabilities) {
     return clientCapabilities?.session?.configOptions?.boolean != null;
   }
+  function buildModelCapabilitiesMeta(modelInfos) {
+    if (modelInfos.length === 0) {
+      return {};
+    }
+    return {
+      _meta: {
+        lody: {
+          modelCapabilities: {
+            version: 1,
+            models: Object.fromEntries(modelInfos.map((info) => [
+              info.value,
+              {
+                ...info.supportsEffort && info.supportedEffortLevels ? {
+                  effortValues: [
+                    ...info.supportedEffortLevels
+                  ]
+                } : {},
+                fastMode: info.supportsFastMode === true
+              }
+            ]))
+          }
+        }
+      }
+    };
+  }
   function createFastModeConfigOption(enabled, useBooleanOption, disabledReason) {
     const explanation = enabled ? void 0 : disabledReason && FAST_MODE_UNAVAILABLE_EXPLANATIONS[disabledReason];
     const base = {

package/dist/codex-acp.js

@@ -3,5 +3,5 @@
     console.error("CODEX_PATH is required for the bundled Codex ACP adapter.");
     process.exit(1);
   }
-  await import("./chunks/index-BNIS69wD.js");
+  await import("./chunks/index-Cy4lnlSp.js");
 })();

package/dist/grok-acp.js

@@ -251,22 +251,21 @@ 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;
+  if (!mapped) return { message, permissionMode: void 0 };
   const translated = {
     ...message,
     params: {
       ...params,
       _meta: {
         ...stripLodySessionConfig(params._meta),
-        yoloMode: mapped.yolo_mode
+        yoloMode: mapped.yolo_mode,
+        autoMode: mapped.auto_mode
       }
     }
   };
   return {
     message: translated,
-    permissionMode,
-    notification: mapped.auto_mode && typeof clientIdentifier === "string" ? permissionNotification(clientIdentifier, permissionMode) : void 0
+    permissionMode
   };
 }
 class GrokAcpCompatibilityProxy {
@@ -281,29 +280,49 @@ class GrokAcpCompatibilityProxy {
     this.permissionModes = /* @__PURE__ */ new Map();
     this.nextInternalRequestId = Number.MAX_SAFE_INTEGER;
   }
-  applyModelSnapshot(state, snapshot) {
+  applyCurrentModel(state, currentModelId, reportedReasoningEffort) {
     const previousModelId = state.currentModelId;
-    const previousReasoningEffort = state.reasoningEffort;
-    const currentModel = snapshot.availableModels.find(
-      (model) => model.modelId === snapshot.currentModelId
-    );
+    const currentModel = state.models.find((model) => model.modelId === currentModelId);
     const reasoningEfforts = readReasoningEfforts(currentModel);
     const metadataReasoningEffort = currentModel?._meta?.reasoningEffort ?? currentModel?._meta?.reasoning_effort;
-    state.currentModelId = snapshot.currentModelId;
-    state.models = snapshot.availableModels;
+    state.currentModelId = currentModelId;
+    if (reasoningEfforts.length === 0) {
+      if (previousModelId !== currentModelId) state.reasoningEfforts = [];
+      if (typeof reportedReasoningEffort === "string") {
+        state.reasoningEffort = reportedReasoningEffort;
+      }
+      return;
+    }
     state.reasoningEfforts = reasoningEfforts;
-    state.reasoningEffort = previousModelId === snapshot.currentModelId && reasoningEfforts.includes(previousReasoningEffort) ? previousReasoningEffort : typeof metadataReasoningEffort === "string" && reasoningEfforts.includes(metadataReasoningEffort) ? metadataReasoningEffort : reasoningEfforts[0];
+    state.reasoningEffort = typeof reportedReasoningEffort === "string" && reasoningEfforts.includes(reportedReasoningEffort) ? reportedReasoningEffort : previousModelId === currentModelId && reasoningEfforts.includes(state.reasoningEffort) ? state.reasoningEffort : typeof metadataReasoningEffort === "string" && reasoningEfforts.includes(metadataReasoningEffort) ? metadataReasoningEffort : reasoningEfforts[0];
+  }
+  applyModelSnapshot(state, snapshot) {
+    state.models = snapshot.availableModels;
+    this.applyCurrentModel(state, snapshot.currentModelId);
   }
   sessionResponseWithState(message, state) {
     const models = typeof state.currentModelId === "string" && state.models.length > 0 ? {
       currentModelId: state.currentModelId,
       availableModels: state.models
     } : message.result?.models;
+    const modelReasoningEfforts = {};
+    for (const model of state.models) {
+      const efforts = readReasoningEfforts(model);
+      if (efforts.length) modelReasoningEfforts[model.modelId] = efforts;
+    }
     return {
       ...message,
       result: {
         ...message.result,
         ...models ? { models } : {},
+        ...Object.keys(modelReasoningEfforts).length > 0 ? {
+          _meta: {
+            ...message.result?._meta ?? {},
+            lody: {
+              modelReasoningEfforts
+            }
+          }
+        } : {},
         configOptions: this.configOptions(state)
       }
     };
@@ -420,7 +439,7 @@ class GrokAcpCompatibilityProxy {
         });
       }
       return {
-        toRuntime: translated2.notification ? [translated2.notification, translated2.message] : [translated2.message],
+        toRuntime: [translated2.message],
         toClient: []
       };
     }
@@ -611,7 +630,7 @@ class GrokAcpCompatibilityProxy {
     }
     const state = this.sessions.get(pending.sessionId);
     if (!state) return { toRuntime: [], toClient: [message] };
-    if (pending.configId === "model") state.currentModelId = pending.value;
+    if (pending.configId === "model") this.applyCurrentModel(state, pending.value);
     if (pending.configId === "reasoning_effort") state.reasoningEffort = pending.value;
     if (pending.configId === "interaction_mode") state.interactionMode = pending.value;
     return {
@@ -652,11 +671,24 @@ class GrokAcpCompatibilityProxy {
     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;
+      if (typeof modelId === "string") {
+        this.applyCurrentModel(state, modelId, reasoningEffort);
+      }
       return {
         toRuntime: [this.internalRequest("context", sessionId)],
-        toClient: [message]
+        toClient: [
+          {
+            jsonrpc: "2.0",
+            method: "session/update",
+            params: {
+              sessionId,
+              update: {
+                sessionUpdate: "config_option_update",
+                configOptions: this.configOptions(state)
+              }
+            }
+          }
+        ]
       };
     }
     return passthrough;