wave-agent-sdk 0.0.1 → 0.0.3

package/src/services/aiService.ts

@@ -5,12 +5,40 @@ import {
   ChatCompletionMessageParam,
   ChatCompletionFunctionTool,
 } from "openai/resources.js";
-import { FAST_MODEL_ID, AGENT_MODEL_ID } from "@/utils/constants.js";
+import type { GatewayConfig, ModelConfig } from "../types.js";
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
 
 /**
- * Model configuration type, based on OpenAI parameters but excluding messages
+ * Check if a directory is a git repository
+ * @param dirPath Directory path to check
+ * @returns "Yes" if it's a git repo, "No" otherwise
  */
-type ModelConfig = Omit<ChatCompletionCreateParamsNonStreaming, "messages">;
+function isGitRepository(dirPath: string): string {
+  try {
+    // Check if .git directory exists in current directory or any parent directory
+    let currentPath = path.resolve(dirPath);
+    while (currentPath !== path.dirname(currentPath)) {
+      const gitPath = path.join(currentPath, ".git");
+      if (fs.existsSync(gitPath)) {
+        return "Yes";
+      }
+      currentPath = path.dirname(currentPath);
+    }
+    return "No";
+  } catch {
+    return "No";
+  }
+}
+
+/**
+ * OpenAI model configuration type, based on OpenAI parameters but excluding messages
+ */
+type OpenAIModelConfig = Omit<
+  ChatCompletionCreateParamsNonStreaming,
+  "messages"
+>;
 
 /**
  * Get specific configuration parameters based on model name
@@ -20,9 +48,9 @@ type ModelConfig = Omit<ChatCompletionCreateParamsNonStreaming, "messages">;
  */
 function getModelConfig(
   modelName: string,
-  baseConfig: Partial<ModelConfig> = {},
-): ModelConfig {
-  const config: ModelConfig = {
+  baseConfig: Partial<OpenAIModelConfig> = {},
+): OpenAIModelConfig {
+  const config: OpenAIModelConfig = {
     model: modelName,
     stream: false,
     ...baseConfig,
@@ -37,13 +65,12 @@ function getModelConfig(
   return config;
 }
 
-// Initialize OpenAI client with environment variables
-const openai = new OpenAI({
-  apiKey: process.env.AIGW_TOKEN,
-  baseURL: process.env.AIGW_URL,
-});
-
 export interface CallAgentOptions {
+  // Resolved configuration
+  gatewayConfig: GatewayConfig;
+  modelConfig: ModelConfig;
+
+  // Existing parameters (preserved)
   messages: ChatCompletionMessageParam[];
   sessionId?: string;
   abortSignal?: AbortSignal;
@@ -67,28 +94,46 @@ export interface CallAgentResult {
 export async function callAgent(
   options: CallAgentOptions,
 ): Promise<CallAgentResult> {
-  const { messages, abortSignal, memory, workdir, tools, model, systemPrompt } =
-    options;
+  const {
+    gatewayConfig,
+    modelConfig,
+    messages,
+    abortSignal,
+    memory,
+    workdir,
+    tools,
+    model,
+    systemPrompt,
+  } = options;
 
   try {
-    // Build system prompt content
-    let systemContent: string;
-
-    if (systemPrompt) {
-      // Use custom system prompt if provided
-      systemContent = systemPrompt;
-    } else {
-      // Use default system prompt
-      systemContent = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+    // Create OpenAI client with injected configuration
+    const openai = new OpenAI({
+      apiKey: gatewayConfig.apiKey,
+      baseURL: gatewayConfig.baseURL,
+    });
 
-## Current Working Directory
-${workdir}
+    // Build system prompt content
+    let systemContent =
+      systemPrompt ||
+      `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
+
+    // Always add environment information
+    systemContent += `
+
+Here is useful information about the environment you are running in:
+<env>
+Working directory: ${workdir}
+Is directory a git repo: ${isGitRepository(workdir)}
+Platform: ${os.platform()}
+OS Version: ${os.type()} ${os.release()}
+Today's date: ${new Date().toISOString().split("T")[0]}
+</env>
 `;
 
-      // If there is memory content, add it to the system prompt
-      if (memory && memory.trim()) {
-        systemContent += `\n\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
-      }
+    // If there is memory content, add it to the system prompt
+    if (memory && memory.trim()) {
+      systemContent += `\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
     }
 
     // Add system prompt
@@ -101,15 +146,15 @@ ${workdir}
     const openaiMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] =
       [systemMessage, ...messages];
 
-    // Get model configuration
-    const modelConfig = getModelConfig(model || AGENT_MODEL_ID, {
+    // Get model configuration - use injected modelConfig with optional override
+    const openaiModelConfig = getModelConfig(model || modelConfig.agentModel, {
       temperature: 0,
       max_completion_tokens: 32768,
     });
 
     // Prepare API call parameters
     const createParams: ChatCompletionCreateParamsNonStreaming = {
-      ...modelConfig,
+      ...openaiModelConfig,
       messages: openaiMessages,
     };
 
@@ -160,6 +205,11 @@ ${workdir}
 }
 
 export interface CompressMessagesOptions {
+  // Resolved configuration
+  gatewayConfig: GatewayConfig;
+  modelConfig: ModelConfig;
+
+  // Existing parameters
   messages: ChatCompletionMessageParam[];
   abortSignal?: AbortSignal;
 }
@@ -167,10 +217,16 @@ export interface CompressMessagesOptions {
 export async function compressMessages(
   options: CompressMessagesOptions,
 ): Promise<string> {
-  const { messages, abortSignal } = options;
+  const { gatewayConfig, modelConfig, messages, abortSignal } = options;
+
+  // Create OpenAI client with injected configuration
+  const openai = new OpenAI({
+    apiKey: gatewayConfig.apiKey,
+    baseURL: gatewayConfig.baseURL,
+  });
 
-  // Get model configuration
-  const modelConfig = getModelConfig(FAST_MODEL_ID, {
+  // Get model configuration - use injected fast model
+  const openaiModelConfig = getModelConfig(modelConfig.fastModel, {
     temperature: 0.1,
     max_tokens: 1500,
   });
@@ -178,7 +234,7 @@ export async function compressMessages(
   try {
     const response = await openai.chat.completions.create(
       {
-        ...modelConfig,
+        ...openaiModelConfig,
         messages: [
           {
             role: "system",

package/src/services/session.ts

@@ -76,6 +76,11 @@ export async function saveSession(
     return;
   }
 
+  // Do not save if there are no messages
+  if (messages.length === 0) {
+    return;
+  }
+
   await ensureSessionDir();
 
   // Filter out diff blocks before saving

package/src/tools/grepTool.ts

@@ -71,7 +71,7 @@ export const grepTool: ToolPlugin = {
           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.',
+              '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",
@@ -209,12 +209,15 @@ export const grepTool: ToolPlugin = {
         };
       }
 
-      // 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");
       }
 
@@ -230,8 +233,8 @@ export const grepTool: ToolPlugin = {
         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 {

package/src/tools/readTool.ts

@@ -1,6 +1,10 @@
 import { readFile } from "fs/promises";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import {
+  isBinaryDocument,
+  getBinaryDocumentError,
+} from "../utils/fileFormat.js";
 
 /**
  * Read Tool Plugin - Read file content
@@ -12,7 +16,7 @@ export const readTool: ToolPlugin = {
     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.",
+        "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: {
@@ -51,6 +55,15 @@ export const readTool: ToolPlugin = {
       };
     }
 
+    // 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
@@ -71,8 +84,19 @@ export const readTool: ToolPlugin = {
         };
       }
 
-      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;
@@ -117,7 +141,10 @@ export const readTool: ToolPlugin = {
 
       // 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 {
         content += `Total lines: ${totalLines}\n`;
@@ -126,15 +153,22 @@ export const readTool: ToolPlugin = {
       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) {
       return {

package/src/tools/skillTool.ts

@@ -0,0 +1,82 @@
+import type { ToolPlugin, ToolResult } 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 function createSkillTool(skillManager: SkillManager): ToolPlugin {
+  const getToolDescription = (): string => {
+    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: Record<string, unknown>): Promise<ToolResult> => {
+      try {
+        // Validate arguments
+        const skillName = args.skill_name as string;
+        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: Record<string, unknown>) => {
+      const skillName = params.skill_name as string;
+      return skillName || "unknown-skill";
+    },
+  };
+}

package/src/tools/taskTool.ts

@@ -0,0 +1,128 @@
+import type { ToolPlugin, ToolResult } 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 function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
+  // 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: Record<string, unknown>): Promise<ToolResult> => {
+      // Input validation
+      const description = args.description as string;
+      const prompt = args.prompt as string;
+      const subagent_type = args.subagent_type as string;
+
+      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: Record<string, unknown>) => {
+      const subagent_type = params.subagent_type as string;
+      const description = params.description as string;
+      return `${subagent_type || "unknown"}: ${description || "no description"}`;
+    },
+  };
+}