wave-agent-sdk 0.6.5 → 0.7.0

package/dist/tools/editTool.js

@@ -16,7 +16,15 @@ function formatCompactParams(args, context) {
 export const editTool = {
     name: EDIT_TOOL_NAME,
     formatCompactParams,
-    prompt: () => `Performs exact string replacements in files. \n\nUsage:\n- You must use your \`${READ_TOOL_NAME}\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from read_file tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`. \n- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`,
+    prompt: () => `Performs exact string replacements in files.
+
+Usage:
+- You must use your \`${READ_TOOL_NAME}\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from ${READ_TOOL_NAME} tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`. 
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`,
     config: {
         type: "function",
         function: {

package/dist/tools/readTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readTool.d.ts","sourceRoot":"","sources":["../../src/tools/readTool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA6HtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAkOtB,CAAC"}
+{"version":3,"file":"readTool.d.ts","sourceRoot":"","sources":["../../src/tools/readTool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA8HtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAiOtB,CAAC"}

package/dist/tools/readTool.js

@@ -2,6 +2,7 @@ import { readFile, stat } from "fs/promises";
 import { extname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { formatLineNumberPrefix } from "../utils/stringUtils.js";
 import { isBinaryDocument, getBinaryDocumentError, } from "../utils/fileFormat.js";
 import { convertImageToBase64 } from "../utils/messageOperations.js";
 import { READ_TOOL_NAME } from "../constants/tools.js";
@@ -123,7 +124,6 @@ Usage:
 - Any lines longer than 2000 characters will be truncated
 - Results are returned using cat -n format, with line numbers starting at 1
 - This tool allows Agent to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Agent is a multimodal LLM.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
 - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
 - You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png
 - If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
@@ -245,7 +245,7 @@ Usage:
                 const lineNumber = startLine + index;
                 // Truncate overly long lines
                 const truncatedLine = line.length > 2000 ? line.substring(0, 2000) + "..." : line;
-                return `${lineNumber.toString().padStart(6)}\t${truncatedLine}`;
+                return `${formatLineNumberPrefix(lineNumber)}${truncatedLine}`;
             })
                 .join("\n");
             // Add file information header

package/dist/tools/skillTool.d.ts

@@ -1,8 +1,6 @@
 import type { ToolPlugin } from "./types.js";
-import type { SkillManager } from "../managers/skillManager.js";
 /**
- * Create a skill tool plugin that uses the provided SkillManager
- * Note: SkillManager should be initialized before calling this function
+ * Skill tool plugin for invoking Wave skills
  */
-export declare function createSkillTool(skillManager: SkillManager): ToolPlugin;
+export declare const skillTool: ToolPlugin;
 //# sourceMappingURL=skillTool.d.ts.map

package/dist/tools/skillTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillTool.d.ts","sourceRoot":"","sources":["../../src/tools/skillTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE;;;GAGG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,UAAU,CA8EtE"}
+{"version":3,"file":"skillTool.d.ts","sourceRoot":"","sources":["../../src/tools/skillTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAItE;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,UAmFvB,CAAC"}

package/dist/tools/skillTool.js

@@ -1,75 +1,75 @@
 import { SKILL_TOOL_NAME } from "../constants/tools.js";
 /**
- * Create a skill tool plugin that uses the provided SkillManager
- * Note: SkillManager should be initialized before calling this function
+ * Skill tool plugin for invoking Wave skills
  */
-export function createSkillTool(skillManager) {
-    // Ensure SkillManager is initialized
-    skillManager.getAvailableSkills();
-    return {
-        name: SKILL_TOOL_NAME,
-        get config() {
-            const availableSkills = skillManager.getAvailableSkills();
-            const getToolDescription = () => {
-                if (availableSkills.length === 0) {
-                    return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
-                }
-                const skillList = availableSkills
-                    .map((skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`)
-                    .join("\n");
-                return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
-            };
-            return {
-                type: "function",
-                function: {
-                    name: SKILL_TOOL_NAME,
-                    description: getToolDescription(),
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            skill_name: {
-                                type: "string",
-                                description: "Name of the skill to invoke",
-                                enum: availableSkills.map((skill) => skill.name),
-                            },
-                        },
-                        required: ["skill_name"],
+export const skillTool = {
+    name: SKILL_TOOL_NAME,
+    config: {
+        type: "function",
+        function: {
+            name: SKILL_TOOL_NAME,
+            description: "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.",
+            parameters: {
+                type: "object",
+                properties: {
+                    skill_name: {
+                        type: "string",
+                        description: "Name of the skill to invoke",
                     },
                 },
-            };
+                required: ["skill_name"],
+            },
         },
-        execute: async (args) => {
-            try {
-                // Validate arguments
-                const skillName = args.skill_name;
-                if (!skillName || typeof skillName !== "string") {
-                    return {
-                        success: false,
-                        content: "",
-                        error: "skill_name parameter is required and must be a string",
-                    };
-                }
-                // Execute the skill
-                const result = await skillManager.executeSkill({
-                    skill_name: skillName,
-                });
+    },
+    prompt: (args) => {
+        const availableSkills = args?.availableSkills;
+        if (!availableSkills || availableSkills.length === 0) {
+            return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
+        }
+        const skillList = availableSkills
+            .map((skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`)
+            .join("\n");
+        return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
+    },
+    execute: async (args, context) => {
+        try {
+            const skillManager = context.skillManager;
+            if (!skillManager) {
                 return {
-                    success: true,
-                    content: result.content,
-                    shortResult: `Invoked skill: ${skillName}`,
+                    success: false,
+                    content: "",
+                    error: "Skill manager not available in tool context",
                 };
             }
-            catch (error) {
+            // Validate arguments
+            const skillName = args.skill_name;
+            if (!skillName || typeof skillName !== "string") {
                 return {
                     success: false,
                     content: "",
-                    error: error instanceof Error ? error.message : String(error),
+                    error: "skill_name parameter is required and must be a string",
                 };
             }
-        },
-        formatCompactParams: (params) => {
-            const skillName = params.skill_name;
-            return skillName || "unknown-skill";
-        },
-    };
-}
+            // Execute the skill
+            const result = await skillManager.executeSkill({
+                skill_name: skillName,
+            });
+            return {
+                success: true,
+                content: result.content,
+                shortResult: `Invoked skill: ${skillName}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                content: "",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+    formatCompactParams: (params) => {
+        const skillName = params.skill_name;
+        return skillName || "unknown-skill";
+    },
+};

package/dist/tools/taskOutputTool.js

@@ -167,7 +167,7 @@ export const taskOutputTool = {
     },
     formatCompactParams: (params) => {
         const taskId = params.task_id;
-        const block = params.block;
+        const block = params.block ?? true;
         return `${taskId}${block ? " (blocking)" : ""}`;
     },
 };

package/dist/tools/taskTool.d.ts

@@ -1,8 +1,6 @@
 import type { ToolPlugin } from "./types.js";
-import type { SubagentManager } from "../managers/subagentManager.js";
 /**
- * Create a task tool plugin that uses the provided SubagentManager
- * Note: SubagentManager should be initialized before calling this function
+ * Task tool plugin for delegating tasks to specialized subagents
  */
-export declare function createTaskTool(subagentManager: SubagentManager): ToolPlugin;
+export declare const taskTool: ToolPlugin;
 //# sourceMappingURL=taskTool.d.ts.map

package/dist/tools/taskTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taskTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAItE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,eAAe,GAAG,UAAU,CA2O3E"}
+{"version":3,"file":"taskTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAKtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA2OtB,CAAC"}

package/dist/tools/taskTool.js

@@ -1,198 +1,203 @@
 import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
 import { TASK_TOOL_NAME } from "../constants/tools.js";
 /**
- * Create a task tool plugin that uses the provided SubagentManager
- * Note: SubagentManager should be initialized before calling this function
+ * Task tool plugin for delegating tasks to specialized subagents
  */
-export function createTaskTool(subagentManager) {
-    // Ensure SubagentManager is initialized
-    subagentManager.getConfigurations();
-    return {
-        name: TASK_TOOL_NAME,
-        get config() {
-            // Get available subagents from the initialized subagent manager
-            const availableSubagents = subagentManager.getConfigurations();
-            const subagentList = availableSubagents
-                .map((config) => `- ${config.name}: ${config.description}`)
-                .join("\n");
-            const description = `Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.
-    
-    Available subagents:
-    ${subagentList || "No subagents configured"}`;
-            return {
-                type: "function",
-                function: {
-                    name: TASK_TOOL_NAME,
-                    description,
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            description: {
-                                type: "string",
-                                description: "A clear, concise description of what needs to be accomplished",
-                            },
-                            prompt: {
-                                type: "string",
-                                description: "The specific instructions or prompt to send to the subagent",
-                            },
-                            subagent_type: {
-                                type: "string",
-                                description: `The type or name of subagent to use. Available options: ${availableSubagents.map((c) => c.name).join(", ") || "none"}`,
-                            },
-                            run_in_background: {
-                                type: "boolean",
-                                description: "Set to true to run this command in the background. Use TaskOutput to read the output later.",
-                            },
-                        },
-                        required: ["description", "prompt", "subagent_type"],
+export const taskTool = {
+    name: TASK_TOOL_NAME,
+    config: {
+        type: "function",
+        function: {
+            name: TASK_TOOL_NAME,
+            description: "Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.",
+            parameters: {
+                type: "object",
+                properties: {
+                    description: {
+                        type: "string",
+                        description: "A short (3-5 word) description of the task",
+                    },
+                    prompt: {
+                        type: "string",
+                        description: "The task for the agent to perform",
+                    },
+                    subagent_type: {
+                        type: "string",
+                        description: "The type of specialized agent to use for this task",
+                    },
+                    run_in_background: {
+                        type: "boolean",
+                        description: "Set to true to run this command in the background. Use TaskOutput to read the output later.",
                     },
                 },
-            };
+                required: ["description", "prompt", "subagent_type"],
+            },
         },
-        prompt: () => `
+    },
+    prompt: (args) => {
+        const subagentList = args?.availableSubagents
+            ? args.availableSubagents
+                .map((config) => `- ${config.name}: ${config.description}`)
+                .join("\n")
+            : "";
+        return `
+Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.
+
+Available subagents:
+${subagentList || "No subagents configured"}
+
 - When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
 - You should proactively use the ${TASK_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`,
-        execute: async (args, context) => {
-            return new Promise((resolve) => {
-                (async () => {
-                    // Input validation
-                    const description = args.description;
-                    const prompt = args.prompt;
-                    const subagent_type = args.subagent_type;
-                    const run_in_background = args.run_in_background;
-                    if (!description || typeof description !== "string") {
-                        return resolve({
-                            success: false,
-                            content: "",
-                            error: "description parameter is required and must be a string",
-                            shortResult: "Task delegation failed",
-                        });
-                    }
-                    if (!prompt || typeof prompt !== "string") {
-                        return resolve({
-                            success: false,
-                            content: "",
-                            error: "prompt parameter is required and must be a string",
-                            shortResult: "Task delegation failed",
-                        });
-                    }
-                    if (!subagent_type || typeof subagent_type !== "string") {
-                        return resolve({
-                            success: false,
-                            content: "",
-                            error: "subagent_type parameter is required and must be a string",
-                            shortResult: "Task delegation failed",
-                        });
-                    }
-                    try {
-                        // Subagent selection logic with explicit name matching only
-                        const configuration = await subagentManager.findSubagent(subagent_type);
-                        if (!configuration) {
-                            // Error handling for nonexistent subagents with available subagents listing
-                            const allConfigs = subagentManager.getConfigurations();
-                            const availableNames = allConfigs.map((c) => c.name).join(", ");
-                            return resolve({
-                                success: false,
-                                content: "",
-                                error: `No subagent found matching "${subagent_type}". Available subagents: ${availableNames || "none"}`,
-                                shortResult: "Subagent not found",
-                            });
-                        }
-                        // Set up callback to update shortResult with tool names, tool count and tokens
-                        const updateShortResult = () => {
-                            const messages = instance.messageManager.getMessages();
-                            const tokens = instance.messageManager.getlatestTotalTokens();
-                            const lastTools = instance.lastTools;
-                            // Count tool blocks in messages
-                            let toolCount = 0;
-                            messages.forEach((msg) => {
-                                msg.blocks.forEach((block) => {
-                                    if (block.type === "tool") {
-                                        toolCount++;
-                                    }
-                                });
-                            });
-                            let shortResult = "";
-                            if (toolCount > 2) {
-                                shortResult += "... ";
-                            }
-                            if (lastTools.length > 0) {
-                                shortResult += `${lastTools.join(", ")} `;
-                            }
-                            shortResult += `(${toolCount} tools`;
-                            if (tokens > 0) {
-                                shortResult += ` | ${tokens.toLocaleString()} tokens`;
-                            }
-                            shortResult += ")";
-                            context.onShortResultUpdate?.(shortResult);
-                        };
-                        // Create subagent instance and execute task
-                        const instance = await subagentManager.createInstance(configuration, {
-                            description,
-                            prompt,
-                            subagent_type,
-                        }, run_in_background, updateShortResult);
-                        // Initial update
-                        updateShortResult();
-                        let isBackgrounded = false;
-                        // Register for backgrounding if not already in background
-                        if (!run_in_background && context.foregroundTaskManager) {
-                            context.foregroundTaskManager.registerForegroundTask({
-                                id: instance.subagentId,
-                                backgroundHandler: async () => {
-                                    isBackgrounded = true;
-                                    const taskId = await subagentManager.backgroundInstance(instance.subagentId);
-                                    // Resolve the tool execution early so the main agent can continue
-                                    resolve({
-                                        success: true,
-                                        content: `Task moved to background with ID: ${taskId}.`,
-                                        shortResult: "Task backgrounded",
-                                        isManuallyBackgrounded: true,
-                                    });
-                                },
-                            });
-                        }
-                        try {
-                            const result = await subagentManager.executeTask(instance, prompt, context.abortSignal, run_in_background);
-                            if (isBackgrounded)
-                                return;
-                            if (run_in_background) {
-                                return resolve({
-                                    success: true,
-                                    content: `Task started in background with ID: ${result}`,
-                                    shortResult: `Task started in background: ${result}`,
-                                });
-                            }
-                            // Cleanup subagent instance after task completion
-                            subagentManager.cleanupInstance(instance.subagentId);
-                            return resolve({
-                                success: true,
-                                content: result,
-                                shortResult: `Task completed by ${configuration.name}`,
-                            });
-                        }
-                        finally {
-                            if (!run_in_background && context.foregroundTaskManager) {
-                                context.foregroundTaskManager.unregisterForegroundTask(instance.subagentId);
-                            }
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
+    },
+    execute: async (args, context) => {
+        const subagentManager = context.subagentManager;
+        if (!subagentManager) {
+            return {
+                success: false,
+                content: "",
+                error: "Subagent manager not available in tool context",
+                shortResult: "Task delegation failed",
+            };
+        }
+        // Input validation
+        const description = args.description;
+        const prompt = args.prompt;
+        const subagent_type = args.subagent_type;
+        const run_in_background = args.run_in_background;
+        if (!description || typeof description !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "description parameter is required and must be a string",
+                shortResult: "Task delegation failed",
+            };
+        }
+        if (!prompt || typeof prompt !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "prompt parameter is required and must be a string",
+                shortResult: "Task delegation failed",
+            };
+        }
+        if (!subagent_type || typeof subagent_type !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "subagent_type parameter is required and must be a string",
+                shortResult: "Task delegation failed",
+            };
+        }
+        try {
+            // Subagent selection logic with explicit name matching only
+            const configuration = await subagentManager.findSubagent(subagent_type);
+            if (!configuration) {
+                // Error handling for nonexistent subagents with available subagents listing
+                const allConfigs = subagentManager.getConfigurations();
+                const availableNames = allConfigs.map((c) => c.name).join(", ");
+                return {
+                    success: false,
+                    content: "",
+                    error: `No subagent found matching "${subagent_type}". Available subagents: ${availableNames || "none"}`,
+                    shortResult: "Subagent not found",
+                };
+            }
+            let isBackgrounded = false;
+            // Create subagent instance and execute task
+            const instance = await subagentManager.createInstance(configuration, {
+                description,
+                prompt,
+                subagent_type,
+            }, run_in_background, () => {
+                // Do not update shortResult if it is running in background
+                if (run_in_background || isBackgrounded)
+                    return;
+                const messages = instance.messageManager.getMessages();
+                const tokens = instance.messageManager.getlatestTotalTokens();
+                const lastTools = instance.lastTools;
+                // Count tool blocks in messages
+                let toolCount = 0;
+                messages.forEach((msg) => {
+                    msg.blocks.forEach((block) => {
+                        if (block.type === "tool") {
+                            toolCount++;
                         }
-                    }
-                    catch (error) {
-                        return resolve({
-                            success: false,
-                            content: "",
-                            error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
-                            shortResult: "Delegation error",
-                        });
-                    }
-                })();
+                    });
+                });
+                let shortResult = "";
+                if (toolCount > 2) {
+                    shortResult += "... ";
+                }
+                if (lastTools.length > 0) {
+                    shortResult += `${lastTools.join(", ")} `;
+                }
+                shortResult += `(${toolCount} tools`;
+                if (tokens > 0) {
+                    shortResult += ` | ${tokens.toLocaleString()} tokens`;
+                }
+                shortResult += ")";
+                context.onShortResultUpdate?.(shortResult);
             });
-        },
-        formatCompactParams: (params) => {
-            const subagent_type = params.subagent_type;
-            const description = params.description;
-            return `${subagent_type || "unknown"}: ${description || "no description"}`;
-        },
-    };
-}
+            // Register for backgrounding if not already in background
+            if (!run_in_background && context.foregroundTaskManager) {
+                context.foregroundTaskManager.registerForegroundTask({
+                    id: instance.subagentId,
+                    backgroundHandler: async () => {
+                        isBackgrounded = true;
+                        await subagentManager.backgroundInstance(instance.subagentId);
+                    },
+                });
+            }
+            try {
+                const result = await subagentManager.executeTask(instance, prompt, context.abortSignal, run_in_background);
+                if (isBackgrounded) {
+                    // If it was backgrounded during execution, the backgroundHandler already returned/will return
+                    // But wait, the backgroundHandler is async and returns a ToolResult.
+                    // In the current ToolManager/AIManager implementation, the backgroundHandler's return value
+                    // is what's used when backgrounding happens.
+                    // However, executeTask might still be running.
+                    // We should return a special value or just let it be.
+                    return {
+                        success: true,
+                        content: "Task backgrounded",
+                        shortResult: "Task backgrounded",
+                        isManuallyBackgrounded: true,
+                    };
+                }
+                if (run_in_background) {
+                    return {
+                        success: true,
+                        content: `Task started in background with ID: ${result}`,
+                        shortResult: `Task started in background: ${result}`,
+                    };
+                }
+                // Cleanup subagent instance after task completion
+                subagentManager.cleanupInstance(instance.subagentId);
+                return {
+                    success: true,
+                    content: result,
+                    shortResult: `Task completed by ${configuration.name}`,
+                };
+            }
+            finally {
+                if (!run_in_background && context.foregroundTaskManager) {
+                    context.foregroundTaskManager.unregisterForegroundTask(instance.subagentId);
+                }
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                content: "",
+                error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+                shortResult: "Delegation error",
+            };
+        }
+    },
+    formatCompactParams: (params) => {
+        const subagent_type = params.subagent_type;
+        const description = params.description;
+        return `${subagent_type || "unknown"}: ${description || "no description"}`;
+    },
+};