@agentclientprotocol/claude-agent-acp 0.81.3-preview.1 → 0.82.0

package/dist/context-compaction.js

@@ -1,4 +1,5 @@
 import { createContextCompactionMeta, } from "./context-compaction-meta.js";
+import { compactionToolCall } from "./tool-calls/reporters/compaction.js";
 export function clientSupportsCompactionUpdates(capabilities) {
     const compaction = capabilities?.session?.compaction;
     return typeof compaction === "object" && compaction !== null && !Array.isArray(compaction);
@@ -106,11 +107,13 @@ export class ContextCompactionLifecycle {
     sessionId;
     presentation;
     logError;
+    airClient;
     constructor(sendUpdate, options) {
         this.sendUpdate = sendUpdate;
         this.sessionId = options.sessionId;
         this.presentation = options.presentation ?? "tool_call";
         this.logError = options.logError ?? (() => { });
+        this.airClient = options.airClient ?? false;
     }
     get hasDeliveredOutput() {
         return this.outputDelivered;
@@ -182,18 +185,11 @@ export class ContextCompactionLifecycle {
                 sessionUpdate: "compaction_update",
                 compactionId,
                 status: "in_progress",
-                _meta: createContextCompactionMeta(),
+                ...(this.airClient ? { _meta: createContextCompactionMeta() } : {}),
             });
             return;
         }
-        await this.send({
-            sessionUpdate: "tool_call",
-            toolCallId: compactionId,
-            title: "Compact conversation",
-            kind: "think",
-            status: "in_progress",
-            _meta: compactionToolMeta(),
-        });
+        await this.send(compactionToolCall.started(compactionId, this.airClient));
     }
     /**
      * Streaming progress from the API's compaction content block.
@@ -211,6 +207,7 @@ export class ContextCompactionLifecycle {
             const state = this.activeCompaction;
             if (!state || state.terminalStatus || !summaryChunk)
                 return;
+            state.streamedSummary = (state.streamedSummary ?? "") + summaryChunk;
             await this.send({
                 sessionUpdate: "compaction_summary_chunk",
                 compactionId: state.compactionId,
@@ -224,12 +221,7 @@ export class ContextCompactionLifecycle {
         if (!state || state.terminalStatus || state.heartbeatSent)
             return;
         state.heartbeatSent = true;
-        await this.send({
-            sessionUpdate: "tool_call_update",
-            toolCallId: state.compactionId,
-            status: "in_progress",
-            _meta: compactionToolMeta(),
-        });
+        await this.send(compactionToolCall.inProgress(state.compactionId, this.airClient));
     }
     /**
      * The PostCompact hook's summary. The CLI awaits the hook before emitting
@@ -280,7 +272,13 @@ export class ContextCompactionLifecycle {
         const terminalStatus = state.terminalStatus ?? status;
         const hasMetadata = Object.keys(metadata).length > 0;
         if (this.presentation === "compaction_update") {
-            const summary = firstTerminal && terminalStatus === "completed" ? state.summary : undefined;
+            // A summary that went out as chunks is not sent again in full. The
+            // chunks are the raw API text and the summary is the cleaned hook text,
+            // so the summary is left out only when both hold the same text.
+            const summaryStreamed = state.streamedSummary === state.summary;
+            const summary = firstTerminal && terminalStatus === "completed" && !summaryStreamed
+                ? state.summary
+                : undefined;
             await this.send({
                 sessionUpdate: "compaction_update",
                 compactionId: state.compactionId,
@@ -290,35 +288,15 @@ export class ContextCompactionLifecycle {
                 // `_meta` is a replace-patch: seed it with the first terminal, then
                 // only re-send it when the boundary adds facts, so a status-only
                 // duplicate can't wipe the token counts.
-                ...(firstTerminal || hasMetadata ? { _meta: createContextCompactionMeta(metadata) } : {}),
+                // The standard `error` field carries the error, so `_meta` does not.
+                // Only AIR gets the compaction facts.
+                ...(this.airClient && (firstTerminal || hasMetadata)
+                    ? { _meta: createContextCompactionMeta(withoutError(metadata)) }
+                    : {}),
             });
             return;
         }
-        const rawOutput = hasMetadata ? metadata : undefined;
-        const errorContent = status === "failed" && metadata.error
-            ? { content: [compactionErrorContent(metadata.error)] }
-            : {};
-        if (opened) {
-            await this.send({
-                sessionUpdate: "tool_call",
-                toolCallId: state.compactionId,
-                title: "Compact conversation",
-                kind: "think",
-                status,
-                ...errorContent,
-                ...(rawOutput ? { rawOutput } : {}),
-                _meta: compactionToolMeta(metadata),
-            });
-            return;
-        }
-        await this.send({
-            sessionUpdate: "tool_call_update",
-            toolCallId: state.compactionId,
-            ...(firstTerminal ? { status } : {}),
-            ...errorContent,
-            ...(rawOutput ? { rawOutput } : {}),
-            _meta: compactionToolMeta(metadata),
-        });
+        await this.send(compactionToolCall.finished(state.compactionId, opened || firstTerminal ? status : undefined, metadata, opened, this.airClient));
     }
     /** Make `compactionId` the active entity, moving a pending hook summary onto
      *  it, and mark compaction output as delivered for the owning turn. */
@@ -346,6 +324,9 @@ export class ContextCompactionLifecycle {
         }
     }
 }
