@elizaos/plugin-commands 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/cjs/index.cjs

@@ -29,6 +29,7 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
+  useRuntime: () => useRuntime,
   unregisterCommand: () => unregisterCommand,
   startsWithCommand: () => startsWithCommand,
   resetCommands: () => resetCommands,
@@ -39,6 +40,7 @@ __export(exports_src, {
   isElevated: () => isElevated,
   isCommandOnly: () => isCommandOnly,
   isAuthorized: () => isAuthorized,
+  initForRuntime: () => initForRuntime,
   hasCommand: () => hasCommand,
   getEnabledCommands: () => getEnabledCommands,
   getCommandsByCategory: () => getCommandsByCategory,
@@ -53,7 +55,7 @@ __export(exports_src, {
   commandRegistryProvider: () => commandRegistryProvider
 });
 module.exports = __toCommonJS(exports_src);
-var import_core = require("@elizaos/core");
+var import_core3 = require("@elizaos/core");
 
 // src/registry.ts
 var DEFAULT_COMMANDS = [
@@ -338,21 +340,39 @@ var DEFAULT_COMMANDS = [
     requiresElevated: true
   }
 ];
-var commands = [...DEFAULT_COMMANDS];
-var aliasMap = null;
+var runtimeStores = new Map;
+var fallbackStore = {
+  commands: DEFAULT_COMMANDS.map((c) => ({ ...c })),
+  aliasMap: null
+};
+var activeStore = fallbackStore;
+function initForRuntime(agentId) {
+  const store = {
+    commands: DEFAULT_COMMANDS.map((c) => ({ ...c })),
+    aliasMap: null
+  };
+  runtimeStores.set(agentId, store);
+  activeStore = store;
+}
+function useRuntime(agentId) {
+  const store = runtimeStores.get(agentId);
+  if (store) {
+    activeStore = store;
+  }
+}
 function getCommands() {
-  return [...commands];
+  return [...activeStore.commands];
 }
 function getEnabledCommands() {
-  return commands.filter((cmd) => cmd.enabled !== false);
+  return activeStore.commands.filter((cmd) => cmd.enabled !== false);
 }
 function getCommandsByCategory(category) {
-  return commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
+  return activeStore.commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
 }
 function registerCommand(command) {
-  commands = commands.filter((c) => c.key !== command.key);
-  commands.push(command);
-  aliasMap = null;
+  activeStore.commands = activeStore.commands.filter((c) => c.key !== command.key);
+  activeStore.commands.push(command);
+  activeStore.aliasMap = null;
 }
 function registerCommands(newCommands) {
   for (const command of newCommands) {
@@ -360,35 +380,35 @@ function registerCommands(newCommands) {
   }
 }
 function unregisterCommand(key) {
-  commands = commands.filter((c) => c.key !== key);
-  aliasMap = null;
+  activeStore.commands = activeStore.commands.filter((c) => c.key !== key);
+  activeStore.aliasMap = null;
 }
 function resetCommands() {
-  commands = [...DEFAULT_COMMANDS];
-  aliasMap = null;
+  activeStore.commands = DEFAULT_COMMANDS.map((c) => ({ ...c }));
+  activeStore.aliasMap = null;
 }
 function getAliasMap() {
-  if (aliasMap)
-    return aliasMap;
-  aliasMap = new Map;
-  for (const command of commands) {
+  if (activeStore.aliasMap)
+    return activeStore.aliasMap;
+  activeStore.aliasMap = new Map;
+  for (const command of activeStore.commands) {
     if (command.enabled === false)
       continue;
     for (const alias of command.textAliases) {
       const normalized = alias.toLowerCase().trim();
-      if (!aliasMap.has(normalized)) {
-        aliasMap.set(normalized, command);
+      if (!activeStore.aliasMap.has(normalized)) {
+        activeStore.aliasMap.set(normalized, command);
       }
     }
   }
-  return aliasMap;
+  return activeStore.aliasMap;
 }
 function findCommandByAlias(alias) {
   const map = getAliasMap();
   return map.get(alias.toLowerCase().trim());
 }
 function findCommandByKey(key) {
-  return commands.find((c) => c.key === key);
+  return activeStore.commands.find((c) => c.key === key);
 }
 function startsWithCommand(text) {
   const map = getAliasMap();
@@ -550,18 +570,18 @@ function extractCommand(text) {
 // src/actions/commands-list.ts
 var commandsListAction = {
   name: "COMMANDS_LIST",
-  description: "List all available commands with their aliases",
-  similes: ["/commands", "/cmds", "list all commands"],
+  description: "List all available commands with their aliases. Only activates for /commands or /cmds slash commands.",
+  similes: ["/commands", "/cmds"],
   async validate(runtime, message) {
     const text = message.content?.text ?? "";
     const detection = detectCommand(text);
     return detection.isCommand && detection.command?.key === "commands";
   },
   async handler(runtime, message, state, options, callback) {
-    const commands2 = getEnabledCommands();
-    const lines = [`**Commands (${commands2.length}):**
+    const commands = getEnabledCommands();
+    const lines = [`**Commands (${commands.length}):**
 `];
-    for (const cmd of commands2) {
+    for (const cmd of commands) {
       const aliases = cmd.textAliases.join(", ");
       const authNote = cmd.requiresAuth ? " [auth]" : "";
       const elevatedNote = cmd.requiresElevated ? " [elevated]" : "";
@@ -573,7 +593,7 @@ var commandsListAction = {
     return {
       success: true,
       text: replyText,
-      data: { commandCount: commands2.length }
+      data: { commandCount: commands.length }
     };
   },
   examples: [
@@ -593,7 +613,7 @@ var commandsListAction = {
 };
 
 // src/actions/help.ts
-function formatCommandList(commands2) {
+function formatCommandList(commands) {
   const lines = [`**Available Commands:**
 `];
   const categories = [
@@ -605,7 +625,7 @@ function formatCommandList(commands2) {
     { key: "tools", name: "Tools" }
   ];
   for (const cat of categories) {
-    const catCommands = commands2.filter((c) => c.category === cat.key);
+    const catCommands = commands.filter((c) => c.category === cat.key);
     if (catCommands.length === 0)
       continue;
     lines.push(`
@@ -615,7 +635,7 @@ function formatCommandList(commands2) {
       lines.push(`• ${aliases} - ${cmd.description}`);
     }
   }
-  const uncategorized = commands2.filter((c) => !c.category);
+  const uncategorized = commands.filter((c) => !c.category);
   if (uncategorized.length > 0) {
     lines.push(`
 **Other:**`);
@@ -629,21 +649,21 @@ function formatCommandList(commands2) {
 }
 var helpAction = {
   name: "HELP_COMMAND",
-  description: "Show available commands and their descriptions",
-  similes: ["/help", "/h", "/?", "help", "show help", "list commands"],
+  description: "Show available commands and their descriptions. Only activates for /help, /h, or /? slash commands.",
+  similes: ["/help", "/h", "/?"],
   async validate(runtime, message) {
     const text = message.content?.text ?? "";
     const detection = detectCommand(text);
     return detection.isCommand && detection.command?.key === "help";
   },
   async handler(runtime, message, state, options, callback) {
-    const commands2 = getEnabledCommands();
-    const helpText = formatCommandList(commands2);
+    const commands = getEnabledCommands();
+    const helpText = formatCommandList(commands);
     await callback?.({ text: helpText });
     return {
       success: true,
       text: helpText,
-      data: { commandCount: commands2.length }
+      data: { commandCount: commands.length }
     };
   },
   examples: [
@@ -675,10 +695,31 @@ var helpAction = {
 };
 
 // src/actions/models.ts
+var import_core = require("@elizaos/core");
+function describeModelType(modelType) {
+  const descriptions = {
+    [import_core.ModelType.TEXT_SMALL]: "Text (Small)",
+    [import_core.ModelType.TEXT_LARGE]: "Text (Large)",
+    [import_core.ModelType.TEXT_REASONING_SMALL]: "Reasoning (Small)",
+    [import_core.ModelType.TEXT_REASONING_LARGE]: "Reasoning (Large)",
+    [import_core.ModelType.TEXT_COMPLETION]: "Text Completion",
+    [import_core.ModelType.TEXT_EMBEDDING]: "Embedding",
+    [import_core.ModelType.IMAGE]: "Image Generation",
+    [import_core.ModelType.IMAGE_DESCRIPTION]: "Image Description",
+    [import_core.ModelType.TRANSCRIPTION]: "Transcription",
+    [import_core.ModelType.TEXT_TO_SPEECH]: "Text-to-Speech",
+    [import_core.ModelType.AUDIO]: "Audio",
+    [import_core.ModelType.VIDEO]: "Video",
+    [import_core.ModelType.OBJECT_SMALL]: "Object (Small)",
+    [import_core.ModelType.OBJECT_LARGE]: "Object (Large)",
+    [import_core.ModelType.RESEARCH]: "Research"
+  };
+  return descriptions[modelType] ?? modelType;
+}
 var modelsAction = {
   name: "MODELS_COMMAND",
-  description: "List available AI models and providers",
-  similes: ["/models", "list models", "show models", "available models"],
+  description: "List available AI models and providers. Only activates for /models slash command.",
+  similes: ["/models"],
   async validate(runtime, message) {
     const text = message.content?.text ?? "";
     const detection = detectCommand(text);
@@ -687,37 +728,41 @@ var modelsAction = {
   async handler(runtime, message, state, options, callback) {
     const lines = [`**Available Models:**
 `];
-    const providers = [
-      {
-        name: "Anthropic",
-        models: [
-          "claude-3-opus",
-          "claude-3-sonnet",
-          "claude-3-haiku",
-          "claude-3.5-sonnet"
-        ]
-      },
-      {
-        name: "OpenAI",
-        models: [
-          "gpt-4o",
-          "gpt-4o-mini",
-          "gpt-4-turbo",
-          "gpt-4",
-          "gpt-3.5-turbo"
-        ]
-      },
-      {
-        name: "Google",
-        models: ["gemini-pro", "gemini-pro-vision", "gemini-ultra"]
+    try {
+      const registeredTypes = [];
+      const seen = new Set;
+      for (const modelType of Object.values(import_core.ModelType)) {
+        if (seen.has(modelType))
+          continue;
+        seen.add(modelType);
+        try {
+          const handler = runtime.getModel(modelType);
+          if (handler) {
+            registeredTypes.push(modelType);
+          }
+        } catch {}
       }
-    ];
-    for (const provider of providers) {
-      lines.push(`
-**${provider.name}:**`);
-      for (const model of provider.models) {
-        lines.push(`• ${provider.name.toLowerCase()}/${model}`);
+      if (registeredTypes.length > 0) {
+        lines.push("**Registered Model Types:**");
+        for (const modelType of registeredTypes) {
+          lines.push(`• ${describeModelType(modelType)} (\`${modelType}\`)`);
+        }
+      } else {
+        lines.push("No model handlers are currently registered.");
       }
+      const modelProvider = runtime.getSetting("MODEL_PROVIDER");
+      const modelName = runtime.getSetting("MODEL_NAME");
+      if (modelProvider || modelName) {
+        lines.push(`
+**Current Configuration:**`);
+        if (modelProvider)
+          lines.push(`• Provider: ${modelProvider}`);
+        if (modelName)
+          lines.push(`• Model: ${modelName}`);
+      }
+    } catch (err) {
+      import_core.logger.warn({ src: "plugin-commands", err }, "Error querying runtime models");
+      lines.push("Unable to query available models.");
     }
     lines.push(`
 
@@ -727,8 +772,7 @@ _Use /model <provider/model> to switch models._`);
     await callback?.({ text: replyText });
     return {
       success: true,
-      text: replyText,
-      data: { providers }
+      text: replyText
     };
   },
   examples: [
@@ -737,11 +781,7 @@ _Use /model <provider/model> to switch models._`);
       {
         user: "assistant",
         content: {
-          text: `**Available Models:**
-
-**Anthropic:**
-• anthropic/claude-3-opus
-• anthropic/claude-3-sonnet...`
+          text: "**Available Models:**\n\n**Registered Model Types:**\n• Text (Large) (`text_large`)\n• Text (Small) (`text_small`)..."
         }
       }
     ]
@@ -752,7 +792,7 @@ _Use /model <provider/model> to switch models._`);
 async function buildStatusReport(runtime, roomId) {
   const lines = [`**Session Status:**
 `];
-  lines.push(`**Agent:** ${runtime.agentId}`);
+  lines.push(`**Agent:** ${runtime.character.name ?? runtime.agentId}`);
   lines.push(`**Room:** ${roomId}`);
   try {
     const directiveService = runtime.getService("directive-parser");
@@ -772,13 +812,20 @@ async function buildStatusReport(runtime, roomId) {
       }
     }
   } catch {}
+  try {
+    const tasks = await runtime.getTasks({ roomId });
+    if (tasks.length > 0) {
+      lines.push(`
+**Tasks:** ${tasks.length} pending`);
+    }
+  } catch {}
   return lines.join(`
 `);
 }
 var statusAction = {
   name: "STATUS_COMMAND",
-  description: "Show current session status, model, and settings",
-  similes: ["/status", "/s", "status", "show status", "what's my status"],
+  description: "Show session directive settings via /status slash command. Only activates for /status or /s prefix.",
+  similes: ["/status", "/s"],
   async validate(runtime, message) {
     const text = message.content?.text ?? "";
     const detection = detectCommand(text);
@@ -800,7 +847,7 @@ var statusAction = {
         content: {
           text: `**Session Status:**
 
-**Agent:** agent-123
+**Agent:** Eliza
 **Room:** room-456
 
 **Directives:**
@@ -812,10 +859,11 @@ var statusAction = {
 };
 
 // src/actions/stop.ts
+var import_core2 = require("@elizaos/core");
 var stopAction = {
   name: "STOP_COMMAND",
-  description: "Stop current operation or abort running tasks",
-  similes: ["/stop", "/abort", "/cancel", "stop", "abort", "cancel"],
+  description: "Stop current operation or abort running tasks. Triggered by /stop, /abort, or /cancel slash commands only.",
+  similes: ["/stop", "/abort", "/cancel"],
   async validate(runtime, message) {
     const text = message.content?.text ?? "";
     const detection = detectCommand(text);
@@ -823,12 +871,22 @@ var stopAction = {
   },
   async handler(runtime, message, state, options, callback) {
     try {
-      await runtime.emitEvent?.("ABORT_REQUESTED", {
-        roomId: message.roomId,
-        userId: message.userId,
-        requestedAt: Date.now()
+      await runtime.emitEvent(import_core2.EventType.HOOK_COMMAND_STOP, {
+        runtime,
+        sessionKey: message.roomId,
+        messages: [],
+        timestamp: new Date,
+        context: {
+          entityId: message.entityId,
+          source: message.content?.source
+        },
+        command: "stop",
+        senderId: message.entityId,
+        commandSource: message.content?.source
       });
-    } catch {}
+    } catch (err) {
+      import_core2.logger.warn({ src: "plugin-commands", err }, "Failed to emit HOOK_COMMAND_STOP event");
+    }
     const replyText = "✓ Stop requested. Current operations will be cancelled.";
     await callback?.({ text: replyText });
     return {
@@ -864,28 +922,44 @@ var commandRegistryProvider = {
   description: "Available chat commands and their descriptions",
   dynamic: true,
   async get(runtime, message, _state) {
-    const commands2 = getEnabledCommands();
-    const commandList = commands2.map((cmd) => {
-      const auth = cmd.requiresAuth ? " (requires auth)" : "";
-      return `- ${cmd.textAliases[0]}: ${cmd.description}${auth}`;
-    });
-    return {
-      text: `Available commands:
+    useRuntime(runtime.agentId);
+    const text = message.content?.text ?? "";
+    const isCommand = hasCommand(text);
+    const commands = getEnabledCommands();
+    if (isCommand) {
+      const commandList = commands.map((cmd) => {
+        const auth = cmd.requiresAuth ? " (requires auth)" : "";
+        return `- ${cmd.textAliases[0]}: ${cmd.description}${auth}`;
+      });
+      return {
+        text: `The user sent a slash command. Available commands:
 ${commandList.join(`
-`)}`,
+`)}
+
+IMPORTANT: This is a slash command — respond by executing the matching command action, not with conversational text.`,
+        values: {
+          commandCount: commands.length,
+          isCommand: true,
+          hasElevatedCommands: commands.some((c) => c.requiresElevated)
+        },
+        data: { commands, isCommand: true }
+      };
+    }
+    return {
+      text: "",
       values: {
-        commandCount: commands2.length,
-        hasElevatedCommands: commands2.some((c) => c.requiresElevated)
+        commandCount: commands.length,
+        isCommand: false
       },
-      data: { commands: commands2 }
+      data: { isCommand: false }
     };
   }
 };
 function formatCommandResult(result) {
   if (result.error) {
-    return `❌ Error: ${result.error}`;
+    return `Error: ${result.error}`;
   }
-  return result.reply ?? "✓ Command executed";
+  return result.reply ?? "Command executed";
 }
 function isAuthorized(context, command) {
   if (!command.requiresAuth) {
@@ -933,7 +1007,7 @@ var commandsPlugin = {
             if (hasCommand("hello world")) {
               throw new Error("Should not detect plain text as command");
             }
-            import_core.logger.success("Command prefix detection works correctly");
+            import_core3.logger.success("Command prefix detection works correctly");
           }
         },
         {
@@ -949,7 +1023,7 @@ var commandsPlugin = {
             if (detection.command?.args[0] !== "high") {
               throw new Error(`Expected arg 'high', got '${detection.command?.args[0]}'`);
             }
-            import_core.logger.success("Command argument parsing works correctly");
+            import_core3.logger.success("Command argument parsing works correctly");
           }
         },
         {
@@ -963,7 +1037,7 @@ var commandsPlugin = {
             if (normalized2 !== "/help") {
               throw new Error(`Expected '/help', got '${normalized2}'`);
             }
-            import_core.logger.success("Command normalization works correctly");
+            import_core3.logger.success("Command normalization works correctly");
           }
         },
         {
@@ -976,7 +1050,7 @@ var commandsPlugin = {
             if (cmd.key !== "help") {
               throw new Error(`Expected key 'help', got '${cmd.key}'`);
             }
-            import_core.logger.success("Command alias lookup works correctly");
+            import_core3.logger.success("Command alias lookup works correctly");
           }
         },
         {
@@ -989,7 +1063,7 @@ var commandsPlugin = {
             if (cmd.key !== "status") {
               throw new Error(`Expected key 'status', got '${cmd.key}'`);
             }
-            import_core.logger.success("Command key lookup works correctly");
+            import_core3.logger.success("Command key lookup works correctly");
           }
         }
       ]
@@ -1000,16 +1074,16 @@ var commandsPlugin = {
         {
           name: "Get enabled commands",
           fn: async (_runtime) => {
-            const commands2 = getEnabledCommands();
-            if (commands2.length === 0) {
+            const commands = getEnabledCommands();
+            if (commands.length === 0) {
               throw new Error("Should have enabled commands");
             }
-            const hasHelp = commands2.some((c) => c.key === "help");
-            const hasStatus = commands2.some((c) => c.key === "status");
-            if (!hasHelp || !hasStatus) {
+            const cmdHelp = commands.some((c) => c.key === "help");
+            const cmdStatus = commands.some((c) => c.key === "status");
+            if (!cmdHelp || !cmdStatus) {
               throw new Error("Should have help and status commands");
             }
-            import_core.logger.success("Command registry works correctly");
+            import_core3.logger.success("Command registry works correctly");
           }
         },
         {
@@ -1031,7 +1105,7 @@ var commandsPlugin = {
             if (notFound) {
               throw new Error("Should not find unregistered command");
             }
-            import_core.logger.success("Custom command registration works correctly");
+            import_core3.logger.success("Custom command registration works correctly");
           }
         },
         {
@@ -1045,17 +1119,19 @@ var commandsPlugin = {
             if (!allStatus) {
               throw new Error("All returned commands should be in status category");
             }
-            import_core.logger.success("Command categorization works correctly");
+            import_core3.logger.success("Command categorization works correctly");
           }
         }
       ]
     }
   ],
   async init(config, runtime) {
-    import_core.logger.log("[plugin-commands] Initializing command system");
+    import_core3.logger.log("[plugin-commands] Initializing command system");
+    initForRuntime(runtime.agentId);
     const configEnabled = config.COMMANDS_CONFIG_ENABLED === "true";
     const debugEnabled = config.COMMANDS_DEBUG_ENABLED === "true";
     const bashEnabled = config.COMMANDS_BASH_ENABLED === "true";
+    const restartEnabled = config.COMMANDS_RESTART_ENABLED !== "false";
     const configCmd = findCommandByKey("config");
     if (configCmd) {
       configCmd.enabled = configEnabled;
@@ -1068,10 +1144,14 @@ var commandsPlugin = {
     if (bashCmd) {
       bashCmd.enabled = bashEnabled;
     }
+    const restartCmd = findCommandByKey("restart");
+    if (restartCmd) {
+      restartCmd.enabled = restartEnabled;
+    }
     const enabledCount = getEnabledCommands().length;
-    import_core.logger.log(`[plugin-commands] ${enabledCount} commands enabled`);
+    import_core3.logger.log(`[plugin-commands] ${enabledCount} commands enabled for agent ${runtime.agentId}`);
   }
 };
 var src_default = commandsPlugin;
 
-//# debugId=F42BC7360B07F25664756E2164756E21
+//# debugId=C959FE7FE395530C64756E2164756E21