@openacp/cli 2026.403.7 → 2026.403.8

package/dist/index.d.ts

@@ -1486,6 +1486,15 @@ declare class Session extends TypedEmitter<SessionEvents> {
     private autoName;
     setInitialConfigOptions(options: ConfigOption[]): void;
     setAgentCapabilities(caps: AgentCapabilities | undefined): void;
+    /**
+     * Hydrate configOptions and agentCapabilities from a spawn response.
+     * Handles both the native configOptions format and legacy modes/models fields.
+     */
+    applySpawnResponse(resp: {
+        modes?: unknown;
+        configOptions?: unknown;
+        models?: unknown;
+    } | undefined, caps: AgentCapabilities | undefined): void;
     getConfigOption(id: string): ConfigOption | undefined;
     getConfigByCategory(category: string): ConfigOption | undefined;
     getConfigValue(id: string): string | undefined;

package/dist/index.js

@@ -1078,7 +1078,7 @@ var BYPASS_KEYWORDS;
 var init_bypass_detection = __esm({
   "src/core/utils/bypass-detection.ts"() {
     "use strict";
-    BYPASS_KEYWORDS = ["bypass", "dangerous", "auto_accept"];
+    BYPASS_KEYWORDS = ["bypass", "dangerous", "auto_accept", "yolo"];
   }
 });
 
@@ -11211,12 +11211,18 @@ ${stderr}`
       cwd: workingDirectory,
       mcpServers: resolvedMcp
     });
+    log4.info(response, "newSession response");
     instance.sessionId = response.sessionId;
     instance.initialSessionResponse = response;
     instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
     instance.setupCrashDetection();
     log4.info(
-      { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
+      {
+        sessionId: response.sessionId,
+        durationMs: Date.now() - spawnStart,
+        configOptions: response.configOptions ?? [],
+        agentCapabilities: instance.agentCapabilities ?? null
+      },
       "Agent spawn complete"
     );
     return instance;
@@ -11228,24 +11234,47 @@ ${stderr}`
       agentDef,
       workingDirectory
     );
