lody 0.92.1 → 0.93.2

package/dist/claude-acp.js

@@ -38,10 +38,10 @@ import { AsyncLocalStorage } from "async_hooks";
 import * as os$2 from "node:os";
 import os__default from "node:os";
 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 { R as RequestError, a as CreateElicitationResponse, n as ndJsonStream, b as agent$1, m as methods } from "./chunks/acp-DCoAUZc7.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, o as object, n as number, l as literal } 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-C-NzK2uQ.js";
 import { WritableStream, ReadableStream as ReadableStream$1 } from "node:stream/web";
 (async () => {
   var One = Object.create;

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-Cy4lnlSp.js");
+  await import("./chunks/index-Bxge7nr7.js");
 })();

package/dist/deepseek-acp.js

@@ -1,9 +1,10 @@
 import { randomUUID, createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { Readable, Writable } from "node:stream";
-import { n as ndJsonStream, A as AgentSideConnection, R as RequestError, P as PROTOCOL_VERSION } from "./chunks/acp-DBqkNziA.js";
-import { j as DEEPSEEK_HARNESS_BASE_URL_ENV, k as DEEPSEEK_HARNESS_API_KEY_ENV, b as ACP_EXTENSION_DSH_VERSION, a as DEEPSEEK_HARNESS_AGENT_PRESETS } from "./chunks/profile-DLuYzIs8.js";
-import "./chunks/schemas-Du3qLZPS.js";
+import { n as ndJsonStream, A as AgentSideConnection, R as RequestError, P as PROTOCOL_VERSION } from "./chunks/acp-DCoAUZc7.js";
+import { j as DEEPSEEK_HARNESS_BASE_URL_ENV, k as DEEPSEEK_HARNESS_API_KEY_ENV, a as DEEPSEEK_HARNESS_AGENT_PRESETS, b as ACP_EXTENSION_DSH_VERSION } from "./chunks/profile-Dv5auBPt.js";
+import { c as createPlanModeConfigOption, L as LODY_PLAN_MODE_CONFIG_ID } from "./chunks/plan-mode-BLOER-fv.js";
+import "./chunks/schemas-C-NzK2uQ.js";
 const name = "acp-extension-dsh";
 const inject = [
   "agents",
@@ -289,6 +290,9 @@ function installModelSelection(agentContext, selection) {
     };
   });
 }
+function planModeService(record) {
+  return record.agent.ctx.get("planMode");
+}
 function configOptions(record) {
   const options = [
     {
@@ -334,6 +338,11 @@ function configOptions(record) {
       }))
     }
   ];
