@posthog/agent 2.1.115 → 2.1.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.115",
+  "version": "2.1.120",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -71,8 +71,8 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@twig/git": "1.0.0",
-    "@posthog/shared": "1.0.0"
+    "@posthog/shared": "1.0.0",
+    "@twig/git": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.14.0",

package/src/adapters/acp-connection.ts

@@ -195,7 +195,7 @@ function createClaudeConnection(config: AcpConnectionConfig): AcpConnection {
 
   let agent: ClaudeAcpAgent | null = null;
   const agentConnection = new AgentSideConnection((client) => {
-    agent = new ClaudeAcpAgent(client, logWriter, config.processCallbacks);
+    agent = new ClaudeAcpAgent(client, config.processCallbacks);
     logger.info(`Created ${agent.adapterName} agent`);
     return agent;
   }, agentStream);

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

@@ -31,8 +31,6 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 import { v7 as uuidv7 } from "uuid";
 import packageJson from "../../../package.json" with { type: "json" };
-import type { SessionContext } from "../../otel-log-writer.js";
-import type { SessionLogWriter } from "../../session-log-writer.js";
 import { unreachable, withTimeout } from "../../utils/common.js";
 import { Logger } from "../../utils/logger.js";
 import { Pushable } from "../../utils/streams.js";
@@ -79,17 +77,11 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   toolUseCache: ToolUseCache;
   backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
   clientCapabilities?: ClientCapabilities;
-  private logWriter?: SessionLogWriter;
   private options?: ClaudeAcpAgentOptions;
   private lastSentConfigOptions?: SessionConfigOption[];
 
-  constructor(
-    client: AgentSideConnection,
-    logWriter?: SessionLogWriter,
-    options?: ClaudeAcpAgentOptions,
-  ) {
+  constructor(client: AgentSideConnection, options?: ClaudeAcpAgentOptions) {
     super(client);
-    this.logWriter = logWriter;
     this.options = options;
     this.toolUseCache = {};
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
@@ -139,7 +131,14 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     this.checkAuthStatus();
 
     const meta = params._meta as NewSessionMeta | undefined;
+    const taskId = meta?.persistence?.taskId;
     const sessionId = uuidv7();
+    this.logger.info("Creating new session", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId,
+      cwd: params.cwd,
+    });
     const permissionMode: TwigExecutionMode =
       meta?.permissionMode &&
       TWIG_EXECUTION_MODES.includes(meta.permissionMode as TwigExecutionMode)
@@ -177,7 +176,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       options.abortController as AbortController,
     );
     session.taskRunId = meta?.taskRunId;
-    this.registerPersistence(sessionId, meta as Record<string, unknown>);
 
     if (meta?.taskRunId) {
       await this.client.extNotification("_posthog/sdk_session", {
@@ -218,6 +216,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     params: LoadSessionRequest,
   ): Promise<LoadSessionResponse> {
     const meta = params._meta as NewSessionMeta | undefined;
+    const taskId = meta?.persistence?.taskId;
     const sessionId = meta?.sessionId;
     if (!sessionId) {
       throw new Error("Cannot resume session without sessionId");
@@ -226,6 +225,13 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       return {};
     }
 
+    this.logger.info("Resuming session", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId,
+      cwd: params.cwd,
+    });
+
     const mcpServers = parseMcpServers(params);
 
     const permissionMode: TwigExecutionMode =
@@ -245,20 +251,42 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
     });
 
-    session.taskRunId = meta?.taskRunId;
+    this.logger.info("Session query initialized, awaiting resumption", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId,
+    });
 
-    this.registerPersistence(sessionId, meta as Record<string, unknown>);
+    session.taskRunId = meta?.taskRunId;
 
-    // Validate the resumed session is alive. For stale sessions this throws
+    // Check the resumed session is alive. For stale sessions this throws
     // (e.g. "No conversation found"), preventing a broken session.
-    const validation = await withTimeout(
-      q.initializationResult(),
-      SESSION_VALIDATION_TIMEOUT_MS,
-    );
-    if (validation.result === "timeout") {
-      throw new Error("Session validation timed out");
+    try {
+      const result = await withTimeout(
+        q.initializationResult(),
+        SESSION_VALIDATION_TIMEOUT_MS,
+      );
+      if (result.result === "timeout") {
+        throw new Error(
+          `Session resumption timed out for sessionId=${sessionId}`,
+        );
+      }
+    } catch (err) {
+      this.logger.error("Session resumption failed", {
+        sessionId,
+        taskId,
+        taskRunId: meta?.taskRunId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+      throw err;
     }
 
+    this.logger.info("Session resumed successfully", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId,
+    });
+
     // Deferred: slash commands + MCP metadata (not needed to return configOptions)
     this.deferBackgroundFetches(q, sessionId);
 
@@ -527,16 +555,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       });
   }
 
