@posthog/agent 2.3.619 → 2.3.643

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.619",
+  "version": "2.3.643",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -106,9 +106,9 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
+    "@posthog/git": "1.0.0",
     "@posthog/shared": "1.0.0",
-    "@posthog/enricher": "1.0.0",
-    "@posthog/git": "1.0.0"
+    "@posthog/enricher": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.19.0",

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

@@ -1,8 +1,34 @@
+import type { PromptRequest } from "@agentclientprotocol/sdk";
 import { describe, expect, it } from "vitest";
-import { promptToClaude } from "./acp-to-sdk";
+import {
+  promptToClaude,
+  readToolGuidanceForPath,
+  workspacePromptFromFileUri,
+} from "./acp-to-sdk";
+
+describe("readToolGuidanceForPath", () => {
+  it.each([
+    ["/docs/x.pdf", ["pages"]],
+    ["/proj/app.ts", ["offset", "limit"]],
+    ["/assets/logo.png", ["Binary", "file_path"]],
+  ])("guides reads for %s", (filePath, keywords) => {
+    const guidance = readToolGuidanceForPath(filePath);
+    for (const keyword of keywords) {
+      expect(guidance).toContain(keyword);
+    }
+  });
+});
+
+describe("workspacePromptFromFileUri", () => {
+  it("includes file_path and Read-oriented chunking hints", () => {
+    const s = workspacePromptFromFileUri("file:///tmp/x.pdf");
+    expect(s).toContain("Read");
+    expect(s).toContain("file_path: /tmp/x.pdf");
+  });
+});
 
 describe("promptToClaude", () => {
-  it("renders file resource links as explicit workspace attachments", () => {
+  it("maps file resource_link to workspace path + Read guidance", () => {
     const result = promptToClaude({
       sessionId: "session-1",
       prompt: [
@@ -14,17 +40,87 @@ describe("promptToClaude", () => {
       ],
     });
 
-    expect(result.message.content).toEqual([
-      {
-        type: "text",
-        text: [
-          "Attached file available in the workspace:",
-          "- name: report.pdf",
-          "- path: /tmp/workspace/.posthog/attachments/run-1/report.pdf",
-          "Use the available tools to inspect this file if needed.",
-        ].join("\n"),
-      },
-    ]);
+    expect(result.message.content.length).toBe(1);
+    expect(result.message.content[0]).toMatchObject({
+      type: "text",
+      text: expect.any(String),
+    });
+    expect(
+      (result.message.content[0] as { type: string; text: string }).text,
+    ).toContain("file_path:");
+    expect(
+      (result.message.content[0] as { type: string; text: string }).text,
+    ).toContain("/tmp/workspace/.posthog/attachments/run-1/report.pdf");
+    const text = (result.message.content[0] as { text: string }).text;
+    expect(text.toLowerCase()).toContain("read");
+    expect(text).toContain("pages");
+  });
+
+  it("drops embedded body for file:// resource but keeps attachment:// payload", () => {
+    const hugeInline = `${"y".repeat(30_000)}KEEP_ATTACH${"y".repeat(30_000)}`;
+    const fileRes = promptToClaude({
+      sessionId: "x",
+      prompt: [
+        {
+          type: "resource",
+          resource: {
+            uri: "file:///tmp/note.txt",
+            text: `${"x".repeat(50_000)}DROP_THIS${"x".repeat(50_000)}`,
+            mimeType: "text/plain",
+          },
+        },
+      ],
+    });
+    expect(fileRes.message.content.length).toBe(1);
+    expect(JSON.stringify(fileRes)).not.toContain("DROP_THIS");
+    expect(fileRes.message.content[0]).toMatchObject({
+      type: "text",
+      text: expect.stringContaining("file_path: /tmp/note.txt"),
+    });
+
+    const attachRes = promptToClaude({
+      sessionId: "y",
+      prompt: [
+        {
+          type: "resource",
+          resource: {
+            uri: "attachment://z?label=f.txt",
+            text: hugeInline,
+            mimeType: "text/plain",
+          },
+        },
+      ],
+    });
+    expect(attachRes.message.content.length).toBe(2);
+    expect(JSON.stringify(attachRes)).toContain("KEEP_ATTACH");
+  });
+
+  it("maps file URI-only image blocks to workspace Read prompt text", () => {
+    const req: PromptRequest = {
+      sessionId: "session-1",
+      prompt: [
+        {
+          type: "image",
+          uri: "file:///tmp/ui/screenshot.png",
+          mimeType: "image/png",
+        } as PromptRequest["prompt"][number],
+      ],
+    };
+    const result = promptToClaude(req);
+
+    expect(result.message.content).toHaveLength(1);
+    expect(result.message.content[0]).toMatchObject({
+      type: "text",
+      text: expect.any(String),
+    });
+    expect(
+      (result.message.content[0] as { type: string; text: string }).text,
+    ).toContain("/tmp/ui/screenshot.png");
+    expect(
+      (
+        result.message.content[0] as { type: string; text: string }
+      ).text.toLowerCase(),
+    ).toContain("read");
   });
 
   it("preserves non-file resource links as links", () => {

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

@@ -6,6 +6,31 @@ import type { ContentBlockParam } from "@anthropic-ai/sdk/resources";
 
 type ImageMimeType = "image/jpeg" | "image/png" | "image/gif" | "image/webp";
 
+const PDF_EXTENSIONS = new Set(["pdf"]);
+
+const COMMON_IMAGE_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "bmp",
+  "svg",
+  "heic",
+  "tif",
+  "tiff",
+]);
+
+const VIDEO_EXTENSIONS = new Set([
+  "mp4",
+  "mov",
+  "webm",
+  "mkv",
+  "avi",
+  "mpeg",
+  "mpg",
+]);
+
 function sdkText(value: string): ContentBlockParam {
   return { type: "text", text: value };
 }
@@ -22,21 +47,42 @@ function formatUriAsLink(uri: string): string {
   }
 }
 
-function formatFileAttachment(uri: string): string {
+/** Chunking hints for Claude Code `Read` (`file_path`, optional `pages` / `offset` / `limit`). */
+export function readToolGuidanceForPath(filePath: string): string {
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  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)) {
+    return "Binary file — use Read with `file_path`; prefer bounded reads where supported.";
+  }
+  return "Large text — use multiple Read calls with optional `offset` and `limit`.";
+}
+
+/** Path-only workspace attach text (never embed `resource.text` from disk). */
+export function workspacePromptFromFileUri(uri: string): string {
   try {
     const filePath = fileURLToPath(uri);
     const name = path.basename(filePath) || filePath;
     return [
-      "Attached file available in the workspace:",
-      `- name: ${name}`,
-      `- path: ${filePath}`,
-      "Use the available tools to inspect this file if needed.",
+      "Attached workspace file — use Read with required `file_path`:",
+      `- file_path: ${filePath}`,
+      `- name (context): ${name}`,
+      readToolGuidanceForPath(filePath),
     ].join("\n");
   } catch {
-    return `Attached file available at ${uri}`;
+    return [
+      "Attached file — decode path from URI, call Read with that path as `file_path`:",
+      uri,
+      'Chunk PDFs with `pages` (e.g. "1-5"); long text with `offset`/`limit`.',
+    ].join("\n");
   }
 }
 
+function isFileSchemeUri(uri: string | undefined | null): boolean {
+  return Boolean(uri?.startsWith("file://"));
+}
+
 function transformMcpCommand(text: string): string {
   const mcpMatch = text.match(/^\/mcp:([^:\s]+):(\S+)(\s+.*)?$/);
   if (mcpMatch) {
@@ -60,7 +106,7 @@ function processPromptChunk(
       content.push(
         sdkText(
           chunk.uri.startsWith("file://")
-            ? formatFileAttachment(chunk.uri)
+            ? workspacePromptFromFileUri(chunk.uri)
             : formatUriAsLink(chunk.uri),
         ),
       );
@@ -68,10 +114,16 @@ function processPromptChunk(
 
     case "resource":
       if ("text" in chunk.resource) {
-        content.push(sdkText(formatUriAsLink(chunk.resource.uri)));
+        const uri = chunk.resource.uri;
+        if (uri != null && isFileSchemeUri(uri)) {
+          content.push(sdkText(workspacePromptFromFileUri(uri)));
+          break;
+        }
+
+        content.push(sdkText(formatUriAsLink(uri ?? "")));
         context.push(
           sdkText(
-            `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>`,
+            `\n<context ref="${uri ?? ""}">\n${chunk.resource.text}\n</context>`,
           ),
         );
       }
@@ -92,6 +144,8 @@ function processPromptChunk(
           type: "image",
           source: { type: "url", url: chunk.uri },
         });
+      } else if (chunk.uri != null && isFileSchemeUri(chunk.uri)) {
+        content.push(sdkText(workspacePromptFromFileUri(chunk.uri)));
       }
       break;