wave-agent-sdk 1.0.4 → 1.0.6

package/src/tools/workflowTool.ts

@@ -1,205 +0,0 @@
-import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { WORKFLOW_TOOL_NAME } from "../constants/tools.js";
-import { logger } from "../utils/globalLogger.js";
-
-/**
- * Workflow tool plugin for executing deterministic multi-subagent orchestration scripts.
- *
- * The AI model calls this tool with a JavaScript script that orchestrates
- * multiple subagents via agent(), parallel(), pipeline(), phase(), log() APIs.
- * Workflows run in the background — the tool returns immediately with a run ID,
- * and a <task-notification> arrives when the workflow completes.
- */
-export const workflowTool: ToolPlugin = {
-  name: WORKFLOW_TOOL_NAME,
-  config: {
-    type: "function" as const,
-    function: {
-      name: WORKFLOW_TOOL_NAME,
-      description:
-        "Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a run ID, and a <task-notification> arrives when the workflow completes. Use /workflows to watch live progress.",
-      parameters: {
-        type: "object",
-        properties: {
-          script: {
-            type: "string",
-            description:
-              "Inline workflow script (JavaScript). Must start with 'export const meta = {name, description, phases}'. Pass the script inline — do not Write it to a file first. Every Workflow invocation automatically persists its script.",
-          },
-          scriptPath: {
-            type: "string",
-            description:
-              "Path to a saved workflow script file. Use this to re-run or iterate on a previously saved script. One of 'script' or 'scriptPath' is required.",
-          },
-          args: {
-            description:
-              "Arguments passed to the workflow script as the `args` global. Pass arrays/objects as actual JSON values, NOT as a JSON-encoded string.",
-          },
-          resumeFromRunId: {
-            type: "string",
-            description:
-              "Resume from a previous run's journal. Cached agent results are replayed instantly; the first edited/new call and everything after it runs live.",
-          },
-        },
-      },
-    },
-  },
-
-  prompt: () =>
-    `Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a task ID, and a <task-notification> arrives when the workflow completes. Use /workflows to watch live progress.
-
-A workflow structures work across many agents — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps). The script is where you encode that structure: what fans out, what verifies, what synthesizes.
-
-ONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of agents and consume a large amount of tokens; the user must request that scale, not have it inferred. Explicit opt-in means one of:
-- The user directly asked you to run a workflow or use multi-agent orchestration in their own words ("use a workflow", "run a workflow", "fan out agents", "orchestrate this with subagents"). The ask must be in the user's words — a task that would merely benefit from a workflow does not count.
-- The user invoked a skill or slash command whose instructions tell you to call Workflow.
-- The user asked you to run a specific named or saved workflow.
-
-For any other task — even one that would clearly benefit from parallelism — do NOT call this tool. Use the Agent tool for individual subagents, or briefly describe what a multi-agent workflow could do and how much it would roughly cost, and ask the user whether to run it.
-
-When you do call it, the right move is often **hybrid**: scout inline first (list the files, find the channels, scope the diff) to discover the work-list, then call Workflow to pipeline over it.
-
-Common single-phase workflows you can chain across turns:
-- **Understand** — parallel readers over relevant subsystems → structured map
-- **Design** — judge panel of N independent approaches → scored synthesis
-- **Review** — dimensions → find → adversarially verify
-- **Research** — multi-modal sweep → deep-read → synthesize
-- **Migrate** — discover sites → transform each (worktree isolation) → verify
-
-For larger work, run several in sequence — read each result before deciding the next phase.
-
-Every script must begin with \`export const meta = {...}\`:
-  export const meta = {
-    name: 'find-flaky-tests',
-    description: 'Find flaky tests and propose fixes',
-    phases: [
-      { title: 'Scan', detail: 'grep test logs for retries' },
-      { title: 'Fix', detail: 'one agent per flaky test' },
-    ],
-  }
-  // script body starts here — use agent()/parallel()/pipeline()/phase()/log()
-
-Script body hooks:
-- **agent(prompt, opts?)**: Promise<any> — spawn a subagent. Without schema, returns its final text as a string. With schema (a JSON Schema), the subagent is forced to call a StructuredOutput tool and agent() returns the validated object — no parsing needed. Returns null if the user skips the agent mid-run or the subagent dies on a terminal API error (filter with .filter(Boolean)). opts.label overrides the display label. opts.phase assigns this agent to a progress group. opts.model overrides the model for this agent call. opts.agentType uses a custom subagent type instead of the default.
-- **pipeline(items, stage1, stage2, ...)**: Promise<any[]> — run each item through all stages independently, NO barrier between stages. Item A can be in stage 3 while item B is still in stage 1. This is the DEFAULT for multi-stage work. Every stage callback receives (prevResult, originalItem, index). In the first stage prevResult is undefined; in later stages it is the return value of the previous stage. A stage that throws drops that item to null. Example single-stage: \`pipeline(files, (prev, file) => agent('Read ' + file))\`. Example two-stage: \`pipeline(files, (prev, file) => agent('Read ' + file), (prev, file) => agent('Summarize: ' + prev))\`.
-- **parallel(thunks: Array<() => Promise<any>>)**: Promise<any[]> — run tasks concurrently. This is a BARRIER: awaits all thunks before returning. A thunk that throws resolves to null in the result array. Use ONLY when you genuinely need all results together.
-- **log(message: string)**: void — emit a progress message
-- **phase(title: string)**: void — start a new phase; subsequent agent() calls are grouped under this title
-- **args**: any — the value passed as Workflow's args input, verbatim
-- **budget**: {total: number|null, spent(): number, remaining(): number} — the turn's token target
-
-Scripts are plain JavaScript, NOT TypeScript — type annotations fail to parse. The script body runs in an async context — use await directly. Standard JS built-ins (JSON, Math, Array, etc.) are available — EXCEPT Date.now()/Math.random()/argless new Date(), which throw (they would break resume). No filesystem or Node.js API access.
-
-DEFAULT TO pipeline(). Only reach for a barrier (parallel between stages) when you genuinely need ALL prior-stage results together.
-
-Concurrent agent() calls are capped at min(16, cpu cores - 2) per workflow. Total agent count is capped at 1000 per run. A single parallel()/pipeline() call accepts at most 4096 items.
-
-Quality patterns:
-- **Adversarial verify**: spawn N independent skeptics per finding, each prompted to REFUTE. Kill if >=majority refute.
-- **Judge panel**: generate N independent approaches, score with parallel judges, synthesize from the winner.
-- **Loop-until-dry**: keep spawning finders until K consecutive rounds return nothing new.
-- **Multi-modal sweep**: parallel agents each searching a different way (by-container, by-content, by-entity).
-- **Completeness critic**: a final agent that asks "what's missing?" — findings become next round of work.
-- **No silent caps**: if a workflow bounds coverage, log() what was dropped.
-
-## Resume
-
-The tool result includes a runId. To resume after a pause, kill, or script edit, relaunch with Workflow({scriptPath, resumeFromRunId}) — the longest unchanged prefix of agent() calls returns cached results instantly; the first edited/new call and everything after it runs live.
-
-Use this tool for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.`,
-
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    const workflowManager = context.workflowManager;
-    if (!workflowManager) {
-      return {
-        success: false,
-        content: "",
-        error: "Workflow manager not available in tool context",
-        shortResult: "Workflow execution failed",
-      };
-    }
-
-    const script = args.script as string | undefined;
-    const scriptPath = args.scriptPath as string | undefined;
-    const workflowArgs = args.args;
-    const resumeFromRunId = args.resumeFromRunId as string | undefined;
-
-    // Resolve script text
-    let scriptText: string;
-    if (script) {
-      scriptText = script;
-    } else if (scriptPath) {
-      try {
-        const fs = await import("fs/promises");
-        scriptText = await fs.readFile(scriptPath, "utf-8");
-      } catch (error) {
-        return {
-          success: false,
-          content: "",
-          error: `Failed to read script file: ${error instanceof Error ? error.message : String(error)}`,
-          shortResult: "Workflow script read failed",
-        };
-      }
-    } else {
-      return {
-        success: false,
-        content: "",
-        error: "Either 'script' or 'scriptPath' parameter is required",
-        shortResult: "Workflow execution failed",
-      };
-    }
-
-    try {
-      // Create run
-      const run = await workflowManager.createRun(scriptText, workflowArgs, {
-        resumeFromRunId,
-      });
-
-      // Start execution in background
-      await workflowManager.startRun(run.runId);
-
-      return {
-        success: true,
-        content: [
-          `Workflow started with run ID: ${run.runId}`,
-          `Name: ${run.meta.name}`,
-          `Description: ${run.meta.description}`,
-          run.meta.phases?.length
-            ? `Phases: ${run.meta.phases.map((p) => p.title).join(" → ")}`
-            : "",
-          `The workflow is running in the background. You will be notified automatically when it completes.`,
-          `Use /workflows to watch live progress.`,
-          `Script saved to: ${run.scriptPath}`,
-        ]
-          .filter(Boolean)
-          .join("\n"),
-        shortResult: `Workflow started: ${run.meta.name} (${run.runId})`,
-      };
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      logger.error(`[Workflow Tool] execution failed: ${msg}`);
-      return {
-        success: false,
-        content: `Workflow failed: ${msg}. Fix the error and try again.`,
-        error: `Workflow execution failed: ${msg}`,
-        shortResult: "Workflow execution failed",
-      };
-    }
-  },
-
-  formatCompactParams: (params: Record<string, unknown>) => {
-    if (params.scriptPath) {
-      return `scriptPath: ${params.scriptPath}`;
-    }
-    const script = params.script as string;
-    if (script) {
-      // Extract meta.name from the script
-      const nameMatch = script.match(/name:\s*['"]([^'"]+)['"]/);
-      return nameMatch ? nameMatch[1] : script.slice(0, 50) + "...";
-    }
-    return "workflow";
-  },
-};