+    const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
     try {
-      const response = await instance.connection.unstable_resumeSession({
-        sessionId: agentSessionId,
-        cwd: workingDirectory
-      });
-      instance.sessionId = response.sessionId;
-      instance.initialSessionResponse = response;
-      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
-      log4.info(
-        { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
-        "Agent resume complete"
-      );
+      if (instance.agentCapabilities?.loadSession) {
+        const response = await instance.connection.loadSession({
+          sessionId: agentSessionId,
+          cwd: workingDirectory,
+          mcpServers: resolvedMcp
+        });
+        instance.sessionId = agentSessionId;
+        instance.initialSessionResponse = response;
+        instance.debugTracer = createDebugTracer(agentSessionId, workingDirectory);
+        log4.info(
+          {
+            sessionId: agentSessionId,
+            durationMs: Date.now() - spawnStart,
+            agentCapabilities: instance.agentCapabilities ?? null
+          },
+          "Agent load complete"
+        );
+      } else {
+        const response = await instance.connection.unstable_resumeSession({
+          sessionId: agentSessionId,
+          cwd: workingDirectory
+        });
+        instance.sessionId = response.sessionId;
+        instance.initialSessionResponse = response;
+        instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
+        log4.info(
+          {
+            sessionId: response.sessionId,
+            durationMs: Date.now() - spawnStart,
+            agentCapabilities: instance.agentCapabilities ?? null
+          },
+          "Agent resume complete"
+        );
+      }
     } catch (err) {
       log4.warn(
         { err, agentSessionId },
         "Resume failed, falling back to new session"
       );
-      const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
       const response = await instance.connection.newSession({
         cwd: workingDirectory,
         mcpServers: resolvedMcp
@@ -11476,11 +11505,31 @@ ${stderr}`
   }
   // ── New ACP methods ──────────────────────────────────────────────────
   async setConfigOption(configId, value) {
-    return await this.connection.setSessionConfigOption({
-      sessionId: this.sessionId,
-      configId,
-      ...value
-    });
+    try {
+      return await this.connection.setSessionConfigOption({
+        sessionId: this.sessionId,
+        configId,
+        ...value
+      });
+    } catch (err) {
+      if (typeof err === "object" && err !== null && err.code === -32601) {
+        if (configId === "mode" && value.type === "select") {
+          await this.connection.setSessionMode({
+            sessionId: this.sessionId,
+            modeId: value.value
+          });
+          return { configOptions: [] };
+        }
+        if (configId === "model" && value.type === "select") {
+          await this.connection.unstable_setSessionModel({
+            sessionId: this.sessionId,
+            modelId: value.value
+          });
+          return { configOptions: [] };
+        }
+      }
+      throw err;
+    }
   }
   async listSessions(cwd, cursor) {
     return await this.connection.listSessions({
@@ -11800,6 +11849,7 @@ var Session = class extends TypedEmitter {
       (err) => {
         this.log.error({ err }, "Prompt execution failed");
         const message = err instanceof Error ? err.message : String(err);
+        this.fail(message);
         this.emit("agent_event", { type: "error", message: `Prompt execution failed: ${message}` });
       }
     );
@@ -12054,6 +12104,42 @@ ${result.text}` : result.text;
   setAgentCapabilities(caps) {
     this.agentCapabilities = caps;
   }
+  /**
+   * Hydrate configOptions and agentCapabilities from a spawn response.
+   * Handles both the native configOptions format and legacy modes/models fields.
+   */
+  applySpawnResponse(resp, caps) {
+    if (caps) this.agentCapabilities = caps;
+    if (!resp) return;
+    if (resp.configOptions) {
+      this.configOptions = resp.configOptions;
+      return;
+    }
+    const legacyOptions = [];
+    if (resp.modes) {
+      const m = resp.modes;
+      legacyOptions.push({
+        id: "mode",
+        name: "Mode",
+        category: "mode",
+        type: "select",
+        currentValue: m.currentModeId,
+        options: m.availableModes.map((x) => ({ value: x.id, name: x.name, description: x.description }))
+      });
+    }
+    if (resp.models) {
+      const m = resp.models;
+      legacyOptions.push({
+        id: "model",
+        name: "Model",
+        category: "model",
+        type: "select",
+        currentValue: m.currentModelId,
+        options: m.availableModels.map((x) => ({ value: x.modelId ?? x.id, name: x.name, description: x.description }))
+      });
+    }
+    if (legacyOptions.length > 0) this.configOptions = legacyOptions;
+  }
   getConfigOption(id) {
     return this.configOptions.find((o) => o.id === id);
   }
@@ -12073,8 +12159,13 @@ ${result.text}` : result.text;
   /** Send a config option change to the agent and update local state from the response. */
   async setConfigOption(configId, value) {
     const response = await this.agentInstance.setConfigOption(configId, value);
-    if (response.configOptions) {
+    if (response.configOptions && response.configOptions.length > 0) {
       await this.updateConfigOptions(response.configOptions);
+    } else if (value.type === "select") {
+      const updated = this.configOptions.map(
+        (o) => o.id === configId && o.type === "select" ? { ...o, currentValue: value.value } : o
+      );
+      await this.updateConfigOptions(updated);
     }
   }
   async updateConfigOptions(options) {
@@ -12138,6 +12229,8 @@ ${result.text}` : result.text;
     this.promptCount = 0;
     this.agentCapabilities = void 0;
     this.configOptions = [];
+    this.latestCommands = null;
+    this.applySpawnResponse(newAgent.initialSessionResponse, newAgent.agentCapabilities);
     this.log.info({ from: this.agentSwitchHistory.at(-1).agentName, to: agentName }, "Agent switched");
   }
   async destroy() {
@@ -12814,6 +12907,9 @@ var SessionBridge = class {
     if (this.session.latestCommands !== null) {
       this.session.emit("agent_event", { type: "commands_update", commands: this.session.latestCommands });
     }
+    if (this.session.configOptions.length > 0) {
+      this.session.emit("agent_event", { type: "config_option_update", options: this.session.configOptions });
+    }
   }
   disconnect() {
     if (!this.connected) return;
@@ -13184,17 +13280,7 @@ var SessionFactory = class {
     if (createParams.initialName) {
       session.name = createParams.initialName;
     }
-    const resp = agentInstance.initialSessionResponse;
-    if (resp) {
-      if (resp.configOptions) {
-        session.setInitialConfigOptions(resp.configOptions);
-      }
-      if (agentInstance.agentCapabilities) {
-        session.setAgentCapabilities(agentInstance.agentCapabilities);
-      }
-    } else if (agentInstance.agentCapabilities) {
-      session.setAgentCapabilities(agentInstance.agentCapabilities);
-    }
+    session.applySpawnResponse(agentInstance.initialSessionResponse, agentInstance.agentCapabilities);
     this.sessionManager.registerSession(session);
     this.eventBus.emit("session:created", {
       sessionId: session.id,