@posthog/agent 2.3.678 → 2.3.696

package/dist/agent.js

@@ -4674,7 +4674,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.678",
+  version: "2.3.696",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -9683,22 +9683,174 @@ function resolveTaskId(meta) {
   return meta?.taskId ?? meta?.persistence?.taskId;
 }
 
+// src/adapters/claude/context-breakdown.ts
+var CLAUDE_PRESET_ESTIMATE_TOKENS = 4e3;
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text2) {
+  if (!text2) return 0;
+  return Math.max(0, Math.round(text2.length / CHARS_PER_TOKEN));
+}
+function estimateJsonTokens(value) {
+  try {
+    return estimateTokens(JSON.stringify(value));
+  } catch {
+    return 0;
+  }
+}
+function estimateSkillsTokens(commands) {
+  if (!commands.length) return 0;
+  return estimateJsonTokens(
+    commands.map((c) => ({
+      name: c.name,
+      description: c.description,
+      hint: c.input?.hint
+    }))
+  );
+}
+function estimateMcpTokens(tools) {
+  if (!tools.length) return 0;
+  return estimateJsonTokens(
+    tools.map((t) => ({ name: t.name, description: t.description }))
+  );
+}
+function estimateRulesTokens(rules) {
+  return estimateTokens(rules);
+}
+function emptyBaseline() {
+  return {
+    systemPrompt: 0,
+    tools: 0,
+    rules: 0,
+    skills: 0,
+    mcp: 0,
+    subagents: 0
+  };
+}
+function estimateSystemPrompt(systemPrompt) {
+  if (!systemPrompt) return CLAUDE_PRESET_ESTIMATE_TOKENS;
+  if (typeof systemPrompt === "string") return estimateTokens(systemPrompt);
+  if (typeof systemPrompt === "object") {
+    const obj = systemPrompt;
+    const appendTokens = typeof obj.append === "string" ? estimateTokens(obj.append) : 0;
+    if (obj.type === "preset") {
+      return CLAUDE_PRESET_ESTIMATE_TOKENS + appendTokens;
+    }
+    return appendTokens;
+  }
+  return 0;
+}
+function buildBreakdown(baseline, currentInputTokens) {
+  const stableSum = baseline.systemPrompt + baseline.tools + baseline.rules + baseline.skills + baseline.mcp + baseline.subagents;
+  const conversation = Math.max(0, currentInputTokens - stableSum);
+  return {
+    systemPrompt: baseline.systemPrompt,
+    tools: baseline.tools,
+    rules: baseline.rules,
+    skills: baseline.skills,
+    mcp: baseline.mcp,
+    subagents: baseline.subagents,
+    conversation
+  };
+}
+
 // src/adapters/claude/conversion/acp-to-sdk.ts
 import * as path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var PDF_EXTENSIONS = /* @__PURE__ */ new Set(["pdf"]);
-var COMMON_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
-  "png",
-  "jpg",
-  "jpeg",
-  "gif",
-  "webp",
-  "bmp",
-  "svg",
-  "heic",
-  "tif",
-  "tiff"
+
+// ../shared/dist/index.js
+var IMAGE_MIME_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  svg: "image/svg+xml",
+  heic: "image/heic",
+  heif: "image/heif",
+  avif: "image/avif"
+};
+var IMAGE_EXTENSIONS = new Set(
+  Object.keys(IMAGE_MIME_TYPES)
+);
+var CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+function isClaudeImageMimeType(mimeType) {
+  return CLAUDE_IMAGE_MIME_TYPES.has(mimeType.toLowerCase());
+}
+var MAX_DATA_URL_LENGTH = 20 * 1024 * 1024;
+var MAX_IMAGE_BASE64_LENGTH = 15 * 1024 * 1024;
+function extensionOf(filename) {
+  const slash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+  const basename3 = slash >= 0 ? filename.slice(slash + 1) : filename;
+  const cleanBasename = basename3.split(/[?#]/)[0];
+  const dot = cleanBasename.lastIndexOf(".");
+  return dot > 0 ? cleanBasename.slice(dot + 1).toLowerCase() : "";
+}
+function isImageFile(filename) {
+  const ext = extensionOf(filename);
+  return ext.length > 0 && IMAGE_EXTENSIONS.has(ext);
+}
+var AUDIO_VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
+  "mp3",
+  "mp4",
+  "wav",
+  "avi",
+  "mov",
+  "mkv",
+  "webm",
+  "mpg",
+  "mpeg",
+  "flac",
+  "ogg",
+  "m4a",
+  "aac"
+]);
+var ARCHIVE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "zip",
+  "tar",
+  "gz",
+  "tgz",
+  "bz2",
+  "xz",
+  "rar",
+  "7z"
+]);
+var EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "wasm",
+  "bin",
+  "o"
 ]);
