@elizaos/plugin-commands 1.0.0 → 2.0.0-alpha.4

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import {
-  logger
+  logger as logger3
 } from "@elizaos/core";
 
 // src/registry.ts
@@ -97,9 +97,7 @@ var DEFAULT_COMMANDS = [
     scope: "both",
     category: "session",
     acceptsArgs: true,
-    args: [
-      { name: "instructions", description: "Optional compaction instructions" }
-    ]
+    args: [{ name: "instructions", description: "Optional compaction instructions" }]
   },
   {
     key: "think",
@@ -109,9 +107,7 @@ var DEFAULT_COMMANDS = [
     scope: "both",
     category: "options",
     acceptsArgs: true,
-    args: [
-      { name: "level", description: "off, minimal, low, medium, high, xhigh" }
-    ]
+    args: [{ name: "level", description: "off, minimal, low, medium, high, xhigh" }]
   },
   {
     key: "verbose",
@@ -286,21 +282,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) {
@@ -308,35 +322,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();
@@ -345,7 +359,7 @@ function startsWithCommand(text) {
     if (normalized === alias) {
       return command;
     }
-    if (normalized.startsWith(alias + " ") || normalized.startsWith(alias + ":")) {
+    if (normalized.startsWith(`${alias} `) || normalized.startsWith(`${alias}:`)) {
       return command;
     }
   }
@@ -389,7 +403,7 @@ function parseCommand(text, definition) {
       matchedAlias = alias;
       break;
     }
-    if (trimmed.toLowerCase().startsWith(normalized + " ") || trimmed.toLowerCase().startsWith(normalized + ":")) {
+    if (trimmed.toLowerCase().startsWith(`${normalized} `) || trimmed.toLowerCase().startsWith(`${normalized}:`)) {
       matchedAlias = alias;
       break;
     }
@@ -498,18 +512,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"],
-  async validate(runtime, message) {
+  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}):**
+  async handler(_runtime, _message, _state, _options, callback) {
+    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]" : "";
@@ -521,7 +535,7 @@ var commandsListAction = {
     return {
       success: true,
       text: replyText,
-      data: { commandCount: commands2.length }
+      data: { commandCount: commands.length }
     };
   },
   examples: [
@@ -541,7 +555,7 @@ var commandsListAction = {
 };
 
 // src/actions/help.ts
-function formatCommandList(commands2) {
+function formatCommandList(commands) {
   const lines = [`**Available Commands:**
 `];
   const categories = [
@@ -553,7 +567,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(`
@@ -563,7 +577,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:**`);
@@ -577,21 +591,21 @@ function formatCommandList(commands2) {
 }
 var helpAction = {
   name: "HELP_COMMAND",
-  description: "Show available commands and their descriptions",
-  similes: ["/help", "/h", "/?", "help", "show help", "list commands"],
-  async validate(runtime, message) {
+  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);
+  async handler(_runtime, _message, _state, _options, callback) {
+    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: [
@@ -623,49 +637,74 @@ var helpAction = {
 };
 
 // src/actions/models.ts
+import { logger, ModelType } from "@elizaos/core";
+function describeModelType(modelType) {
+  const descriptions = {
+    [ModelType.TEXT_SMALL]: "Text (Small)",
+    [ModelType.TEXT_LARGE]: "Text (Large)",
+    [ModelType.TEXT_REASONING_SMALL]: "Reasoning (Small)",
+    [ModelType.TEXT_REASONING_LARGE]: "Reasoning (Large)",
+    [ModelType.TEXT_COMPLETION]: "Text Completion",
+    [ModelType.TEXT_EMBEDDING]: "Embedding",
+    [ModelType.IMAGE]: "Image Generation",
+    [ModelType.IMAGE_DESCRIPTION]: "Image Description",
+    [ModelType.TRANSCRIPTION]: "Transcription",
+    [ModelType.TEXT_TO_SPEECH]: "Text-to-Speech",
+    [ModelType.AUDIO]: "Audio",
+    [ModelType.VIDEO]: "Video",
+    [ModelType.OBJECT_SMALL]: "Object (Small)",
+    [ModelType.OBJECT_LARGE]: "Object (Large)",
+    [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"],
-  async validate(runtime, message) {
+  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);
     return detection.isCommand && detection.command?.key === "models";
   },
-  async handler(runtime, message, state, options, callback) {
+  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(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) {
+      logger.warn({ src: "plugin-commands", err }, "Error querying runtime models");
+      lines.push("Unable to query available models.");
     }
     lines.push(`
 
@@ -675,8 +714,7 @@ _Use /model <provider/model> to switch models._`);
     await callback?.({ text: replyText });
     return {
       success: true,
-      text: replyText,
-      data: { providers }
+      text: replyText
     };
   },
   examples: [
@@ -685,11 +723,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`)..."
         }
       }
     ]
@@ -700,7 +734,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");
@@ -720,19 +754,26 @@ 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"],
-  async validate(runtime, message) {
+  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);
     return detection.isCommand && detection.command?.key === "status";
   },
-  async handler(runtime, message, state, options, callback) {
+  async handler(runtime, message, _state, _options, callback) {
     const statusText = await buildStatusReport(runtime, message.roomId);
     await callback?.({ text: statusText });
     return {
@@ -748,7 +789,7 @@ var statusAction = {
         content: {
           text: `**Session Status:**
 
-**Agent:** agent-123
+**Agent:** Eliza
 **Room:** room-456
 
 **Directives:**
@@ -760,23 +801,34 @@ var statusAction = {
 };
 
 // src/actions/stop.ts
+import { EventType, logger as logger2 } from "@elizaos/core";
 var stopAction = {
   name: "STOP_COMMAND",
-  description: "Stop current operation or abort running tasks",
-  similes: ["/stop", "/abort", "/cancel", "stop", "abort", "cancel"],
-  async validate(runtime, message) {
+  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);
     return detection.isCommand && ["stop", "abort", "cancel"].includes(detection.command?.key ?? "");
   },
-  async handler(runtime, message, state, options, callback) {
+  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(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) {
+      logger2.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 {
@@ -812,28 +864,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) {
@@ -851,13 +919,7 @@ var commandsPlugin = {
   name: "commands",
   description: "Chat command system with /help, /status, /reset, etc.",
   providers: [commandRegistryProvider],
-  actions: [
-    helpAction,
-    statusAction,
-    stopAction,
-    modelsAction,
-    commandsListAction
-  ],
+  actions: [helpAction, statusAction, stopAction, modelsAction, commandsListAction],
   config: {
     COMMANDS_ENABLED: "true",
     COMMANDS_CONFIG_ENABLED: "false",
@@ -881,7 +943,7 @@ var commandsPlugin = {
             if (hasCommand("hello world")) {
               throw new Error("Should not detect plain text as command");
             }
-            logger.success("Command prefix detection works correctly");
+            logger3.success("Command prefix detection works correctly");
           }
         },
         {
@@ -897,7 +959,7 @@ var commandsPlugin = {
             if (detection.command?.args[0] !== "high") {
               throw new Error(`Expected arg 'high', got '${detection.command?.args[0]}'`);
             }
-            logger.success("Command argument parsing works correctly");
+            logger3.success("Command argument parsing works correctly");
           }
         },
         {
@@ -911,7 +973,7 @@ var commandsPlugin = {
             if (normalized2 !== "/help") {
               throw new Error(`Expected '/help', got '${normalized2}'`);
             }
-            logger.success("Command normalization works correctly");
+            logger3.success("Command normalization works correctly");
           }
         },
         {
@@ -924,7 +986,7 @@ var commandsPlugin = {
             if (cmd.key !== "help") {
               throw new Error(`Expected key 'help', got '${cmd.key}'`);
             }
-            logger.success("Command alias lookup works correctly");
+            logger3.success("Command alias lookup works correctly");
           }
         },
         {
@@ -937,7 +999,7 @@ var commandsPlugin = {
             if (cmd.key !== "status") {
               throw new Error(`Expected key 'status', got '${cmd.key}'`);
             }
-            logger.success("Command key lookup works correctly");
+            logger3.success("Command key lookup works correctly");
           }
         }
       ]
@@ -948,16 +1010,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");
             }
-            logger.success("Command registry works correctly");
+            logger3.success("Command registry works correctly");
           }
         },
         {
@@ -979,7 +1041,7 @@ var commandsPlugin = {
             if (notFound) {
               throw new Error("Should not find unregistered command");
             }
-            logger.success("Custom command registration works correctly");
+            logger3.success("Custom command registration works correctly");
           }
         },
         {
@@ -993,17 +1055,19 @@ var commandsPlugin = {
             if (!allStatus) {
               throw new Error("All returned commands should be in status category");
             }
-            logger.success("Command categorization works correctly");
+            logger3.success("Command categorization works correctly");
           }
         }
       ]
     }
   ],
   async init(config, runtime) {
-    logger.log("[plugin-commands] Initializing command system");
+    logger3.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;
@@ -1016,12 +1080,17 @@ var commandsPlugin = {
     if (bashCmd) {
       bashCmd.enabled = bashEnabled;
     }
+    const restartCmd = findCommandByKey("restart");
+    if (restartCmd) {
+      restartCmd.enabled = restartEnabled;
+    }
     const enabledCount = getEnabledCommands().length;
-    logger.log(`[plugin-commands] ${enabledCount} commands enabled`);
+    logger3.log(`[plugin-commands] ${enabledCount} commands enabled for agent ${runtime.agentId}`);
   }
 };
 var src_default = commandsPlugin;
 export {
+  useRuntime,
   unregisterCommand,
   startsWithCommand,
   resetCommands,
@@ -1032,6 +1101,7 @@ export {
   isElevated,
   isCommandOnly,
   isAuthorized,
+  initForRuntime,
   hasCommand,
   getEnabledCommands,
   getCommandsByCategory,
@@ -1046,4 +1116,4 @@ export {
   commandRegistryProvider
 };
 
-//# debugId=4D1F6605A437A12664756E2164756E21
+//# debugId=0433499C9EE6AF7764756E2164756E21