lody 0.91.1 → 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-C_L6J8dc.js → review-viewer-CEr3NCEE.js}

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

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;