+function withoutError({ error: _error, ...facts }) {
+    return facts;
+}
 export function contextCompactionMetadataFromBoundary(compactMetadata) {
     return {
         trigger: compactMetadata.trigger === "auto" ? "automatic" : "manual",
@@ -358,18 +339,3 @@ export function contextCompactionMetadataFromBoundary(compactMetadata) {
             : {}),
     };
 }
-function compactionToolMeta(metadata = {}) {
-    return {
-        ...createContextCompactionMeta(metadata),
-        claudeCode: { toolName: "compact" },
-    };
-}
-function compactionErrorContent(error) {
-    return {
-        type: "content",
-        content: {
-            type: "text",
-            text: `Compaction failed: ${error}`,
-        },
-    };
-}

package/dist/diff.d.ts

@@ -1,13 +1,81 @@
 import { ToolCallContent, ToolCallLocation } from "@agentclientprotocol/sdk";
 /**
- * Builds diff ToolUpdate content from the structured toolResponse provided by
- * the PostToolUse hook for diff-producing tools (Edit, Write). Unlike parsing
- * the plain unified diff string, this uses the pre-parsed structuredPatch
- * which supports multiple replacement sites (replaceAll) and always includes
- * context lines for better readability.
+ * The largest file, in bytes, that the adapter turns into a git patch.
+ *
+ * A larger file, a larger new text, or an Edit whose result can be larger
+ * gets no patch. The tool call then keeps its standard ACP content. The limit
+ * bounds the file read, the replacement, and the line diff that run while
+ * Claude waits for an approval.
+ */
+export declare const MAX_PATCH_FILE_BYTES: number;
+/**
+ * One unified-diff hunk in the `diff` package convention.
+ *
+ * A side with zero lines stores the number of the line after the change as its
+ * start. {@link hunkHeader} converts that start to the git convention.
+ */
+interface PatchHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+}
+/** The kind of file change that a git patch describes. */
+type FileChange = "create" | "update";
+/**
+ * Builds the exact patch shown before Claude runs an Edit or Write tool.
+ *
+ * Returns undefined when the adapter cannot predict the file change exactly.
+ * The caller then keeps the standard tool-call content. The adapter declines
+ * a file that is missing for an Edit, too large, binary, or that has CR line
+ * endings. Claude converts the line endings of an edited file, so an in-memory
+ * replacement would not match the bytes that Claude writes. It also declines
+ * an `old_string` that does not match exactly once, because Claude then
+ * normalizes quotes or fails.
+ *
+ * A Write always gets content that shows the change: the patch, the standard
+ * diff of a text that cannot have an exact patch, or a notice that the Write
+ * overwrites a file that the adapter cannot show.
+ *
+ * The preview uses the tool input as it is. Claude can still remove the
+ * trailing whitespace of a line before it writes. The PostToolUse hook then
+ * sends the patch of the written file.
+ */
+export declare function previewPatchContent(toolName: string, input: Record<string, unknown>, cwd?: string): Promise<ToolCallContent[] | undefined>;
+/**
+ * Builds the git patch for a finished Edit or Write from the file on disk.
+ *
+ * The Claude SDK `structuredPatch` is display data: Claude converts leading
+ * tabs to spaces and CRLF line endings to LF before it computes the hunks. A
+ * patch built from those hunks does not match the file. This function diffs
+ * `originalFile` against the written file instead. It returns undefined when
+ * it cannot build an exact patch, and the caller then sends the standard diff.
+ * A written file that contains a CR or a byte order mark is declined, because
+ * Claude removed those bytes from `originalFile`.
+ */
+export declare function patchUpdateFromDiffToolResponse(toolResponse: unknown): Promise<{
+    content: ToolCallContent[];
+    locations: ToolCallLocation[];
+} | undefined>;
+/**
+ * Builds standard ACP diff content from the structured toolResponse provided
+ * by the PostToolUse hook for diff-producing tools (Edit, Write). Unlike
+ * parsing the plain unified diff string, this uses the pre-parsed
+ * structuredPatch which supports multiple replacement sites (replaceAll) and
+ * always includes context lines for better readability.
  */
 export declare function toolUpdateFromDiffToolResponse(toolResponse: unknown): {
     content?: ToolCallContent[];
     locations?: ToolCallLocation[];
 };
+/**
+ * The text of one git patch for `filePath`.
+ *
+ * The headers follow `git diff`: the path loses its leading slash, gets the
+ * `a/` and `b/` prefixes, and is quoted when git would quote it. A created
+ * file gets its mode line and a `/dev/null` side.
+ */
+export declare function gitPatchText(filePath: string, change: FileChange, hunks: PatchHunk[]): string;
+export {};
 //# sourceMappingURL=diff.d.ts.map

package/dist/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAwB7E;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,YAAY,EAAE,OAAO,GAAG;IACrE,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC,CA2HA"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAQ7E;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,QAAc,CAAC;AAkBhD;;;;;GAKG;AACH,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AA0BD,0DAA0D;AAC1D,KAAK,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,EAAE,GAAG,SAAS,CAAC,CAkExC;AA0CD;;;;;;;;;;GAUG;AACH,wBAAsB,+BAA+B,CACnD,YAAY,EAAE,OAAO,GACpB,OAAO,CAAC;IAAE,OAAO,EAAE,eAAe,EAAE,CAAC;IAAC,SAAS,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,SAAS,CAAC,CA0CpF;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,YAAY,EAAE,OAAO,GAAG;IACrE,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC,CAoEA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAM7F"}