@posthog/agent 2.1.114 → 2.1.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.114",
+  "version": "2.1.118",
   "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/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/server/agent-server.ts

@@ -651,7 +651,10 @@ Important:
 
   private configureEnvironment(): void {
     const { apiKey, apiUrl, projectId } = this.config;
-    const gatewayUrl = process.env.LLM_GATEWAY_URL || getLlmGatewayUrl(apiUrl);
+    const product =
+      this.config.mode === "background" ? "background_agents" : "twig";
+    const gatewayUrl =
+      process.env.LLM_GATEWAY_URL || getLlmGatewayUrl(apiUrl, product);
     const openaiBaseUrl = gatewayUrl.endsWith("/v1")
       ? gatewayUrl
       : `${gatewayUrl}/v1`;

package/src/session-log-writer.ts

@@ -50,11 +50,15 @@ export class SessionLogWriter {
 
   async flushAll(): Promise<void> {
     const sessionIds = [...this.sessions.keys()];
-    const pendingCounts = sessionIds.map((id) => ({
-      id,
-      pending: this.pendingEntries.get(id)?.length ?? 0,
-      messages: this.messageCounts.get(id) ?? 0,
-    }));
+    const pendingCounts = sessionIds.map((id) => {
+      const session = this.sessions.get(id);
+      return {
+        taskId: session?.context.taskId,
+        runId: session?.context.runId,
+        pending: this.pendingEntries.get(id)?.length ?? 0,
+        messages: this.messageCounts.get(id) ?? 0,
+      };
+    });
     this.logger.info("flushAll called", {
       sessions: sessionIds.length,
       pending: pendingCounts,
@@ -73,8 +77,8 @@ export class SessionLogWriter {
     }
 
     this.logger.info("Session registered", {
-      sessionId,
       taskId: context.taskId,
+      runId: context.runId,
     });
     this.sessions.set(sessionId, { context });
 
@@ -113,7 +117,11 @@ export class SessionLogWriter {
     const count = (this.messageCounts.get(sessionId) ?? 0) + 1;
     this.messageCounts.set(sessionId, count);
     if (count % 10 === 1) {
-      this.logger.info("Messages received", { count, sessionId });
+      this.logger.info("Messages received", {
+        count,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
+      });
     }
 
     try {
@@ -153,7 +161,8 @@ export class SessionLogWriter {
       }
     } catch {
       this.logger.warn("Failed to parse raw line for persistence", {
-        sessionId,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
         lineLength: line.length,
       });
     }
@@ -172,7 +181,8 @@ export class SessionLogWriter {
     const pending = this.pendingEntries.get(sessionId);
     if (!this.posthogAPI || !pending?.length) {
       this.logger.info("flush: nothing to persist", {
-        sessionId,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
         hasPosthogAPI: !!this.posthogAPI,
         pendingCount: pending?.length ?? 0,
       });
@@ -196,7 +206,8 @@ export class SessionLogWriter {
       );
       this.retryCounts.set(sessionId, 0);
       this.logger.info("Flushed session logs", {
-        sessionId,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
         entryCount: pending.length,
       });
     } catch (error) {
@@ -206,7 +217,11 @@ export class SessionLogWriter {
       if (retryCount >= SessionLogWriter.MAX_FLUSH_RETRIES) {
         this.logger.error(
           `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
-          { sessionId, error },
+          {
+            taskId: session.context.taskId,
+            runId: session.context.runId,
+            error,
+          },
         );
         this.retryCounts.set(sessionId, 0);
       } else {
@@ -316,7 +331,12 @@ export class SessionLogWriter {
     try {
       fs.appendFileSync(logPath, `${JSON.stringify(entry)}\n`);
     } catch (error) {
-      this.logger.warn("Failed to write to local cache", { logPath, error });
+      this.logger.warn("Failed to write to local cache", {
+        taskId: session.context.taskId,
+        runId: session.context.runId,
+        logPath,
+        error,
+      });
     }
   }
 }

package/src/utils/gateway.ts

@@ -1,18 +1,23 @@
-export function getLlmGatewayUrl(posthogHost: string): string {
+export type GatewayProduct = "twig" | "background_agents";
+
+export function getLlmGatewayUrl(
+  posthogHost: string,
+  product: GatewayProduct = "twig",
+): string {
   const url = new URL(posthogHost);
   const hostname = url.hostname;
 
   // Local development (normalize 127.0.0.1 to localhost)
   if (hostname === "localhost" || hostname === "127.0.0.1") {
-    return `${url.protocol}//localhost:3308/twig`;
+    return `${url.protocol}//localhost:3308/${product}`;
   }
 
   // Docker containers accessing host
   if (hostname === "host.docker.internal") {
-    return `${url.protocol}//host.docker.internal:3308/twig`;
+    return `${url.protocol}//host.docker.internal:3308/${product}`;
   }
 
   // Production - extract region from hostname, default to US
   const region = hostname.match(/^(us|eu)\.posthog\.com$/)?.[1] ?? "us";
-  return `https://gateway.${region}.posthog.com/twig`;
+  return `https://gateway.${region}.posthog.com/${product}`;
 }