wave-agent-sdk 0.0.1 → 0.0.3

package/dist/tools/grepTool.js

@@ -58,7 +58,7 @@ export const grepTool = {
                     },
                     head_limit: {
                         type: "number",
-                        description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). When unspecified, shows all results from ripgrep.',
+                        description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 100 to prevent excessive token usage.',
                     },
                     multiline: {
                         type: "boolean",
@@ -176,11 +176,13 @@ export const grepTool = {
                     shortResult: "No matches found",
                 };
             }
-            // Apply head_limit
+            // Apply head_limit with default fallback
             let finalOutput = output;
             let lines = output.split("\n");
-            if (headLimit && headLimit > 0 && lines.length > headLimit) {
-                lines = lines.slice(0, headLimit);
+            // Set default head_limit if not specified to prevent excessive token usage
+            const effectiveHeadLimit = headLimit || 100;
+            if (lines.length > effectiveHeadLimit) {
+                lines = lines.slice(0, effectiveHeadLimit);
                 finalOutput = lines.join("\n");
             }
             // Generate short result
@@ -195,8 +197,8 @@ export const grepTool = {
             else {
                 shortResult = `Found ${totalLines} matching line${totalLines === 1 ? "" : "s"}`;
             }
-            if (headLimit && totalLines > headLimit) {
-                shortResult += ` (showing first ${headLimit})`;
+            if (effectiveHeadLimit && totalLines > effectiveHeadLimit) {
+                shortResult += ` (showing first ${effectiveHeadLimit})`;
             }
             return {
                 success: true,

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

@@ -1 +1 @@
-{"version":3,"file":"readTool.d.ts","sourceRoot":"","sources":["../../src/tools/readTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAGtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA6JtB,CAAC"}
+{"version":3,"file":"readTool.d.ts","sourceRoot":"","sources":["../../src/tools/readTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAOtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA2LtB,CAAC"}

package/dist/tools/readTool.js

@@ -1,5 +1,6 @@
 import { readFile } from "fs/promises";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { isBinaryDocument, getBinaryDocumentError, } from "../utils/fileFormat.js";
 /**
  * Read Tool Plugin - Read file content
  */
@@ -9,7 +10,7 @@ export const readTool = {
         type: "function",
         function: {
             name: "Read",
-            description: "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- 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.\n- 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\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.",
+            description: "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- 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.\n- 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\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.\n- Binary document formats (PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX) are not supported and will return an error.",
             parameters: {
                 type: "object",
                 properties: {
@@ -41,6 +42,14 @@ export const readTool = {
                 error: "file_path parameter is required and must be a string",
             };
         }
+        // Check for binary document formats
+        if (isBinaryDocument(filePath)) {
+            return {
+                success: false,
+                content: "",
+                error: getBinaryDocumentError(filePath),
+            };
+        }
         try {
             // Note: New Read tool requires absolute paths, so we don't use resolvePath
             // But for compatibility, if it's not an absolute path, we still try to resolve
@@ -57,8 +66,17 @@ export const readTool = {
                     shortResult: "Empty file",
                 };
             }
-            const lines = fileContent.split("\n");
+            // 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;
             // Handle offset and limit
             let startLine = 1;
             let endLine = Math.min(totalLines, 2000); // Default maximum read 2000 lines
@@ -94,7 +112,11 @@ export const readTool = {
                 .join("\n");
             // Add file information header
             let content = `File: ${filePath}\n`;
-            if (startLine > 1 || endLine < totalLines) {
+            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) {
                 content += `Lines ${startLine}-${endLine} of ${totalLines}\n`;
             }
             else {
@@ -103,14 +125,22 @@ export const readTool = {
             content += "─".repeat(50) + "\n";
             content += formattedContent;
             // If only showing partial content, add prompt
-            if (endLine < totalLines) {
+            if (endLine < totalLines || contentTruncated) {
                 content += `\n${"─".repeat(50)}\n`;
-                content += `... ${totalLines - endLine} more lines not shown`;
+                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`;
+                }
             }
             return {
                 success: true,
                 content,
-                shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 ? " (truncated)" : ""}`,
+                shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 || contentTruncated ? " (truncated)" : ""}`,
             };
         }
         catch (error) {

package/dist/tools/skillTool.d.ts

@@ -0,0 +1,8 @@
+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
+ */
+export declare function createSkillTool(skillManager: SkillManager): ToolPlugin;
+//# sourceMappingURL=skillTool.d.ts.map

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

@@ -0,0 +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;AAEhE;;;GAGG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,UAAU,CA0EtE"}

package/dist/tools/skillTool.js

@@ -0,0 +1,72 @@
+/**
+ * Create a skill tool plugin that uses the provided SkillManager
+ * Note: SkillManager should be initialized before calling this function
+ */
+export function createSkillTool(skillManager) {
+    const getToolDescription = () => {
+        const availableSkills = skillManager.getAvailableSkills();
+        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 {
+        name: "skill",
+        config: {
+            type: "function",
+            function: {
+                name: "skill",
+                description: getToolDescription(),
+                parameters: {
+                    type: "object",
+                    properties: {
+                        skill_name: {
+                            type: "string",
+                            description: "Name of the skill to invoke",
+                            enum: skillManager
+                                .getAvailableSkills()
+                                .map((skill) => skill.name),
+                        },
+                    },
+                    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,
+                });
+                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/taskTool.d.ts

@@ -0,0 +1,8 @@
+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
+ */
+export declare function createTaskTool(subagentManager: SubagentManager): ToolPlugin;
+//# sourceMappingURL=taskTool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taskTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,eAAe,GAAG,UAAU,CAwH3E"}

package/dist/tools/taskTool.js

@@ -0,0 +1,109 @@
+/**
+ * Create a task tool plugin that uses the provided SubagentManager
+ * Note: SubagentManager should be initialized before calling this function
+ */
+export function createTaskTool(subagentManager) {
+    // 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 {
+        name: "Task",
+        config: {
+            type: "function",
+            function: {
+                name: "Task",
+                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"}`,
+                        },
+                    },
+                    required: ["description", "prompt", "subagent_type"],
+                },
+            },
+        },
+        execute: async (args) => {
+            // Input validation
+            const description = args.description;
+            const prompt = args.prompt;
+            const subagent_type = args.subagent_type;
+            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",
+                    };
+                }
+                // Create subagent instance and execute task
+                const instance = await subagentManager.createInstance(configuration, description);
+                const response = await subagentManager.executeTask(instance, prompt);
+                return {
+                    success: true,
+                    content: response,
+                    shortResult: `Task completed by ${configuration.name}`,
+                };
+            }
+            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"}`;
+        },
+    };
+}

package/dist/tools/todoWriteTool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * TodoWrite tool for creating and managing structured task lists
+ */
+export declare const todoWriteTool: ToolPlugin;
+//# sourceMappingURL=todoWriteTool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"todoWriteTool.d.ts","sourceRoot":"","sources":["../../src/tools/todoWriteTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,YAAY,CAAC;AAQzD;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UA4N3B,CAAC"}

package/dist/tools/todoWriteTool.js

@@ -0,0 +1,203 @@
+/**
+ * TodoWrite tool for creating and managing structured task lists
+ */
+export const todoWriteTool = {
+    name: "TodoWrite",
+    config: {
+        type: "function",
+        function: {
+            name: "TodoWrite",
+            description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
+            parameters: {
+                type: "object",
+                properties: {
+                    todos: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                content: {
+                                    type: "string",
+                                    minLength: 1,
+                                },
+                                status: {
+                                    type: "string",
+                                    enum: ["pending", "in_progress", "completed"],
+                                },
+                                id: {
+                                    type: "string",
+                                },
+                            },
+                            required: ["content", "status", "id"],
+                            additionalProperties: false,
+                        },
+                        description: "The updated todo list",
+                    },
+                },
+                required: ["todos"],
+                additionalProperties: false,
+            },
+        },
+    },
+    execute: async (args) => {
+        try {
+            // Validate arguments
+            const { todos } = args;
+            if (!todos || !Array.isArray(todos)) {
+                return {
+                    success: false,
+                    content: "",
+                    error: "todos parameter must be an array",
+                    shortResult: "Invalid todos format",
+                };
+            }
+            // Validate each task item
+            for (const [index, todo] of todos.entries()) {
+                if (!todo || typeof todo !== "object") {
+                    return {
+                        success: false,
+                        content: "",
+                        error: `Todo item at index ${index} must be an object`,
+                        shortResult: "Invalid todo item",
+                    };
+                }
+                if (!todo.content ||
+                    typeof todo.content !== "string" ||
+                    todo.content.trim().length === 0) {
+                    return {
+                        success: false,
+                        content: "",
+                        error: `Todo item at index ${index} must have non-empty content`,
+                        shortResult: "Invalid todo content",
+                    };
+                }
+                if (!["pending", "in_progress", "completed"].includes(todo.status)) {
+                    return {
+                        success: false,
+                        content: "",
+                        error: `Todo item at index ${index} has invalid status: ${todo.status}`,
+                        shortResult: "Invalid todo status",
+                    };
+                }
+                if (!todo.id ||
+                    typeof todo.id !== "string" ||
+                    todo.id.trim().length === 0) {
+                    return {
+                        success: false,
+                        content: "",
+                        error: `Todo item at index ${index} must have a non-empty id`,
+                        shortResult: "Invalid todo id",
+                    };
+                }
+            }
+            // Check for duplicate IDs
+            const ids = todos.map((todo) => todo.id);
+            const duplicateIds = ids.filter((id, index) => ids.indexOf(id) !== index);
+            if (duplicateIds.length > 0) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `Duplicate todo IDs found: ${duplicateIds.join(", ")}`,
+                    shortResult: "Duplicate todo IDs",
+                };
+            }
+            // Check that only one task is in_progress
+            const inProgressTodos = todos.filter((todo) => todo.status === "in_progress");
+            if (inProgressTodos.length > 1) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `Only one todo can be in_progress at a time. Found ${inProgressTodos.length} in_progress todos`,
+                    shortResult: "Multiple in_progress todos",
+                };
+            }
+            const completedCount = todos.filter((t) => t.status === "completed").length;
+            const totalCount = todos.length;
+            let shortResult = `${completedCount}/${totalCount} done`;
+            if (totalCount > 0) {
+                const symbols = {
+                    pending: "[ ]",
+                    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}`;
+                    }
+                }
+            }
+            return {
+                success: true,
+                content: `Todo list updated: ${completedCount}/${totalCount} completed`,
+                shortResult: shortResult,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                content: "",
+                error: error instanceof Error ? error.message : String(error),
+                shortResult: "Todo list update failed",
+            };
+        }
+    },
+};

package/dist/types.d.ts

@@ -13,7 +13,7 @@ export interface Message {
     role: "user" | "assistant";
     blocks: MessageBlock[];
 }
-export type MessageBlock = TextBlock | ErrorBlock | ToolBlock | ImageBlock | DiffBlock | CommandOutputBlock | CompressBlock | MemoryBlock | CustomCommandBlock;
+export type MessageBlock = TextBlock | ErrorBlock | ToolBlock | ImageBlock | DiffBlock | CommandOutputBlock | CompressBlock | MemoryBlock | CustomCommandBlock | SubagentBlock;
 export interface TextBlock {
     type: "text";
     content: string;
@@ -75,6 +75,13 @@ export interface CustomCommandBlock {
     content: string;
     originalInput?: string;
 }
+export interface SubagentBlock {
+    type: "subagent";
+    subagentId: string;
+    subagentName: string;
+    status: "active" | "completed" | "error" | "aborted";
+    messages: Message[];
+}
 export interface AIRequest {
     content: string;
     files: unknown[];
@@ -209,4 +216,61 @@ export declare const SKILL_DEFAULTS: {
     readonly SCAN_TIMEOUT: 5000;
     readonly LOAD_TIMEOUT: 2000;
 };
+export interface GatewayConfig {
+    apiKey: string;
+    baseURL: string;
+}
+export interface ModelConfig {
+    agentModel: string;
+    fastModel: string;
+}
+export interface ConfigurationResolver {
+    /**
+     * Resolves gateway configuration from constructor args and environment
+     * @param apiKey - API key from constructor (optional)
+     * @param baseURL - Base URL from constructor (optional)
+     * @returns Resolved gateway configuration
+     * @throws Error if required configuration is missing after fallbacks
+     */
+    resolveGatewayConfig(apiKey?: string, baseURL?: string): GatewayConfig;
+    /**
+     * Resolves model configuration with fallbacks
+     * @param agentModel - Agent model from constructor (optional)
+     * @param fastModel - Fast model from constructor (optional)
+     * @returns Resolved model configuration with defaults
+     */
+    resolveModelConfig(agentModel?: string, fastModel?: string): ModelConfig;
+    /**
+     * Resolves token limit with fallbacks
+     * @param constructorLimit - Token limit from constructor (optional)
+     * @returns Resolved token limit
+     */
+    resolveTokenLimit(constructorLimit?: number): number;
+}
+export interface ConfigurationValidator {
+    /**
+     * Validates gateway configuration
+     * @param config - Configuration to validate
+     * @throws Error with descriptive message if invalid
+     */
+    validateGatewayConfig(config: GatewayConfig): void;
+    /**
+     * Validates token limit value
+     * @param tokenLimit - Token limit to validate
+     * @throws Error if invalid
+     */
+    validateTokenLimit(tokenLimit: number): void;
+}
+export declare class ConfigurationError extends Error {
+    readonly field: string;
+    readonly provided?: unknown | undefined;
+    constructor(message: string, field: string, provided?: unknown | undefined);
+}
+export declare const CONFIG_ERRORS: {
+    readonly MISSING_API_KEY: "Gateway configuration requires apiKey. Provide via constructor or AIGW_TOKEN environment variable.";
+    readonly MISSING_BASE_URL: "Gateway configuration requires baseURL. Provide via constructor or AIGW_URL environment variable.";
+    readonly INVALID_TOKEN_LIMIT: "Token limit must be a positive integer.";
+    readonly EMPTY_API_KEY: "API key cannot be empty string.";
+    readonly EMPTY_BASE_URL: "Base URL cannot be empty string.";
+};
 //# sourceMappingURL=types.d.ts.map