@posthog/agent 2.1.35 → 2.1.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.35",
+  "version": "2.1.47",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {

package/src/adapters/acp-connection.ts

@@ -23,6 +23,8 @@ export type AcpConnectionConfig = {
   /** Deployment environment - "local" for desktop, "cloud" for cloud sandbox */
   deviceType?: "local" | "cloud";
   logger?: Logger;
+  /** Enable dev-only instrumentation (timing, verbose logging) */
+  debug?: boolean;
   processCallbacks?: ProcessSpawnedCallback;
   codexOptions?: CodexProcessOptions;
   allowedModelIds?: Set<string>;
@@ -194,7 +196,10 @@ 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, logWriter, {
+      ...config.processCallbacks,
+      debug: config.debug,
+    });
     logger.info(`Created ${agent.adapterName} agent`);
     return agent;
   }, agentStream);

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

@@ -29,6 +29,7 @@ import {
   type SDKMessage,
   type SDKUserMessage,
 } from "@anthropic-ai/claude-agent-sdk";
+import { createTimingCollector } from "@posthog/shared";
 import { v7 as uuidv7 } from "uuid";
 import packageJson from "../../../package.json" with { type: "json" };
 import type { SessionContext } from "../../otel-log-writer.js";
@@ -69,6 +70,8 @@ import type {
 export interface ClaudeAcpAgentOptions {
   onProcessSpawned?: (info: ProcessSpawnedInfo) => void;
   onProcessExited?: (pid: number) => void;
+  /** Enable dev-only instrumentation (timing, verbose logging) */
+  debug?: boolean;
 }
 
 export class ClaudeAcpAgent extends BaseAcpAgent {
@@ -78,17 +81,19 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
   clientCapabilities?: ClientCapabilities;
   private logWriter?: SessionLogWriter;
-  private processCallbacks?: ClaudeAcpAgentOptions;
+  private options?: ClaudeAcpAgentOptions;
   private lastSentConfigOptions?: SessionConfigOption[];
+  private debug: boolean;
 
   constructor(
     client: AgentSideConnection,
     logWriter?: SessionLogWriter,
-    processCallbacks?: ClaudeAcpAgentOptions,
+    options?: ClaudeAcpAgentOptions,
   ) {
     super(client);
     this.logWriter = logWriter;
-    this.processCallbacks = processCallbacks;
+    this.options = options;
+    this.debug = options?.debug ?? false;
     this.toolUseCache = {};
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
   }
@@ -136,6 +141,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
     this.checkAuthStatus();
 
+    const tc = createTimingCollector(this.debug, (msg, data) =>
+      this.logger.info(msg, data),
+    );
+
     const meta = params._meta as NewSessionMeta | undefined;
     const sessionId = uuidv7();
     const permissionMode: TwigExecutionMode =
@@ -144,26 +153,29 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         ? (meta.permissionMode as TwigExecutionMode)
         : "default";
 
-    const mcpServers = parseMcpServers(params);
-    await fetchMcpToolMetadata(mcpServers, this.logger);
+    const mcpServers = tc.timeSync("parseMcpServers", () =>
+      parseMcpServers(params),
+    );
 
-    const options = buildSessionOptions({
-      cwd: params.cwd,
-      mcpServers,
-      permissionMode,
-      canUseTool: this.createCanUseTool(sessionId),
-      logger: this.logger,
-      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
-      userProvidedOptions: meta?.claudeCode?.options,
-      sessionId,
-      isResume: false,
-      onModeChange: this.createOnModeChange(sessionId),
-      onProcessSpawned: this.processCallbacks?.onProcessSpawned,
-      onProcessExited: this.processCallbacks?.onProcessExited,
-    });
+    const options = tc.timeSync("buildSessionOptions", () =>
+      buildSessionOptions({
+        cwd: params.cwd,
+        mcpServers,
+        permissionMode,
+        canUseTool: this.createCanUseTool(sessionId),
+        logger: this.logger,
+        systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+        userProvidedOptions: meta?.claudeCode?.options,
+        sessionId,
+        isResume: false,
+        onModeChange: this.createOnModeChange(sessionId),
+        onProcessSpawned: this.options?.onProcessSpawned,
+        onProcessExited: this.options?.onProcessExited,
+      }),
+    );
 
     const input = new Pushable<SDKUserMessage>();
-    const q = query({ prompt: input, options });
+    const q = tc.timeSync("sdkQuery", () => query({ prompt: input, options }));
 
     const session = this.createSession(
       sessionId,
@@ -177,25 +189,36 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     this.registerPersistence(sessionId, meta as Record<string, unknown>);
 
     if (meta?.taskRunId) {
-      await this.client.extNotification("_posthog/sdk_session", {
-        taskRunId: meta.taskRunId,
-        sessionId,
-        adapter: "claude",
-      });
+      await tc.time("extNotification", () =>
+        this.client.extNotification("_posthog/sdk_session", {
+          taskRunId: meta.taskRunId!,
+          sessionId,
+          adapter: "claude",
+        }),
+      );
     }
 
-    const modelOptions = await this.getModelConfigOptions();
+    // Only await model config — slash commands and MCP metadata are deferred
+    // since they're not needed to return configOptions to the client.
+    const modelOptions = await tc.time("fetchModels", () =>
+      this.getModelConfigOptions(),
+    );
+
+    // Deferred: slash commands + MCP metadata (not needed to return configOptions)
+    this.deferBackgroundFetches(tc, q, sessionId, mcpServers);
+
     session.modelId = modelOptions.currentModelId;
     await this.trySetModel(q, modelOptions.currentModelId);
 
-    this.sendAvailableCommandsUpdate(
-      sessionId,
-      await getAvailableSlashCommands(q),
+    const configOptions = await tc.time("buildConfigOptions", () =>
+      this.buildConfigOptions(modelOptions),
     );
 
+    tc.summarize("newSession");
+
     return {
       sessionId,
-      configOptions: await this.buildConfigOptions(modelOptions),
+      configOptions,
     };
   }
 
@@ -206,6 +229,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   async resumeSession(
     params: LoadSessionRequest,
   ): Promise<LoadSessionResponse> {
+    const tc = createTimingCollector(this.debug, (msg, data) =>
+      this.logger.info(msg, data),
+    );
+
     const meta = params._meta as NewSessionMeta | undefined;
     const sessionId = meta?.sessionId;
     if (!sessionId) {
@@ -215,8 +242,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       return {};
     }
 
-    const mcpServers = parseMcpServers(params);
-    await fetchMcpToolMetadata(mcpServers, this.logger);
+    const mcpServers = tc.timeSync("parseMcpServers", () =>
+      parseMcpServers(params),
+    );
 
     const permissionMode: TwigExecutionMode =
       meta?.permissionMode &&
@@ -224,28 +252,33 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         ? (meta.permissionMode as TwigExecutionMode)
         : "default";
 
-    const { query: q, session } = await this.initializeQuery({
-      cwd: params.cwd,
-      permissionMode,
-      mcpServers,
-      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
-      userProvidedOptions: meta?.claudeCode?.options,
-      sessionId,
-      isResume: true,
-      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
-    });
+    const { query: q, session } = await tc.time("initializeQuery", () =>
+      this.initializeQuery({
+        cwd: params.cwd,
+        permissionMode,
+        mcpServers,
+        systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+        userProvidedOptions: meta?.claudeCode?.options,
+        sessionId,
+        isResume: true,
+        additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
+      }),
+    );
 
     session.taskRunId = meta?.taskRunId;
 
     this.registerPersistence(sessionId, meta as Record<string, unknown>);
-    this.sendAvailableCommandsUpdate(
-      sessionId,
-      await getAvailableSlashCommands(q),
+
+    // Deferred: slash commands + MCP metadata (not needed to return configOptions)
+    this.deferBackgroundFetches(tc, q, sessionId, mcpServers);
+
+    const configOptions = await tc.time("buildConfigOptions", () =>
+      this.buildConfigOptions(),
     );
 
-    return {
-      configOptions: await this.buildConfigOptions(),
-    };
+    tc.summarize("resumeSession");
+
+    return { configOptions };
   }
 
   async prompt(params: PromptRequest): Promise<PromptResponse> {
@@ -354,8 +387,8 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       isResume: config.isResume,
       additionalDirectories: config.additionalDirectories,
       onModeChange: this.createOnModeChange(config.sessionId),
-      onProcessSpawned: this.processCallbacks?.onProcessSpawned,
-      onProcessExited: this.processCallbacks?.onProcessExited,
+      onProcessSpawned: this.options?.onProcessSpawned,
+      onProcessExited: this.options?.onProcessExited,
     });
 
     const q = query({ prompt: input, options });
@@ -491,6 +524,30 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     }
   }
 
+  /**
+   * Fire-and-forget: fetch slash commands and MCP tool metadata in parallel.
+   * Both populate caches used later — neither is needed to return configOptions.
+   */
+  private deferBackgroundFetches(
+    tc: ReturnType<typeof createTimingCollector>,
+    q: Query,
+    sessionId: string,
+    mcpServers: ReturnType<typeof parseMcpServers>,
+  ): void {
+    Promise.all([
+      tc.time("slashCommands", () => getAvailableSlashCommands(q)),
+      tc.time("mcpMetadata", () =>
+        fetchMcpToolMetadata(mcpServers, this.logger),
+      ),
+    ])
+      .then(([slashCommands]) => {
+        this.sendAvailableCommandsUpdate(sessionId, slashCommands);
+      })
+      .catch((err) => {
+        this.logger.warn("Failed to fetch deferred session data", { err });
+      });
+  }
+
   private registerPersistence(
     sessionId: string,
     meta: Record<string, unknown> | undefined,

package/src/adapters/claude/session/options.ts

@@ -245,11 +245,7 @@ function clearStatsigCache(): void {
     process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"),
     "statsig",
   );
-  try {
-    if (fs.existsSync(statsigPath)) {
-      fs.rmSync(statsigPath, { recursive: true, force: true });
-    }
-  } catch {
-    // Ignore errors - cache clearing is best-effort
-  }
+  fs.rm(statsigPath, { recursive: true, force: true }, () => {
+    // Best-effort, ignore errors
+  });
 }

package/src/agent.ts

@@ -111,6 +111,7 @@ export class Agent {
       taskId,
       deviceType: "local",
       logger: this.logger,
+      debug: this.debug,
       processCallbacks: options.processCallbacks,
       allowedModelIds,
       codexOptions:

package/src/gateway-models.ts

@@ -26,6 +26,14 @@ type ArrayModelsResponse =
     }
   | Array<{ id?: string; owned_by?: string }>;
 
+const CACHE_TTL = 10 * 60 * 1000; // 10 minutes
+
+let gatewayModelsCache: {
+  models: GatewayModel[];
+  expiry: number;
+  url: string;
+} | null = null;
+
 export async function fetchGatewayModels(
   options?: FetchGatewayModelsOptions,
 ): Promise<GatewayModel[]> {
@@ -34,6 +42,14 @@ export async function fetchGatewayModels(
     return [];
   }
 
+  if (
+    gatewayModelsCache &&
+    gatewayModelsCache.url === gatewayUrl &&
+    Date.now() < gatewayModelsCache.expiry
+  ) {
+    return gatewayModelsCache.models;
+  }
+
   const modelsUrl = `${gatewayUrl}/v1/models`;
 
   try {
@@ -44,8 +60,13 @@ export async function fetchGatewayModels(
     }
 
     const data = (await response.json()) as GatewayModelsResponse;
-    const models = data.data ?? [];
-    return models.filter((m) => !BLOCKED_MODELS.has(m.id));
+    const models = (data.data ?? []).filter((m) => !BLOCKED_MODELS.has(m.id));
+    gatewayModelsCache = {
+      models,
+      expiry: Date.now() + CACHE_TTL,
+      url: gatewayUrl,
+    };
+    return models;
   } catch {
     return [];
   }
@@ -70,6 +91,12 @@ export interface ArrayModelInfo {
   owned_by?: string;
 }
 
+let arrayModelsCache: {
+  models: ArrayModelInfo[];
+  expiry: number;
+  url: string;
+} | null = null;
+
 export async function fetchArrayModels(
   options?: FetchGatewayModelsOptions,
 ): Promise<ArrayModelInfo[]> {
@@ -78,6 +105,14 @@ export async function fetchArrayModels(
     return [];
   }
 
+  if (
+    arrayModelsCache &&
+    arrayModelsCache.url === gatewayUrl &&
+    Date.now() < arrayModelsCache.expiry
+  ) {
+    return arrayModelsCache.models;
+  }
+
   try {
     const base = new URL(gatewayUrl);
     base.pathname = "/array/v1/models";
@@ -97,6 +132,11 @@ export async function fetchArrayModels(
       if (!id) continue;
       results.push({ id, owned_by: model?.owned_by });
     }
+    arrayModelsCache = {
+      models: results,
+      expiry: Date.now() + CACHE_TTL,
+      url: gatewayUrl,
+    };
     return results;
   } catch {
     return [];