-  private registerPersistence(
-    sessionId: string,
-    meta: Record<string, unknown> | undefined,
-  ) {
-    const persistence = meta?.persistence as SessionContext | undefined;
-    if (persistence && this.logWriter) {
-      this.logWriter.register(sessionId, persistence);
-    }
-  }
-
   private sendAvailableCommandsUpdate(
     sessionId: string,
     availableCommands: AvailableCommand[],

package/src/adapters/claude/conversion/acp-to-sdk.ts

@@ -87,6 +87,12 @@ export function promptToClaude(prompt: PromptRequest): SDKUserMessage {
   const content: ContentBlockParam[] = [];
   const context: ContentBlockParam[] = [];
 
+  const prContext = (prompt._meta as Record<string, unknown> | undefined)
+    ?.prContext;
+  if (typeof prContext === "string") {
+    content.push(sdkText(prContext));
+  }
+
   for (const chunk of prompt.prompt) {
     processPromptChunk(chunk, content, context);
   }

package/src/adapters/claude/permissions/permission-handlers.ts

@@ -276,9 +276,15 @@ async function handleAskUserQuestionTool(
   });
 
   if (response.outcome?.outcome !== "selected") {
+    const customMessage = (
+      response._meta as Record<string, unknown> | undefined
+    )?.message;
     return {
       behavior: "deny",
-      message: "User cancelled the questions",
+      message:
+        typeof customMessage === "string"
+          ? customMessage
+          : "User cancelled the questions",
       interrupt: true,
     };
   }

package/src/adapters/claude/types.ts

@@ -56,6 +56,7 @@ export type NewSessionMeta = {
   systemPrompt?: unknown;
   sessionId?: string;
   permissionMode?: string;
+  persistence?: { taskId?: string; runId?: string; logUrl?: string };
   claudeCode?: {
     options?: Options;
   };

package/src/posthog-api.ts

@@ -137,6 +137,21 @@ export class PostHogAPIClient {
     );
   }
 
+  async relayMessage(
+    taskId: string,
+    runId: string,
+    text: string,
+  ): Promise<void> {
+    const teamId = this.getTeamId();
+    await this.apiRequest<{ status: string }>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/relay_message/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ text }),
+      },
+    );
+  }
+
   async uploadTaskArtifacts(
     taskId: string,
     runId: string,

package/src/server/agent-server.test.ts

@@ -3,6 +3,7 @@ import { type SetupServerApi, setupServer } from "msw/node";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { createTestRepo, type TestRepo } from "../test/fixtures/api.js";
 import { createPostHogHandlers } from "../test/mocks/msw-handlers.js";
+import type { TaskRun } from "../types.js";
 import { AgentServer } from "./agent-server.js";
 import { type JwtPayload, SANDBOX_CONNECTION_AUDIENCE } from "./jwt.js";
 
@@ -217,4 +218,112 @@ describe("AgentServer HTTP Mode", () => {
       expect(body.error).toBe("Not found");
     });
   });
+
+  describe("getInitialPromptOverride", () => {
+    it("returns override string from run state", () => {
+      const s = createServer();
+      const run = {
+        state: { initial_prompt_override: "do something else" },
+      } as unknown as TaskRun;
+      const result = (s as any).getInitialPromptOverride(run);
+      expect(result).toBe("do something else");
+    });
+
+    it("returns null when override is absent", () => {
+      const s = createServer();
+      const run = { state: {} } as unknown as TaskRun;
+      const result = (s as any).getInitialPromptOverride(run);
+      expect(result).toBeNull();
+    });
+
+    it("returns null for whitespace-only override", () => {
+      const s = createServer();
+      const run = {
+        state: { initial_prompt_override: "  " },
+      } as unknown as TaskRun;
+      const result = (s as any).getInitialPromptOverride(run);
+      expect(result).toBeNull();
+    });
+
+    it("returns null for non-string override", () => {
+      const s = createServer();
+      const run = {
+        state: { initial_prompt_override: 42 },
+      } as unknown as TaskRun;
+      const result = (s as any).getInitialPromptOverride(run);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("detectedPrUrl tracking", () => {
+    it("stores PR URL when detectAndAttachPrUrl finds a match", () => {
+      const s = createServer();
+      const payload = {
+        task_id: "test-task-id",
+        run_id: "test-run-id",
+      };
+      const update = {
+        _meta: {
+          claudeCode: {
+            toolName: "Bash",
+            toolResponse: {
+              stdout:
+                "https://github.com/PostHog/posthog/pull/42\nCreating pull request...",
+            },
+          },
+        },
+      };
+
+      (s as any).detectAndAttachPrUrl(payload, update);
+      expect((s as any).detectedPrUrl).toBe(
+        "https://github.com/PostHog/posthog/pull/42",
+      );
+    });
+
+    it("does not set detectedPrUrl when no PR URL is found", () => {
+      const s = createServer();
+      const payload = {
+        task_id: "test-task-id",
+        run_id: "test-run-id",
+      };
+      const update = {
+        _meta: {
+          claudeCode: {
+            toolName: "Bash",
+            toolResponse: { stdout: "just some output" },
+          },
+        },
+      };
+
+      (s as any).detectAndAttachPrUrl(payload, update);
+      expect((s as any).detectedPrUrl).toBeNull();
+    });
+  });
+
+  describe("buildCloudSystemPrompt", () => {
+    it("returns PR-aware prompt when prUrl is provided", () => {
+      const s = createServer();
+      const prompt = (s as any).buildCloudSystemPrompt(
+        "https://github.com/org/repo/pull/1",
+      );
+      expect(prompt).toContain("Do NOT create a new branch");
+      expect(prompt).toContain("https://github.com/org/repo/pull/1");
+      expect(prompt).toContain("gh pr checkout");
+      expect(prompt).not.toContain("Create a pull request");
+    });
+
+    it("returns default prompt when no prUrl", () => {
+      const s = createServer();
+      const prompt = (s as any).buildCloudSystemPrompt();
+      expect(prompt).toContain("Create a new branch");
+      expect(prompt).toContain("Create a pull request");
+    });
+
+    it("returns default prompt when prUrl is null", () => {
+      const s = createServer();
+      const prompt = (s as any).buildCloudSystemPrompt(null);
+      expect(prompt).toContain("Create a new branch");
+      expect(prompt).toContain("Create a pull request");
+    });
+  });
 });