@posthog/agent 2.3.297 → 2.3.298

package/dist/agent.js

@@ -245,7 +245,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.297",
+  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: {
@@ -414,6 +414,22 @@ var POSTHOG_NOTIFICATIONS = {
   /** Response to a relayed permission request (plan approval, question) */
   PERMISSION_RESPONSE: "_posthog/permission_response"
 };
+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 === expected || method === `_${expected}`;
+}
+function isMethod(method, expected) {
+  return matchesExt(method, expected);
+}
 
 // src/utils/common.ts
 async function withTimeout(operation, timeoutMs) {
@@ -3704,6 +3720,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 RequestError2.methodNotFound(method);
+    }
+    if (params.mcpServers === void 0) {
+      throw new RequestError2(
+        -32602,
+        "refresh_session requires at least one refreshable field (e.g. mcpServers)"
+      );
+    }
+    if (!Array.isArray(params.mcpServers)) {
+      throw new RequestError2(
+        -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 RequestError2(
+        -32002,
+        "Cannot refresh session while a prompt turn is in flight"
+      );
+    }
+    if (prev.modelId && !supportsMcpInjection(prev.modelId)) {
+      throw new RequestError2(
+        -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 = 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;