wave-agent-sdk 0.11.6 → 0.11.7

package/src/utils/messageOperations.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "crypto";
-import type { Message, Usage } from "../types/index.js";
+import type { Message, Usage, ToolBlock } from "../types/index.js";
 import { MessageSource } from "../types/index.js";
 import { readFileSync } from "fs";
 import { extname } from "path";
@@ -12,6 +12,7 @@ export interface UserMessageParams {
   images?: Array<{ path: string; mimeType: string }>;
   customCommandContent?: string;
   source?: MessageSource;
+  isMeta?: boolean;
 }
 
 // Parameter interfaces for message operations
@@ -23,6 +24,7 @@ export interface AddUserMessageParams extends UserMessageParams {
 export interface UpdateToolBlockParams {
   messages: Message[];
   id: string;
+  messageId?: string; // Optional message ID to target a specific message
   parameters?: string;
   result?: string;
   success?: boolean;
@@ -34,7 +36,7 @@ export interface UpdateToolBlockParams {
    * - 'running': Tool execution in progress
    * - 'end': Tool execution completed with final result
    */
-  stage: "start" | "streaming" | "running" | "end";
+  stage?: "start" | "streaming" | "running" | "end";
   name?: string;
   shortResult?: string;
   startLineNumber?: number;
@@ -125,6 +127,7 @@ export const addUserMessageToMessages = ({
   customCommandContent,
   source,
   id,
+  isMeta,
 }: AddUserMessageParams): Message[] => {
   const blocks: Message["blocks"] = [];
 
@@ -150,6 +153,7 @@ export const addUserMessageToMessages = ({
     id: id || generateMessageId(),
     role: "user",
     blocks,
+    ...(isMeta !== undefined && { isMeta }),
   };
   return [...messages, userMessage];
 };
@@ -177,7 +181,11 @@ export const updateUserMessageInMessages = (
         }
         return block;
       });
-      return { ...msg, blocks: newBlocks };
+      return {
+        ...msg,
+        blocks: newBlocks,
+        ...(params.isMeta !== undefined && { isMeta: params.isMeta }),
+      };
     }
     return msg;
   });
@@ -223,10 +231,43 @@ export const addAssistantMessageToMessages = (
   return [...messages, initialAssistantMessage];
 };
 
