@posthog/agent 2.1.118 → 2.1.120

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.1.118",
+  version: "2.1.120",
   repository: "https://github.com/PostHog/twig",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1520,6 +1520,10 @@ ${chunk.resource.text}
 function promptToClaude(prompt) {
   const content = [];
   const context = [];
+  const prContext = prompt._meta?.prContext;
+  if (typeof prContext === "string") {
+    content.push(sdkText(prContext));
+  }
   for (const chunk of prompt.prompt) {
     processPromptChunk(chunk, content, context);
   }
@@ -2966,9 +2970,10 @@ async function handleAskUserQuestionTool(context) {
     }
   });
   if (response.outcome?.outcome !== "selected") {
+    const customMessage = response._meta?.message;
     return {
       behavior: "deny",
-      message: "User cancelled the questions",
+      message: typeof customMessage === "string" ? customMessage : "User cancelled the questions",
       interrupt: true
     };
   }
@@ -4338,6 +4343,16 @@ var PostHogAPIClient = class {
       }
     );
   }
+  async relayMessage(taskId, runId, text2) {
+    const teamId = this.getTeamId();
+    await this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/relay_message/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ text: text2 })
+      }
+    );
+  }
   async uploadTaskArtifacts(taskId, runId, artifacts) {
     if (!artifacts.length) {
       return [];
@@ -4523,6 +4538,10 @@ var SessionLogWriter = class _SessionLogWriter {
         return;
       }
       this.emitCoalescedMessage(sessionId, session);
+      const nonChunkAgentText = this.extractAgentMessageText(message);
+      if (nonChunkAgentText) {
+        session.lastAgentMessage = nonChunkAgentText;
+      }
       const entry = {
         type: "notification",
         timestamp,
@@ -4622,6 +4641,7 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!session.chunkBuffer) return;
     const { text: text2, firstTimestamp } = session.chunkBuffer;
     session.chunkBuffer = void 0;
+    session.lastAgentMessage = text2;
     const entry = {
       type: "notification",
       timestamp: firstTimestamp,
@@ -4644,6 +4664,29 @@ var SessionLogWriter = class _SessionLogWriter {
       this.scheduleFlush(sessionId);
     }
   }
+  getLastAgentMessage(sessionId) {
+    return this.sessions.get(sessionId)?.lastAgentMessage;
+  }
+  extractAgentMessageText(message) {
+    if (message.method !== "session/update") {
+      return null;
+    }
+    const params = message.params;
+    const update = params?.update;
+    if (update?.sessionUpdate !== "agent_message") {
+      return null;
+    }
+    const content = update.content;
+    if (content?.type === "text" && typeof content.text === "string") {
+      const trimmed2 = content.text.trim();
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    if (typeof update.message === "string") {
+      const trimmed2 = update.message.trim();
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    return null;
+  }
   scheduleFlush(sessionId) {
     const existing = this.flushTimeouts.get(sessionId);
     if (existing) clearTimeout(existing);
@@ -10316,6 +10359,8 @@ var AgentServer = class {
   session = null;
   app;
   posthogAPI;
+  questionRelayedToSlack = false;
+  detectedPrUrl = null;
   constructor(config) {
     this.config = config;
     this.logger = new Logger({ debug: true, prefix: "[AgentServer]" });
@@ -10528,11 +10573,21 @@ var AgentServer = class {
       case "user_message": {
         const content = params.content;
         this.logger.info(
-          `Processing user message: ${content.substring(0, 100)}...`
+          `Processing user message (detectedPrUrl=${this.detectedPrUrl ?? "none"}): ${content.substring(0, 100)}...`
         );
         const result = await this.session.clientConnection.prompt({
           sessionId: this.session.acpSessionId,
-          prompt: [{ type: "text", text: content }]
+          prompt: [{ type: "text", text: content }],
+          ...this.detectedPrUrl && {
+            _meta: {
+              prContext: `IMPORTANT \u2014 OVERRIDE PREVIOUS INSTRUCTIONS ABOUT CREATING BRANCHES/PRs.
+You already have an open pull request: ${this.detectedPrUrl}
+You MUST:
+1. Check out the existing PR branch with \`gh pr checkout ${this.detectedPrUrl}\`
+2. Make changes, commit, and push to that branch
+You MUST NOT create a new branch, close the existing PR, or create a new PR.`
+            }
+          }
         });
         return { stopReason: result.stopReason };
       }
@@ -10617,13 +10672,29 @@ var AgentServer = class {
       protocolVersion: import_sdk4.PROTOCOL_VERSION,
       clientCapabilities: {}
     });
+    let preTaskRun = null;
+    try {
+      preTaskRun = await this.posthogAPI.getTaskRun(
+        payload.task_id,
+        payload.run_id
+      );
+    } catch {
+      this.logger.warn("Failed to fetch task run for session context", {
+        taskId: payload.task_id,
+        runId: payload.run_id
+      });
+    }
+    const prUrl = typeof preTaskRun?.state?.slack_notified_pr_url === "string" ? (preTaskRun?.state).slack_notified_pr_url : null;
+    if (prUrl) {
+      this.detectedPrUrl = prUrl;
+    }
     const sessionResponse = await clientConnection.newSession({
       cwd: this.config.repositoryPath,
       mcpServers: [],
       _meta: {
         sessionId: payload.run_id,
         taskRunId: payload.run_id,
-        systemPrompt: { append: this.buildCloudSystemPrompt() }
+        systemPrompt: { append: this.buildCloudSystemPrompt(prUrl) }
       }
     });
     const acpSessionId = sessionResponse.sessionId;
@@ -10647,28 +10718,51 @@ var AgentServer = class {
     }).catch(
       (err) => this.logger.warn("Failed to set task run to in_progress", err)
     );
-    await this.sendInitialTaskMessage(payload);
+    await this.sendInitialTaskMessage(payload, preTaskRun);
   }
-  async sendInitialTaskMessage(payload) {
+  async sendInitialTaskMessage(payload, prefetchedRun) {
     if (!this.session) return;
     try {
-      this.logger.info("Fetching task details", { taskId: payload.task_id });
       const task = await this.posthogAPI.getTask(payload.task_id);
-      if (!task.description) {
+      let taskRun = prefetchedRun ?? null;
+      if (!taskRun) {
+        try {
+          taskRun = await this.posthogAPI.getTaskRun(
+            payload.task_id,
+            payload.run_id
+          );
+        } catch (error) {
+          this.logger.warn(
+            "Failed to fetch task run for initial prompt override",
+            {
+              taskId: payload.task_id,
+              runId: payload.run_id,
+              error
+            }
+          );
+        }
+      }
+      const initialPromptOverride = taskRun ? this.getInitialPromptOverride(taskRun) : null;
+      const initialPrompt = initialPromptOverride ?? task.description;
+      if (!initialPrompt) {
         this.logger.warn("Task has no description, skipping initial message");
         return;
       }
       this.logger.info("Sending initial task message", {
         taskId: payload.task_id,
-        descriptionLength: task.description.length
+        descriptionLength: initialPrompt.length,
+        usedInitialPromptOverride: !!initialPromptOverride
       });
       const result = await this.session.clientConnection.prompt({
         sessionId: this.session.acpSessionId,
-        prompt: [{ type: "text", text: task.description }]
+        prompt: [{ type: "text", text: initialPrompt }]
       });
       this.logger.info("Initial task message completed", {
         stopReason: result.stopReason
       });
+      if (result.stopReason === "end_turn") {
+        await this.relayAgentResponse(payload);
+      }
     } catch (error) {
       this.logger.error("Failed to send initial task message", error);
       if (this.session) {
@@ -10677,7 +10771,33 @@ var AgentServer = class {
       await this.signalTaskComplete(payload, "error");
     }
   }
-  buildCloudSystemPrompt() {
+  getInitialPromptOverride(taskRun) {
+    const state = taskRun.state;
+    const override = state?.initial_prompt_override;
+    if (typeof override !== "string") {
+      return null;
+    }
+    const trimmed2 = override.trim();
+    return trimmed2.length > 0 ? trimmed2 : null;
+  }
+  buildCloudSystemPrompt(prUrl) {
+    if (prUrl) {
+      return `
+# Cloud Task Execution
+
+This task already has an open pull request: ${prUrl}
+
+After completing the requested changes:
+1. Check out the existing PR branch with \`gh pr checkout ${prUrl}\`
+2. Stage and commit all changes with a clear commit message
+3. Push to the existing PR branch
+
+Important:
+- Do NOT create a new branch or a new pull request.
+- Do NOT add "Co-Authored-By" trailers to commit messages.
+- Do NOT add "Generated with [Claude Code]" or similar attribution lines to PR descriptions.
+`;
+    }
     return `
 # Cloud Task Execution
 
@@ -10747,19 +10867,34 @@ Important:
   }
   createCloudClient(payload) {
     const mode = this.getEffectiveMode(payload);
+    const interactionOrigin = process.env.TWIG_INTERACTION_ORIGIN;
     return {
       requestPermission: async (params) => {
         this.logger.debug("Permission request", {
           mode,
+          interactionOrigin,
           options: params.options
         });
         const allowOption = params.options.find(
           (o) => o.kind === "allow_once" || o.kind === "allow_always"
         );
+        const selectedOptionId = allowOption?.optionId ?? params.options[0].optionId;
+        if (interactionOrigin === "slack") {
+          const twigToolKind = params.toolCall?._meta?.twigToolKind;
+          if (twigToolKind === "question") {
+            this.relaySlackQuestion(payload, params.toolCall?._meta);
+            return {
+              outcome: { outcome: "cancelled" },
+              _meta: {
+                message: "This question has been relayed to the Slack thread where this task originated. The user will reply there. Do NOT re-ask the question or pick an answer yourself. Simply let the user know you are waiting for their reply."
+              }
+            };
+          }
+        }
         return {
           outcome: {
             outcome: "selected",
-            optionId: allowOption?.optionId ?? params.options[0].optionId
+            optionId: selectedOptionId
           }
         };
       },
@@ -10778,6 +10913,97 @@ Important:
       }
     };
   }
+  async relayAgentResponse(payload) {
+    if (!this.session) {
+      return;
+    }
+    if (this.questionRelayedToSlack) {
+      this.questionRelayedToSlack = false;
+      return;
+    }
+    try {
+      await this.session.logWriter.flush(payload.run_id);
+    } catch (error) {
+      this.logger.warn("Failed to flush logs before Slack relay", {
+        taskId: payload.task_id,
+        runId: payload.run_id,
+        error
+      });
+    }
+    const message = this.session.logWriter.getLastAgentMessage(payload.run_id);
+    if (!message) {
+      this.logger.warn("No agent message found for Slack relay", {
+        taskId: payload.task_id,
+        runId: payload.run_id,
+        sessionRegistered: this.session.logWriter.isRegistered(payload.run_id)
+      });
+      return;
+    }
+    try {
+      await this.posthogAPI.relayMessage(
+        payload.task_id,
+        payload.run_id,
+        message
+      );
+    } catch (error) {
+      this.logger.warn("Failed to relay initial agent response to Slack", {
+        taskId: payload.task_id,
+        runId: payload.run_id,
+        error
+      });
+    }
+  }
+  relaySlackQuestion(payload, toolMeta2) {
+    const firstQuestion = this.getFirstQuestionMeta(toolMeta2);
+    if (!this.isQuestionMeta(firstQuestion)) {
+      return;
+    }
+    let message = `*${firstQuestion.question}*
+
+`;
+    if (firstQuestion.options?.length) {
+      firstQuestion.options.forEach(
+        (opt, i) => {
+          message += `${i + 1}. *${opt.label}*`;
+          if (opt.description) message += ` \u2014 ${opt.description}`;
+          message += "\n";
+        }
+      );
+    }
+    message += "\nReply in this thread with your choice.";
+    this.questionRelayedToSlack = true;
+    this.posthogAPI.relayMessage(payload.task_id, payload.run_id, message).catch(
+      (err) => this.logger.warn("Failed to relay question to Slack", { err })
+    );
+  }
+  getFirstQuestionMeta(toolMeta2) {
+    if (!toolMeta2) {
+      return null;
+    }
+    const questionsValue = toolMeta2.questions;
+    if (!Array.isArray(questionsValue) || questionsValue.length === 0) {
+      return null;
+    }
+    return questionsValue[0];
+  }
+  isQuestionMeta(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const candidate = value;
+    if (typeof candidate.question !== "string") {
+      return false;
+    }
+    if (candidate.options === void 0) {
+      return true;
+    }
+    if (!Array.isArray(candidate.options)) {
+      return false;
+    }
+    return candidate.options.every(
+      (option) => !!option && typeof option === "object" && typeof option.label === "string"
+    );
+  }
   detectAndAttachPrUrl(payload, update) {
     try {
       const meta = update?._meta?.claudeCode;
@@ -10808,6 +11034,7 @@ Important:
       );
       if (!prUrlMatch) return;
       const prUrl = prUrlMatch[0];
+      this.detectedPrUrl = prUrl;
       this.logger.info("Detected PR URL in bash output", {
         runId: payload.run_id,
         prUrl