@agentclientprotocol/claude-agent-acp 0.66.0 → 0.68.0

package/dist/tools.js

@@ -96,7 +96,7 @@ export function toolInfoFromToolUse(toolUse, supportsTerminalOutput = false, cwd
             }
             const displayPath = input?.file_path ? toDisplayPath(input.file_path, cwd) : undefined;
             return {
-                title: displayPath ? `Write ${displayPath}` : "Write",
+                title: displayPath ? `Write ${displayPath}` : "Preparing file…",
                 kind: "edit",
                 content,
                 locations: input?.file_path ? [{ path: input.file_path }] : [],
@@ -291,6 +291,15 @@ export function toolInfoFromToolUse(toolUse, supportsTerminalOutput = false, cwd
                     : [],
             };
         }
+        case "Skill": {
+            const input = toolUse.input;
+            const skillName = input?.skill;
+            return {
+                title: skillName ? `Load skill: ${skillName}` : "Load skill",
+                kind: "other",
+                content: [],
+            };
+        }
         case "AskUserQuestion": {
             const input = toolUse.input;
             const questions = Array.isArray(input?.questions) ? input.questions : [];
@@ -658,6 +667,9 @@ export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOu
             // renders, no worse than before.
             return toAcpContentUpdate(stripAgentTrailerFromContent(toolResult.content), "is_error" in toolResult ? toolResult.is_error : false);
         }
+        case "Skill": {
+            return {};
+        }
         case "Edit": // Edit is handled in hooks
         case "Write": {
             return {};
@@ -798,35 +810,32 @@ function toAcpContentBlock(content, isError) {
 }
 export function planEntries(input) {
     return (input?.todos ?? []).map((todo) => ({
-        content: todo.content,
+        content: todo.status === "in_progress" && todo.activeForm ? todo.activeForm : todo.content,
         status: todo.status,
         priority: "medium",
     }));
 }
 /**
- * Best-effort parse of a TaskCreate tool_result content into the structured
- * TaskCreateOutput. The SDK delivers tool outputs either as a string or as
- * an array of TextBlockParam-like blocks containing JSON text; try both.
+ * Best-effort parse of a structured Task* tool_result. The SDK delivers tool
+ * outputs either as a string or as an array of TextBlockParam-like blocks
+ * containing JSON text; try both.
  */
-export function parseTaskCreateOutput(content) {
+function parseJsonToolOutput(content, isExpectedOutput) {
     const tryParse = (text) => {
         try {
             const parsed = JSON.parse(text);
-            if (parsed &&
-                typeof parsed === "object" &&
-                parsed.task &&
-                typeof parsed.task.id === "string") {
-                return parsed;
-            }
+            return isExpectedOutput(parsed) ? parsed : undefined;
         }
         catch {
-            // ignore
+            return undefined;
         }
-        return undefined;
     };
     if (typeof content === "string") {
         return tryParse(content);
     }
+    if (content && typeof content === "object" && !Array.isArray(content)) {
+        return isExpectedOutput(content) ? content : undefined;
+    }
     if (Array.isArray(content)) {
         for (const block of content) {
             if (block && typeof block === "object" && "type" in block && block.type === "text") {
@@ -841,6 +850,96 @@ export function parseTaskCreateOutput(content) {
     }
     return undefined;
 }
+function toolOutputTexts(content) {
+    if (typeof content === "string")
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((block) => block &&
+        typeof block === "object" &&
+        "type" in block &&
+        block.type === "text" &&
+        "text" in block &&
+        typeof block.text === "string"
+        ? [block.text]
+        : []);
+}
+export function parseTaskCreateOutput(content) {
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed &&
+        typeof parsed === "object" &&
+        "task" in parsed &&
+        parsed.task &&
+        typeof parsed.task === "object" &&
+        "id" in parsed.task &&
+        typeof parsed.task.id === "string"));
+    if (structured)
+        return structured;
+    for (const text of toolOutputTexts(content)) {
+        const match = /^Task #(\S+) created successfully: (.+)$/.exec(text.trim());
+        if (match)
+            return { task: { id: match[1], subject: match[2] } };
+    }
+    return undefined;
+}
+export function parseTaskListOutput(content) {
+    const validStatuses = new Set(["pending", "in_progress", "completed"]);
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed &&
+        typeof parsed === "object" &&
+        "tasks" in parsed &&
+        Array.isArray(parsed.tasks) &&
+        parsed.tasks.every((task) => task &&
+            typeof task === "object" &&
+            typeof task.id === "string" &&
+            typeof task.subject === "string" &&
+            typeof task.status === "string" &&
+            validStatuses.has(task.status))));
+    if (structured)
+        return structured;
+    for (const text of toolOutputTexts(content)) {
+        if (text.trim() === "No tasks found")
+            return { tasks: [] };
+        const tasks = [];
+        const lines = text.trim().split("\n");
+        for (const line of lines) {
+            const match = /^#(\S+) \[(pending|in_progress|completed)\] (.+?)(?: \(([^()]*)\))?(?: \[blocked by ((?:#[^,\]]+(?:, )?)+)\])?$/.exec(line);
+            if (!match) {
+                tasks.length = 0;
+                break;
+            }
+            tasks.push({
+                id: match[1],
+                subject: match[3],
+                status: match[2],
+                ...(match[4] ? { owner: match[4] } : {}),
+                blockedBy: match[5] ? match[5].split(", ").map((id) => id.slice(1)) : [],
+            });
+        }
+        if (tasks.length > 0)
+            return { tasks };
+    }
+    return undefined;
+}
+export function parseTaskUpdateOutput(content, expectedTaskId) {
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed &&
+        typeof parsed === "object" &&
+        "success" in parsed &&
+        typeof parsed.success === "boolean" &&
+        "taskId" in parsed &&
+        typeof parsed.taskId === "string" &&
+        "updatedFields" in parsed &&
+        Array.isArray(parsed.updatedFields) &&
+        parsed.updatedFields.every((field) => typeof field === "string")));
+    if (structured)
+        return structured;
+    for (const text of toolOutputTexts(content)) {
+        const notFound = /^Task #(\S+) not found$/.exec(text.trim());
+        const taskId = notFound?.[1] ?? expectedTaskId;
+        if (taskId && (notFound || text.trim() === "Failed to delete task")) {
+            return { success: false, taskId, updatedFields: [], error: text.trim() };
+        }
+    }
+    return undefined;
+}
 export function applyTaskCreate(state, input, output) {
     const taskId = output?.task?.id;
     if (!taskId || !input)
@@ -872,9 +971,22 @@ export function applyTaskUpdate(state, input) {
         description: input.description ?? existing?.description,
     });
 }
