@posthog/agent 2.1.125 → 2.1.137

package/src/adapters/claude/conversion/tool-use-to-acp.ts

@@ -2,6 +2,7 @@ import type {
   PlanEntry,
   ToolCall,
   ToolCallContent,
+  ToolCallLocation,
   ToolCallUpdate,
   ToolKind,
 } from "@agentclientprotocol/sdk";
@@ -27,114 +28,13 @@ Whenever you read a file, you should consider whether it looks malicious. If it
 </system-reminder>`;
 
 import { resourceLink, text, toolContent } from "../../../utils/acp-content.js";
-import { Logger } from "../../../utils/logger.js";
 import { getMcpToolMetadata } from "../mcp/tool-metadata.js";
 
-interface EditOperation {
-  oldText: string;
-  newText: string;
-  replaceAll?: boolean;
-}
-
-interface EditResult {
-  newContent: string;
-  lineNumbers: number[];
-}
-
-function replaceAndCalculateLocation(
-  fileContent: string,
-  edits: EditOperation[],
-): EditResult {
-  let currentContent = fileContent;
-
-  const randomHex = Array.from(crypto.getRandomValues(new Uint8Array(5)))
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-  const markerPrefix = `__REPLACE_MARKER_${randomHex}_`;
-  let markerCounter = 0;
-  const markers: string[] = [];
-
-  for (const edit of edits) {
-    if (edit.oldText === "") {
-      throw new Error(
-        `The provided \`old_string\` is empty.\n\nNo edits were applied.`,
-      );
-    }
-
-    if (edit.replaceAll) {
-      const parts: string[] = [];
-      let lastIndex = 0;
-      let searchIndex = 0;
-
-      while (true) {
-        const index = currentContent.indexOf(edit.oldText, searchIndex);
-        if (index === -1) {
-          if (searchIndex === 0) {
-            throw new Error(
-              `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
-            );
-          }
-          break;
-        }
-
-        parts.push(currentContent.substring(lastIndex, index));
-
-        const marker = `${markerPrefix}${markerCounter++}__`;
-        markers.push(marker);
-        parts.push(marker + edit.newText);
-
-        lastIndex = index + edit.oldText.length;
-        searchIndex = lastIndex;
-      }
-
-      parts.push(currentContent.substring(lastIndex));
-      currentContent = parts.join("");
-    } else {
-      const index = currentContent.indexOf(edit.oldText);
-      if (index === -1) {
-        throw new Error(
-          `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
-        );
-      } else {
-        const marker = `${markerPrefix}${markerCounter++}__`;
-        markers.push(marker);
-        currentContent =
-          currentContent.substring(0, index) +
-          marker +
-          edit.newText +
-          currentContent.substring(index + edit.oldText.length);
-      }
-    }
-  }
-
-  const lineNumbers: number[] = [];
-  for (const marker of markers) {
-    const index = currentContent.indexOf(marker);
-    if (index !== -1) {
-      const lineNumber = Math.max(
-        0,
-        currentContent.substring(0, index).split(/\r\n|\r|\n/).length - 1,
-      );
-      lineNumbers.push(lineNumber);
-    }
-  }
-
-  let finalContent = currentContent;
-  for (const marker of markers) {
-    finalContent = finalContent.replace(marker, "");
-  }
-
-  const uniqueLineNumbers = [...new Set(lineNumbers)].sort();
-
-  return { newContent: finalContent, lineNumbers: uniqueLineNumbers };
-}
-
 type ToolInfo = Pick<ToolCall, "title" | "kind" | "content" | "locations">;
 
 export function toolInfoFromToolUse(
   toolUse: Pick<ToolUseBlock, "name" | "input">,
-  cachedFileContent: { [key: string]: string },
-  logger: Logger = new Logger({ debug: false, prefix: "[ClaudeTools]" }),
+  options?: { supportsTerminalOutput?: boolean; toolUseId?: string },
 ): ToolInfo {
   const name = toolUse.name;
   const input = toolUse.input as Record<string, unknown> | undefined;
@@ -176,6 +76,15 @@ export function toolInfoFromToolUse(
       };
 
     case "Bash":
+      if (options?.supportsTerminalOutput && options?.toolUseId) {
+        return {
+          title: input?.description
+            ? String(input.description)
+            : "Execute command",
+          kind: "execute",
+          content: [{ type: "terminal", terminalId: options.toolUseId }],
+        };
+      }
       return {
         title: input?.description
           ? String(input.description)
@@ -203,11 +112,11 @@ export function toolInfoFromToolUse(
     case "Read": {
       let limit = "";
       const inputLimit = input?.limit as number | undefined;
-      const inputOffset = (input?.offset as number | undefined) ?? 0;
+      const inputOffset = (input?.offset as number | undefined) ?? 1;
       if (inputLimit) {
-        limit = ` (${inputOffset + 1} - ${inputOffset + inputLimit})`;
-      } else if (inputOffset) {
-        limit = ` (from line ${inputOffset + 1})`;
+        limit = ` (${inputOffset} - ${inputOffset + inputLimit - 1})`;
+      } else if (inputOffset > 1) {
+        limit = ` (from line ${inputOffset})`;
       }
       return {
         title: `Read ${input?.file_path ? String(input.file_path) : "File"}${limit}`,
@@ -234,27 +143,9 @@ export function toolInfoFromToolUse(
 
     case "Edit": {
       const path = input?.file_path ? String(input.file_path) : undefined;
-      let oldText = input?.old_string ? String(input.old_string) : null;
-      let newText = input?.new_string ? String(input.new_string) : "";
-      let affectedLines: number[] = [];
-
-      if (path && oldText) {
-        try {
-          const oldContent = cachedFileContent[path] || "";
-          const newContent = replaceAndCalculateLocation(oldContent, [
-            {
-              oldText,
-              newText,
-              replaceAll: false,
-            },
-          ]);
-          oldText = oldContent;
-          newText = newContent.newContent;
-          affectedLines = newContent.lineNumbers;
-        } catch (e) {
-          logger.error("Failed to edit file", e);
-        }
-      }
+      const oldText = input?.old_string ? String(input.old_string) : null;
+      const newText = input?.new_string ? String(input.new_string) : "";
+
       return {
         title: path ? `Edit \`${path}\`` : "Edit",
         kind: "edit",
@@ -269,11 +160,7 @@ export function toolInfoFromToolUse(
                 },
               ]
             : [],
-        locations: path
-          ? affectedLines.length > 0
-            ? affectedLines.map((line) => ({ line, path }))
-            : [{ path }]
-          : [],
+        locations: path ? [{ path }] : [],
       };
     }
 
@@ -335,10 +222,10 @@ export function toolInfoFromToolUse(
 
       if (input?.output_mode) {
         switch (input.output_mode) {
-          case "FilesWithMatches":
+          case "files_with_matches":
             label += " -l";
             break;
-          case "Count":
+          case "count":
             label += " -c";
             break;
           default:
@@ -362,7 +249,9 @@ export function toolInfoFromToolUse(
         label += " -P";
       }
 
-      label += ` "${input?.pattern ? String(input.pattern) : ""}"`;
+      if (input?.pattern) {
+        label += ` "${String(input.pattern)}"`;
+      }
 
       if (input?.path) {
         label += ` ${String(input.path)}`;
@@ -487,6 +376,70 @@ function mcpToolInfo(
   };
 }
 
+interface StructuredPatchHunk {
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  lines: string[];
+}
+
+interface StructuredPatch {
+  oldFileName: string;
+  newFileName: string;
+  hunks: StructuredPatchHunk[];
+}
+
+export function toolUpdateFromEditToolResponse(
+  toolResponse: unknown,
+): { content: ToolCallContent[]; locations: ToolCallLocation[] } | null {
+  if (!toolResponse || typeof toolResponse !== "object") return null;
+  const response = toolResponse as Record<string, unknown>;
+
+  const patches = response.structuredPatch as StructuredPatch[] | undefined;
+  if (!Array.isArray(patches) || patches.length === 0) return null;
+
+  const content: ToolCallContent[] = [];
+  const locations: ToolCallLocation[] = [];
+
+  for (const patch of patches) {
+    if (!patch.hunks || patch.hunks.length === 0) continue;
+
+    const filePath = patch.newFileName || patch.oldFileName;
+
+    const oldLines: string[] = [];
+    const newLines: string[] = [];
+    for (const hunk of patch.hunks) {
+      for (const line of hunk.lines) {
+        if (line.startsWith("-")) {
+          oldLines.push(line.slice(1));
+        } else if (line.startsWith("+")) {
+          newLines.push(line.slice(1));
+        } else if (line.startsWith(" ")) {
+          oldLines.push(line.slice(1));
+          newLines.push(line.slice(1));
+        }
+      }
+    }
+
+    content.push({
+      type: "diff",
+      path: filePath,
+      oldText: oldLines.join("\n"),
+      newText: newLines.join("\n"),
+    });
+
+    const firstHunk = patch.hunks[0];
+    locations.push({
+      path: filePath,
+      line: firstHunk.newStart,
+    });
+  }
+
+  if (content.length === 0) return null;
+  return { content, locations };
+}
+
 export function toolUpdateFromToolResult(
   toolResult:
     | ToolResultBlockParam
@@ -499,13 +452,27 @@ export function toolUpdateFromToolResult(
     | BetaRequestMCPToolResultBlockParam
     | BetaToolSearchToolResultBlockParam,
   toolUse: Pick<ToolUseBlock, "name" | "input"> | undefined,
-): Pick<ToolCallUpdate, "title" | "content" | "locations"> {
+  options?: { supportsTerminalOutput?: boolean; toolUseId?: string },
+): Pick<ToolCallUpdate, "title" | "content" | "locations" | "_meta"> {
+  if (
+    "is_error" in toolResult &&
+    toolResult.is_error &&
+    toolResult.content &&
+    (toolResult.content as unknown[]).length > 0
+  ) {
+    return toAcpContentUpdate(toolResult.content, true);
+  }
+
   switch (toolUse?.name) {
     case "Read":
       if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
         return {
           content: toolResult.content.map((item) => {
-            const itemObj = item as { type?: string; text?: string };
+            const itemObj = item as {
+              type?: string;
+              text?: string;
+              source?: { data?: string; media_type?: string };
+            };
             if (itemObj.type === "text") {
               return {
                 type: "content" as const,
@@ -516,6 +483,16 @@ export function toolUpdateFromToolResult(
                 ),
               };
             }
+            if (itemObj.type === "image" && itemObj.source) {
+              return {
+                type: "content" as const,
+                content: {
+                  type: "image" as const,
+                  data: itemObj.source.data ?? "",
+                  mimeType: itemObj.source.media_type ?? "image/png",
+                },
+              };
+            }
             return {
               type: "content" as const,
               content: item as { type: "text"; text: string },
@@ -537,23 +514,71 @@ export function toolUpdateFromToolResult(
       return {};
 
     case "Bash": {
-      return toAcpContentUpdate(
-        toolResult.content,
-        "is_error" in toolResult ? toolResult.is_error : false,
-      );
-    }
-    case "Edit":
-    case "Write": {
+      const result = toolResult.content;
+      const terminalId =
+        "tool_use_id" in toolResult ? String(toolResult.tool_use_id) : "";
+      const isError = "is_error" in toolResult && toolResult.is_error;
+
+      let output = "";
+      let exitCode = isError ? 1 : 0;
+
       if (
-        "is_error" in toolResult &&
-        toolResult.is_error &&
-        toolResult.content &&
-        toolResult.content.length > 0
+        result &&
+        typeof result === "object" &&
+        "type" in result &&
+        (result as { type: string }).type === "bash_code_execution_result"
       ) {
-        return toAcpContentUpdate(toolResult.content, true);
+        const bashResult = result as {
+          stdout?: string;
+          stderr?: string;
+          return_code: number;
+        };
+        output = [bashResult.stdout, bashResult.stderr]
+          .filter(Boolean)
+          .join("\n");
+        exitCode = bashResult.return_code;
+      } else if (typeof result === "string") {
+        output = result;
+      } else if (
+        Array.isArray(result) &&
+        result.length > 0 &&
+        "text" in result[0] &&
+        typeof result[0].text === "string"
+      ) {
+        output = result.map((c: { text?: string }) => c.text ?? "").join("\n");
+      }
+
+      if (options?.supportsTerminalOutput) {
+        return {
+          content: [{ type: "terminal" as const, terminalId }],
+          _meta: {
+            terminal_info: {
+              terminal_id: terminalId,
+            },
+            terminal_output: {
+              terminal_id: terminalId,
+              data: output,
+            },
+            terminal_exit: {
+              terminal_id: terminalId,
+              exit_code: exitCode,
+              signal: null,
+            },
+          },
+        };
+      }
+      if (output.trim()) {
+        return {
+          content: toolContent()
+            .text(`\`\`\`console\n${output.trimEnd()}\n\`\`\``)
+            .build(),
+        };
       }
       return {};
     }
+    case "Edit":
+    case "Write":
+      return {};
 
     case "ExitPlanMode": {
       return { title: "Exited Plan Mode" };

package/src/adapters/claude/hooks.ts

@@ -1,4 +1,6 @@
 import type { HookCallback, HookInput } from "@anthropic-ai/claude-agent-sdk";
+import type { Logger } from "../../utils/logger.js";
+import type { SettingsManager } from "./session/settings.js";
 import type { TwigExecutionMode } from "./tools.js";
 
 const toolUseCallbacks: {
@@ -32,10 +34,11 @@ export type OnModeChange = (mode: TwigExecutionMode) => Promise<void>;
 
 interface CreatePostToolUseHookParams {
   onModeChange?: OnModeChange;
+  logger?: Logger;
 }
 
 export const createPostToolUseHook =
-  ({ onModeChange }: CreatePostToolUseHookParams): HookCallback =>
+  ({ onModeChange, logger }: CreatePostToolUseHookParams): HookCallback =>
   async (
     input: HookInput,
     toolUseID: string | undefined,
@@ -57,8 +60,57 @@ export const createPostToolUseHook =
             input.tool_response,
           );
           delete toolUseCallbacks[toolUseID];
+        } else {
+          logger?.error(
+            `No onPostToolUseHook found for tool use ID: ${toolUseID}`,
+          );
+          delete toolUseCallbacks[toolUseID];
         }
       }
     }
     return { continue: true };
   };
+
+export const createPreToolUseHook =
+  (settingsManager: SettingsManager, logger: Logger): HookCallback =>
+  async (input: HookInput, _toolUseID: string | undefined) => {
+    if (input.hook_event_name !== "PreToolUse") {
+      return { continue: true };
+    }
+
+    const toolName = input.tool_name;
+    const toolInput = input.tool_input;
+    const permissionCheck = settingsManager.checkPermission(
+      toolName,
+      toolInput,
+    );
+
+    if (permissionCheck.decision !== "ask") {
+      logger.info(
+        `[PreToolUseHook] Tool: ${toolName}, Decision: ${permissionCheck.decision}, Rule: ${permissionCheck.rule}`,
+      );
+    }
+
+    switch (permissionCheck.decision) {
+      case "allow":
+        return {
+          continue: true,
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse" as const,
+            permissionDecision: "allow" as const,
+            permissionDecisionReason: `Allowed by settings rule: ${permissionCheck.rule}`,
+          },
+        };
+      case "deny":
+        return {
+          continue: true,
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse" as const,
+            permissionDecision: "deny" as const,
+            permissionDecisionReason: `Denied by settings rule: ${permissionCheck.rule}`,
+          },
+        };
+      default:
+        return { continue: true };
+    }
+  };

package/src/adapters/claude/permissions/permission-handlers.ts

@@ -43,11 +43,12 @@ interface ToolHandlerContext {
   toolInput: Record<string, unknown>;
   toolUseID: string;
   suggestions?: PermissionUpdate[];
+  signal?: AbortSignal;
   client: AgentSideConnection;
   sessionId: string;
   fileContentCache: { [key: string]: string };
   logger: Logger;
-  emitConfigOptionsUpdate: () => Promise<void>;
+  updateConfigOption: (configId: string, value: string) => Promise<void>;
 }
 
 async function emitToolDenial(
@@ -132,13 +133,12 @@ async function requestPlanApproval(
   context: ToolHandlerContext,
   updatedInput: Record<string, unknown>,
 ): Promise<RequestPermissionResponse> {
-  const { client, sessionId, toolUseID, fileContentCache } = context;
+  const { client, sessionId, toolUseID } = context;
 
-  const toolInfo = toolInfoFromToolUse(
-    { name: context.toolName, input: updatedInput },
-    fileContentCache,
-    context.logger,
-  );
+  const toolInfo = toolInfoFromToolUse({
+    name: context.toolName,
+    input: updatedInput,
+  });
 
   return await client.requestPermission({
     options: buildExitPlanModePermissionOptions(),
@@ -168,7 +168,14 @@ async function applyPlanApproval(
   ) {
     session.permissionMode = response.outcome.optionId;
     await session.query.setPermissionMode(response.outcome.optionId);
-    await context.emitConfigOptionsUpdate();
+    await context.client.sessionUpdate({
+      sessionId: context.sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        currentModeId: response.outcome.optionId,
+      },
+    });
+    await context.updateConfigOption("mode", response.outcome.optionId);
 
     return {
       behavior: "allow",
@@ -196,7 +203,7 @@ async function handleEnterPlanModeTool(
 
   session.permissionMode = "plan";
   await session.query.setPermissionMode("plan");
-  await context.emitConfigOptionsUpdate();
+  await context.updateConfigOption("mode", "plan");
 
   return {
     behavior: "allow",
@@ -221,6 +228,9 @@ async function handleExitPlanModeTool(
   }
 
   const response = await requestPlanApproval(context, updatedInput);
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
   return await applyPlanApproval(response, context, updatedInput);
 }
 
@@ -250,15 +260,14 @@ async function handleAskUserQuestionTool(
     };
   }
 
-  const { client, sessionId, toolUseID, toolInput, fileContentCache } = context;
+  const { client, sessionId, toolUseID, toolInput } = context;
   const firstQuestion = questions[0];
   const options = buildQuestionOptions(firstQuestion);
 
-  const toolInfo = toolInfoFromToolUse(
-    { name: context.toolName, input: toolInput },
-    fileContentCache,
-    context.logger,
-  );
+  const toolInfo = toolInfoFromToolUse({
+    name: context.toolName,
+    input: toolInput,
+  });
 
   const response = await client.requestPermission({
     options,
@@ -275,6 +284,10 @@ async function handleAskUserQuestionTool(
     },
   });
 
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
+
   if (response.outcome?.outcome !== "selected") {
     const customMessage = (
       response._meta as Record<string, unknown> | undefined
@@ -317,15 +330,10 @@ async function handleDefaultPermissionFlow(
     toolUseID,
     client,
     sessionId,
-    fileContentCache,
     suggestions,
   } = context;
 
-  const toolInfo = toolInfoFromToolUse(
-    { name: toolName, input: toolInput },
-    fileContentCache,
-    context.logger,
-  );
+  const toolInfo = toolInfoFromToolUse({ name: toolName, input: toolInput });
 
   const options = buildPermissionOptions(
     toolName,
@@ -347,6 +355,10 @@ async function handleDefaultPermissionFlow(
     },
   });
 
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
+
   if (
     response.outcome?.outcome === "selected" &&
     (response.outcome.optionId === "allow" ||
@@ -436,5 +448,11 @@ export async function canUseTool(
     return planFileResult;
   }
 
+  // if (session.permissionMode === "dontAsk") {
+  //   const message = "Tool not pre-approved. Denied by dontAsk mode.";
+  //   await emitToolDenial(context, message);
+  //   return { behavior: "deny", message, interrupt: false };
+  // }
+
   return handleDefaultPermissionFlow(context);
 }

package/src/adapters/claude/session/commands.ts

@@ -1,9 +1,10 @@
 import type { AvailableCommand } from "@agentclientprotocol/sdk";
-import type { Query } from "@anthropic-ai/claude-agent-sdk";
+import type { SlashCommand } from "@anthropic-ai/claude-agent-sdk";
 
 const UNSUPPORTED_COMMANDS = [
   "context",
   "cost",
+  "keybindings-help",
   "login",
   "logout",
   "output-style:new",
@@ -11,16 +12,19 @@ const UNSUPPORTED_COMMANDS = [
   "todos",
 ];
 
-export async function getAvailableSlashCommands(
-  q: Query,
-): Promise<AvailableCommand[]> {
-  const commands = await q.supportedCommands();
-
+export function getAvailableSlashCommands(
+  commands: SlashCommand[],
+): AvailableCommand[] {
   return commands
     .map((command) => {
-      const input = command.argumentHint
-        ? { hint: command.argumentHint }
-        : null;
+      const input =
+        command.argumentHint != null
+          ? {
+              hint: Array.isArray(command.argumentHint)
+                ? command.argumentHint.join(" ")
+                : command.argumentHint,
+            }
+          : null;
       let name = command.name;
       if (command.name.endsWith(" (MCP)")) {
         name = `mcp:${name.replace(" (MCP)", "")}`;

package/src/adapters/claude/session/mcp-config.ts

@@ -1,11 +1,8 @@
-import type {
-  LoadSessionRequest,
-  NewSessionRequest,
-} from "@agentclientprotocol/sdk";
+import type { NewSessionRequest } from "@agentclientprotocol/sdk";
 import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
 
 export function parseMcpServers(
-  params: NewSessionRequest | LoadSessionRequest,
+  params: Pick<NewSessionRequest, "mcpServers">,
 ): Record<string, McpServerConfig> {
   const mcpServers: Record<string, McpServerConfig> = {};
   if (!Array.isArray(params.mcpServers)) {