wave-agent-sdk 1.0.4 → 1.0.6

package/src/utils/containerSetup.ts

@@ -1,371 +0,0 @@
-import { Container } from "./container.js";
-import { ForegroundTaskManager } from "../managers/foregroundTaskManager.js";
-import { BackgroundTaskManager } from "../managers/backgroundTaskManager.js";
-import { MessageQueue } from "../managers/messageQueue.js";
-import { TaskManager } from "../services/taskManager.js";
-import { MessageManager } from "../managers/messageManager.js";
-import { AIManager } from "../managers/aiManager.js";
-import { ToolManager } from "../managers/toolManager.js";
-import { McpManager } from "../managers/mcpManager.js";
-import { LspManager } from "../managers/lspManager.js";
-import { PermissionManager } from "../managers/permissionManager.js";
-import { PlanManager } from "../managers/planManager.js";
-import { HookManager } from "../managers/hookManager.js";
-import { SkillManager } from "../managers/skillManager.js";
-import { SlashCommandManager } from "../managers/slashCommandManager.js";
-import { PluginManager } from "../managers/pluginManager.js";
-import { BangManager } from "../managers/bangManager.js";
-import { CronManager } from "../managers/cronManager.js";
-import { WorkflowManager } from "../managers/workflowManager.js";
-import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
-import { ReversionManager } from "../managers/reversionManager.js";
-import { SubagentManager } from "../managers/subagentManager.js";
-import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
-import { LiveConfigManager } from "../managers/liveConfigManager.js";
-import { ConfigurationService } from "../services/configurationService.js";
-import { ReversionService } from "../services/reversionService.js";
-import { cleanupMetaOnlySessions } from "../services/session.js";
-import { MemoryService } from "../services/memory.js";
-import { AutoMemoryService } from "../services/autoMemoryService.js";
-import { USER_MEMORY_FILE } from "./constants.js";
-import { getGitMainRepoRoot } from "./gitUtils.js";
-import type { AgentOptions, McpServerConfig } from "../types/index.js";
-import type {
-  PermissionMode,
-  Usage,
-  Task,
-  BackgroundTask,
-  ToolPermissionContext,
-} from "../types/index.js";
-
-import { logger } from "./globalLogger.js";
-import { authService } from "../services/authService.js";
-import { remoteSettingsService } from "../services/remoteSettingsService.js";
-
-export interface AgentContainerSetupOptions {
-  options: AgentOptions;
-  workdir: string;
-  configurationService: ConfigurationService;
-  systemPrompt?: string;
-  stream: boolean;
-
-  // Callbacks to Agent methods
-  onBackgroundTasksChange: (tasks: BackgroundTask[]) => void;
-  onTasksChange: (tasks: Task[]) => void;
-  onPermissionModeChange: (mode: PermissionMode) => void;
-  handlePlanModeTransition: (mode: PermissionMode) => void;
-  setPermissionMode: (mode: PermissionMode) => void;
-  addPermissionRule: (rule: string) => Promise<void>;
-  addUsage: (usage: Usage) => void;
-}
-
-export function setupAgentContainer(
-  setupOptions: AgentContainerSetupOptions,
-): Container {
-  const {
-    options,
-    workdir,
-    configurationService,
-    systemPrompt,
-    stream,
-    onBackgroundTasksChange,
-    onTasksChange,
-    onPermissionModeChange,
-    handlePlanModeTransition,
-    setPermissionMode,
-    addPermissionRule,
-    addUsage,
-  } = setupOptions;
-
-  const callbacks = options.callbacks || {};
-  const container = new Container();
-  container.register("AgentOptions", options);
-  container.register("Workdir", workdir);
-
-  if (options.worktreeName) {
-    container.register("WorktreeName", options.worktreeName);
-    container.register("MainRepoRoot", getGitMainRepoRoot(workdir));
-  }
-
-  // Per-agent worktree session state (EnterWorktree/ExitWorktree). Stored in the
-  // container so it is isolated per session, not shared process-wide.
-  container.register("WorktreeSession", null);
-
-  const messageQueue = new MessageQueue();
-  container.register("MessageQueue", messageQueue);
-
-  const foregroundTaskManager = new ForegroundTaskManager(container);
-  container.register("ForegroundTaskManager", foregroundTaskManager);
-  container.register("ConfigurationService", configurationService);
-
-  const memoryService = new MemoryService(container);
-  container.register("MemoryService", memoryService);
-
-  const autoMemoryService = new AutoMemoryService(container);
-  container.register("AutoMemoryService", autoMemoryService);
-
-  const memoryRuleManager = new MemoryRuleManager(container, { workdir });
-  container.register("MemoryRuleManager", memoryRuleManager);
-
-  const messageManager = new MessageManager(container, {
-    callbacks: {
-      ...callbacks,
-      onSessionIdChange: (sessionId) => {
-        const taskManager = container.get<TaskManager>("TaskManager");
-        if (taskManager) {
-          taskManager.syncWithSession().catch((error) => {
-            logger.error("Failed to sync task list with session:", error);
-          });
-        }
-        memoryService.clearCache();
-        callbacks.onSessionIdChange?.(sessionId);
-      },
-    },
-    workdir,
-  });
-  container.register("MessageManager", messageManager);
-
-  const resolvedTaskListId =
-    process.env.WAVE_TASK_LIST_ID || messageManager.getRootSessionId();
-
-  const taskManager = new TaskManager(container, resolvedTaskListId);
-  container.register("TaskManager", taskManager);
-  taskManager.on("tasksChange", async () => {
-    const tasks = await taskManager.listTasks();
-    onTasksChange(tasks);
-  });
-  taskManager.cleanupOldTaskLists(30).catch((error) => {
-    logger.error("Failed to cleanup old task lists:", error);
-  });
-
-  const backgroundTaskManager = new BackgroundTaskManager(container, {
-    callbacks: {
-      ...callbacks,
-      onBackgroundTasksChange: (tasks) => {
-        onBackgroundTasksChange(tasks);
-        callbacks.onBackgroundTasksChange?.(tasks);
-      },
-    },
-    workdir,
-  });
-  container.register("BackgroundTaskManager", backgroundTaskManager);
-
-  if (options.serverUrl) {
-    authService.setServerUrl(options.serverUrl);
-  }
-  const mcpManager = new McpManager(container, {
-    callbacks,
-    mcpServers: options.mcpServers as
-      | Record<string, McpServerConfig>
-      | undefined,
-  });
-  container.register("McpManager", mcpManager);
-
-  // Wire up auth change callback to refresh/clear remote settings
-  authService.onAuthChange(async (event) => {
-    if (event === "login") {
-      await remoteSettingsService.refresh();
-    } else if (event === "logout") {
-      remoteSettingsService.clear();
-    }
-  });
-
-  const lspManager = options.lspManager || new LspManager(container);
-  container.register("LspManager", lspManager);
-
-  const permissionManager = new PermissionManager(container, {
-    instanceAllowedRules: options.allowedTools,
-    instanceDeniedRules: options.disallowedTools,
-    instanceAdditionalDirectories: options.additionalDirectories,
-  });
-  if (configurationService.resolveAutoMemoryEnabled()) {
-    const autoMemoryDir = memoryService.getAutoMemoryDirectory(workdir);
-    permissionManager.addSystemAdditionalDirectory(autoMemoryDir);
-    permissionManager.addSystemAdditionalDirectory(USER_MEMORY_FILE);
-  }
-  container.register("PermissionManager", permissionManager);
-  permissionManager.setOnConfiguredPermissionModeChange((mode) => {
-    handlePlanModeTransition(mode);
-    onPermissionModeChange(mode);
-  });
-
-  const planManager = new PlanManager(container);
-  container.register("PlanManager", planManager);
-
-  const hookManager = new HookManager(container, workdir);
-  if (options.hooks) {
-    hookManager.loadConfiguration(options.hooks);
-  }
-  container.register("HookManager", hookManager);
-
-  const skillManager = new SkillManager(container, {
-    workdir,
-    watch: options.watchSkills ?? true,
-  });
-  container.register("SkillManager", skillManager);
-
-  const rootSessionId = messageManager.getRootSessionId();
-
-  const reversionService = new ReversionService(rootSessionId);
-  container.register("ReversionService", reversionService);
-  reversionService.cleanupOldSessions(30).catch((error) => {
-    logger.error("Failed to cleanup old file history:", error);
-  });
-  // Remove pre-existing meta-only session files (SessionStart hook context
-  // with no real messages) that were persisted before lazy materialization.
-  cleanupMetaOnlySessions()
-    .then((count) => {
-      if (count > 0) {
-        logger.debug(`Removed ${count} meta-only session file(s)`);
-      }
-    })
-    .catch((error) => {
-      logger.error("Failed to cleanup meta-only session files:", error);
-    });
-  const reversionManager = new ReversionManager(container);
-  container.register("ReversionManager", reversionManager);
-
-  const canUseToolWithPermissionRequest = options.canUseTool
-    ? async (context: ToolPermissionContext) => {
-        try {
-          const results = await hookManager.executeHooks("PermissionRequest", {
-            event: "PermissionRequest",
-            projectDir: workdir,
-            timestamp: new Date(),
-            sessionId: messageManager.getSessionId(),
-            transcriptPath: messageManager.getTranscriptPath(),
-            cwd: workdir,
-            toolName: context.toolName,
-            toolInput: context.toolInput,
-            planFilePath: permissionManager.getPlanFilePath(),
-            env: Object.fromEntries(
-              Object.entries(configurationService.getMergedEnv()).filter(
-                (e) => e[1] !== undefined,
-              ),
-            ) as Record<string, string>,
-          });
-
-          if (results.length > 0) {
-            const processResult = hookManager.processHookResults(
-              "PermissionRequest",
-              results,
-              messageManager,
-            );
-
-            if (processResult.shouldBlock) {
-              return {
-                behavior: "deny",
-                message:
-                  processResult.errorMessage ||
-                  "Permission denied by hook execution",
-              };
-            }
-          }
-        } catch (error) {
-          logger.warn("Failed to execute permission request hooks", {
-            toolName: context.toolName,
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-
-        const decision = await options.canUseTool!(context);
-
-        if (decision.newPermissionMode) {
-          setPermissionMode(decision.newPermissionMode);
-        }
-
-        if (decision.newPermissionRule) {
-          await addPermissionRule(decision.newPermissionRule);
-        }
-
-        return decision;
-      }
-    : undefined;
-
-  const toolManager = new ToolManager({
-    container,
-    tools: options.tools,
-    customTools: options.customTools,
-  });
-  container.register("ToolManager", toolManager);
-
-  container.register("PermissionMode", options.permissionMode);
-  // Register the full permission mode transition (Agent.setPermissionMode) so
-  // tools like EnterPlanMode can trigger planManager.handlePlanModeTransition
-  // and onPermissionModeChange even in bypass mode (where canUseTool is skipped).
-  container.register("PermissionModeTransition", setPermissionMode);
-  logger.info("Registering CanUseToolCallback", {
-    hasCallback: !!canUseToolWithPermissionRequest,
-  });
-  container.register("CanUseToolCallback", canUseToolWithPermissionRequest);
-
-  const liveConfigManager = new LiveConfigManager(container, {
-    workdir,
-    onReload: () => {
-      const models = configurationService.getConfiguredModels();
-      callbacks.onConfiguredModelsChange?.(models);
-    },
-  });
-  container.register("LiveConfigManager", liveConfigManager);
-
-  // Wire up remote settings hot-update: when polling detects changed settings,
-  // reload configuration so admin changes propagate to the running agent.
-  remoteSettingsService.onSettingsUpdate(async () => {
-    await liveConfigManager.reload();
-  });
-
-  const subagentManager = new SubagentManager(container, {
-    workdir,
-    callbacks: {
-      onSubagentUserMessageAdded: callbacks.onSubagentUserMessageAdded,
-      onSubagentAssistantMessageAdded:
-        callbacks.onSubagentAssistantMessageAdded,
-      onSubagentAssistantContentUpdated:
-        callbacks.onSubagentAssistantContentUpdated,
-      onSubagentAssistantReasoningUpdated:
-        callbacks.onSubagentAssistantReasoningUpdated,
-      onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
-      onSubagentMessagesChange: (subagentId, messages) => {
-        callbacks.onSubagentMessagesChange?.(subagentId, messages);
-      },
-      onSubagentLatestTotalTokensChange:
-        callbacks.onSubagentLatestTotalTokensChange,
-    },
-    onUsageAdded: (usage: Usage) => addUsage(usage),
-    stream,
-  });
-  container.register("SubagentManager", subagentManager);
-
-  const forkedAgentManager = new ForkedAgentManager(container);
-  container.register("ForkedAgentManager", forkedAgentManager);
-
-  const aiManager = new AIManager(container, {
-    callbacks: {
-      ...callbacks,
-      onUsageAdded: (usage: Usage) => addUsage(usage),
-    },
-    workdir,
-    systemPrompt,
-    stream,
-  });
-  container.register("AIManager", aiManager);
-
-  const slashCommandManager = new SlashCommandManager(container, { workdir });
-  container.register("SlashCommandManager", slashCommandManager);
-  slashCommandManager.initialize();
-
-  const pluginManager = new PluginManager(container, { workdir });
-  container.register("PluginManager", pluginManager);
-
-  const bangManager = new BangManager(container, { workdir });
-  container.register("BangManager", bangManager);
-
-  const cronManager = new CronManager(container, messageManager.getSessionId());
-  container.register("CronManager", cronManager);
-  cronManager.start();
-
-  const workflowManager = new WorkflowManager(container);
-  container.register("WorkflowManager", workflowManager);
-
-  return container;
-}

package/src/utils/convertMessagesForAPI.ts

@@ -1,326 +0,0 @@
-import type { Message } from "../types/index.js";
-import { convertImageToBase64 } from "./messageOperations.js";
-import { taskNotificationToXml } from "./notificationXml.js";
-import { ChatCompletionMessageToolCall } from "openai/resources";
-import { recoverTruncatedJson, stripAnsiColors } from "./stringUtils.js";
-import {
-  ChatCompletionContentPart,
-  ChatCompletionMessageParam,
-} from "openai/resources.js";
-import { logger } from "./globalLogger.js";
-
-/**
- * Safely handle tool call parameters, ensuring a legal JSON string is returned.
- * Attempts to recover truncated JSON (e.g., missing closing braces).
- * @param args Tool call parameters
- * @returns Legal JSON string
- */
-function safeToolArguments(args: string): string {
-  if (!args) {
-    return "{}";
-  }
-
-  try {
-    // Try to parse as JSON to validate format
-    JSON.parse(args);
-    return args;
-  } catch {
-    // Attempt to recover truncated JSON
-    const recovered = recoverTruncatedJson(args);
-    try {
-      JSON.parse(recovered);
-      return recovered;
-    } catch {
-      // Truly malformed JSON — return sanitized fallback
-      return JSON.stringify({
-        invalid_arguments: args,
-      });
-    }
-  }
-}
-
-/**
- * Options for converting messages to API format.
- */
-export interface ConvertMessagesOptions {
-  /** When false, images are stripped and replaced with text placeholders. */
-  supportsVision?: boolean;
-}
-
-/**
- * Convert message format to API call format, stopping when a compacted message is encountered.
- * Messages with no meaningful content or tool calls are filtered out.
- * @param messages Message list
- * @param options Optional conversion options (e.g. supportsVision)
- * @returns Converted API message format list
- */
-export function convertMessagesForAPI(
-  messages: Message[],
-  options?: ConvertMessagesOptions,
-): ChatCompletionMessageParam[] {
-  const supportsVision = options?.supportsVision !== false;
-  const recentMessages: ChatCompletionMessageParam[] = [];
-
-  const startIndex = messages.length - 1;
-  for (let i = startIndex; i >= 0; i--) {
-    const message = messages[i];
-
-    // Check if a compaction block is encountered, if so, stop iteration
-    if (
-      message.role === "assistant" &&
-      message.blocks.some((block) => block.type === "compact")
-    ) {
-      // Add the content of the compaction block as an assistant message to the history
-      const compactBlock = message.blocks.find(
-        (block) => block.type === "compact",
-      );
-      if (compactBlock && compactBlock.type === "compact") {
-        recentMessages.unshift({
-          role: "user",
-          content: compactBlock.content,
-        });
-      }
-      break;
-    }
-
-    // Skip empty assistant messages (no blocks or all blocks are empty)
-    if (message.role === "assistant" && message.blocks.length === 0) {
-      continue;
-    }
-
-    if (message.role === "assistant") {
-      // First check if there is a tool block, if so, add the tool message first
-      // Filter out incomplete tool blocks (no result or still running)
-      const toolBlocks = message.blocks.filter(
-        (block) => block.type === "tool",
-      );
-      const completedToolIds = new Set<string>(); // Record completed tool IDs
-
-      if (toolBlocks.length > 0) {
-        // Collect image user messages to place after all tool messages
-        const imageUserMessages: ChatCompletionMessageParam[] = [];
-
-        toolBlocks.forEach((toolBlock) => {
-          // Only add completed tool blocks (i.e., stage is 'end')
-          if (toolBlock.id && toolBlock.stage === "end") {
-            completedToolIds.add(toolBlock.id);
-
-            // Always add a proper tool message to satisfy tool_call_id pairing
-            recentMessages.unshift({
-              tool_call_id: toolBlock.id,
-              role: "tool",
-              content: stripAnsiColors(toolBlock.result || ""),
-            });
-
-            // If there are images, also prepare a user message with image content
-            if (toolBlock.images && toolBlock.images.length > 0) {
-              if (supportsVision) {
-                const contentParts: ChatCompletionContentPart[] = [];
-
-                toolBlock.images.forEach((image) => {
-                  const imageUrl = image.data.startsWith("data:")
-                    ? image.data
-                    : `data:${image.mediaType || "image/png"};base64,${image.data}`;
-
-                  contentParts.push({
-                    type: "image_url",
-                    image_url: {
-                      url: imageUrl,
-                      detail: "auto",
-                    },
-                  });
-                });
-
-                imageUserMessages.push({
-                  role: "user",
-                  content: contentParts,
-                });
-              } else {
-                // Non-vision model: replace images with a text placeholder
-                imageUserMessages.push({
-                  role: "user",
-                  content:
-                    "[Tool returned an image, but the current model does not support image recognition]",
-                });
-              }
-            }
-          }
-        });
-
-        // Insert image user messages after all tool messages but before the
-        // assistant message (which will be unshifted next). Since tool messages
-        // were unshifted to the front, we splice images right after them.
-        if (imageUserMessages.length > 0) {
-          // Tool messages are at indices 0..N-1, existing messages start at N
-          const toolMsgCount = completedToolIds.size;
-          recentMessages.splice(toolMsgCount, 0, ...imageUserMessages);
-        }
-      }
-
-      // Construct the content of the assistant message
-      let content = "";
-      let tool_calls: ChatCompletionMessageToolCall[] | undefined = undefined;
-
-      // Construct content from text blocks - filter out empty content
-      const textBlocks = message.blocks.filter(
-        (block) =>
-          block.type === "text" &&
-          block.content &&
-          block.content.trim().length > 0,
-      );
-      if (textBlocks.length > 0) {
-        content = textBlocks
-          .map((block) => (block.type === "text" ? block.content : ""))
-          .join("\n");
-      }
-
-      // Extract reasoning content from reasoning blocks
-      const reasoningBlocks = message.blocks.filter(
-        (block) =>
-          block.type === "reasoning" &&
-          block.content &&
-          block.content.trim().length > 0,
-      );
-      let reasoning_content: string | undefined;
-      if (reasoningBlocks.length > 0) {
-        reasoning_content = reasoningBlocks
-          .map((block) => (block.type === "reasoning" ? block.content : ""))
-          .join("\n");
-      }
-
-      // Construct tool calls from tool blocks
-      if (toolBlocks.length > 0) {
-        tool_calls = toolBlocks
-          .filter(
-            (toolBlock) => toolBlock.id && completedToolIds.has(toolBlock.id),
-          )
-          .map((toolBlock) => ({
-            id: toolBlock.id!,
-            type: "function",
-            function: {
-              name: toolBlock.name || "",
-              arguments: safeToolArguments(
-                String(toolBlock.parameters || "{}"),
-              ),
-            },
-          }));
-
-        if (tool_calls.length === 0) {
-          tool_calls = undefined;
-        }
-      }
-
-      // Construct assistant message - only add if there is meaningful content or tool calls
-      const hasContent = content && content.trim().length > 0;
-      const hasToolCalls = tool_calls && tool_calls.length > 0;
-
-      if (hasContent || hasToolCalls) {
-        const assistantMessage: ChatCompletionMessageParam = {
-          role: "assistant",
-          content: hasContent ? content : undefined,
-          tool_calls,
-          ...(reasoning_content ? { reasoning_content } : {}),
-          ...(message.additionalFields ? { ...message.additionalFields } : {}),
-        } as ChatCompletionMessageParam;
-
-        recentMessages.unshift(assistantMessage);
-      }
-    } else if (message.role === "user") {
-      // User messages converted to standard format
-      const contentParts: ChatCompletionContentPart[] = [];
-
-      message.blocks.forEach((block) => {
-        // Add text content - only if it has meaningful content
-        if (
-          block.type === "text" &&
-          block.content &&
-          block.content.trim().length > 0
-        ) {
-          const textForApi = block.customCommandContent ?? block.content;
-          contentParts.push({
-            type: "text",
-            text: textForApi,
-          });
-        }
-
-        // If there is an image, add image content
-        if (
-          block.type === "image" &&
-          block.imageUrls &&
-          block.imageUrls.length > 0
-        ) {
-          if (!supportsVision) {
-            // Non-vision model: replace images with a text placeholder
-            contentParts.push({
-              type: "text",
-              text: "[User shared an image, but the current model does not support image recognition]",
-            });
-          } else {
-            block.imageUrls.forEach((imageUrl: string) => {
-              // Check if it's already base64, convert if not
-              let finalImageUrl = imageUrl;
-              if (!imageUrl.startsWith("data:image/")) {
-                // If it's a file path, it needs to be converted to base64
-                try {
-                  finalImageUrl = convertImageToBase64(imageUrl);
-                } catch (error) {
-                  logger.error(
-                    "Failed to convert image path to base64:",
-                    imageUrl,
-                    error,
-                  );
-                  // Skip this image, do not add to content
-                  return;
-                }
-              }
-
-              contentParts.push({
-                type: "image_url",
-                image_url: {
-                  url: finalImageUrl,
-                  detail: "auto",
-                },
-              });
-            });
-          }
-        }
-
-        // If there is a tool block in user message, add its result
-        if (block.type === "tool" && block.stage === "end" && block.result) {
-          contentParts.push({
-            type: "text",
-            text: `<local-command-stdout>\n${stripAnsiColors(block.result)}\n</local-command-stdout>`,
-          });
-        }
-
-        // If there is a task notification block, convert it back to XML
-        if (block.type === "task_notification") {
-          contentParts.push({
-            type: "text",
-            text: taskNotificationToXml(block),
-          });
-        }
-      });
-
-      // Only add user message if there is meaningful content
-      if (contentParts.length > 0) {
-        // Filter out empty text parts
-        const meaningfulParts = contentParts.filter((part) => {
-          if (part.type === "text") {
-            return part.text && part.text.trim().length > 0;
-          }
-          return true; // Keep image parts
-        });
-
-        if (meaningfulParts.length > 0) {
-          recentMessages.unshift({
-            role: "user",
-            content: meaningfulParts,
-          });
-        }
-      }
-    }
-  }
-
-  return recentMessages;
-}