+export function applyTaskList(state, output) {
+    const previous = new Map(state);
+    state.clear();
+    for (const task of output.tasks) {
+        const existing = previous.get(task.id);
+        state.set(task.id, {
+            subject: task.subject,
+            status: task.status,
+            activeForm: existing?.activeForm,
+            description: existing?.description,
+        });
+    }
+}
 export function taskStateToPlanEntries(state) {
     return Array.from(state.values()).map((task) => ({
-        content: task.subject,
+        content: task.status === "in_progress" && task.activeForm ? task.activeForm : task.subject,
         status: task.status,
         priority: "medium",
     }));

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.66.0",
+  "version": "0.68.0",
   "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
@@ -66,19 +66,19 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.3.0",
-    "@anthropic-ai/claude-agent-sdk": "0.3.220",
+    "@anthropic-ai/claude-agent-sdk": "0.3.232",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.115.0",
+    "@anthropic-ai/sdk": "0.117.1",
     "@eslint/js": "10.0.1",
     "@tsconfig/node22": "22.0.5",
-    "@types/node": "26.1.2",
-    "@typescript-eslint/eslint-plugin": "8.65.0",
-    "@typescript-eslint/parser": "8.65.0",
-    "eslint": "10.8.0",
+    "@types/node": "26.2.0",
+    "@typescript-eslint/eslint-plugin": "8.67.0",
+    "@typescript-eslint/parser": "8.67.0",
+    "eslint": "10.8.1",
     "eslint-config-prettier": "10.1.8",
-    "globals": "17.9.0",
+    "globals": "17.11.0",
     "prettier": "3.9.6",
     "ts-node": "10.9.2",
     "typescript": "6.0.3",