@posthog/agent 2.1.35 → 2.1.47

package/dist/server/agent-server.js

@@ -1178,12 +1178,174 @@ import {
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
+
+// ../shared/dist/index.js
+var consoleLogger = {
+  info: (_message, _data) => {
+  },
+  debug: (_message, _data) => {
+  },
+  error: (_message, _data) => {
+  },
+  warn: (_message, _data) => {
+  }
+};
+var Saga = class {
+  completedSteps = [];
+  currentStepName = "unknown";
+  stepTimings = [];
+  log;
+  constructor(logger) {
+    this.log = logger ?? consoleLogger;
+  }
+  /**
+   * Run the saga with the given input.
+   * Returns a discriminated union result - either success with data or failure with error details.
+   */
+  async run(input) {
+    this.completedSteps = [];
+    this.currentStepName = "unknown";
+    this.stepTimings = [];
+    const sagaStart = performance.now();
+    this.log.info("Starting saga", { sagaName: this.constructor.name });
+    try {
+      const result = await this.execute(input);
+      const totalDuration = performance.now() - sagaStart;
+      this.log.debug("Saga completed successfully", {
+        sagaName: this.constructor.name,
+        stepsCompleted: this.completedSteps.length,
+        totalDurationMs: Math.round(totalDuration),
+        stepTimings: this.stepTimings
+      });
+      return { success: true, data: result };
+    } catch (error) {
+      this.log.error("Saga failed, initiating rollback", {
+        sagaName: this.constructor.name,
+        failedStep: this.currentStepName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await this.rollback();
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        failedStep: this.currentStepName
+      };
+    }
+  }
+  /**
+   * Execute a step with its rollback action.
+   * If the step succeeds, its rollback action is stored for potential rollback.
+   * The step name is automatically tracked for error reporting.
+   *
+   * @param config - Step configuration with name, execute, and rollback functions
+   * @returns The result of the execute function
+   * @throws Re-throws any error from the execute function (triggers rollback)
+   */
+  async step(config) {
+    this.currentStepName = config.name;
+    this.log.debug(`Executing step: ${config.name}`);
+    const stepStart = performance.now();
+    const result = await config.execute();
+    const durationMs = Math.round(performance.now() - stepStart);
+    this.stepTimings.push({ name: config.name, durationMs });
+    this.log.debug(`Step completed: ${config.name}`, { durationMs });
+    this.completedSteps.push({
+      name: config.name,
+      rollback: () => config.rollback(result)
+    });
+    return result;
+  }
+  /**
+   * Execute a step that doesn't need rollback.
+   * Useful for read-only operations or operations that are idempotent.
+   * The step name is automatically tracked for error reporting.
+   *
+   * @param name - Step name for logging and error tracking
+   * @param execute - The action to execute
+   * @returns The result of the execute function
+   */
+  async readOnlyStep(name, execute) {
+    this.currentStepName = name;
+    this.log.debug(`Executing read-only step: ${name}`);
+    const stepStart = performance.now();
+    const result = await execute();
+    const durationMs = Math.round(performance.now() - stepStart);
+    this.stepTimings.push({ name, durationMs });
+    this.log.debug(`Read-only step completed: ${name}`, { durationMs });
+    return result;
+  }
+  /**
+   * Roll back all completed steps in reverse order.
+   * Rollback errors are logged but don't stop the rollback of other steps.
+   */
+  async rollback() {
+    this.log.info("Rolling back saga", {
+      stepsToRollback: this.completedSteps.length
+    });
+    const stepsReversed = [...this.completedSteps].reverse();
+    for (const step of stepsReversed) {
+      try {
+        this.log.debug(`Rolling back step: ${step.name}`);
+        await step.rollback();
+        this.log.debug(`Step rolled back: ${step.name}`);
+      } catch (error) {
+        this.log.error(`Failed to rollback step: ${step.name}`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.log.info("Rollback completed", {
+      stepsAttempted: this.completedSteps.length
+    });
+  }
+  /**
+   * Get the number of completed steps (useful for testing)
+   */
+  getCompletedStepCount() {
+    return this.completedSteps.length;
+  }
+};
+var NOOP_COLLECTOR = {
+  time: (_label, fn) => fn(),
+  timeSync: (_label, fn) => fn(),
+  record: () => {
+  },
+  summarize: () => {
+  }
+};
+function createTimingCollector(enabled, log) {
+  if (!enabled) return NOOP_COLLECTOR;
+  const steps = {};
+  return {
+    async time(label, fn) {
+      const start = Date.now();
+      const result = await fn();
+      steps[label] = Date.now() - start;
+      return result;
+    },
+    timeSync(label, fn) {
+      const start = Date.now();
+      const result = fn();
+      steps[label] = Date.now() - start;
+      return result;
+    },
+    record(label, ms) {
+      steps[label] = ms;
+    },
+    summarize(label) {
+      const total = Object.values(steps).reduce((a, b) => a + b, 0);
+      log(`[timing] ${label}: ${total}ms`, steps);
+    }
+  };
+}
+
+// src/adapters/claude/claude-agent.ts
 import { v7 as uuidv7 } from "uuid";
 
 // package.json
 var package_default = {
   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: {
@@ -1314,11 +1476,16 @@ function unreachable(value, logger) {
 // src/gateway-models.ts
 var DEFAULT_GATEWAY_MODEL = "claude-opus-4-6";
 var BLOCKED_MODELS = /* @__PURE__ */ new Set(["gpt-5-mini", "openai/gpt-5-mini"]);
+var CACHE_TTL = 10 * 60 * 1e3;
+var gatewayModelsCache = null;
 async function fetchGatewayModels(options) {
   const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
   if (!gatewayUrl) {
     return [];
   }
+  if (gatewayModelsCache && gatewayModelsCache.url === gatewayUrl && Date.now() < gatewayModelsCache.expiry) {
+    return gatewayModelsCache.models;
+  }
   const modelsUrl = `${gatewayUrl}/v1/models`;
   try {
     const response = await fetch(modelsUrl);
@@ -1326,8 +1493,13 @@ async function fetchGatewayModels(options) {
       return [];
     }
     const data = await response.json();
-    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 [];
   }
@@ -3235,12 +3407,8 @@ function clearStatsigCache() {
     process.env.CLAUDE_CONFIG_DIR || path2.join(os2.homedir(), ".claude"),
     "statsig"
   );
-  try {
-    if (fs.existsSync(statsigPath)) {
-      fs.rmSync(statsigPath, { recursive: true, force: true });
-    }
-  } catch {
-  }
+  fs.rm(statsigPath, { recursive: true, force: true }, () => {
+  });
 }
 
 // src/adapters/claude/claude-agent.ts
@@ -3250,12 +3418,14 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   backgroundTerminals = {};
   clientCapabilities;
   logWriter;
-  processCallbacks;
+  options;
   lastSentConfigOptions;
-  constructor(client, logWriter, processCallbacks) {
+  debug;
+  constructor(client, logWriter, options) {
     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]" });
   }
@@ -3298,27 +3468,36 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   }
   async newSession(params) {
     this.checkAuthStatus();
+    const tc = createTimingCollector(
+      this.debug,
+      (msg, data) => this.logger.info(msg, data)
+    );
     const meta = params._meta;
     const sessionId = uuidv7();
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
-    const mcpServers = parseMcpServers(params);
-    await fetchMcpToolMetadata(mcpServers, this.logger);
-    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 mcpServers = tc.timeSync(
+      "parseMcpServers",
+      () => parseMcpServers(params)
+    );
+    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();
-    const q = query({ prompt: input, options });
+    const q = tc.timeSync("sdkQuery", () => query({ prompt: input, options }));
     const session = this.createSession(
       sessionId,
       q,
@@ -3330,28 +3509,40 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     session.taskRunId = meta?.taskRunId;
     this.registerPersistence(sessionId, meta);
     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();
+    const modelOptions = await tc.time(
+      "fetchModels",
+      () => this.getModelConfigOptions()
+    );
+    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
     };
   }
   async loadSession(params) {
     return this.resumeSession(params);
   }
   async resumeSession(params) {
+    const tc = createTimingCollector(
+      this.debug,
+      (msg, data) => this.logger.info(msg, data)
+    );
     const meta = params._meta;
     const sessionId = meta?.sessionId;
     if (!sessionId) {
@@ -3360,28 +3551,33 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (this.sessionId === sessionId) {
       return {};
     }
-    const mcpServers = parseMcpServers(params);
-    await fetchMcpToolMetadata(mcpServers, this.logger);
+    const mcpServers = tc.timeSync(
+      "parseMcpServers",
+      () => parseMcpServers(params)
+    );
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "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);
-    this.sendAvailableCommandsUpdate(
-      sessionId,
-      await getAvailableSlashCommands(q)
+    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) {
     this.session.cancelled = false;
@@ -3453,8 +3649,8 @@ var ClaudeAcpAgent = class 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 });
     const abortController = options.abortController;
@@ -3564,6 +3760,23 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       await q.setModel(fallback);
     }
   }
+  /**
+   * Fire-and-forget: fetch slash commands and MCP tool metadata in parallel.
+   * Both populate caches used later — neither is needed to return configOptions.
+   */
+  deferBackgroundFetches(tc, q, sessionId, mcpServers) {
+    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 });
+    });
+  }
   registerPersistence(sessionId, meta) {
     const persistence = meta?.persistence;
     if (persistence && this.logWriter) {
@@ -3851,7 +4064,10 @@ function createClaudeConnection(config) {
   const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
   let agent = 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);
@@ -9231,136 +9447,9 @@ async function getHeadSha(baseDir, options) {
 }
 
 // src/sagas/apply-snapshot-saga.ts
-import { mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { join as join5 } from "path";
 
-// ../shared/dist/index.js
-var consoleLogger = {
-  info: (_message, _data) => {
-  },
-  debug: (_message, _data) => {
-  },
-  error: (_message, _data) => {
-  },
-  warn: (_message, _data) => {
-  }
-};
-var Saga = class {
-  completedSteps = [];
-  currentStepName = "unknown";
-  stepTimings = [];
-  log;
-  constructor(logger) {
-    this.log = logger ?? consoleLogger;
-  }
-  /**
-   * Run the saga with the given input.
-   * Returns a discriminated union result - either success with data or failure with error details.
-   */
-  async run(input) {
-    this.completedSteps = [];
-    this.currentStepName = "unknown";
-    this.stepTimings = [];
-    const sagaStart = performance.now();
-    this.log.info("Starting saga", { sagaName: this.constructor.name });
-    try {
-      const result = await this.execute(input);
-      const totalDuration = performance.now() - sagaStart;
-      this.log.debug("Saga completed successfully", {
-        sagaName: this.constructor.name,
-        stepsCompleted: this.completedSteps.length,
-        totalDurationMs: Math.round(totalDuration),
-        stepTimings: this.stepTimings
-      });
-      return { success: true, data: result };
-    } catch (error) {
-      this.log.error("Saga failed, initiating rollback", {
-        sagaName: this.constructor.name,
-        failedStep: this.currentStepName,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      await this.rollback();
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        failedStep: this.currentStepName
-      };
-    }
-  }
-  /**
-   * Execute a step with its rollback action.
-   * If the step succeeds, its rollback action is stored for potential rollback.
-   * The step name is automatically tracked for error reporting.
-   *
-   * @param config - Step configuration with name, execute, and rollback functions
-   * @returns The result of the execute function
-   * @throws Re-throws any error from the execute function (triggers rollback)
-   */
-  async step(config) {
-    this.currentStepName = config.name;
-    this.log.debug(`Executing step: ${config.name}`);
-    const stepStart = performance.now();
-    const result = await config.execute();
-    const durationMs = Math.round(performance.now() - stepStart);
-    this.stepTimings.push({ name: config.name, durationMs });
-    this.log.debug(`Step completed: ${config.name}`, { durationMs });
-    this.completedSteps.push({
-      name: config.name,
-      rollback: () => config.rollback(result)
-    });
-    return result;
-  }
-  /**
-   * Execute a step that doesn't need rollback.
-   * Useful for read-only operations or operations that are idempotent.
-   * The step name is automatically tracked for error reporting.
-   *
-   * @param name - Step name for logging and error tracking
-   * @param execute - The action to execute
-   * @returns The result of the execute function
-   */
-  async readOnlyStep(name, execute) {
-    this.currentStepName = name;
-    this.log.debug(`Executing read-only step: ${name}`);
-    const stepStart = performance.now();
-    const result = await execute();
-    const durationMs = Math.round(performance.now() - stepStart);
-    this.stepTimings.push({ name, durationMs });
-    this.log.debug(`Read-only step completed: ${name}`, { durationMs });
-    return result;
-  }
-  /**
-   * Roll back all completed steps in reverse order.
-   * Rollback errors are logged but don't stop the rollback of other steps.
-   */
-  async rollback() {
-    this.log.info("Rolling back saga", {
-      stepsToRollback: this.completedSteps.length
-    });
-    const stepsReversed = [...this.completedSteps].reverse();
-    for (const step of stepsReversed) {
-      try {
-        this.log.debug(`Rolling back step: ${step.name}`);
-        await step.rollback();
-        this.log.debug(`Step rolled back: ${step.name}`);
-      } catch (error) {
-        this.log.error(`Failed to rollback step: ${step.name}`, {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    this.log.info("Rollback completed", {
-      stepsAttempted: this.completedSteps.length
-    });
-  }
-  /**
-   * Get the number of completed steps (useful for testing)
-   */
-  getCompletedStepCount() {
-    return this.completedSteps.length;
-  }
-};
-
 // ../git/dist/sagas/tree.js
 import { existsSync as existsSync4 } from "fs";
 import * as fs5 from "fs/promises";
@@ -9672,7 +9761,7 @@ var ApplySnapshotSaga = class extends Saga {
       },
       rollback: async () => {
         if (this.archivePath) {
-          await rm2(this.archivePath, { force: true }).catch(() => {
+          await rm3(this.archivePath, { force: true }).catch(() => {
           });
         }
       }
@@ -9688,7 +9777,7 @@ var ApplySnapshotSaga = class extends Saga {
     if (!applyResult.success) {
       throw new Error(`Failed to apply tree: ${applyResult.error}`);
     }
-    await rm2(this.archivePath, { force: true }).catch(() => {
+    await rm3(this.archivePath, { force: true }).catch(() => {
     });
     this.log.info("Tree snapshot applied", {
       treeHash: snapshot.treeHash,
@@ -9701,7 +9790,7 @@ var ApplySnapshotSaga = class extends Saga {
 
 // src/sagas/capture-tree-saga.ts
 import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile3, rm as rm3 } from "fs/promises";
+import { readFile as readFile3, rm as rm4 } from "fs/promises";
 import { join as join6 } from "path";
 var CaptureTreeSaga2 = class extends Saga {
   async execute(input) {
@@ -9750,7 +9839,7 @@ var CaptureTreeSaga2 = class extends Saga {
           runId
         );
       } finally {
-        await rm3(createdArchivePath, { force: true }).catch(() => {
+        await rm4(createdArchivePath, { force: true }).catch(() => {
         });
       }
     }
@@ -9794,7 +9883,7 @@ var CaptureTreeSaga2 = class extends Saga {
         return void 0;
       },
       rollback: async () => {
-        await rm3(archivePath, { force: true }).catch(() => {
+        await rm4(archivePath, { force: true }).catch(() => {
         });
       }
     });