+  const plan = planModeService(record);
+  if (plan) {
+    const state = plan.get(record.agent);
+    options.push(createPlanModeConfigOption(state.pending ?? state.active));
+  }
   const model = record.models.find((candidate) => candidate.id === record.selection.current.model);
   if (model?.reasoning && record.selection.current.reasoningEffort) {
     options.push({
@@ -710,6 +719,12 @@ function apply(ctx, rawConfig) {
     const record = sessions.get(session.header.id);
     if (!record || record.agent.session !== session)
       return;
+    if (event.type === "plan/mode") {
+      enqueueNotification(record, {
+        sessionId: record.agent.session.id,
+        update: { sessionUpdate: "config_option_update", configOptions: configOptions(record) }
+      });
+    }
     if (PERMISSION_EVENT_TYPES.has(event.type))
       schedulePermissionSync(record);
     try {
@@ -827,6 +842,14 @@ function apply(ctx, rawConfig) {
     record.permissionOptions = permissionState(ctx, permissionMode);
   };
   const setConfigOption = (record, params) => {
+    if (params.configId === LODY_PLAN_MODE_CONFIG_ID) {
+      const plan = planModeService(record);
+      if (!plan || typeof params.value !== "boolean") {
+        throw invalidParams("Plan mode requires a supported Agent preset and a boolean value");
+      }
+      plan.set(record.agent, params.value);
+      return { configOptions: configOptions(record) };
+    }
     const value = requireSelectValue(params);
     if (params.configId === MODE_CONFIG_ID) {
       setPermissionMode(record, value);

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

@@ -1,7 +1,7 @@
 import { opendir } from "node:fs/promises";
 import path__default from "node:path";
-import { z as buildCodeCollabFileIndexState, F as scanGitDirectoryEntries, H as joinWorkspacePath, I as isInsideGitWorktree, D as computeAllChanges, J as pathSegmentComparisonKey, G as closeDirectoryQuietly } from "./chunks/directory-handle-Bp47LF5g.js";
-import "./chunks/schemas-Du3qLZPS.js";
+import { z as buildCodeCollabFileIndexState, F as scanGitDirectoryEntries, H as joinWorkspacePath, I as isInsideGitWorktree, D as computeAllChanges, J as pathSegmentComparisonKey, G as closeDirectoryQuietly } from "./chunks/directory-handle-35P9qcGk.js";
+import "./chunks/schemas-C-NzK2uQ.js";
 import "node:child_process";
 import "node:util";
 import "./chunks/diff-line-counts-bmGB_T-n.js";

package/dist/grok-acp.js

@@ -1,11 +1,159 @@
 import { createInterface } from "node:readline";
-import { r as runtimeManifest } from "./chunks/runtime-manifest-DnyvD_EC.js";
+import { r as runtimeManifest } from "./chunks/runtime-manifest-FeOT7MvW.js";
 import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
+import { L as LODY_PLAN_MODE_CONFIG_ID, c as createPlanModeConfigOption } from "./chunks/plan-mode-BLOER-fv.js";
 import { spawn } from "node:child_process";
+function update(sessionId, value) {
+  return { jsonrpc: "2.0", method: "session/update", params: { sessionId, update: value } };
+}
+class GrokPlanReviewBridge {
+  constructor() {
+    this.pending = /* @__PURE__ */ new Map();
+  }
+  start(message, sessions, capabilities) {
+    const wrapped = message.params?.method === "x.ai/exit_plan_mode";
+    const params = wrapped ? message.params.params : message.params;
+    const { sessionId, toolCallId, planContent } = params ?? {};
+    if (message.id === void 0) return { toRuntime: [], toClient: [] };
+    if (!sessions.has(sessionId) || typeof toolCallId !== "string" || !toolCallId || planContent != null && typeof planContent !== "string") {
+      return {
+        toRuntime: [
+          {
+            jsonrpc: "2.0",
+            id: message.id,
+            error: { code: -32602, message: "Invalid plan approval request" }
+          }
+        ],
+        toClient: []
+      };
+    }
+    const plan = planContent ?? "";
+    const review = {
+      id: message.id,
+      sessionId,
+      toolCallId,
+      wrapped,
+      feedbackSupported: Boolean(capabilities.elicitation?.form),
+      phase: "approval"
+    };
+    this.pending.set(message.id, review);
+    const separatePlan = capabilities.plan != null;
+    const toolCall = {
+      toolCallId,
+      title: "Implement this plan?",
+      kind: "switch_mode",
+      status: "pending",
+      rawInput: { plan },
+      content: separatePlan && plan.trim() ? [] : [
+        {
+          type: "content",
+          content: {
+            type: "text",
+            text: plan.trim() ? plan : "No plan written yet."
+          }
+        }
+      ]
+    };
+    const toClient = [];
+    if (separatePlan)
+      toClient.push(
+        update(sessionId, {
+          sessionUpdate: "plan_update",
+          plan: { type: "markdown", planId: toolCallId, content: plan }
+        })
+      );
+    toClient.push(update(sessionId, { sessionUpdate: "tool_call", ...toolCall }));
+    toClient.push({
+      jsonrpc: "2.0",
+      id: message.id,
+      method: "session/request_permission",
+      params: {
+        sessionId,
+        toolCall,
+        options: [
+          { optionId: "approve", name: "Implement this plan", kind: "allow_once" },
+          { optionId: "revise", name: "Keep planning", kind: "reject_once" },
+          { optionId: "abandon", name: "Exit without implementing this plan", kind: "reject_once" }
+        ]
+      }
+    });
+    return { toRuntime: [], toClient };
+  }
+  response(message) {
+    if (typeof message.method === "string") return void 0;
+    const review = this.pending.get(message.id);
+    if (!review) return void 0;
+    if (review.phase === "feedback") {
+      const feedback = !message.error && message.result?.action === "accept" && typeof message.result.content?.feedback === "string" ? message.result.content.feedback : void 0;
+      return this.finish(review, "cancelled", feedback);
+    }
+    const selected = message.result?.outcome?.outcome === "selected" ? message.result.outcome.optionId : void 0;
+    if (!message.error && selected === "approve") return this.finish(review, "approved");
+    if (!message.error && selected === "abandon") return this.finish(review, "abandoned");
+    if (!message.error && selected === "revise" && review.feedbackSupported) {
+      review.phase = "feedback";
+      return {
+        toRuntime: [],
+        toClient: [
+          {
+            jsonrpc: "2.0",
+            id: review.id,
+            method: "elicitation/create",
+            params: {
+              sessionId: review.sessionId,
+              toolCallId: `${review.toolCallId}:feedback`,
+              mode: "form",
+              message: "What should change in the plan?",
+              requestedSchema: {
+                type: "object",
+                properties: { feedback: { type: "string", title: "Feedback" } }
+              },
+              _meta: { lody: { elicitation: { version: 1 } } }
+            }
+          }
+        ]
+      };
+    }
+    return this.finish(review, "cancelled");
+  }
+  finish(review, outcome, feedback) {
+    this.pending.delete(review.id);
+    const result = { outcome, ...feedback ? { feedback } : {} };
+    const toClient = [
+      update(review.sessionId, {
+        sessionUpdate: "tool_call_update",
+        toolCallId: review.toolCallId,
+        status: "completed",
+        rawOutput: result
+      })
+    ];
+    if (review.phase === "feedback")
+      toClient.push(
+        update(review.sessionId, {
+          sessionUpdate: "tool_call_update",
+          toolCallId: `${review.toolCallId}:feedback`,
+          status: "completed"
+        })
+      );
+    return {
+      toRuntime: [{ jsonrpc: "2.0", id: review.id, result: review.wrapped ? { result } : result }],
+      toClient
+    };
+  }
+  cancel(sessionId) {
+    const output = { toRuntime: [], toClient: [] };
+    for (const review of [...this.pending.values()]) {
+      if (review.sessionId !== sessionId) continue;
+      const result = this.finish(review, "cancelled");
+      output.toRuntime.push(...result.toRuntime);
+      output.toClient.push(...result.toClient);
+    }
+    return output;
+  }
+}
 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,
@@ -249,7 +397,8 @@ function readLodySessionConfigOption(meta, configId) {
 }
 function translateSessionStart(message) {
   const params = message.params ?? {};
-  const permissionMode = readLodySessionConfigOption(params._meta, "permission_mode");
+  const requestedMode = readLodySessionConfigOption(params._meta, "permission_mode");
+  const permissionMode = requestedMode === "auto" ? "ask" : requestedMode;
   const mapped = typeof permissionMode === "string" ? PERMISSION_MODES[permissionMode] : void 0;
   if (!mapped) return { message, permissionMode: void 0 };
   const translated = {
@@ -259,7 +408,7 @@ function translateSessionStart(message) {
       _meta: {
         ...stripLodySessionConfig(params._meta),
         yoloMode: mapped.yolo_mode,
-        autoMode: mapped.auto_mode
+        autoMode: false
       }
     }
   };
@@ -271,6 +420,8 @@ function translateSessionStart(message) {
 class GrokAcpCompatibilityProxy {
   constructor({ deferSessionResponseUntilModelSnapshot = false } = {}) {
     this.sessions = /* @__PURE__ */ new Map();
+    this.planReviews = new GrokPlanReviewBridge();
+    this.clientCapabilities = {};
     this.pending = /* @__PURE__ */ new Map();
     this.pendingSessionResponses = /* @__PURE__ */ new Map();
     this.clientVisibleSessions = /* @__PURE__ */ new Set();
@@ -413,8 +564,15 @@ class GrokAcpCompatibilityProxy {
   }
   handleClient(message) {
     if (!message || typeof message !== "object") return { toRuntime: [message], toClient: [] };
+    const planResponse = this.planReviews.response(message);
+    if (planResponse) return planResponse;
     const params = message.params ?? {};
+    if (message.method === "session/cancel") {
+      const cancelled = this.planReviews.cancel(params.sessionId);
+      return { toRuntime: [...cancelled.toRuntime, message], toClient: cancelled.toClient };
+    }
     if (message.method === "initialize" && message.id !== void 0) {
+      this.clientCapabilities = params.clientCapabilities ?? {};
       this.pending.set(message.id, { kind: "initialize" });
       return { toRuntime: [message], toClient: [] };
     }
@@ -457,13 +615,16 @@ class GrokAcpCompatibilityProxy {
     }
     const { sessionId, configId, value } = params;
     const state = this.sessions.get(sessionId);
-    if (!state || typeof value !== "string") {
+    if (!state || (configId === LODY_PLAN_MODE_CONFIG_ID ? typeof value !== "boolean" : typeof value !== "string")) {
       return {
         toRuntime: [],
         toClient: [errorResponse(message.id, "Unknown Grok session or invalid config value")]
       };
     }
     if (configId === "permission_mode") {
+      if (!Object.hasOwn(PERMISSION_MODES, value)) {
+        return unsupportedConfigOption(message.id, configId);
+      }
       const notification = permissionNotification(state.clientIdentifier, value);
       if (!notification || !state.clientIdentifier) {
         return {
@@ -516,8 +677,8 @@ class GrokAcpCompatibilityProxy {
         method: "session/set_model",
         params: { sessionId, modelId: value }
       };
-    } else if (configId === "interaction_mode") {
-      effectiveValue = LEGACY_INTERACTION_ALIASES[value] ?? value;
+    } else if (configId === LODY_PLAN_MODE_CONFIG_ID || configId === "interaction_mode") {
+      effectiveValue = configId === LODY_PLAN_MODE_CONFIG_ID ? value ? "plan" : "agent" : LEGACY_INTERACTION_ALIASES[value] ?? value;
       const modeId = INTERACTION_TO_RUNTIME[effectiveValue];
       if (!modeId) return unsupportedConfigOption(message.id, configId);
       translated = {
@@ -632,7 +793,8 @@ class GrokAcpCompatibilityProxy {
     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 === "interaction_mode") state.interactionMode = pending.value;
+    if (pending.configId === LODY_PLAN_MODE_CONFIG_ID || pending.configId === "interaction_mode")
+      state.interactionMode = pending.value;
     return {
       toRuntime: [],
       toClient: [
@@ -647,30 +809,67 @@ class GrokAcpCompatibilityProxy {
   handleRuntimeMethod(message) {
     const passthrough = { toRuntime: [], toClient: [message] };
     const logicalMethod = logicalExtensionMethod(message.method);
+    if (logicalMethod === contract.planApprovalRequest) {
+      return this.planReviews.start(message, this.sessions, this.clientCapabilities);
+    }
     if (logicalMethod === contract.modelsUpdateNotification) {
       return this.handleModelSnapshot(message);
     }
     const sessionId = message.params?.sessionId;
-    const update = message.params?.update;
+    const update2 = message.params?.update;
     const state = this.sessions.get(sessionId);
     if (!state) return passthrough;
-    if (logicalMethod === contract.sessionUpdateNotification && update?.sessionUpdate === contract.turnCompletedUpdate) {
+    if (message.method === "session/request_permission" && message.id !== void 0 && this.permissionModes.get(state.clientIdentifier) === "always-approve" && !message.params?._meta?.lody?.elicitation && message.params?.toolCall?.kind !== "switch_mode" && Array.isArray(message.params?.options)) {
+      const options = message.params.options;
+      const isSelectable = (option) => typeof option?.optionId === "string";
+      const allow = options.find((option) => isSelectable(option) && option.kind === "allow_once") ?? options.find((option) => isSelectable(option) && option.kind === "allow_always");
+      if (allow) {
+        return {
+          toRuntime: [
+            {
+              jsonrpc: "2.0",
+              id: message.id,
+              result: { outcome: { outcome: "selected", optionId: allow.optionId } }
+            }
+          ],
+          toClient: []
+        };
+      }
+    }
+    if (logicalMethod === contract.sessionUpdateNotification && update2?.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);
+      const promptId = update2.prompt_id ?? update2.promptId;
+      const usage = this.usageForPrompt(state, promptId, update2.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 (message.method === "session/update" && update2?.sessionUpdate === "current_mode_update") {
+      const interactionMode = INTERACTION_FROM_RUNTIME[update2.currentModeId];
+      if (!interactionMode) return passthrough;
+      state.interactionMode = interactionMode;
+      return {
+        toRuntime: [],
+        toClient: [
+          message,
+          {
+            jsonrpc: "2.0",
+            method: "session/update",
+            params: {
+              sessionId,
+              update: {
+                sessionUpdate: "config_option_update",
+                configOptions: this.configOptions(state)
+              }
+            }
+          }
+        ]
+      };
     }
-    if (logicalMethod === contract.sessionNotification && update?.sessionUpdate === "model_changed") {
-      const modelId = update.model_id ?? update.modelId;
-      const reasoningEffort = update.reasoning_effort ?? update.reasoningEffort;
+    if (logicalMethod === contract.sessionNotification && update2?.sessionUpdate === "model_changed") {
+      const modelId = update2.model_id ?? update2.modelId;
+      const reasoningEffort = update2.reasoning_effort ?? update2.reasoningEffort;
       if (typeof modelId === "string") {
         this.applyCurrentModel(state, modelId, reasoningEffort);
       }
@@ -720,18 +919,6 @@ class GrokAcpCompatibilityProxy {
     };
   }
   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",
@@ -744,22 +931,8 @@ class GrokAcpCompatibilityProxy {
         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"
-      ),
+      createPlanModeConfigOption(state.interactionMode === "plan"),
       selectOption(
         "permission_mode",
         "Permission Mode",