wave-agent-sdk 0.0.6 → 0.0.7

package/dist/utils/messageOperations.js

@@ -57,15 +57,16 @@ export const convertImageToBase64 = (imagePath) => {
     }
 };
 // Add user message
-export const addUserMessageToMessages = ({ messages, content, images, customCommandBlock, }) => {
+export const addUserMessageToMessages = ({ messages, content, images, customCommandContent, source, }) => {
     const blocks = [];
-    // If there's a custom command block, use it instead of text content
-    if (customCommandBlock) {
-        blocks.push(customCommandBlock);
-    }
-    else {
-        blocks.push({ type: "text", content });
-    }
+    // Create text block with optional customCommandContent and source
+    const textBlock = {
+        type: "text",
+        content,
+        ...(customCommandContent && { customCommandContent }),
+        ...(source && { source }),
+    };
+    blocks.push(textBlock);
     // If there are images, add image block
     if (images && images.length > 0) {
         const imageUrls = images.map((img) => img.path);
@@ -174,23 +175,23 @@ export const updateToolBlockInMessage = ({ messages, id, parameters, result, suc
 // Add Error Block to the last assistant message
 export const addErrorBlockToMessage = ({ messages, error, }) => {
     const newMessages = [...messages];
-    // Find the last assistant message
-    let assistantMessageFound = false;
-    for (let i = newMessages.length - 1; i >= 0; i--) {
-        if (newMessages[i].role === "assistant") {
-            newMessages[i].blocks = [
-                ...newMessages[i].blocks,
+    // Check if the last message is an assistant message
+    const lastMessage = newMessages[newMessages.length - 1];
+    if (lastMessage && lastMessage.role === "assistant") {
+        // Create a new message object with the error block added
+        newMessages[newMessages.length - 1] = {
+            ...lastMessage,
+            blocks: [
+                ...lastMessage.blocks,
                 {
                     type: "error",
                     content: error,
                 },
-            ];
-            assistantMessageFound = true;
-            break;
-        }
+            ],
+        };
     }
-    // If no assistant message found, create a new assistant message with only error block
-    if (!assistantMessageFound) {
+    else {
+        // If the last message is not an assistant message, create a new assistant message
         newMessages.push({
             role: "assistant",
             blocks: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -487,13 +487,13 @@ export class Agent {
       this.addToInputHistory(content);
 
       // Add user message first, will automatically sync to UI
-      this.messageManager.addUserMessage(
+      this.messageManager.addUserMessage({
         content,
-        images?.map((img) => ({
+        images: images?.map((img) => ({
           path: img.path,
           mimeType: img.mimeType,
         })),
-      );
+      });
 
       // Execute UserPromptSubmit hooks after adding the user message
       if (this.hookManager) {

package/src/managers/aiManager.ts

@@ -282,6 +282,7 @@ export class AIManager {
 
       if (result.tool_calls) {
         for (const toolCall of result.tool_calls) {
+          this.logger?.debug("ToolCall", toolCall);
           if (toolCall.type === "function") {
             toolCalls.push(toolCall);
           }
@@ -351,8 +352,8 @@ export class AIManager {
               );
 
               this.messageManager.updateToolBlock({
-                toolId,
-                args: JSON.stringify(toolArgs, null, 2),
+                id: toolId,
+                parameters: JSON.stringify(toolArgs, null, 2),
                 isRunning: true, // isRunning: true
                 name: toolName,
                 compactParams,
@@ -390,8 +391,8 @@ export class AIManager {
 
                 // Update message state - tool execution completed
                 this.messageManager.updateToolBlock({
-                  toolId,
-                  args: JSON.stringify(toolArgs, null, 2),
+                  id: toolId,
+                  parameters: JSON.stringify(toolArgs, null, 2),
                   result:
                     toolResult.content ||
                     (toolResult.error ? `Error: ${toolResult.error}` : ""),
@@ -429,8 +430,8 @@ export class AIManager {
                     : String(toolError);
 
                 this.messageManager.updateToolBlock({
-                  toolId,
-                  args: JSON.stringify(toolArgs, null, 2),
+                  id: toolId,
+                  parameters: JSON.stringify(toolArgs, null, 2),
                   result: `Tool execution failed: ${errorMessage}`,
                   success: false,
                   error: errorMessage,
@@ -614,6 +615,7 @@ export class AIManager {
           results,
           this.messageManager,
           toolId, // Pass toolId for proper PreToolUse blocking error handling
+          JSON.stringify(toolInput || {}, null, 2), // Pass serialized tool parameters
         );
         shouldContinue = !processResult.shouldBlock;
       }
@@ -671,14 +673,11 @@ export class AIManager {
 
       // Process hook results to handle exit codes and update tool results
       if (results.length > 0) {
-        const originalToolResult = toolResponse?.content || "";
-
         this.hookManager.processHookResults(
           "PostToolUse",
           results,
           this.messageManager,
           toolId,
-          originalToolResult,
         );
       }
 

package/src/managers/hookManager.ts

@@ -18,50 +18,25 @@ import {
   isValidHookEvent,
   isValidHookEventConfig,
 } from "../types/hooks.js";
-import { type IHookMatcher, HookMatcher } from "../utils/hookMatcher.js";
+import { HookMatcher } from "../utils/hookMatcher.js";
 import {
   executeCommand,
   isCommandSafe,
   loadMergedHooksConfig,
 } from "../services/hook.js";
 import type { Logger } from "../types/index.js";
+import { MessageSource } from "../types/index.js";
 import type { MessageManager } from "./messageManager.js";
 
-export interface IHookManager {
-  // Load configuration from settings
-  loadConfiguration(
-    userHooks?: PartialHookConfiguration,
-    projectHooks?: PartialHookConfiguration,
-  ): void;
-
-  // Load configuration from filesystem settings
-  loadConfigurationFromSettings(): void;
-
-  // Execute hooks for specific event
-  executeHooks(
-    event: HookEvent,
-    context: HookExecutionContext | ExtendedHookExecutionContext,
-  ): Promise<HookExecutionResult[]>;
-
-  // Check if hooks are configured for event
-  hasHooks(event: HookEvent, toolName?: string): boolean;
-
-  // Validate hook configuration
-  validateConfiguration(config: HookConfiguration): ValidationResult;
-
-  // Get current configuration
-  getConfiguration(): PartialHookConfiguration | undefined;
-}
-
-export class HookManager implements IHookManager {
+export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
-  private readonly matcher: IHookMatcher;
+  private readonly matcher: HookMatcher;
   private readonly logger?: Logger;
   private readonly workdir: string;
 
   constructor(
     workdir: string,
-    matcher: IHookMatcher = new HookMatcher(),
+    matcher: HookMatcher = new HookMatcher(),
     logger?: Logger,
   ) {
     this.workdir = workdir;
@@ -274,7 +249,7 @@ export class HookManager implements IHookManager {
     results: HookExecutionResult[],
     messageManager?: MessageManager,
     toolId?: string,
-    originalToolResult?: string,
+    toolParameters?: string,
   ): {
     shouldBlock: boolean;
     errorMessage?: string;
@@ -293,7 +268,7 @@ export class HookManager implements IHookManager {
           result,
           messageManager,
           toolId,
-          originalToolResult,
+          toolParameters,
         );
       }
     }
@@ -327,7 +302,10 @@ export class HookManager implements IHookManager {
   ): void {
     if (event === "UserPromptSubmit" && result.stdout?.trim()) {
       // Inject stdout as user message context for UserPromptSubmit
-      messageManager.addUserMessage(result.stdout.trim());
+      messageManager.addUserMessage({
+        content: result.stdout.trim(),
+        source: MessageSource.HOOK,
+      });
     }
     // For other hook types (PreToolUse, PostToolUse, Stop), ignore stdout
   }
@@ -340,7 +318,7 @@ export class HookManager implements IHookManager {
     result: HookExecutionResult,
     messageManager: MessageManager,
     toolId?: string,
-    originalToolResult?: string,
+    toolParameters?: string,
   ): {
     shouldBlock: boolean;
     errorMessage?: string;
@@ -361,7 +339,8 @@ export class HookManager implements IHookManager {
         // Block tool execution and show error to Wave Agent via tool block
         if (toolId) {
           messageManager.updateToolBlock({
-            toolId,
+            id: toolId,
+            parameters: toolParameters || "",
             result: errorMessage,
             success: false,
             error: "Hook blocked tool execution",
@@ -370,19 +349,19 @@ export class HookManager implements IHookManager {
         return { shouldBlock: true };
 
       case "PostToolUse":
-        // Show error to Wave Agent via tool block, execution continues
-        if (toolId && originalToolResult !== undefined) {
-          messageManager.updateToolBlock({
-            toolId,
-            result: `${originalToolResult}\n\nHook feedback: ${errorMessage}`,
-            success: false,
-          });
-        }
+        // Show error to Wave Agent via user message and allow AI to continue
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
         return { shouldBlock: false };
 
       case "Stop":
         // Show error to Wave Agent via user message and block stopping to continue conversation
-        messageManager.addUserMessage(errorMessage);
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
         return { shouldBlock: true, errorMessage };
 
       default:

package/src/managers/messageManager.ts

@@ -13,6 +13,7 @@ import {
   addSubagentBlockToMessage,
   updateSubagentBlockInMessage,
   removeLastUserMessage,
+  UserMessageParams,
   type AddSubagentBlockParams,
   type UpdateSubagentBlockParams,
   type AgentToolBlockUpdateParams,
@@ -35,10 +36,7 @@ export interface MessageManagerCallbacks {
   onUserInputHistoryChange?: (history: string[]) => void;
   onUsagesChange?: (usages: Usage[]) => void;
   // Incremental callback
-  onUserMessageAdded?: (
-    content: string,
-    images?: Array<{ path: string; mimeType: string }>,
-  ) => void;
+  onUserMessageAdded?: (params: UserMessageParams) => void;
   onAssistantMessageAdded?: (
     content?: string,
     toolCalls?: ChatCompletionMessageFunctionToolCall[],
@@ -54,12 +52,6 @@ export interface MessageManagerCallbacks {
     type: "project" | "user",
     storagePath: string,
   ) => void;
-  // Custom command callback
-  onCustomCommandAdded?: (
-    commandName: string,
-    content: string,
-    originalInput?: string,
-  ) => void;
   // Bash command callback
   onAddCommandOutputMessage?: (command: string) => void;
   onUpdateCommandOutputMessage?: (command: string, output: string) => void;
@@ -281,36 +273,13 @@ export class MessageManager {
   }
 
   // Encapsulated message operation functions
-  public addUserMessage(
-    content: string,
-    images?: Array<{ path: string; mimeType: string }>,
-  ): void {
-    const newMessages = addUserMessageToMessages({
-      messages: this.messages,
-      content,
-      images,
-    });
-    this.setMessages(newMessages);
-    this.callbacks.onUserMessageAdded?.(content, images);
-  }
-
-  public addCustomCommandMessage(
-    commandName: string,
-    content: string,
-    originalInput?: string,
-  ): void {
+  public addUserMessage(params: UserMessageParams): void {
     const newMessages = addUserMessageToMessages({
       messages: this.messages,
-      content: "", // Empty content, as we will use CustomCommandBlock
-      customCommandBlock: {
-        type: "custom_command",
-        commandName,
-        content,
-        originalInput,
-      },
+      ...params,
     });
     this.setMessages(newMessages);
-    this.callbacks.onCustomCommandAdded?.(commandName, content, originalInput);
+    this.callbacks.onUserMessageAdded?.(params);
   }
 
   public addAssistantMessage(
@@ -331,14 +300,15 @@ export class MessageManager {
   public updateToolBlock(params: AgentToolBlockUpdateParams): void {
     const newMessages = updateToolBlockInMessage({
       messages: this.messages,
-      id: params.toolId,
-      parameters: params.args || "",
+      id: params.id,
+      parameters: params.parameters,
       result: params.result,
       success: params.success,
       error: params.error,
       isRunning: params.isRunning,
       name: params.name,
       shortResult: params.shortResult,
+      images: params.images,
       compactParams: params.compactParams,
     });
     this.setMessages(newMessages);

package/src/managers/slashCommandManager.ts

@@ -257,15 +257,14 @@ export class SlashCommandManager {
           ? replaceBashCommandsWithOutput(processedContent, bashResults)
           : processedContent;
 
-      // Add custom command block to show the command being executed
+      // Add custom command message to show the command being executed
       const originalInput = args
         ? `/${commandName} ${args}`
         : `/${commandName}`;
-      this.messageManager.addCustomCommandMessage(
-        commandName,
-        finalContent,
-        originalInput,
-      );
+      this.messageManager.addUserMessage({
+        content: originalInput,
+        customCommandContent: finalContent,
+      });
 
       // Execute the AI conversation with custom configuration
       await this.aiManager.sendAIMessage({

package/src/managers/subagentManager.ts

@@ -232,7 +232,7 @@ export class SubagentManager {
       }
 
       // Add the user's prompt as a message
-      instance.messageManager.addUserMessage(prompt);
+      instance.messageManager.addUserMessage({ content: prompt });
 
       // Create allowed tools list - always exclude Task tool to prevent subagent recursion
       let allowedTools = instance.configuration.tools;

package/src/tools/todoWriteTool.ts

@@ -200,18 +200,10 @@ When in doubt, use this tool. Being proactive with task management demonstrates
           in_progress: "[>]",
           completed: "[x]",
         };
-        const inProgress = todos.filter((t) => t.status === "in_progress");
-        const pending = todos.filter((t) => t.status === "pending");
 
-        if (inProgress.length > 0) {
-          shortResult += `\n${symbols.in_progress} ${inProgress[0].content}`;
-        }
-
-        if (pending.length > 0) {
-          shortResult += `\n${symbols.pending} ${pending[0].content}`;
-          if (pending.length > 1) {
-            shortResult += ` +${pending.length - 1}`;
-          }
+        // Show all todos in the shortResult
+        for (const todo of todos) {
+          shortResult += `\n${symbols[todo.status]} ${todo.content}`;
         }
       }
 

package/src/types/messaging.ts

@@ -5,6 +5,11 @@
 
 import type { Usage } from "./core.js";
 
+export enum MessageSource {
+  USER = "user",
+  HOOK = "hook",
+}
+
 export interface Message {
   role: "user" | "assistant";
   blocks: MessageBlock[];
@@ -20,12 +25,13 @@ export type MessageBlock =
   | CommandOutputBlock
   | CompressBlock
   | MemoryBlock
-  | CustomCommandBlock
   | SubagentBlock;
 
 export interface TextBlock {
   type: "text";
   content: string;
+  customCommandContent?: string;
+  source?: MessageSource;
 }
 
 export interface ErrorBlock {
@@ -87,13 +93,6 @@ export interface MemoryBlock {
   storagePath?: string; // Storage path text
 }
 
-export interface CustomCommandBlock {
-  type: "custom_command";
-  commandName: string;
-  content: string; // Complete command content, used when passing to AI
-  originalInput?: string; // Original user input, used for UI display (e.g., "/fix-issue 123 high")
-}
-
 export interface SubagentBlock {
   type: "subagent";
   subagentId: string;

package/src/utils/convertMessagesForAPI.ts

@@ -176,15 +176,7 @@ export function convertMessagesForAPI(
         if (block.type === "text" && block.content) {
           contentParts.push({
             type: "text",
-            text: block.content,
-          });
-        }
-
-        // Handle custom command blocks - pass full content as text to AI
-        if (block.type === "custom_command" && block.content) {
-          contentParts.push({
-            type: "text",
-            text: block.content,
+            text: block.customCommandContent || block.content,
           });
         }
 

package/src/utils/hookMatcher.ts

@@ -7,18 +7,7 @@
 
 import { minimatch } from "minimatch";
 
-export interface IHookMatcher {
-  // Test if pattern matches tool name
-  matches(pattern: string, toolName: string): boolean;
-
-  // Validate pattern syntax
-  isValidPattern(pattern: string): boolean;
-
-  // Get pattern type for optimization
-  getPatternType(pattern: string): "exact" | "glob" | "regex" | "alternatives";
-}
-
-export class HookMatcher implements IHookMatcher {
+export class HookMatcher {
   /**
    * Test if pattern matches tool name
    * Supports multiple matching strategies:

package/src/utils/messageOperations.ts

@@ -1,19 +1,19 @@
-import type { Message, Usage } from "../types/index.js";
+import type { Message, Usage, MessageSource } from "../types/index.js";
 import { readFileSync } from "fs";
 import { extname } from "path";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 
-// Parameter interfaces for message operations
-export interface AddUserMessageParams {
-  messages: Message[];
+// Base user message parameters interface
+export interface UserMessageParams {
   content: string;
   images?: Array<{ path: string; mimeType: string }>;
-  customCommandBlock?: {
-    type: "custom_command";
-    commandName: string;
-    content: string;
-    originalInput?: string;
-  };
+  customCommandContent?: string;
+  source?: MessageSource;
+}
+
+// Parameter interfaces for message operations
+export interface AddUserMessageParams extends UserMessageParams {
+  messages: Message[];
 }
 
 export interface UpdateToolBlockParams {
@@ -31,17 +31,10 @@ export interface UpdateToolBlockParams {
 }
 
 // Agent specific interfaces (without messages parameter)
-export interface AgentToolBlockUpdateParams {
-  toolId: string;
-  args?: string;
-  result?: string;
-  success?: boolean;
-  error?: string;
-  isRunning?: boolean;
-  name?: string;
-  shortResult?: string;
-  compactParams?: string;
-}
+export type AgentToolBlockUpdateParams = Omit<
+  UpdateToolBlockParams,
+  "messages"
+>;
 
 export interface AddDiffBlockParams {
   messages: Message[];
@@ -145,16 +138,19 @@ export const addUserMessageToMessages = ({
   messages,
   content,
   images,
-  customCommandBlock,
+  customCommandContent,
+  source,
 }: AddUserMessageParams): Message[] => {
   const blocks: Message["blocks"] = [];
 
-  // If there's a custom command block, use it instead of text content
-  if (customCommandBlock) {
-    blocks.push(customCommandBlock);
-  } else {
-    blocks.push({ type: "text", content });
-  }
+  // Create text block with optional customCommandContent and source
+  const textBlock = {
+    type: "text" as const,
+    content,
+    ...(customCommandContent && { customCommandContent }),
+    ...(source && { source }),
+  };
+  blocks.push(textBlock);
 
   // If there are images, add image block
   if (images && images.length > 0) {
@@ -294,24 +290,23 @@ export const addErrorBlockToMessage = ({
   error,
 }: AddErrorBlockParams): Message[] => {
   const newMessages = [...messages];
-  // Find the last assistant message
-  let assistantMessageFound = false;
-  for (let i = newMessages.length - 1; i >= 0; i--) {
-    if (newMessages[i].role === "assistant") {
-      newMessages[i].blocks = [
-        ...newMessages[i].blocks,
+
+  // Check if the last message is an assistant message
+  const lastMessage = newMessages[newMessages.length - 1];
+  if (lastMessage && lastMessage.role === "assistant") {
+    // Create a new message object with the error block added
+    newMessages[newMessages.length - 1] = {
+      ...lastMessage,
+      blocks: [
+        ...lastMessage.blocks,
         {
           type: "error",
           content: error,
         },
-      ];
-      assistantMessageFound = true;
-      break;
-    }
-  }
-
-  // If no assistant message found, create a new assistant message with only error block
-  if (!assistantMessageFound) {
+      ],
+    };
+  } else {
+    // If the last message is not an assistant message, create a new assistant message
     newMessages.push({
       role: "assistant",
       blocks: [