package/src/tools/writeTool.ts

@@ -1,267 +0,0 @@
-import { readFile, writeFile, mkdir, stat } from "fs/promises";
-import { createHash } from "crypto";
-import { dirname } from "path";
-import { logger } from "../utils/globalLogger.js";
-import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { READ_TOOL_NAME } from "../constants/tools.js";
-
-/**
- * File Write Tool Plugin
- */
-export const writeTool: ToolPlugin = {
-  name: "Write",
-  isConcurrencySafe: false,
-  config: {
-    type: "function",
-    function: {
-      name: "Write",
-      description: "Writes a file to the local filesystem.",
-      parameters: {
-        type: "object",
-        properties: {
-          file_path: {
-            type: "string",
-            description:
-              "The absolute path to the file to write (must be absolute, not relative)",
-          },
-          content: {
-            type: "string",
-            description: "The content to write to the file",
-          },
-        },
-        required: ["file_path", "content"],
-        additionalProperties: false,
-      },
-    },
-  },
-  prompt: () => `Writes a file to the local filesystem.
-
-Usage:
-- This tool will overwrite the existing file if there is one at the provided path.
-- If this is an existing file, you MUST use the \`${READ_TOOL_NAME}\` tool first to read the file's contents. This tool will fail if you did not read the file first.
-- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
-- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
-- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
-- IMPORTANT: Always provide file_path parameter before content parameter when calling this tool.`,
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    const filePath = args.file_path as string;
-    const content = args.content as string;
-
-    // Validate required parameters
-    if (!filePath || typeof filePath !== "string") {
-      return {
-        success: false,
-        content: "",
-        error: "file_path parameter is required and must be a string",
-      };
-    }
-
-    if (typeof content !== "string") {
-      return {
-        success: false,
-        content: "",
-        error: "content parameter is required and must be a string",
-      };
-    }
-
-    // Trigger conditional rule loading for this file
-    context.messageManager?.triggerFileRead(filePath);
-
-    try {
-      const resolvedPath = resolvePath(filePath, context.workdir);
-
-      // Check if file already exists
-      let originalContent = "";
-      let isExistingFile = false;
-
-      try {
-        originalContent = await readFile(resolvedPath, "utf-8");
-        isExistingFile = true;
-      } catch {
-        // File doesn't exist, this is normal for new file creation
-        isExistingFile = false;
-      }
-
-      // Read-before-write + staleness guards (aligned with Claude Code).
-      // Only enforced for existing files when readFileState is available
-      // (production always injects it; new-file creation always bypasses).
-      // Grep does not register a file as read, so Grep-then-Write on an
-      // existing file is still rejected. Staleness uses the same `>` + full-
-      // read content-hash fallback as editTool to avoid false positives from
-      // git checkout / editor round-trip save / cloud sync / antivirus.
-      // Plan mode is excluded: it has its own stricter write gate (plan-file-
-      // only, enforced in permissionManager) whose denial message must surface
-      // instead of being masked by a read-state rejection.
-      if (
-        isExistingFile &&
-        context.readFileState &&
-        context.permissionMode !== "plan"
-      ) {
-        const state = context.readFileState.get(resolvedPath);
-        if (!state) {
-          return {
-            success: false,
-            content: "",
-            error:
-              "File has not been read yet. Read it first before writing to it.",
-          };
-        }
-        const currentStats = await stat(resolvedPath);
-        if (currentStats.mtime.getTime() > state.mtime) {
-          const isFullRead =
-            state.offset === undefined && state.limit === undefined;
-          const contentUnchanged =
-            isFullRead &&
-            createHash("sha256").update(originalContent).digest("hex") ===
-              state.hash;
-          if (!contentUnchanged) {
-            return {
-              success: false,
-              content: "",
-              error:
-                "File has been unexpectedly modified since last read. Read it again before writing to it.",
-            };
-          }
-        }
-      }
-
-      // Check if overwriting existing file but content is the same
-      if (isExistingFile && originalContent === content) {
-        return {
-          success: true,
-          content: `File ${filePath} already has the same content, no changes needed`,
-          shortResult: "No changes needed",
-          filePath: resolvedPath,
-        };
-      }
-
-      // Ensure directory exists
-      const fileDir = dirname(resolvedPath);
-      try {
-        await mkdir(fileDir, { recursive: true });
-      } catch (mkdirError) {
-        // Ignore directory already exists error
-        if (
-          mkdirError instanceof Error &&
-          !mkdirError.message.includes("EEXIST")
-        ) {
-          logger.warn(
-            `Failed to create directory ${fileDir}: ${mkdirError.message}`,
-          );
-        }
-      }
-
-      // Permission check after validation but before real operation
-      if (context.permissionManager) {
-        try {
-          const permissionContext = context.permissionManager.createContext(
-            "Write",
-            context.permissionMode || "default",
-            context.canUseToolCallback,
-            { file_path: filePath, content },
-            context.toolCallId,
-          );
-          const permissionResult =
-            await context.permissionManager.checkPermission(permissionContext);
-
-          if (permissionResult.behavior === "deny") {
-            return {
-              success: false,
-              content: "",
-              error: `Write operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
-            };
-          }
-        } catch {
-          return {
-            success: false,
-            content: "",
-            error: "Permission check failed",
-          };
-        }
-      }
-
-      // Record snapshot for reversion
-      let snapshotId: string | undefined;
-      if (context.reversionManager && context.messageId) {
-        snapshotId = await context.reversionManager.recordSnapshot(
-          context.messageId,
-          resolvedPath,
-          isExistingFile ? "modify" : "create",
-        );
-      }
-
-      // Write file
-      try {
-        await writeFile(resolvedPath, content, "utf-8");
-        // Commit snapshot on success
-        if (context.reversionManager && snapshotId) {
-          await context.reversionManager.commitSnapshot(snapshotId);
-        }
-      } catch (writeError) {
-        return {
-          success: false,
-          content: "",
-          error: `Failed to write file: ${writeError instanceof Error ? writeError.message : String(writeError)}`,
-        };
-      }
-
-      // Update readFileState so subsequent serialized edits pass staleness check
-      if (context.readFileState) {
-        const newStats = await stat(resolvedPath);
-        const hash = createHash("sha256").update(content).digest("hex");
-        context.readFileState.set(resolvedPath, {
-          mtime: newStats.mtime.getTime(),
-          hash,
-          offset: undefined,
-          limit: undefined,
-        });
-      }
-
-      const shortResult = isExistingFile ? "File overwritten" : "File created";
-
-      const lines = content.split("\n").length;
-      const chars = content.length;
-      const detailedContent = `${shortResult} (${lines} lines, ${chars} characters)`;
-
-      logger.debug(`Write tool: ${shortResult}`);
-
-      return {
-        success: true,
-        content: detailedContent,
-        shortResult,
-        filePath: resolvedPath,
-        startLineNumber: 1,
-      };
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      logger.error(`Write tool error: ${errorMessage}`);
-      return {
-        success: false,
-        content: "",
-        error: errorMessage,
-      };
-    }
-  },
-  formatCompactParams: (
-    params: Record<string, unknown>,
-    context: ToolContext,
-  ) => {
-    const filePath = params.file_path as string;
-    const content = params.content as string;
-
-    let displayPath = getDisplayPath(filePath || "", context.workdir);
-
-    if (content) {
-      const lines = content.split("\n").length;
-      const chars = content.length;
-      displayPath += ` ${lines} lines, ${chars} chars`;
-    }
-
-    return displayPath;
-  },
-};

package/src/types/agent.ts

@@ -1,128 +0,0 @@
-import type { ClientOptions } from "openai";
-import type { QueuedMessage } from "../managers/messageQueue.js";
-import type {
-  Message,
-  Logger,
-  PermissionMode,
-  PermissionCallback,
-  ILspManager,
-  PluginConfig,
-  BackgroundTask,
-  McpServerConfig,
-} from "./index.js";
-import type { MessageManagerCallbacks } from "../managers/messageManager.js";
-import type { BackgroundTaskManagerCallbacks } from "../managers/backgroundTaskManager.js";
-import type { McpManagerCallbacks } from "../managers/mcpManager.js";
-import type { SubagentManagerCallbacks } from "../managers/subagentManager.js";
-import type { PartialHookConfiguration } from "./configuration.js";
-import type { ToolPlugin } from "../tools/types.js";
-
-/**
- * Configuration options for Agent instances
- *
- * IMPORTANT: This interface is used by both Agent constructor and Agent.create()
- * Any changes to this interface must be compatible with both methods.
- */
-export interface AgentOptions {
-  // Optional configuration with environment fallbacks
-  apiKey?: string;
-  baseURL?: string;
-  /** Wave server URL for SSO authentication (fallback to WAVE_SERVER_URL env var) */
-  serverUrl?: string;
-  defaultHeaders?: Record<string, string>;
-  /** Per-subagent-type headers, merged into defaultHeaders for matching subagents */
-  subagentHeaders?: Record<string, Record<string, string>>;
-  fetchOptions?: ClientOptions["fetchOptions"];
-  fetch?: ClientOptions["fetch"];
-  model?: string;
-  fastModel?: string;
-  maxInputTokens?: number;
-  maxTokens?: number;
-  /** Preferred language for agent communication */
-  language?: string;
-
-  // Existing options (preserved)
-  callbacks?: AgentCallbacks;
-  restoreSessionId?: string;
-  continueLastSession?: boolean;
-  logger?: Logger;
-  /**Add optional initial messages parameter for testing convenience */
-  messages?: Message[];
-  /**Working directory - if not specified, use process.cwd() */
-  workdir?: string;
-  /**Optional custom system prompt - if provided, replaces default system prompt */
-  systemPrompt?: string;
-  /**Permission mode - defaults to "default" */
-  permissionMode?: PermissionMode;
-  /**Custom permission callback */
-  canUseTool?: PermissionCallback;
-  /**Whether to use streaming mode for AI responses - defaults to true */
-  stream?: boolean;
-  /**Optional custom LSP manager - if not provided, a standalone one will be created */
-  lspManager?: ILspManager;
-  /**Optional local plugins to load */
-  plugins?: PluginConfig[];
-  /**
-   * Optional list of tool names to enable.
-   * - undefined: Enable all built-in tools and plugins (default).
-   * - []: Disable all tools.
-   * - string[]: Enable only the tools with the specified names.
-   */
-  tools?: string[];
-  /**Optional worktree name */
-  worktreeName?: string;
-  /**Whether this is a newly created worktree */
-  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[];
-  /**
-   * Optional list of additional directories to include in the Safe Zone
-   * for this agent session. These directories are listed in the system
-   * prompt and treated as safe for file operations (e.g. in acceptEdits mode).
-   */
-  additionalDirectories?: string[];
-  /**
-   * Optional MCP server configs to connect at startup.
-   * Overrides .mcp.json for specified server names.
-   */
-  mcpServers?: Record<string, McpServerConfig>;
-  /** Custom tools provided by the SDK user, registered alongside built-in tools */
-  customTools?: ToolPlugin[];
-  /**
-   * Optional hook configuration to inject at creation time.
-   * File-based hooks (from config.json/.waverc.json) merge on top of these.
-   */
-  hooks?: PartialHookConfiguration;
-  [key: string]: unknown;
-}
-
-export interface AgentCallbacks
-  extends MessageManagerCallbacks,
-    BackgroundTaskManagerCallbacks,
-    McpManagerCallbacks,
-    SubagentManagerCallbacks {
-  onBackgroundTasksChange?: (tasks: BackgroundTask[]) => void;
-  onTasksChange?: (tasks: import("./tasks.js").Task[]) => void;
-  onPermissionModeChange?: (mode: PermissionMode) => void;
-  onSubagentLatestTotalTokensChange?: (
-    subagentId: string,
-    tokens: number,
-  ) => void;
-  onBackgroundCurrentTask?: () => void;
-  onModelChange?: (model: string) => void;
-  onConfiguredModelsChange?: (models: string[]) => void;
-  onLoadingChange?: (loading: boolean) => void;
-  onCommandRunningChange?: (running: boolean) => void;
-  onWorkdirChange?: (newCwd: string) => void;
-  onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
-}

package/src/types/auth.ts

@@ -1,19 +0,0 @@
-export interface AuthUser {
-  id: string;
-  email?: string;
-}
-
-export interface AuthConfig {
-  SSO_TOKEN?: string;
-  SSO_REFRESH_TOKEN?: string;
-  SSO_TOKEN_EXPIRES_AT?: number; // Unix timestamp (ms) when SSO_TOKEN expires
-  user?: AuthUser;
-}
-
-/** Server response from POST /api/auth/token */
-export interface TokenResponse {
-  token: string;
-  refreshToken?: string;
-  expiresIn?: number; // seconds until token expires
-  user: { id: string; email?: string };
-}

package/src/types/commands.ts

@@ -1,30 +0,0 @@
-/**
- * Slash command and custom command types
- * Dependencies: None
- */
-
-export interface SlashCommand {
-  id: string;
-  name: string;
-  description: string;
-  handler: (args?: string, signal?: AbortSignal) => Promise<void> | void;
-  /** Whether this command should bypass the message queue when AI is busy.
-   * - `true`: always immediate
-   * - Function: receives args, returns true for immediate variants */
-  immediate?: boolean | ((args?: string) => boolean);
-}
-
-export interface CustomSlashCommandConfig {
-  model?: string;
-  description?: string;
-  allowedTools?: string[];
-}
-
-export interface CustomSlashCommand {
-  id: string;
-  name: string;
-  description?: string; // Add description field
-  filePath: string;
-  content: string;
-  config?: CustomSlashCommandConfig;
-}