lody 0.97.2 → 0.99.0

package/dist/grok-acp.js

@@ -1,7 +1,7 @@
 import { createInterface } from "node:readline";
-import { r as runtimeManifest } from "./chunks/runtime-manifest-DqfOlvSw.js";
-import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
+import { r as runtimeManifest } from "./chunks/runtime-manifest-DZsDOOW3.js";
 import { L as LODY_PLAN_MODE_CONFIG_ID, c as createPlanModeConfigOption } from "./chunks/plan-mode-BLOER-fv.js";
+import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
 import { S as SessionUsageAccumulator } from "./chunks/usage-DY4Eg1Mf.js";
 import { spawn } from "node:child_process";
 function update(sessionId, value) {
@@ -336,10 +336,58 @@ function legacyOptions(result) {
   const options = result?._meta?.[contract.sessionConfigMeta]?.options;
   return Array.isArray(options) ? options : [];
 }
-function readReasoningEfforts(model) {
+function readReasoningOptions(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");
+  return raw.map((item) => {
+    if (typeof item === "string") {
+      return {
+        id: item,
+        value: item,
+        name: optionName(item),
+        description: null,
+        default: false
+      };
+    }
+    const id = item?.id ?? item?.reasoningEffort ?? item?.value;
+    const value = item?.value ?? item?.reasoningEffort ?? item?.id;
+    if (typeof id !== "string" || typeof value !== "string") return void 0;
+    return {
+      id,
+      value,
+      name: typeof item.label === "string" ? item.label : optionName(id),
+      description: typeof item.description === "string" ? item.description : null,
+      default: item.default === true
+    };
+  }).filter(Boolean);
+}
+function readReasoningEfforts(model) {
+  return readReasoningOptions(model).map((option) => option.id);
+}
+function reasoningOptionsFromConfig(option) {
+  if (!Array.isArray(option?.options)) return [];
+  return option.options.map((item) => {
+    if (!item || typeof item.value !== "string") return void 0;
+    return {
+      id: item.value,
+      value: item.value,
+      name: typeof item.name === "string" ? item.name : optionName(item.value),
+      description: typeof item.description === "string" ? item.description : null,
+      default: false
+    };
+  }).filter(Boolean);
+}
+function reasoningSelector(options, reportedValue) {
+  if (typeof reportedValue !== "string") return void 0;
+  return options.find((option) => option.id === reportedValue)?.id ?? options.find((option) => option.value === reportedValue)?.id;
+}
+function standardConfigOptions(result) {
+  return Array.isArray(result?.configOptions) ? result.configOptions.filter(
+    (option) => option && typeof option === "object" && typeof option.id === "string"
+  ) : [];
+}
+function configOption(options, id) {
+  return options.find((option) => option.id === id);
 }
 function readModelSnapshot(params) {
   if (!params || typeof params !== "object" || !Array.isArray(params.availableModels)) {
@@ -414,6 +462,23 @@ function translateSessionStart(message) {
     permissionMode
   };
 }
+function translateInitialize(message) {
+  const params = message.params ?? {};
+  const clientCapabilities = params.clientCapabilities ?? {};
+  return {
+    ...message,
+    params: {
+      ...params,
+      clientCapabilities: {
+        ...clientCapabilities,
+        _meta: {
+          ...clientCapabilities._meta ?? {},
+          [contract.userMessageEchoCapability]: false
+        }
+      }
+    }
+  };
+}
 class GrokAcpCompatibilityProxy {
   constructor({ deferSessionResponseUntilModelSnapshot = false } = {}) {
     this.sessions = /* @__PURE__ */ new Map();
@@ -431,18 +496,63 @@ class GrokAcpCompatibilityProxy {
   applyCurrentModel(state, currentModelId, reportedReasoningEffort) {
     const previousModelId = state.currentModelId;
     const currentModel = state.models.find((model) => model.modelId === currentModelId);
-    const reasoningEfforts = readReasoningEfforts(currentModel);
+    const reasoningOptions = readReasoningOptions(currentModel);
+    const reasoningEfforts = reasoningOptions.map((option) => option.id);
     const metadataReasoningEffort = currentModel?._meta?.reasoningEffort ?? currentModel?._meta?.reasoning_effort;
     state.currentModelId = currentModelId;
     if (reasoningEfforts.length === 0) {
-      if (previousModelId !== currentModelId) state.reasoningEfforts = [];
+      if (previousModelId !== currentModelId) {
+        state.reasoningOptions = [];
+        state.reasoningEfforts = [];
+      }
       if (typeof reportedReasoningEffort === "string") {
         state.reasoningEffort = reportedReasoningEffort;
       }
       return;
     }
+    state.reasoningOptions = reasoningOptions;
     state.reasoningEfforts = reasoningEfforts;
-    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];
+    const reportedValue = reasoningSelector(reasoningOptions, reportedReasoningEffort) ?? (typeof reportedReasoningEffort === "string" ? reportedReasoningEffort : void 0);
+    const metadataValue = reasoningSelector(reasoningOptions, metadataReasoningEffort) ?? (typeof metadataReasoningEffort === "string" ? metadataReasoningEffort : void 0);
+    state.reasoningEffort = reportedValue !== void 0 ? reportedValue : previousModelId === currentModelId && typeof state.reasoningEffort === "string" ? state.reasoningEffort : metadataValue ?? reasoningOptions.find((option) => option.default)?.id ?? reasoningEfforts[0];
+  }
+  applyRuntimeConfigOptions(state, options) {
+    if (!Array.isArray(options)) return;
+    state.runtimeConfigOptions = options.filter(
+      (option) => option && typeof option === "object" && typeof option.id === "string" && option.id !== LODY_PLAN_MODE_CONFIG_ID && option.id !== "permission_mode" && option.id !== "interaction_mode"
+    );
+    const modelOption = configOption(state.runtimeConfigOptions, "model");
+    if (Array.isArray(modelOption?.options)) {
+      state.models = modelOption.options.filter((option) => option && typeof option.value === "string").map((option) => {
+        const existing = state.models.find((model) => model.modelId === option.value);
+        return {
+          ...existing ?? {},
+          modelId: option.value,
+          name: typeof option.name === "string" ? option.name : existing?.name ?? option.value,
+          description: option.description ?? existing?.description
+        };
+      });
+    }
+    if (typeof modelOption?.currentValue === "string") {
+      this.applyCurrentModel(state, modelOption.currentValue);
+    }
+    const reasoningOption = configOption(state.runtimeConfigOptions, "reasoning_effort");
+    if (!reasoningOption) return;
+    const currentModel = state.models.find((model) => model.modelId === state.currentModelId);
+    const metadataReasoningOptions = readReasoningOptions(currentModel);
+    if (metadataReasoningOptions.length) {
+      state.reasoningOptions = metadataReasoningOptions;
+      state.reasoningEfforts = metadataReasoningOptions.map((option) => option.id);
+    } else {
+      state.reasoningOptions = reasoningOptionsFromConfig(reasoningOption);
+      state.reasoningEfforts = state.reasoningOptions.map((option) => option.id);
+    }
+    const selected = reasoningSelector(state.reasoningOptions, reasoningOption.currentValue);
+    if (selected !== void 0) {
+      state.reasoningEffort = selected;
+    } else if (typeof reasoningOption.currentValue === "string") {
+      state.reasoningEffort = reasoningOption.currentValue;
+    }
   }
   applyModelSnapshot(state, snapshot) {
     state.models = snapshot.availableModels;
@@ -573,9 +683,10 @@ class GrokAcpCompatibilityProxy {
       return { toRuntime: [...cancelled.toRuntime, message], toClient: cancelled.toClient };
     }
     if (message.method === "initialize" && message.id !== void 0) {
-      this.clientCapabilities = params.clientCapabilities ?? {};
+      const translated2 = translateInitialize(message);
+      this.clientCapabilities = translated2.params.clientCapabilities;
       this.pending.set(message.id, { kind: "initialize" });
-      return { toRuntime: [message], toClient: [] };
+      return { toRuntime: [translated2], toClient: [] };
     }
     if (message.method === LODY_EXTENSION_METHODS.rateLimitsGet) {
       return {
@@ -616,7 +727,9 @@ class GrokAcpCompatibilityProxy {
     }
     const { sessionId, configId, value } = params;
     const state = this.sessions.get(sessionId);
-    if (!state || (configId === LODY_PLAN_MODE_CONFIG_ID ? typeof value !== "boolean" : typeof value !== "string")) {
+    const runtimeOption = configOption(state?.runtimeConfigOptions ?? [], configId);
+    const expectsBoolean = configId === LODY_PLAN_MODE_CONFIG_ID || runtimeOption?.type === "boolean";
+    if (!state || (expectsBoolean ? typeof value !== "boolean" : typeof value !== "string")) {
       return {
         toRuntime: [],
         toClient: [errorResponse(message.id, "Unknown Grok session or invalid config value")]
@@ -659,7 +772,7 @@ class GrokAcpCompatibilityProxy {
           toClient: [errorResponse(message.id, "Unsupported Grok reasoning effort")]
         };
       }
-      translated = {
+      translated = configOption(state.runtimeConfigOptions, configId) ? message : {
         jsonrpc: "2.0",
         id: message.id,
         method: "session/set_model",
@@ -667,12 +780,12 @@ class GrokAcpCompatibilityProxy {
           sessionId,
           modelId: state.currentModelId,
           _meta: {
-            [contract.reasoningEffortMeta]: value
+            [contract.reasoningEffortMeta]: state.reasoningOptions.find((option) => option.id === value)?.value ?? value
           }
         }
       };
     } else if (configId === "model") {
-      translated = {
+      translated = configOption(state.runtimeConfigOptions, configId) ? message : {
         jsonrpc: "2.0",
         id: message.id,
         method: "session/set_model",
@@ -688,6 +801,8 @@ class GrokAcpCompatibilityProxy {
         method: "session/set_mode",
         params: { sessionId, modeId }
       };
+    } else if (configOption(state.runtimeConfigOptions, configId)) {
+      translated = message;
     } else {
       return unsupportedConfigOption(message.id, configId);
     }
@@ -792,17 +907,21 @@ class GrokAcpCompatibilityProxy {
     }
     const state = this.sessions.get(pending.sessionId);
     if (!state) return { toRuntime: [], toClient: [message] };
-    if (pending.configId === "model") this.applyCurrentModel(state, pending.value);
-    if (pending.configId === "reasoning_effort") state.reasoningEffort = pending.value;
-    if (pending.configId === LODY_PLAN_MODE_CONFIG_ID || pending.configId === "interaction_mode")
-      state.interactionMode = pending.value;
+    if (message.error) return { toRuntime: [], toClient: [message] };
+    if (Array.isArray(message.result?.configOptions)) {
+      this.applyRuntimeConfigOptions(state, message.result.configOptions);
+    } else {
+      if (pending.configId === "model") this.applyCurrentModel(state, pending.value);
+      if (pending.configId === "reasoning_effort") state.reasoningEffort = pending.value;
+      if (pending.configId === LODY_PLAN_MODE_CONFIG_ID || pending.configId === "interaction_mode")
+        state.interactionMode = pending.value;
+    }
     return {
       toRuntime: [],
       toClient: [
         {
-          jsonrpc: "2.0",
-          id: message.id,
-          result: { configOptions: this.configOptions(state) }
+          ...message,
+          result: { ...message.result ?? {}, configOptions: this.configOptions(state) }
         }
       ]
     };
@@ -846,6 +965,21 @@ class GrokAcpCompatibilityProxy {
         toClient: usage ? [message, usage] : [message]
       };
     }
+    if (message.method === "session/update" && update2?.sessionUpdate === "config_option_update" && Array.isArray(update2.configOptions)) {
+      this.applyRuntimeConfigOptions(state, update2.configOptions);
+      return {
+        toRuntime: [],
+        toClient: [
+          {
+            ...message,
+            params: {
+              ...message.params,
+              update: { ...update2, configOptions: this.configOptions(state) }
+            }
+          }
+        ]
+      };
+    }
     if (message.method === "session/update" && update2?.sessionUpdate === "current_mode_update") {
       const interactionMode = INTERACTION_FROM_RUNTIME[update2.currentModeId];
       if (!interactionMode) return passthrough;
@@ -874,6 +1008,13 @@ class GrokAcpCompatibilityProxy {
       if (typeof modelId === "string") {
         this.applyCurrentModel(state, modelId, reasoningEffort);
       }
+      const publishesStandardConfig = configOption(state.runtimeConfigOptions, "model") !== void 0 || configOption(state.runtimeConfigOptions, "reasoning_effort") !== void 0;
+      if (publishesStandardConfig) {
+        return {
+          toRuntime: [this.internalRequest("context", sessionId)],
+          toClient: []
+        };
+      }
       return {
         toRuntime: [this.internalRequest("context", sessionId)],
         toClient: [
@@ -898,12 +1039,25 @@ class GrokAcpCompatibilityProxy {
     const legacy = legacyOptions(result);
     const legacyModels = legacy.filter((option) => option.category === "model");
     const legacyEfforts = legacy.filter((option) => option.category === "mode");
+    const hasRuntimeConfigOptions = Array.isArray(result.configOptions);
+    const runtimeConfigOptions = standardConfigOptions(result);
+    const runtimeModelOption = configOption(runtimeConfigOptions, "model");
+    const runtimeReasoningOption = configOption(runtimeConfigOptions, "reasoning_effort");
     const availableModels = result.models?.availableModels ?? [];
-    const currentModelId = result.models?.currentModelId ?? legacyModels.find((option) => option.selected)?.id ?? old?.currentModelId;
+    const currentModelId = result.models?.currentModelId ?? runtimeModelOption?.currentValue ?? 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 {
+    const metadataReasoningOptions = readReasoningOptions(currentModel);
+    const runtimeReasoningOptions = reasoningOptionsFromConfig(runtimeReasoningOption);
+    const legacyReasoningOptions = legacyEfforts.map((option) => ({
+      id: option.id,
+      value: option.id,
+      name: option.label ?? optionName(option.id),
+      description: option.description ?? null,
+      default: false
+    }));
+    const reasoningOptions = metadataReasoningOptions.length ? metadataReasoningOptions : runtimeReasoningOptions.length ? runtimeReasoningOptions : legacyReasoningOptions;
+    const reportedReasoningEffort = runtimeReasoningOption?.currentValue ?? legacyEfforts.find((option) => option.selected)?.id ?? currentModel?._meta?.reasoningEffort ?? currentModel?._meta?.reasoning_effort;
+    const state = {
       sessionId,
       clientIdentifier: clientIdentifier ?? old?.clientIdentifier,
       interactionMode: INTERACTION_FROM_RUNTIME[result.modes?.currentModeId] ?? old?.interactionMode ?? "agent",
@@ -913,11 +1067,15 @@ class GrokAcpCompatibilityProxy {
         name: option.label,
         description: option.description
       })),
-      reasoningEfforts,
-      reasoningEffort: legacyEfforts.find((option) => option.selected)?.id ?? old?.reasoningEffort ?? reasoningEfforts[0],
+      runtimeConfigOptions: hasRuntimeConfigOptions ? runtimeConfigOptions : old?.runtimeConfigOptions ?? [],
+      reasoningOptions,
+      reasoningEfforts: reasoningOptions.map((option) => option.id),
+      reasoningEffort: reasoningSelector(reasoningOptions, reportedReasoningEffort) ?? (typeof reportedReasoningEffort === "string" ? reportedReasoningEffort : void 0) ?? old?.reasoningEffort ?? reasoningOptions.find((option) => option.default)?.id ?? reasoningOptions[0]?.id,
       usageAccumulator: old?.usageAccumulator ?? new SessionUsageAccumulator(),
       usageRefreshPromptIds: old?.usageRefreshPromptIds ?? /* @__PURE__ */ new Set()
     };
+    if (hasRuntimeConfigOptions) this.applyRuntimeConfigOptions(state, runtimeConfigOptions);
+    return state;
   }
   configOptions(state) {
     const permissions = [
@@ -943,7 +1101,53 @@ class GrokAcpCompatibilityProxy {
         "_permission"
       )
     ];
-    if (state.currentModelId) {
+    const runtimeOptions = state.runtimeConfigOptions ?? [];
+    const emittedRuntimeIds = /* @__PURE__ */ new Set();
+    for (const runtimeOption of runtimeOptions) {
+      if (runtimeOption.id === "model") {
+        emittedRuntimeIds.add(runtimeOption.id);
+        options.push({
+          ...runtimeOption,
+          ...state.currentModelId ? { currentValue: state.currentModelId } : {},
+          ...state.models.length ? {
+            options: state.models.map((model) => {
+              const published = runtimeOption.options?.find(
+                (option) => option?.value === model.modelId
+              );
+              return {
+                ...published,
+                value: model.modelId,
+                name: published?.name || model.name || model.modelId,
+                description: published?.description ?? model.description ?? null
+              };
+            })
+          } : {}
+        });
+      } else if (runtimeOption.id === "reasoning_effort" && state.reasoningOptions.length && state.reasoningEffort) {
+        emittedRuntimeIds.add(runtimeOption.id);
+        options.push({
+          ...runtimeOption,
+          ...state.reasoningEffort ? { currentValue: state.reasoningEffort } : {},
+          ...state.reasoningOptions.length ? {
+            options: state.reasoningOptions.map((option) => {
+              const published = runtimeOption.options?.find(
+                (candidate) => candidate?.value === option.id
+              );
+              return {
+                ...published,
+                value: option.id,
+                name: published?.name || option.name || optionName(option.id),
+                description: published?.description ?? option.description ?? null
+              };
+            })
+          } : {}
+        });
+      } else if (runtimeOption.id !== "model" && runtimeOption.id !== "reasoning_effort") {
+        emittedRuntimeIds.add(runtimeOption.id);
+        options.push(runtimeOption);
+      }
+    }
+    if (state.currentModelId && !emittedRuntimeIds.has("model")) {
       options.push(
         selectOption(
           "model",
@@ -959,17 +1163,17 @@ class GrokAcpCompatibilityProxy {
         )
       );
     }
-    if (state.reasoningEfforts.length && state.reasoningEffort) {
+    if (state.reasoningOptions.length && state.reasoningEffort && !emittedRuntimeIds.has("reasoning_effort")) {
       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
+          state.reasoningOptions.map((option) => ({
+            value: option.id,
+            name: option.name,
+            description: option.description
           })),
           "thought_level"
         )