@posthog/agent 2.3.293 → 2.3.298

package/dist/server/bin.cjs

@@ -5805,7 +5805,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.293",
+  version: "2.3.298",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -5974,9 +5974,24 @@ var POSTHOG_NOTIFICATIONS = {
   /** Response to a relayed permission request (plan approval, question) */
   PERMISSION_RESPONSE: "_posthog/permission_response"
 };
-function isNotification(method, notification) {
+var POSTHOG_METHODS = {
+  /**
+   * Client requests a session refresh between turns. Payload may include
+   * `mcpServers` to trigger a resume-with-new-options reinit; future fields
+   * can extend this without adding new methods. Returns once the refresh has
+   * completed so the caller can safely send the next prompt.
+   */
+  REFRESH_SESSION: "_posthog/refresh_session"
+};
+function matchesExt(method, expected) {
   if (!method) return false;
-  return method === notification || method === `_${notification}`;
+  return method === expected || method === `_${expected}`;
+}
+function isNotification(method, expected) {
+  return matchesExt(method, expected);
+}
+function isMethod(method, expected) {
+  return matchesExt(method, expected);
 }
 
 // src/adapters/acp-connection.ts
@@ -9372,6 +9387,93 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     this.session.pendingMessages.clear();
     await this.session.query.interrupt();
   }
+  /**
+   * Refresh the session between turns. Currently the only refreshable field
+   * is `mcpServers` — a resume-with-new-options reinit that bakes the servers
+   * into query() options (preserving conversation history via resume).
+   *
+   * This is an `extMethod` (request/response), not `extNotification`, so the
+   * caller can await completion before sending the next prompt. The sandbox
+   * agent-server uses this on pre-prompt TTL checks.
+   *
+   * Why resume+rebuild instead of query.setMcpServers()?
+   * setMcpServers() does NOT always overwrite servers installed by local/plugin
+   * config — it can non-deterministically surface either the config-provided
+   * server or the plugin-installed one. In the sandbox, repos may have Claude
+   * plugins with their own MCPs, and we want the CLI-supplied set to fully win.
+   * Passing mcpServers via query() options (as a "managed"/static set) has that
+   * overwrite guarantee, so we tear down the current Query and construct a new
+   * one with resume.
+   *
+   * Caller contract: only call REFRESH_SESSION between turns (no prompt in flight).
+   */
+  async extMethod(method, params) {
+    if (!isMethod(method, POSTHOG_METHODS.REFRESH_SESSION)) {
+      throw import_sdk2.RequestError.methodNotFound(method);
+    }
+    if (params.mcpServers === void 0) {
+      throw new import_sdk2.RequestError(
+        -32602,
+        "refresh_session requires at least one refreshable field (e.g. mcpServers)"
+      );
+    }
+    if (!Array.isArray(params.mcpServers)) {
+      throw new import_sdk2.RequestError(
+        -32602,
+        "refresh_session: mcpServers must be an array"
+      );
+    }
+    const mcpServers = parseMcpServers(
+      params
+    );
+    await this.refreshSession(mcpServers);
+    return { refreshed: true };
+  }
+  async refreshSession(mcpServers) {
+    const prev = this.session;
+    if (prev.promptRunning) {
+      throw new import_sdk2.RequestError(
+        -32002,
+        "Cannot refresh session while a prompt turn is in flight"
+      );
+    }
+    if (prev.modelId && !supportsMcpInjection(prev.modelId)) {
+      throw new import_sdk2.RequestError(
+        -32002,
+        `Model ${prev.modelId} does not support MCP injection; cannot refresh`
+      );
+    }
+    this.logger.info("Refreshing session with fresh MCP servers", {
+      serverCount: Object.keys(mcpServers).length,
+      sessionId: this.sessionId
+    });
+    prev.abortController.abort();
+    await prev.query.interrupt();
+    prev.input.end();
+    const newAbortController = new AbortController();
+    const { sessionId: _drop, ...rest } = prev.queryOptions;
+    const newOptions = {
+      ...rest,
+      mcpServers,
+      resume: this.sessionId,
+      forkSession: false,
+      abortController: newAbortController
+    };
+    const newInput = new Pushable();
+    const newQuery = (0, import_claude_agent_sdk.query)({ prompt: newInput, options: newOptions });
+    prev.query = newQuery;
+    prev.input = newInput;
+    prev.queryOptions = newOptions;
+    prev.abortController = newAbortController;
+    const result = await withTimeout(
+      newQuery.initializationResult(),
+      SESSION_VALIDATION_TIMEOUT_MS
+    );
+    if (result.result === "timeout") {
+      throw new Error(`Session refresh timed out for ${this.sessionId}`);
+    }
+    this.deferBackgroundFetches(newQuery);
+  }
   async unstable_setSessionModel(params) {
     await this.session.query.setModel(toSdkModelId(params.modelId));
     this.session.modelId = params.modelId;
@@ -12865,6 +12967,7 @@ var AgentServer = class _AgentServer {
       await this.initializationPromise;
       if (this.session && sseController) {
         this.session.sseController = sseController;
+        this.session.hasDesktopConnected = true;
         this.replayPendingEvents();
       }
       return;
@@ -13555,11 +13658,12 @@ ${attributionInstructions}
         {
           const isQuestion = codeToolKind === "question";
           const sessionPermissionMode = this.getSessionPermissionMode();
-          const needsRelay = isQuestion || isPlanApproval || this.shouldRelayPermissionToClient(sessionPermissionMode);
-          if (needsRelay && this.session?.hasDesktopConnected) {
-            this.logger.info("Relaying permission to connected client", {
+          const needsDesktopApproval = isQuestion || this.shouldRelayPermissionToClient(sessionPermissionMode);
+          if (isPlanApproval || needsDesktopApproval && this.session?.hasDesktopConnected) {
+            this.logger.info("Relaying permission request", {
               kind: params.toolCall?.kind,
               isQuestion,
+              hasDesktopConnected: this.session?.hasDesktopConnected ?? false,
               sessionPermissionMode
             });
             return this.relayPermissionToClient(params);