-// Update Tool Block of the last assistant message
+/**
+ * Add a tool block to a specific message by ID.
+ */
+export const addToolBlockToMessageInMessages = (
+  messages: Message[],
+  messageId: string,
+  params: Omit<AgentToolBlockUpdateParams, "id">,
+): { messages: Message[]; toolBlockId: string } => {
+  const toolBlockId = randomUUID();
+  const newMessages = messages.map((msg) => {
+    if (msg.id === messageId) {
+      return {
+        ...msg,
+        blocks: [
+          ...msg.blocks,
+          {
+            type: "tool" as const,
+            id: toolBlockId,
+            name: params.name || "unknown",
+            parameters: params.parameters || "",
+            result: params.result || "",
+            stage: "start",
+            ...params,
+          } as ToolBlock,
+        ],
+      };
+    }
+    return msg;
+  });
+  return { messages: newMessages, toolBlockId };
+};
+
+// Update Tool Block of the last assistant or user message
 export const updateToolBlockInMessage = ({
   messages,
   id,
+  messageId,
   parameters,
   result,
   success,
@@ -241,9 +282,42 @@ export const updateToolBlockInMessage = ({
   isManuallyBackgrounded,
 }: UpdateToolBlockParams): Message[] => {
   const newMessages = [...messages];
-  // Find the last assistant message
+
+  // If messageId is provided, target that specific message
+  if (messageId) {
+    const messageIndex = newMessages.findIndex((msg) => msg.id === messageId);
+    if (messageIndex !== -1) {
+      const toolBlockIndex = newMessages[messageIndex].blocks.findIndex(
+        (block) => block.type === "tool" && block.id === id,
+      );
+
+      if (toolBlockIndex !== -1) {
+        const toolBlock = newMessages[messageIndex].blocks[toolBlockIndex];
+        if (toolBlock.type === "tool") {
+          if (parameters !== undefined) toolBlock.parameters = parameters;
+          if (result !== undefined) toolBlock.result = result;
+          if (shortResult !== undefined) toolBlock.shortResult = shortResult;
+          if (startLineNumber !== undefined)
+            toolBlock.startLineNumber = startLineNumber;
+          if (images !== undefined) toolBlock.images = images;
+          if (success !== undefined) toolBlock.success = success;
+          if (error !== undefined) toolBlock.error = error;
+          if (stage !== undefined) toolBlock.stage = stage;
+          if (compactParams !== undefined)
+            toolBlock.compactParams = compactParams;
+          if (parametersChunk !== undefined)
+            toolBlock.parametersChunk = parametersChunk;
+          if (isManuallyBackgrounded !== undefined)
+            toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
+        }
+      }
+    }
+    return newMessages;
+  }
+
+  // Find the last assistant or user message
   for (let i = newMessages.length - 1; i >= 0; i--) {
-    if (newMessages[i].role === "assistant") {
+    if (newMessages[i].role === "assistant" || newMessages[i].role === "user") {
       const toolBlockIndex = newMessages[i].blocks.findIndex(
         (block) => block.type === "tool" && block.id === id,
       );
@@ -267,8 +341,9 @@ export const updateToolBlockInMessage = ({
           if (isManuallyBackgrounded !== undefined)
             toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
         }
-      } else {
-        // If existing block not found, create new one
+        break; // Found and updated, stop searching
+      } else if (newMessages[i].role === "assistant") {
+        // If existing block not found in assistant message, create new one
         // This handles cases where we're streaming tool parameters before execution
         newMessages[i].blocks.push({
           type: "tool",
@@ -286,8 +361,8 @@ export const updateToolBlockInMessage = ({
           parametersChunk: parametersChunk,
           isManuallyBackgrounded: isManuallyBackgrounded,
         });
+        break; // Created and added, stop searching
       }
-      break;
     }
   }
   return newMessages;

package/dist/tools/taskOutputTool.d.ts

@@ -1,3 +0,0 @@
-import { ToolPlugin } from "./types.js";
-export declare const taskOutputTool: ToolPlugin;
-//# sourceMappingURL=taskOutputTool.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"taskOutputTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskOutputTool.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,UAAU,EAAc,MAAM,YAAY,CAAC;AAKjE,eAAO,MAAM,cAAc,EAAE,UAuN5B,CAAC"}

package/dist/tools/taskOutputTool.js

@@ -1,198 +0,0 @@
-import { TASK_OUTPUT_TOOL_NAME } from "../constants/tools.js";
-import { stripAnsiColors } from "../utils/stringUtils.js";
-const MAX_OUTPUT_LENGTH = 30000;
-export const taskOutputTool = {
-    name: TASK_OUTPUT_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: TASK_OUTPUT_TOOL_NAME,
-            description: "Retrieves output from a running or completed task",
-            parameters: {
-                type: "object",
-                properties: {
-                    task_id: {
-                        type: "string",
-                        description: "The task ID to get output from",
-                    },
-                    block: {
-                        type: "boolean",
-                        default: true,
-                        description: "Whether to wait for completion",
-                    },
-                    timeout: {
-                        type: "number",
-                        minimum: 0,
-                        maximum: 600000,
-                        default: 30000,
-                        description: "Max wait time in ms",
-                    },
-                },
-                required: ["task_id", "block", "timeout"],
-            },
-        },
-    },
-    prompt: () => `- Retrieves output from a running or completed task (background shell, agent, or remote session)
-- Takes a task_id parameter identifying the task
-- Returns the task output along with status information
-- Use block=true (default) to wait for task completion
-- Use block=false for non-blocking check of current status
-- Task IDs can be found using the /tasks command
-- Works with all task types: background shells, async agents, and remote sessions`,
-    execute: async (args, context) => {
-        const taskId = args.task_id;
-        const filter = args.filter;
-        const block = args.block ?? true;
-        const timeout = args.timeout ?? 30000;
-        if (!taskId || typeof taskId !== "string") {
-            return {
-                success: false,
-                content: "",
-                error: "task_id parameter is required and must be a string",
-            };
-        }
-        const backgroundTaskManager = context?.backgroundTaskManager;
-        if (!backgroundTaskManager) {
-            return {
-                success: false,
-                content: "",
-                error: "Background task manager not available",
-            };
-        }
-        const getResult = () => {
-            const output = backgroundTaskManager.getOutput(taskId, filter);
-            if (!output)
-                return null;
-            let content = "";
-            if (output.stdout) {
-                content += stripAnsiColors(output.stdout);
-            }
-            if (output.stderr) {
-                content += (content ? "\n" : "") + stripAnsiColors(output.stderr);
-            }
-            const finalContent = content || "No output available";
-            let processedContent = finalContent;
-            let isTruncated = false;
-            if (finalContent.length > MAX_OUTPUT_LENGTH) {
-                processedContent =
-                    "\n\n... (output truncated)\n" +
-                        finalContent.substring(finalContent.length - MAX_OUTPUT_LENGTH);
-                isTruncated = true;
-            }
-            if (isTruncated && output.outputPath) {
-                processedContent += `\n\nFull output available at: ${output.outputPath}`;
-            }
-            let shortResult = `${taskId}: ${output.status}`;
-            if (output.status === "failed" && output.exitCode !== undefined) {
-                shortResult += ` (exit code: ${output.exitCode})`;
-            }
-            return {
-                success: true,
-                content: processedContent,
-                shortResult,
-                metadata: {
-                    outputPath: output.outputPath,
-                    status: output.status,
-                    type: output.type,
-                    exitCode: output.exitCode,
-                },
-            };
-        };
-        if (block) {
-            // Polling for completion
-            return new Promise((resolve) => {
-                let timeoutHandle = null;
-                let isAborted = false;
-                const startTime = Date.now();
-                const cleanup = () => {
-                    if (timeoutHandle) {
-                        clearTimeout(timeoutHandle);
-                        timeoutHandle = null;
-                    }
-                };
-                const onAbort = () => {
-                    isAborted = true;
-                    cleanup();
-                    resolve({
-                        success: false,
-                        content: "",
-                        error: "Task output retrieval was aborted",
-                    });
-                };
-                if (context.abortSignal) {
-                    if (context.abortSignal.aborted) {
-                        onAbort();
-                        return;
-                    }
-                    context.abortSignal.addEventListener("abort", onAbort, {
-                        once: true,
-                    });
-                }
-                const check = () => {
-                    if (isAborted)
-                        return;
-                    if (Date.now() - startTime > timeout) {
-                        if (context.abortSignal) {
-                            context.abortSignal.removeEventListener("abort", onAbort);
-                        }
-                        const result = getResult();
-                        if (result) {
-                            result.shortResult = `${taskId}: timeout`;
-                            resolve(result);
-                        }
-                        else {
-                            resolve({
-                                success: true,
-                                content: "Retrieval timed out",
-                                shortResult: `${taskId}: timeout`,
-                            });
-                        }
-                        return;
-                    }
-                    const task = backgroundTaskManager.getTask(taskId);
-                    if (!task) {
-                        if (context.abortSignal) {
-                            context.abortSignal.removeEventListener("abort", onAbort);
-                        }
-                        resolve({
-                            success: false,
-                            content: "",
-                            error: `Task with ID ${taskId} not found`,
-                        });
-                        return;
-                    }
-                    if (task.status !== "running") {
-                        if (context.abortSignal) {
-                            context.abortSignal.removeEventListener("abort", onAbort);
-                        }
-                        const result = getResult();
-                        resolve(result || {
-                            success: false,
-                            content: "",
-                            error: "Task not found",
-                        });
-                    }
-                    else {
-                        const pollingInterval = process.env.NODE_ENV === "test" ? 10 : 500;
-                        timeoutHandle = setTimeout(check, pollingInterval);
-                    }
-                };
-                check();
-            });
-        }
-        const result = getResult();
-        if (!result) {
-            return {
-                success: false,
-                content: "",
-                error: `Task with ID ${taskId} not found`,
-            };
-        }
-        return result;
-    },
-    formatCompactParams: (params) => {
-        const taskId = params.task_id;
-        const block = params.block ?? true;
-        return `${taskId}${block ? " (blocking)" : ""}`;
-    },
-};

package/src/tools/taskOutputTool.ts

@@ -1,222 +0,0 @@
-import { TASK_OUTPUT_TOOL_NAME } from "../constants/tools.js";
-import { ToolContext, ToolPlugin, ToolResult } from "./types.js";
-import { stripAnsiColors } from "../utils/stringUtils.js";
-
-const MAX_OUTPUT_LENGTH = 30000;
-
-export const taskOutputTool: ToolPlugin = {
-  name: TASK_OUTPUT_TOOL_NAME,
-  config: {
-    type: "function",
-    function: {
-      name: TASK_OUTPUT_TOOL_NAME,
-      description: "Retrieves output from a running or completed task",
-      parameters: {
-        type: "object",
-        properties: {
-          task_id: {
-            type: "string",
-            description: "The task ID to get output from",
-          },
-          block: {
-            type: "boolean",
-            default: true,
-            description: "Whether to wait for completion",
-          },
-          timeout: {
-            type: "number",
-            minimum: 0,
-            maximum: 600000,
-            default: 30000,
-            description: "Max wait time in ms",
-          },
-        },
-        required: ["task_id", "block", "timeout"],
-      },
-    },
-  },
-  prompt:
-    () => `- Retrieves output from a running or completed task (background shell, agent, or remote session)
-- Takes a task_id parameter identifying the task
-- Returns the task output along with status information
-- Use block=true (default) to wait for task completion
-- Use block=false for non-blocking check of current status
-- Task IDs can be found using the /tasks command
-- Works with all task types: background shells, async agents, and remote sessions`,
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    const taskId = args.task_id as string;
-    const filter = args.filter as string | undefined;
-    const block = (args.block as boolean | undefined) ?? true;
-    const timeout = (args.timeout as number | undefined) ?? 30000;
-
-    if (!taskId || typeof taskId !== "string") {
-      return {
-        success: false,
-        content: "",
-        error: "task_id parameter is required and must be a string",
-      };
-    }
-
-    const backgroundTaskManager = context?.backgroundTaskManager;
-    if (!backgroundTaskManager) {
-      return {
-        success: false,
-        content: "",
-        error: "Background task manager not available",
-      };
-    }
-
-    const getResult = () => {
-      const output = backgroundTaskManager.getOutput(taskId, filter);
-      if (!output) return null;
-
-      let content = "";
-      if (output.stdout) {
-        content += stripAnsiColors(output.stdout);
-      }
-      if (output.stderr) {
-        content += (content ? "\n" : "") + stripAnsiColors(output.stderr);
-      }
-
-      const finalContent = content || "No output available";
-      let processedContent = finalContent;
-      let isTruncated = false;
-
-      if (finalContent.length > MAX_OUTPUT_LENGTH) {
-        processedContent =
-          "\n\n... (output truncated)\n" +
-          finalContent.substring(finalContent.length - MAX_OUTPUT_LENGTH);
-        isTruncated = true;
-      }
-
-      if (isTruncated && output.outputPath) {
-        processedContent += `\n\nFull output available at: ${output.outputPath}`;
-      }
-
-      let shortResult = `${taskId}: ${output.status}`;
-      if (output.status === "failed" && output.exitCode !== undefined) {
-        shortResult += ` (exit code: ${output.exitCode})`;
-      }
-
-      return {
-        success: true,
-        content: processedContent,
-        shortResult,
-        metadata: {
-          outputPath: output.outputPath,
-          status: output.status,
-          type: output.type,
-          exitCode: output.exitCode,
-        },
-      };
-    };
-
-    if (block) {
-      // Polling for completion
-      return new Promise((resolve) => {
-        let timeoutHandle: NodeJS.Timeout | null = null;
-        let isAborted = false;
-        const startTime = Date.now();
-
-        const cleanup = () => {
-          if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-            timeoutHandle = null;
-          }
-        };
-
-        const onAbort = () => {
-          isAborted = true;
-          cleanup();
-          resolve({
-            success: false,
-            content: "",
-            error: "Task output retrieval was aborted",
-          });
-        };
-
-        if (context.abortSignal) {
-          if (context.abortSignal.aborted) {
-            onAbort();
-            return;
-          }
-          context.abortSignal.addEventListener("abort", onAbort, {
-            once: true,
-          });
-        }
-
-        const check = () => {
-          if (isAborted) return;
-
-          if (Date.now() - startTime > timeout) {
-            if (context.abortSignal) {
-              context.abortSignal.removeEventListener("abort", onAbort);
-            }
-            const result = getResult();
-            if (result) {
-              result.shortResult = `${taskId}: timeout`;
-              resolve(result);
-            } else {
-              resolve({
-                success: true,
-                content: "Retrieval timed out",
-                shortResult: `${taskId}: timeout`,
-              });
-            }
-            return;
-          }
-
-          const task = backgroundTaskManager.getTask(taskId);
-          if (!task) {
-            if (context.abortSignal) {
-              context.abortSignal.removeEventListener("abort", onAbort);
-            }
-            resolve({
-              success: false,
-              content: "",
-              error: `Task with ID ${taskId} not found`,
-            });
-            return;
-          }
-
-          if (task.status !== "running") {
-            if (context.abortSignal) {
-              context.abortSignal.removeEventListener("abort", onAbort);
-            }
-            const result = getResult();
-            resolve(
-              result || {
-                success: false,
-                content: "",
-                error: "Task not found",
-              },
-            );
-          } else {
-            const pollingInterval = process.env.NODE_ENV === "test" ? 10 : 500;
-            timeoutHandle = setTimeout(check, pollingInterval);
-          }
-        };
-        check();
-      });
-    }
-
-    const result = getResult();
-    if (!result) {
-      return {
-        success: false,
-        content: "",
-        error: `Task with ID ${taskId} not found`,
-      };
-    }
-
-    return result;
-  },
-  formatCompactParams: (params: Record<string, unknown>) => {
-    const taskId = params.task_id as string;
-    const block = (params.block as boolean | undefined) ?? true;
-    return `${taskId}${block ? " (blocking)" : ""}`;
-  },
-};