+var FONT_EXTENSIONS = /* @__PURE__ */ new Set([
+  "ttf",
+  "otf",
+  "woff",
+  "woff2",
+  "eot"
+]);
+var DOCUMENT_BINARY_EXTENSIONS = /* @__PURE__ */ new Set(["pdf"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ...Object.keys(IMAGE_MIME_TYPES).filter((ext) => ext !== "svg"),
+  ...AUDIO_VIDEO_EXTENSIONS,
+  ...ARCHIVE_EXTENSIONS,
+  ...EXECUTABLE_EXTENSIONS,
+  ...FONT_EXTENSIONS,
+  ...DOCUMENT_BINARY_EXTENSIONS
+]);
+
+// src/adapters/claude/conversion/acp-to-sdk.ts
+var PDF_EXTENSIONS = /* @__PURE__ */ new Set(["pdf"]);
 var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
   "mp4",
   "mov",
@@ -9727,7 +9879,7 @@ function readToolGuidanceForPath(filePath) {
   if (PDF_EXTENSIONS.has(ext)) {
     return 'Optional `pages` string (e.g. "1-5") per Read call instead of loading the entire PDF.';
   }
-  if (COMMON_IMAGE_EXTENSIONS.has(ext) || VIDEO_EXTENSIONS.has(ext)) {
+  if (isImageFile(filePath) || VIDEO_EXTENSIONS.has(ext)) {
     return "Binary file \u2014 use Read with `file_path`; prefer bounded reads where supported.";
   }
   return "Large text \u2014 use multiple Read calls with optional `offset` and `limit`.";
@@ -9793,14 +9945,22 @@ ${chunk.resource.text}
       break;
     case "image":
       if (chunk.data) {
-        content.push({
-          type: "image",
-          source: {
-            type: "base64",
-            data: chunk.data,
-            media_type: chunk.mimeType
-          }
-        });
+        if (isClaudeImageMimeType(chunk.mimeType)) {
+          content.push({
+            type: "image",
+            source: {
+              type: "base64",
+              data: chunk.data,
+              media_type: chunk.mimeType
+            }
+          });
+        } else {
+          content.push(
+            sdkText(
+              `[Unsupported image MIME type: ${chunk.mimeType}. Supported: image/jpeg, image/png, image/gif, image/webp.]`
+            )
+          );
+        }
       } else if (chunk.uri?.startsWith("http")) {
         content.push({
           type: "image",
@@ -10269,6 +10429,9 @@ function getConnectedMcpServerNames() {
   }
   return [...names];
 }
+function getCachedMcpTools() {
+  return [...mcpToolMetadataCache.values()];
+}
 function getMcpToolApprovalState(toolName) {
   return mcpToolMetadataCache.get(toolName)?.approvalState;
 }
@@ -18017,6 +18180,19 @@ var SettingsManager = class {
 var SESSION_VALIDATION_TIMEOUT_MS = 3e4;
 var MAX_TITLE_LENGTH = 256;
 var LOCAL_ONLY_COMMANDS = /* @__PURE__ */ new Set(["/context", "/heapdump", "/extra-usage"]);
+function readClaudeMdQuietly(cwd, logger) {
+  try {
+    return fs10.readFileSync(path14.join(cwd, "CLAUDE.md"), "utf-8");
+  } catch (err2) {
+    if (err2?.code !== "ENOENT") {
+      logger.warn("Failed to read CLAUDE.md for context breakdown", {
+        cwd,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+    }
+    return void 0;
+  }
+}
 function sanitizeTitle(text2) {
   const sanitized = text2.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
   if (sanitized.length <= MAX_TITLE_LENGTH) {
@@ -18344,6 +18520,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
                 }
               });
             }
+            const breakdownInputTokens = lastStreamUsage.input_tokens + lastStreamUsage.cache_read_input_tokens + lastStreamUsage.cache_creation_input_tokens;
             await this.client.extNotification(
               POSTHOG_NOTIFICATIONS.USAGE_UPDATE,
               {
@@ -18354,7 +18531,11 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
                   cachedReadTokens: message.usage.cache_read_input_tokens,
                   cachedWriteTokens: message.usage.cache_creation_input_tokens
                 },
-                cost: message.total_cost_usd
+                cost: message.total_cost_usd,
+                breakdown: buildBreakdown(
+                  this.session.contextBreakdownBaseline ?? emptyBaseline(),
+                  breakdownInputTokens
+                )
               }
             );
             const usage = {
@@ -18805,6 +18986,11 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       pendingMessages: /* @__PURE__ */ new Map(),
       nextPendingOrder: 0,
       emitRawSDKMessages: meta?.claudeCode?.emitRawSDKMessages ?? false,
+      contextBreakdownBaseline: {
+        ...emptyBaseline(),
+        systemPrompt: estimateSystemPrompt(systemPrompt),
+        rules: estimateRulesTokens(readClaudeMdQuietly(cwd, this.logger))
+      },
       // Custom properties
       cwd,
       notificationHistory: [],
@@ -19062,13 +19248,26 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   }
   async sendAvailableCommandsUpdate() {
     const commands = await this.session.query.supportedCommands();
+    const available = getAvailableSlashCommands(commands);
     await this.client.sessionUpdate({
       sessionId: this.sessionId,
       update: {
         sessionUpdate: "available_commands_update",
-        availableCommands: getAvailableSlashCommands(commands)
+        availableCommands: available
       }
     });
+    this.updateBreakdownCategory("skills", estimateSkillsTokens(available));
+  }
+  /** Update one category of the context-breakdown baseline so the next
+   *  `_posthog/usage_update` carries fresher numbers. No-op when the baseline
+   *  hasn't been initialized yet (e.g. in a unit-test session). */
+  updateBreakdownCategory(key, tokens) {
+    if (!this.session?.contextBreakdownBaseline) return;
+    if (this.session.contextBreakdownBaseline[key] === tokens) return;
+    this.session.contextBreakdownBaseline = {
+      ...this.session.contextBreakdownBaseline,
+      [key]: tokens
+    };
   }
   async replaySessionHistory(sessionId) {
     try {
@@ -19117,6 +19316,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         () => this.sendAvailableCommandsUpdate()
       ),
       fetchMcpToolMetadata(q, this.logger).then(() => {
+        this.updateBreakdownCategory(
+          "mcp",
+          estimateMcpTokens(getCachedMcpTools())
+        );
         const serverNames = getConnectedMcpServerNames();
         if (serverNames.length > 0) {
           this.options?.onMcpServersReady?.(serverNames);
@@ -19381,6 +19584,25 @@ function createSessionState(sessionId, cwd, opts) {
     taskId: opts?.taskId
   };
 }
+function resetSessionState(state, sessionId, cwd, opts) {
+  state.sessionId = sessionId;
+  state.cwd = cwd;
+  state.modeId = opts?.modeId ?? "auto";
+  state.modelId = opts?.modelId;
+  state.configOptions = [];
+  state.accumulatedUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedReadTokens: 0,
+    cachedWriteTokens: 0
+  };
+  state.contextSize = void 0;
+  state.contextUsed = void 0;
+  state.contextBreakdownBaseline = void 0;
+  state.permissionMode = opts?.permissionMode ?? "auto";
+  state.taskRunId = opts?.taskRunId;
+  state.taskId = opts?.taskId;
+}
 function resetUsage(state) {
   state.accumulatedUsage = {
     inputTokens: 0,
@@ -19602,6 +19824,12 @@ function classifyPromptError(error) {
     message
   );
 }
+var CODEX_BASELINE_TOKENS = 12e3;
+function buildCodexBaseline(meta) {
+  const baseline = emptyBaseline();
+  baseline.systemPrompt = CODEX_BASELINE_TOKENS + estimateTokens(meta?.systemPrompt);
+  return baseline;
+}
 var CODEX_NATIVE_MODE = {
   auto: "auto",
   default: "auto",
@@ -19771,7 +19999,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     response.configOptions = normalizeCodexConfigOptions(
       response.configOptions
     );
-    this.sessionState = createSessionState(response.sessionId, params.cwd, {
+    resetSessionState(this.sessionState, response.sessionId, params.cwd, {
       taskRunId: meta?.taskRunId,
       taskId: resolveTaskId(meta),
       modeId: response.modes?.currentModeId ?? "auto",
@@ -19780,6 +20008,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     });
     this.sessionId = response.sessionId;
     this.sessionState.configOptions = response.configOptions ?? [];
+    this.sessionState.contextBreakdownBaseline = buildCodexBaseline(meta);
     await this.applyInitialPermissionMode(
       response.sessionId,
       meta?.permissionMode,
@@ -19812,7 +20041,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       response.modes?.currentModeId,
       meta?.permissionMode
     );
-    this.sessionState = createSessionState(params.sessionId, params.cwd, {
+    resetSessionState(this.sessionState, params.sessionId, params.cwd, {
       taskRunId: meta?.taskRunId,
       taskId: resolveTaskId(meta),
       modeId: response.modes?.currentModeId ?? "auto",
@@ -19820,6 +20049,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     });
     this.sessionId = params.sessionId;
     this.sessionState.configOptions = response.configOptions ?? [];
+    this.sessionState.contextBreakdownBaseline = buildCodexBaseline(meta);
     if (meta?.taskRunId) {
       await this.client.extNotification(POSTHOG_NOTIFICATIONS.SDK_SESSION, {
         taskRunId: meta.taskRunId,
@@ -19851,7 +20081,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       loadResponse.modes?.currentModeId,
       meta?.permissionMode
     );
-    this.sessionState = createSessionState(params.sessionId, params.cwd, {
+    resetSessionState(this.sessionState, params.sessionId, params.cwd, {
       taskRunId: meta?.taskRunId,
       taskId: resolveTaskId(meta),
       modeId: loadResponse.modes?.currentModeId ?? "auto",
@@ -19859,6 +20089,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     });
     this.sessionId = params.sessionId;
     this.sessionState.configOptions = loadResponse.configOptions ?? [];
+    this.sessionState.contextBreakdownBaseline = buildCodexBaseline(meta);
     if (meta?.taskRunId) {
       await this.client.extNotification(POSTHOG_NOTIFICATIONS.SDK_SESSION, {
         taskRunId: meta.taskRunId,
@@ -19890,7 +20121,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       newResponse.configOptions
     );
     const requestedPermissionMode = toCodexPermissionMode(meta?.permissionMode);
-    this.sessionState = createSessionState(newResponse.sessionId, params.cwd, {
+    resetSessionState(this.sessionState, newResponse.sessionId, params.cwd, {
       taskRunId: meta?.taskRunId,
       taskId: resolveTaskId(meta),
       modeId: newResponse.modes?.currentModeId ?? "auto",
@@ -19898,6 +20129,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     });
     this.sessionId = newResponse.sessionId;
     this.sessionState.configOptions = newResponse.configOptions ?? [];
+    this.sessionState.contextBreakdownBaseline = buildCodexBaseline(meta);
     await this.applyInitialPermissionMode(
       newResponse.sessionId,
       meta?.permissionMode,
@@ -20034,6 +20266,15 @@ var CodexAcpAgent = class extends BaseAcpAgent {
         });
       }
     }
+    if (this.sessionState.contextUsed !== void 0) {
+      await this.client.extNotification(POSTHOG_NOTIFICATIONS.USAGE_UPDATE, {
+        sessionId: params.sessionId,
+        breakdown: buildBreakdown(
+          this.sessionState.contextBreakdownBaseline ?? emptyBaseline(),
+          this.sessionState.contextUsed
+        )
+      });
+    }
     return response;
   }
   async interrupt() {