fix: use proper ACP setSessionMode, restore multi-provider gateway env (#596)

### TL;DR

Refactored agent connection handling and simplified session management in the Claude agent implementation.

Author: jonathanlab

apps/twig/src/main/services/agent/service.ts

@@ -641,10 +641,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     }
 
     try {
-      await session.clientSideConnection.extMethod("session/setMode", {
-        sessionId,
-        modeId,
-      });
+      await session.clientSideConnection.setSessionMode({ sessionId, modeId });
       log.info("Session mode updated", { sessionId, modeId });
     } catch (err) {
       log.error("Failed to set session mode", { sessionId, modeId, err });

packages/agent/src/adapters/base-acp-agent.ts

@@ -26,8 +26,8 @@ export interface BaseSession {
 
 export abstract class BaseAcpAgent implements Agent {
   abstract readonly adapterName: string;
-  protected session: BaseSession | null = null;
-  protected sessionId: string | null = null;
+  protected session!: BaseSession;
+  protected sessionId!: string;
   client: AgentSideConnection;
   protected logger: Logger;
   protected fileContentCache: { [key: string]: string } = {};
@@ -43,7 +43,7 @@ export abstract class BaseAcpAgent implements Agent {
   protected abstract interruptSession(): Promise<void>;
 
   async cancel(params: CancelNotification): Promise<void> {
-    if (this.sessionId !== params.sessionId || !this.session) {
+    if (this.sessionId !== params.sessionId) {
       throw new Error("Session not found");
     }
     this.session.cancelled = true;
@@ -55,9 +55,6 @@ export abstract class BaseAcpAgent implements Agent {
   }
 
   async closeSession(): Promise<void> {
-    if (!this.session || !this.sessionId) {
-      return;
-    }
     try {
       await this.cancel({ sessionId: this.sessionId });
       this.session.abortController.abort();
@@ -68,19 +65,17 @@ export abstract class BaseAcpAgent implements Agent {
         error: err,
       });
     }
-    this.session = null;
-    this.sessionId = null;
   }
 
   hasSession(sessionId: string): boolean {
-    return this.sessionId === sessionId && this.session !== null;
+    return this.sessionId === sessionId;
   }
 
   appendNotification(
     sessionId: string,
     notification: SessionNotification,
   ): void {
-    if (this.sessionId === sessionId && this.session) {
+    if (this.sessionId === sessionId) {
       this.session.notificationHistory.push(notification);
     }
   }

packages/agent/src/adapters/claude/claude-agent.ts

@@ -146,7 +146,7 @@ async function getAvailableSlashCommands(
 
 export class ClaudeAcpAgent extends BaseAcpAgent {
   readonly adapterName = "claude";
-  declare session: Session | null;
+  declare session: Session;
   toolUseCache: ToolUseCache;
   backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
   clientCapabilities?: ClientCapabilities;
@@ -239,13 +239,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     }, 0);
   }
 
-  private getSession(): Session {
-    if (!this.session) {
-      throw new Error("Session not found");
-    }
-    return this.session;
-  }
-
   private registerPersistence(
     sessionId: string,
     meta: Record<string, unknown> | undefined,
@@ -420,11 +413,10 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
   }
 
   async prompt(params: PromptRequest): Promise<PromptResponse> {
-    const session = this.getSession();
-    session.cancelled = false;
-    session.interruptReason = undefined;
+    this.session.cancelled = false;
+    this.session.interruptReason = undefined;
 
-    const { query: q, input } = session;
+    const { query: q, input } = this.session;
 
     for (const chunk of params.prompt) {
       const userNotification = {
@@ -441,7 +433,7 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
     input.push(promptToClaude({ ...params, prompt: params.prompt }));
 
     const context = {
-      session,
+      session: this.session,
       sessionId: params.sessionId,
       client: this.client,
       toolUseCache: this.toolUseCache,
@@ -452,11 +444,11 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
     while (true) {
       const { value: message, done } = await q.next();
       if (done || !message) {
-        if (session.cancelled) {
+        if (this.session.cancelled) {
           return {
             stopReason: "cancelled",
-            _meta: session.interruptReason
-              ? { interruptReason: session.interruptReason }
+            _meta: this.session.interruptReason
+              ? { interruptReason: this.session.interruptReason }
               : undefined,
           };
         }
@@ -506,30 +498,24 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
   }
 
   protected async interruptSession(): Promise<void> {
-    if (!this.session) {
-      return;
-    }
     await this.session.query.interrupt();
   }
 
   async setSessionModel(params: SetSessionModelRequest) {
-    const session = this.getSession();
-    await session.query.setModel(params.modelId);
+    await this.session.query.setModel(params.modelId);
   }
 
   async setSessionMode(
     params: SetSessionModeRequest,
   ): Promise<SetSessionModeResponse> {
-    const session = this.getSession();
-
     switch (params.modeId) {
       case "default":
       case "acceptEdits":
       case "bypassPermissions":
       case "plan":
-        session.permissionMode = params.modeId;
+        this.session.permissionMode = params.modeId;
         try {
-          await session.query.setPermissionMode(params.modeId);
+          await this.session.query.setPermissionMode(params.modeId);
         } catch (error) {
           const errorMessage =
             error instanceof Error && error.message
@@ -549,17 +535,16 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
 
   canUseTool(sessionId: string): CanUseTool {
     return async (toolName, toolInput, { suggestions, toolUseID }) => {
-      if (this.sessionId !== sessionId || !this.session) {
+      if (this.sessionId !== sessionId) {
         return {
           behavior: "deny",
           message: "Session not found",
           interrupt: true,
         };
       }
-      const session = this.session;
 
       const context = {
-        session,
+        session: this.session,
         toolName,
         toolInput: toolInput as Record<string, unknown>,
         toolUseID,
@@ -592,15 +577,6 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
       return {};
     }
 
-    if (method === "session/setMode") {
-      const { sessionId, modeId } = params as {
-        sessionId: string;
-        modeId: string;
-      };
-      await this.setSessionMode({ sessionId, modeId });
-      return {};
-    }
-
     throw RequestError.methodNotFound(method);
   }
 
@@ -610,7 +586,7 @@ Before pushing a "workspace-*" branch to origin, rename it to something descript
     this.logger.info("[RESUME] Resuming session", { params });
     const { sessionId } = params;
 
-    if (this.sessionId === sessionId && this.session) {
+    if (this.sessionId === sessionId) {
       return {};
     }
 

packages/agent/src/agent.ts

@@ -42,6 +42,10 @@ export class Agent {
       const apiKey = this.posthogAPI.getApiKey();
       process.env.ANTHROPIC_BASE_URL = gatewayUrl;
       process.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+      process.env.OPENAI_BASE_URL = gatewayUrl;
+      process.env.OPENAI_API_KEY = apiKey;
+      process.env.GEMINI_BASE_URL = gatewayUrl;
+      process.env.GEMINI_API_KEY = apiKey;
     } catch (error) {
       this.logger.error("Failed to configure LLM gateway", error);
       throw error;