wave-agent-sdk 0.10.3 → 0.11.0

package/src/tools/agentTool.ts

@@ -67,7 +67,7 @@ The Agent tool launches specialized agents (subprocesses) that autonomously hand
 Available agent types and the tools they have access to:
 ${subagentList || "No agents configured"}
 
-When using the Agent tool, you must specify a subagent_type parameter to select which agent type to use.
+When using the Agent tool, you must specify a subagent_type parameter to select which agent type to use from the list above. Choose the agent whose description best matches the task you want to delegate.
 
 - When doing file search, prefer to use the ${AGENT_TOOL_NAME} tool in order to reduce context usage.
 - You should proactively use the ${AGENT_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.

package/src/tools/bashTool.ts

@@ -1,4 +1,7 @@
 import { spawn, ChildProcess } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
 import { logger } from "../utils/globalLogger.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
@@ -15,6 +18,33 @@ import {
 const MAX_OUTPUT_LENGTH = 30000;
 const BASH_DEFAULT_TIMEOUT_MS = 120000;
 
+/**
+ * Helper function to handle large output by truncation and persistence to a temporary file.
+ */
+function processOutput(output: string): string {
+  if (output.length <= MAX_OUTPUT_LENGTH) {
+    return output;
+  }
+
+  try {
+    const tempDir = os.tmpdir();
+    const fileName = `bash_output_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.txt`;
+    const filePath = path.join(tempDir, fileName);
+    fs.writeFileSync(filePath, output, "utf8");
+
+    return (
+      output.substring(0, MAX_OUTPUT_LENGTH) +
+      `\n\n... (output truncated)\nFull output persisted to: ${filePath}`
+    );
+  } catch (error) {
+    logger.error("Failed to persist large bash output:", error);
+    return (
+      output.substring(0, MAX_OUTPUT_LENGTH) +
+      "\n\n... (output truncated, failed to persist full output)"
+    );
+  }
+}
+
 /**
  * Bash command execution tool - supports both foreground and background execution
  */
@@ -75,7 +105,7 @@ Usage notes:
   - The command argument is required.
   - You can specify an optional timeout in milliseconds (up to ${BASH_DEFAULT_TIMEOUT_MS}ms / ${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes). If not specified, commands will timeout after ${BASH_DEFAULT_TIMEOUT_MS}ms (${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes).
   - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
-  - If the output exceeds ${MAX_OUTPUT_LENGTH} characters, output will be truncated before being returned to you.
+  - If the output exceeds ${MAX_OUTPUT_LENGTH} characters, output will be truncated and the full output will be persisted to a temporary file.
   - You can use the \`run_in_background\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the ${BASH_TOOL_NAME} tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.
   - Avoid using ${BASH_TOOL_NAME} with the \`find\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
     - File search: Use ${GLOB_TOOL_NAME} (NOT find or ls)
@@ -292,7 +322,9 @@ Usage notes:
 
           resolve({
             success: false,
-            content: outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""),
+            content: processOutput(
+              outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""),
+            ),
             error: reason,
           });
         }
@@ -340,20 +372,17 @@ Usage notes:
           const combinedOutput =
             outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
 
-          // Handle large output by truncation if needed
+          // Handle large output by truncation and persistence if needed
           const finalOutput =
             combinedOutput || `Command executed with exit code: ${exitCode}`;
-          const content =
-            finalOutput.length > MAX_OUTPUT_LENGTH
-              ? finalOutput.substring(0, MAX_OUTPUT_LENGTH) +
-                "\n\n... (output truncated)"
-              : finalOutput;
-
-          const shortResult = combinedOutput
-            .trim()
-            .split("\n")
-            .slice(-3)
-            .join("\n");
+          const content = processOutput(finalOutput);
+
+          const lines = combinedOutput.trim().split("\n");
+          const shortResult =
+            lines.length <= 3
+              ? lines.join("\n")
+              : lines.slice(0, 3).join("\n") +
+                `\n... +${lines.length - 3} lines`;
 
           resolve({
             success: exitCode === 0,

package/src/tools/cronCreateTool.ts

@@ -0,0 +1,73 @@
+import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { CRON_CREATE_TOOL_NAME } from "../constants/tools.js";
+
+export const cronCreateTool: ToolPlugin = {
+  name: CRON_CREATE_TOOL_NAME,
+  config: {
+    type: "function",
+    function: {
+      name: CRON_CREATE_TOOL_NAME,
+      description:
+        "Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.",
+      parameters: {
+        type: "object",
+        properties: {
+          cron: {
+            type: "string",
+            description:
+              'Standard 5-field cron expression in local time: "M H DoM Mon DoW"',
+          },
+          prompt: {
+            type: "string",
+            description: "The prompt to enqueue at each fire time",
+          },
+          recurring: {
+            type: "boolean",
+            description:
+              "Default: true. true = fire on every cron match until deleted or auto-expired after 7 days. false = fire once at the next match, then auto-delete",
+            default: true,
+          },
+        },
+        required: ["cron", "prompt"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const {
+      cron,
+      prompt,
+      recurring = true,
+    } = args as { cron: string; prompt: string; recurring?: boolean };
+
+    if (!context.cronManager) {
+      return {
+        success: false,
+        content: "",
+        error: "CronManager not available",
+      };
+    }
+
+    try {
+      const job = context.cronManager.createJob({
+        cron,
+        prompt,
+        recurring,
+      });
+
+      return {
+        success: true,
+        content: JSON.stringify({ id: job.id }, null, 2),
+        shortResult: `Scheduled job ${job.id}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        content: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};

package/src/tools/cronDeleteTool.ts

@@ -0,0 +1,47 @@
+import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { CRON_DELETE_TOOL_NAME } from "../constants/tools.js";
+
+export const cronDeleteTool: ToolPlugin = {
+  name: CRON_DELETE_TOOL_NAME,
+  config: {
+    type: "function",
+    function: {
+      name: CRON_DELETE_TOOL_NAME,
+      description:
+        "Cancel a cron job previously scheduled with CronCreate. Removes it from the in-memory session store.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Job ID returned by CronCreate",
+          },
+        },
+        required: ["id"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const { id } = args as { id: string };
+
+    if (!context.cronManager) {
+      return {
+        success: false,
+        content: "",
+        error: "CronManager not available",
+      };
+    }
+
+    const success = context.cronManager.deleteJob(id);
+
+    return {
+      success,
+      content: JSON.stringify({ success }, null, 2),
+      shortResult: success ? `Deleted job ${id}` : `Job ${id} not found`,
+      error: success ? undefined : `Job ${id} not found`,
+    };
+  },
+};

package/src/tools/cronListTool.ts

@@ -0,0 +1,38 @@
+import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { CRON_LIST_TOOL_NAME } from "../constants/tools.js";
+
+export const cronListTool: ToolPlugin = {
+  name: CRON_LIST_TOOL_NAME,
+  config: {
+    type: "function",
+    function: {
+      name: CRON_LIST_TOOL_NAME,
+      description:
+        "List all cron jobs scheduled via CronCreate in this session.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  },
+  execute: async (
+    _args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    if (!context.cronManager) {
+      return {
+        success: false,
+        content: "",
+        error: "CronManager not available",
+      };
+    }
+
+    const jobs = context.cronManager.listJobs();
+
+    return {
+      success: true,
+      content: JSON.stringify({ jobs }, null, 2),
+      shortResult: `Found ${jobs.length} jobs`,
+    };
+  },
+};

package/src/tools/readTool.ts

@@ -243,31 +243,19 @@ Usage:
         };
       }
 
-      // Check content size limit (100KB)
-      const MAX_CONTENT_SIZE = 100 * 1024; // 100KB
-      let contentToProcess = fileContent;
-      let contentTruncated = false;
-
-      if (fileContent.length > MAX_CONTENT_SIZE) {
-        contentToProcess = fileContent.substring(0, MAX_CONTENT_SIZE);
-        contentTruncated = true;
-      }
-
-      const lines = contentToProcess.split("\n");
-      const totalLines = lines.length;
-      const originalTotalLines = fileContent.split("\n").length;
+      const allLines = fileContent.split("\n");
+      const totalLines = allLines.length;
 
       // Handle offset and limit
       let startLine = 1;
-      let endLine = Math.min(totalLines, 2000); // Default maximum read 2000 lines
-
       if (typeof offset === "number") {
         startLine = Math.max(1, offset);
       }
 
-      if (typeof limit === "number") {
-        endLine = Math.min(totalLines, startLine + limit - 1);
-      }
+      let endLine = Math.min(
+        totalLines,
+        startLine + (typeof limit === "number" ? limit : 2000) - 1,
+      );
 
       // If no offset and limit specified, read entire file (maximum 2000 lines)
       if (typeof offset !== "number" && typeof limit !== "number") {
@@ -285,7 +273,7 @@ Usage:
       }
 
       // Extract specified line range
-      const selectedLines = lines.slice(startLine - 1, endLine);
+      const selectedLines = allLines.slice(startLine - 1, endLine);
 
       // Format output (cat -n format, with line numbers)
       const formattedContent = selectedLines
@@ -300,10 +288,7 @@ Usage:
 
       // Add file information header
       let content = `File: ${filePath}\n`;
-      if (contentTruncated) {
-        content += `Content truncated at ${MAX_CONTENT_SIZE} bytes\n`;
-        content += `Lines ${startLine}-${endLine} of ${totalLines} (original file: ${originalTotalLines} lines)\n`;
-      } else if (startLine > 1 || endLine < totalLines) {
+      if (startLine > 1 || endLine < totalLines) {
         content += `Lines ${startLine}-${endLine} of ${totalLines}\n`;
       } else {
         content += `Total lines: ${totalLines}\n`;
@@ -312,22 +297,15 @@ Usage:
       content += formattedContent;
 
       // If only showing partial content, add prompt
-      if (endLine < totalLines || contentTruncated) {
+      if (endLine < totalLines) {
         content += `\n${"─".repeat(50)}\n`;
-        if (contentTruncated) {
-          content += `... content truncated due to size limit (${MAX_CONTENT_SIZE} bytes)`;
-          if (endLine < totalLines) {
-            content += ` and ${totalLines - endLine} more lines not shown`;
-          }
-        } else {
-          content += `... ${totalLines - endLine} more lines not shown`;
-        }
+        content += `... ${totalLines - endLine} more lines not shown`;
       }
 
       return {
         success: true,
         content,
-        shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 || contentTruncated ? " (truncated)" : ""}`,
+        shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 ? " (truncated)" : ""}`,
       };
     } catch (error) {
       return {

package/src/tools/skillTool.ts

@@ -11,14 +11,16 @@ import {
 /**
  * Skill tool plugin for invoking Wave skills
  */
+const SKILL_TOOL_DESCRIPTION =
+  "Execute a skill within the main conversation. When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.";
+
 export const skillTool: ToolPlugin = {
   name: SKILL_TOOL_NAME,
   config: {
     type: "function" as const,
     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.",
+      description: SKILL_TOOL_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {
@@ -41,7 +43,7 @@ export const skillTool: ToolPlugin = {
       (skill) => !skill.disableModelInvocation,
     );
     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.";
+      return `${SKILL_TOOL_DESCRIPTION} No skills are currently available.`;
     }
 
     const skillList = availableSkills
@@ -50,7 +52,7 @@ export const skillTool: ToolPlugin = {
       )
       .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 `${SKILL_TOOL_DESCRIPTION} Do not invoke the same skill repeatedly if it has already been called with the same arguments.\n\nAvailable skills:\n${skillList}`;
   },
 
   execute: async (

package/src/tools/taskOutputTool.ts

@@ -31,7 +31,7 @@ export const taskOutputTool: ToolPlugin = {
             description: "Max wait time in ms",
           },
         },
-        required: ["task_id"],
+        required: ["task_id", "block", "timeout"],
       },
     },
   },
@@ -87,8 +87,8 @@ export const taskOutputTool: ToolPlugin = {
 
       if (finalContent.length > MAX_OUTPUT_LENGTH) {
         processedContent =
-          finalContent.substring(0, MAX_OUTPUT_LENGTH) +
-          "\n\n... (output truncated)";
+          "\n\n... (output truncated)\n" +
+          finalContent.substring(finalContent.length - MAX_OUTPUT_LENGTH);
         isTruncated = true;
       }
 
@@ -155,11 +155,17 @@ export const taskOutputTool: ToolPlugin = {
             if (context.abortSignal) {
               context.abortSignal.removeEventListener("abort", onAbort);
             }
-            resolve({
-              success: true,
-              content: "Retrieval timed out",
-              shortResult: `${taskId}: timeout`,
-            });
+            const result = getResult();
+            if (result) {
+              result.shortResult = `${taskId}: timeout`;
+              resolve(result);
+            } else {
+              resolve({
+                success: true,
+                content: "Retrieval timed out",
+                shortResult: `${taskId}: timeout`,
+              });
+            }
             return;
           }
 

package/src/tools/types.ts

@@ -79,6 +79,8 @@ export interface ToolContext {
   subagentManager?: import("../managers/subagentManager.js").SubagentManager;
   /** Skill manager instance for skill invocation */
   skillManager?: import("../managers/skillManager.js").SkillManager;
+  /** Cron manager instance for scheduling tasks */
+  cronManager?: import("../managers/cronManager.js").CronManager;
   /** Current session ID */
   sessionId?: string;
   /** The ID of the current tool call */

package/src/types/agent.ts

@@ -67,6 +67,16 @@ export interface AgentOptions {
   isNewWorktree?: boolean;
   /**Whether to watch for skill changes - defaults to true */
   watchSkills?: boolean;
+  /**
+   * Optional list of tool names to always allow.
+   * These rules follow the standard permission rule syntax: `ToolName` or `ToolName(pattern)`.
+   */
+  allowedTools?: string[];
+  /**
+   * Optional list of tool names to always disallow.
+   * These rules follow the standard permission rule syntax: `ToolName` or `ToolName(pattern)`.
+   */
+  disallowedTools?: string[];
 }
 
 export interface AgentCallbacks

package/src/types/configuration.ts

@@ -21,7 +21,7 @@ export interface WaveConfiguration {
   permissions?: {
     allow?: string[];
     deny?: string[];
-    defaultMode?: PermissionMode; // Default permission mode for restricted tools
+    permissionMode?: PermissionMode; // Default permission mode for restricted tools
     /**
      * List of directories that are considered part of the Safe Zone.
      * File operations within these directories can be auto-accepted.

package/src/types/cron.ts

@@ -0,0 +1,9 @@
+export interface CronJob {
+  id: string;
+  cron: string;
+  prompt: string;
+  recurring: boolean;
+  createdAt: number;
+  nextRun: number;
+  periodMs: number;
+}

package/src/types/hooks.ts

@@ -19,7 +19,7 @@ export type HookEvent =
   | "UserPromptSubmit"
   | "Stop"
   | "SubagentStop"
-  | "Notification"
+  | "PermissionRequest"
   | "WorktreeCreate";
 
 // Individual hook command configuration
@@ -100,7 +100,7 @@ export function isValidHookEvent(event: string): event is HookEvent {
     "UserPromptSubmit",
     "Stop",
     "SubagentStop",
-    "Notification",
+    "PermissionRequest",
     "WorktreeCreate",
   ].includes(event);
 }
@@ -154,16 +154,14 @@ export interface HookJsonInput {
   session_id: string; // Format: "wave_session_{uuid}_{shortId}"
   transcript_path: string; // Format: "~/.wave/sessions/session_{shortId}.json"
   cwd: string; // Absolute path to current working directory
-  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "Notification"
+  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate"
 
   // Optional fields based on event type
-  tool_name?: string; // Present for PreToolUse, PostToolUse
-  tool_input?: unknown; // Present for PreToolUse, PostToolUse
+  tool_name?: string; // Present for PreToolUse, PostToolUse, PermissionRequest
+  tool_input?: unknown; // Present for PreToolUse, PostToolUse, PermissionRequest
   tool_response?: unknown; // Present for PostToolUse only
   user_prompt?: string; // Present for UserPromptSubmit only
   subagent_type?: string; // Present when hook is executed by a subagent
-  message?: string; // Present for Notification events
-  notification_type?: string; // Present for Notification events
   name?: string; // Present for WorktreeCreate events
 }
 
@@ -177,8 +175,6 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   env?: Record<string, string>; // Additional environment variables (from configuration)
   userPrompt?: string; // User prompt text (UserPromptSubmit only)
   subagentType?: string; // Subagent type when hook is executed by a subagent
-  message?: string; // Notification message (Notification only)
-  notificationType?: string; // Notification type (Notification only)
   worktreeName?: string; // Worktree name (WorktreeCreate only)
 }
 

package/src/types/index.ts

@@ -35,3 +35,4 @@ export * from "./memoryRule.js";
 export * from "./history.js";
 export * from "./tasks.js";
 export * from "./agent.js";
+export * from "./cron.js";

package/src/types/messaging.ts

@@ -11,7 +11,7 @@ export enum MessageSource {
 }
 
 export interface Message {
-  id?: string; // Unique identifier for the message
+  id: string; // Unique identifier for the message
   role: "user" | "assistant";
   blocks: MessageBlock[];
   usage?: Usage; // Usage data for this message's AI operation (assistant messages only)