@openacp/cli 2026.403.6 → 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;
@@ -2008,6 +2017,7 @@ declare class SessionFactory {
     private lazyResume;
     handleNewSession(channelId: string, agentName?: string, workspacePath?: string, options?: {
         createThread?: boolean;
+        threadId?: string;
     }): Promise<Session>;
     /** NOTE: handleNewChat is currently dead code — never called outside core.ts itself.
      *  Moving it anyway for completeness; can be removed in a future cleanup. */
@@ -2019,6 +2029,7 @@ declare class SessionFactory {
         contextQuery: ContextQuery;
         contextOptions?: ContextOptions;
         createThread?: boolean;
+        threadId?: string;
     }): Promise<{
         session: Session;
         contextResult: ContextResult | null;
@@ -2154,6 +2165,7 @@ interface AssistantManagerCore {
         workingDirectory: string;
         initialName?: string;
         isAssistant?: boolean;
+        threadId?: string;
     }): Promise<Session>;
     connectSessionBridge(session: Session): void;
     configManager: {
@@ -2258,6 +2270,7 @@ declare class OpenACPCore {
     }): Promise<Session>;
     handleNewSession(channelId: string, agentName?: string, workspacePath?: string, options?: {
         createThread?: boolean;
+        threadId?: string;
     }): Promise<Session>;
     adoptSession(agentName: string, agentSessionId: string, cwd: string, channelId?: string): Promise<{
         ok: true;
@@ -2277,6 +2290,7 @@ declare class OpenACPCore {
         contextQuery: ContextQuery;
         contextOptions?: ContextOptions;
         createThread?: boolean;
+        threadId?: string;
     }): Promise<{
         session: Session;
         contextResult: ContextResult | null;

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"];
   }
 });
 
@@ -6311,9 +6311,7 @@ async function createSessionDirect(ctx, core, chatId, agentName, workspace, onCo
       message_thread_id: threadId,
       parse_mode: "HTML"
     });
-    const session = await core.handleNewSession("telegram", agentName, workspace);
-    session.threadId = String(threadId);
-    await core.sessionManager.patchRecord(session.id, { platform: { topicId: threadId } });
+    const session = await core.handleNewSession("telegram", agentName, workspace, { threadId: String(threadId) });
     const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
     try {
       await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
@@ -11213,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;
@@ -11230,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
@@ -11478,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,8 +11847,10 @@ var Session = class extends TypedEmitter {
     this.queue = new PromptQueue(
       (text3, attachments) => this.processPrompt(text3, attachments),
       (err) => {
-        this.fail("Prompt execution failed");
         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}` });
       }
     );
     this.agentInstance.on("agent_event", (event) => {
@@ -12055,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);
   }
@@ -12074,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) {
@@ -12139,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() {
@@ -12815,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;
@@ -13185,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,
@@ -13348,7 +13433,8 @@ var SessionFactory = class {
       channelId: params.channelId,
       agentName: params.agentName,
       workingDirectory: params.workingDirectory,
-      createThread: params.createThread
+      createThread: params.createThread,
+      threadId: params.threadId
     });
     if (contextResult) {
       session.setContext(contextResult.markdown);
@@ -14911,9 +14997,9 @@ var AssistantManager = class {
       agentName: this.core.configManager.get().defaultAgent,
       workingDirectory: this.core.configManager.resolveWorkspace(),
       initialName: "Assistant",
-      isAssistant: true
+      isAssistant: true,
+      threadId
     });
-    session.threadId = threadId;
     this.sessions.set(channelId, session);
     const systemPrompt = this.registry.buildSystemPrompt(channelId);
     this.pendingSystemPrompts.set(channelId, systemPrompt);