@posthog/agent 2.3.341 → 2.3.349

package/dist/server/bin.cjs

@@ -3912,6 +3912,9 @@ function isSupportedReasoningEffort(adapter, modelId, value) {
 }
 
 // src/server/agent-server.ts
+var import_promises5 = require("fs/promises");
+var import_node_path8 = require("path");
+var import_node_url2 = require("url");
 var import_sdk5 = require("@agentclientprotocol/sdk");
 var import_node_server = require("@hono/node-server");
 
@@ -8698,7 +8701,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.341",
+  version: "2.3.349",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8788,6 +8791,7 @@ var package_default = {
   devDependencies: {
     "@posthog/shared": "workspace:*",
     "@posthog/git": "workspace:*",
+    "@posthog/enricher": "workspace:*",
     "@types/bun": "latest",
     "@types/tar": "^6.1.13",
     msw: "^2.12.7",
@@ -8807,7 +8811,6 @@ var package_default = {
     "@opentelemetry/resources": "^2.0.0",
     "@opentelemetry/sdk-logs": "^0.208.0",
     "@opentelemetry/semantic-conventions": "^1.28.0",
-    "@posthog/enricher": "workspace:*",
     "@types/jsonwebtoken": "^9.0.10",
     commander: "^14.0.2",
     hono: "^4.11.7",
@@ -12503,16 +12506,12 @@ var BaseAcpAgent = class {
 
 // src/adapters/claude/conversion/acp-to-sdk.ts
 var path5 = __toESM(require("path"), 1);
+var import_node_url = require("url");
 function sdkText(value) {
   return { type: "text", text: value };
 }
 function formatUriAsLink(uri) {
   try {
-    if (uri.startsWith("file://")) {
-      const filePath = uri.slice(7);
-      const name2 = path5.basename(filePath) || filePath;
-      return `[@${name2}](${uri})`;
-    }
     if (uri.startsWith("zed://")) {
       const name2 = path5.basename(uri) || uri;
       return `[@${name2}](${uri})`;
@@ -12522,6 +12521,20 @@ function formatUriAsLink(uri) {
     return uri;
   }
 }
+function formatFileAttachment(uri) {
+  try {
+    const filePath = (0, import_node_url.fileURLToPath)(uri);
+    const name2 = path5.basename(filePath) || filePath;
+    return [
+      "Attached file available in the workspace:",
+      `- name: ${name2}`,
+      `- path: ${filePath}`,
+      "Use the available tools to inspect this file if needed."
+    ].join("\n");
+  } catch {
+    return `Attached file available at ${uri}`;
+  }
+}
 function transformMcpCommand(text2) {
   const mcpMatch = text2.match(/^\/mcp:([^:\s]+):(\S+)(\s+.*)?$/);
   if (mcpMatch) {
@@ -12536,7 +12549,11 @@ function processPromptChunk(chunk, content, context) {
       content.push(sdkText(transformMcpCommand(chunk.text)));
       break;
     case "resource_link":
-      content.push(sdkText(formatUriAsLink(chunk.uri)));
+      content.push(
+        sdkText(
+          chunk.uri.startsWith("file://") ? formatFileAttachment(chunk.uri) : formatUriAsLink(chunk.uri)
+        )
+      );
       break;
     case "resource":
       if ("text" in chunk.resource) {
@@ -17387,32 +17404,21 @@ var PostHogAPIClient = class {
     );
     return response.artifacts ?? [];
   }
-  async getArtifactPresignedUrl(taskId, runId, storagePath) {
+  /**
+   * Download artifact content by storage path
+   * Streams the file through the PostHog backend so the sandbox does not need
+   * direct access to object storage.
+   */
+  async downloadArtifact(taskId, runId, storagePath) {
     const teamId = this.getTeamId();
     try {
-      const response = await this.apiRequest(
-        `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/presign/`,
+      const response = await this.performRequestWithRetry(
+        `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/download/`,
         {
           method: "POST",
           body: JSON.stringify({ storage_path: storagePath })
         }
       );
-      return response.url;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Download artifact content by storage path
-   * Gets a presigned URL and fetches the content
-   */
-  async downloadArtifact(taskId, runId, storagePath) {
-    const url = await this.getArtifactPresignedUrl(taskId, runId, storagePath);
-    if (!url) {
-      return null;
-    }
-    try {
-      const response = await fetch(url);
       if (!response.ok) {
         throw new Error(`Failed to download artifact: ${response.status}`);
       }
@@ -18883,8 +18889,16 @@ var userMessageParamsSchema = import_v4.z.object({
   content: import_v4.z.union([
     import_v4.z.string().min(1, "Content is required"),
     import_v4.z.array(import_v4.z.record(import_v4.z.string(), import_v4.z.unknown())).min(1, "Content is required")
-  ])
-});
+  ]).optional(),
+  artifacts: import_v4.z.array(import_v4.z.record(import_v4.z.string(), import_v4.z.unknown())).optional()
+}).refine(
+  (params) => {
+    const hasContent = typeof params.content === "string" ? params.content.trim().length > 0 : Array.isArray(params.content) && params.content.length > 0;
+    const hasArtifacts = Array.isArray(params.artifacts) && params.artifacts.length > 0;
+    return hasContent || hasArtifacts;
+  },
+  { error: "Either content or artifacts are required" }
+);
 var permissionResponseParamsSchema = import_v4.z.object({
   requestId: import_v4.z.string().min(1, "requestId is required"),
   optionId: import_v4.z.string().min(1, "optionId is required"),
@@ -19139,7 +19153,7 @@ var AgentServer = class _AgentServer {
           });
         },
         cancel: () => {
-          this.logger.info("SSE connection closed");
+          this.logger.debug("SSE connection closed");
           if (this.session?.sseController) {
             this.session.sseController = null;
           }
@@ -19307,9 +19321,22 @@ var AgentServer = class _AgentServer {
     switch (method) {
       case POSTHOG_NOTIFICATIONS.USER_MESSAGE:
       case "user_message": {
-        const prompt = normalizeCloudPromptContent(
-          params.content
-        );
+        this.logger.info("Received user_message command", {
+          hasContent: typeof params.content === "string" ? params.content.trim().length > 0 : Array.isArray(params.content) && params.content.length > 0,
+          artifactCount: Array.isArray(params.artifacts) ? params.artifacts.length : 0
+        });
+        const prompt = await this.buildPromptFromContentAndArtifacts({
+          content: params.content,
+          artifacts: Array.isArray(params.artifacts) ? params.artifacts : [],
+          taskId: this.session.payload.task_id,
+          runId: this.session.payload.run_id
+        });
+        if (prompt.length === 0) {
+          throw new Error("User message cannot be empty");
+        }
+        this.logger.info("Built user_message prompt", {
+          blockTypes: prompt.map((block) => block.type)
+        });
         const promptPreview = promptBlocksToText(prompt);
         this.logger.info(
           `Processing user message (detectedPrUrl=${this.detectedPrUrl ?? "none"}): ${promptPreview.substring(0, 100)}...`
@@ -19667,7 +19694,7 @@ var AgentServer = class _AgentServer {
     try {
       const task = await this.posthogAPI.getTask(payload.task_id);
       const initialPromptOverride = taskRun ? this.getInitialPromptOverride(taskRun) : null;
-      const pendingUserPrompt = this.getPendingUserPrompt(taskRun);
+      const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
       let initialPrompt = [];
       if (pendingUserPrompt?.length) {
         initialPrompt = pendingUserPrompt;
@@ -19694,6 +19721,7 @@ var AgentServer = class _AgentServer {
       this.logger.info("Initial task message completed", {
         stopReason: result.stopReason
       });
+      await this.clearPendingInitialPromptState(payload, taskRun);
       if (result.stopReason === "end_turn") {
         void this.syncCloudBranchMetadata(payload);
       }
@@ -19715,7 +19743,7 @@ var AgentServer = class _AgentServer {
       const conversationSummary = this.formatConversationForResume(
         this.resumeState.conversation
       );
-      const pendingUserPrompt = this.getPendingUserPrompt(taskRun);
+      const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
       const sandboxContext = this.resumeState.snapshotApplied ? `The workspace environment (all files, packages, and code changes) has been fully restored from where you left off.` : `The workspace files from the previous session were not restored (the file snapshot may have expired), so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
       let resumePromptBlocks;
       if (pendingUserPrompt?.length) {
@@ -19826,15 +19854,134 @@ ${toolSummary}`);
     const trimmed2 = override.trim();
     return trimmed2.length > 0 ? trimmed2 : null;
   }
-  getPendingUserPrompt(taskRun) {
+  async getPendingUserPrompt(taskRun) {
     if (!taskRun) return null;
     const state = taskRun.state;
     const message = state?.pending_user_message;
-    if (typeof message !== "string") {
+    const artifactIds = Array.isArray(state?.pending_user_artifact_ids) ? state.pending_user_artifact_ids.filter(
+      (artifactId) => typeof artifactId === "string" && artifactId.trim().length > 0
+    ) : [];
+    const prompt = await this.buildPromptFromContentAndArtifacts({
+      content: typeof message === "string" ? message : void 0,
+      artifacts: this.getArtifactsById(taskRun.artifacts, artifactIds),
+      taskId: taskRun.task,
+      runId: taskRun.id
+    });
+    this.logger.info("Built pending user prompt", {
+      hasMessage: typeof message === "string" && message.trim().length > 0,
+      requestedArtifactCount: artifactIds.length,
+      blockTypes: prompt.map((block) => block.type)
+    });
+    return prompt.length > 0 ? prompt : null;
+  }
+  getClearedPendingUserState(taskRun) {
+    const state = taskRun?.state && typeof taskRun.state === "object" ? taskRun.state : null;
+    if (!state) {
       return null;
     }
-    const prompt = deserializeCloudPrompt(message);
-    return prompt.length > 0 ? prompt : null;
+    const pendingKeys = [
+      "pending_user_message",
+      "pending_user_artifact_ids",
+      "pending_user_message_ts"
+    ].filter((key) => key in state);
+    return pendingKeys.length > 0 ? pendingKeys : null;
+  }
+  async clearPendingInitialPromptState(payload, taskRun) {
+    const stateRemoveKeys = this.getClearedPendingUserState(taskRun);
+    if (!stateRemoveKeys) {
+      return;
+    }
+    await this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
+      state_remove_keys: stateRemoveKeys
+    });
+  }
+  async buildPromptFromContentAndArtifacts({
+    content,
+    artifacts,
+    taskId,
+    runId
+  }) {
+    const contentBlocks = content ? normalizeCloudPromptContent(content) : [];
+    const artifactBlocks = await this.hydrateArtifactsToPrompt(
+      taskId,
+      runId,
+      artifacts ?? []
+    );
+    return [...contentBlocks, ...artifactBlocks];
+  }
+  getArtifactsById(artifacts, artifactIds) {
+    if (!artifacts?.length || artifactIds.length === 0) {
+      return [];
+    }
+    const artifactsById = new Map(
+      artifacts.filter(
+        (artifact) => typeof artifact.id === "string" && artifact.id.trim().length > 0
+      ).map((artifact) => [artifact.id, artifact])
+    );
+    return artifactIds.flatMap((artifactId) => {
+      const artifact = artifactsById.get(artifactId);
+      if (!artifact) {
+        this.logger.warn("Pending artifact missing from run manifest", {
+          artifactId
+        });
+        return [];
+      }
+      return [artifact];
+    });
+  }
+  async hydrateArtifactsToPrompt(taskId, runId, artifacts) {
+    if (artifacts.length === 0) {
+      return [];
+    }
+    this.logger.debug("Hydrating prompt artifacts", {
+      taskId,
+      runId,
+      artifactCount: artifacts.length,
+      artifactNames: artifacts.map((artifact) => artifact.name)
+    });
+    return (await Promise.all(
+      artifacts.map(
+        (artifact) => this.hydrateArtifactToPromptBlock(taskId, runId, artifact)
+      )
+    )).flatMap((artifactBlock) => artifactBlock ? [artifactBlock] : []);
+  }
+  async hydrateArtifactToPromptBlock(taskId, runId, artifact) {
+    if (!artifact.storage_path) {
+      this.logger.warn("Skipping artifact without storage path", {
+        taskId,
+        runId,
+        artifactName: artifact.name
+      });
+      return null;
+    }
+    const data = await this.posthogAPI.downloadArtifact(
+      taskId,
+      runId,
+      artifact.storage_path
+    );
+    if (!data) {
+      throw new Error(`Failed to download artifact ${artifact.name}`);
+    }
+    const safeName = this.getSafeArtifactName(artifact.name);
+    const artifactDir = (0, import_node_path8.join)(
+      this.config.repositoryPath ?? "/tmp/workspace",
+      ".posthog",
+      "attachments",
+      runId,
+      artifact.id ?? safeName
+    );
+    await (0, import_promises5.mkdir)(artifactDir, { recursive: true });
+    const artifactPath = (0, import_node_path8.join)(artifactDir, safeName);
+    await (0, import_promises5.writeFile)(artifactPath, Buffer.from(data));
+    return resourceLink((0, import_node_url2.pathToFileURL)(artifactPath).toString(), artifact.name, {
+      ...artifact.content_type ? { mimeType: artifact.content_type } : {},
+      ...typeof artifact.size === "number" ? { size: artifact.size } : {}
+    });
+  }
+  getSafeArtifactName(name2) {
+    const baseName = (0, import_node_path8.basename)(name2).trim();
+    const normalizedName = baseName.replace(/[^\w.-]/g, "_");
+    return normalizedName.length > 0 ? normalizedName : "attachment";
   }
   getResumeRunId(taskRun) {
     const envRunId = process.env.POSTHOG_RESUME_RUN_ID;