@elizaos/plugin-commands 2.0.0-alpha.9 → 2.0.3-beta.2

package/dist/cjs/index.cjs

@@ -1,1214 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  useRuntime: () => useRuntime,
-  unregisterCommand: () => unregisterCommand,
-  startsWithCommand: () => startsWithCommand,
-  resetCommands: () => resetCommands,
-  registerCommands: () => registerCommands,
-  registerCommand: () => registerCommand,
-  parseCommand: () => parseCommand,
-  normalizeCommandBody: () => normalizeCommandBody,
-  isElevated: () => isElevated,
-  isCommandOnly: () => isCommandOnly,
-  isAuthorized: () => isAuthorized,
-  initForRuntime: () => initForRuntime,
-  hasCommand: () => hasCommand,
-  getEnabledCommands: () => getEnabledCommands,
-  getCommandsByCategory: () => getCommandsByCategory,
-  getCommands: () => getCommands,
-  formatCommandResult: () => formatCommandResult,
-  findCommandByKey: () => findCommandByKey,
-  findCommandByAlias: () => findCommandByAlias,
-  extractCommand: () => extractCommand,
-  detectCommand: () => detectCommand,
-  default: () => src_default,
-  commandsPlugin: () => commandsPlugin,
-  commandRegistryProvider: () => commandRegistryProvider
-});
-module.exports = __toCommonJS(exports_src);
-var import_core3 = require("@elizaos/core");
-
-// src/registry.ts
-var DEFAULT_COMMANDS = [
-  {
-    key: "help",
-    nativeName: "help",
-    description: "Show available commands",
-    textAliases: ["/help", "/h", "/?"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "commands",
-    nativeName: "commands",
-    description: "List all commands",
-    textAliases: ["/commands", "/cmds"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "status",
-    nativeName: "status",
-    description: "Show current session status",
-    textAliases: ["/status", "/s"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "context",
-    nativeName: "context",
-    description: "Show current context information",
-    textAliases: ["/context", "/ctx"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: true,
-    args: [{ name: "mode", description: "Output mode (list, detail, json)" }]
-  },
-  {
-    key: "whoami",
-    nativeName: "whoami",
-    description: "Show your identity information",
-    textAliases: ["/whoami", "/who"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "stop",
-    nativeName: "stop",
-    description: "Stop current operation",
-    textAliases: ["/stop", "/abort", "/cancel"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false
-  },
-  {
-    key: "restart",
-    nativeName: "restart",
-    description: "Restart the session",
-    textAliases: ["/restart"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false,
-    requiresAuth: true
-  },
-  {
-    key: "reset",
-    nativeName: "reset",
-    description: "Reset session state",
-    textAliases: ["/reset"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false,
-    requiresAuth: true
-  },
-  {
-    key: "new",
-    nativeName: "new",
-    description: "Start a new conversation",
-    textAliases: ["/new"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false
-  },
-  {
-    key: "compact",
-    nativeName: "compact",
-    description: "Compact conversation history",
-    textAliases: ["/compact"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: true,
-    args: [
-      { name: "instructions", description: "Optional compaction instructions" }
-    ]
-  },
-  {
-    key: "think",
-    nativeName: "think",
-    description: "Set thinking level",
-    textAliases: ["/think", "/thinking", "/t"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [
-      { name: "level", description: "off, minimal, low, medium, high, xhigh" }
-    ]
-  },
-  {
-    key: "verbose",
-    nativeName: "verbose",
-    description: "Set verbose output level",
-    textAliases: ["/verbose", "/v"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "level", description: "off, on, full" }]
-  },
-  {
-    key: "reasoning",
-    nativeName: "reasoning",
-    description: "Set reasoning visibility",
-    textAliases: ["/reasoning", "/reason"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "level", description: "off, on, stream" }]
-  },
-  {
-    key: "elevated",
-    nativeName: "elevated",
-    description: "Set elevated permission mode",
-    textAliases: ["/elevated", "/elev"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "level", description: "off, on, ask, full" }],
-    requiresAuth: true
-  },
-  {
-    key: "model",
-    nativeName: "model",
-    description: "Set or show current model",
-    textAliases: ["/model", "/m"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "model", description: "provider/model or alias" }]
-  },
-  {
-    key: "models",
-    nativeName: "models",
-    description: "List available models",
-    textAliases: ["/models"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: false
-  },
-  {
-    key: "usage",
-    nativeName: "usage",
-    description: "Show token usage",
-    textAliases: ["/usage"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: false
-  },
-  {
-    key: "queue",
-    nativeName: "queue",
-    description: "Set queue mode",
-    textAliases: ["/queue", "/q"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [
-      {
-        name: "mode",
-        description: "steer, followup, collect, interrupt, or options"
-      }
-    ]
-  },
-  {
-    key: "allowlist",
-    nativeName: "allowlist",
-    description: "Manage sender allowlist",
-    textAliases: ["/allowlist", "/allow"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [
-      { name: "action", description: "list, add, remove" },
-      { name: "value", description: "sender to add/remove" }
-    ],
-    requiresAuth: true
-  },
-  {
-    key: "approve",
-    nativeName: "approve",
-    description: "Approve or deny a pending action",
-    textAliases: ["/approve"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [
-      { name: "id", description: "Approval ID", required: true },
-      { name: "action", description: "allow-once, allow-always, deny" }
-    ],
-    requiresAuth: true
-  },
-  {
-    key: "subagents",
-    nativeName: "subagents",
-    description: "Manage subagents",
-    textAliases: ["/subagents", "/sub"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [{ name: "action", description: "list, stop, log, info, send" }],
-    requiresAuth: true
-  },
-  {
-    key: "config",
-    nativeName: "config",
-    description: "View or set configuration",
-    textAliases: ["/config", "/cfg"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [
-      { name: "key", description: "Configuration key" },
-      { name: "value", description: "Value to set" }
-    ],
-    requiresAuth: true,
-    enabled: false
-  },
-  {
-    key: "debug",
-    nativeName: "debug",
-    description: "Debug information",
-    textAliases: ["/debug"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    requiresAuth: true,
-    enabled: false
-  },
-  {
-    key: "tts",
-    nativeName: "tts",
-    description: "Text-to-speech settings",
-    textAliases: ["/tts", "/voice"],
-    scope: "both",
-    category: "media",
-    acceptsArgs: true,
-    args: [
-      {
-        name: "action",
-        description: "on, off, status, provider, limit, audio"
-      }
-    ]
-  },
-  {
-    key: "bash",
-    nativeName: "bash",
-    description: "Execute shell command",
-    textAliases: ["/bash", "/sh", "/!"],
-    scope: "text",
-    category: "tools",
-    acceptsArgs: true,
-    args: [
-      {
-        name: "command",
-        description: "Shell command to execute",
-        captureRemaining: true
-      }
-    ],
-    requiresAuth: true,
-    requiresElevated: true
-  }
-];
-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 [...activeStore.commands];
-}
-function getEnabledCommands() {
-  return activeStore.commands.filter((cmd) => cmd.enabled !== false);
-}
-function getCommandsByCategory(category) {
-  return activeStore.commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
-}
-function registerCommand(command) {
-  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) {
-    registerCommand(command);
-  }
-}
-function unregisterCommand(key) {
-  activeStore.commands = activeStore.commands.filter((c) => c.key !== key);
-  activeStore.aliasMap = null;
-}
-function resetCommands() {
-  activeStore.commands = DEFAULT_COMMANDS.map((c) => ({ ...c }));
-  activeStore.aliasMap = null;
-}
-function getAliasMap() {
-  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 (!activeStore.aliasMap.has(normalized)) {
-        activeStore.aliasMap.set(normalized, command);
-      }
-    }
-  }
-  return activeStore.aliasMap;
-}
-function findCommandByAlias(alias) {
-  const map = getAliasMap();
-  return map.get(alias.toLowerCase().trim());
-}
-function findCommandByKey(key) {
-  return activeStore.commands.find((c) => c.key === key);
-}
-function startsWithCommand(text) {
-  const map = getAliasMap();
-  const normalized = text.toLowerCase().trim();
-  for (const [alias, command] of map) {
-    if (normalized === alias) {
-      return command;
-    }
-    if (normalized.startsWith(`${alias} `) || normalized.startsWith(`${alias}:`)) {
-      return command;
-    }
-  }
-  return;
-}
-
-// src/parser.ts
-var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-function hasCommand(text) {
-  if (!text)
-    return false;
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/") && !trimmed.startsWith("!"))
-    return false;
-  return Boolean(startsWithCommand(trimmed));
-}
-function detectCommand(text) {
-  if (!text) {
-    return { isCommand: false };
-  }
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/") && !trimmed.startsWith("!")) {
-    return { isCommand: false };
-  }
-  const command = startsWithCommand(trimmed);
-  if (!command) {
-    return { isCommand: false };
-  }
-  const parsed = parseCommand(trimmed, command);
-  if (!parsed) {
-    return { isCommand: false };
-  }
-  return { isCommand: true, command: parsed };
-}
-function parseCommand(text, definition) {
-  const trimmed = text.trim();
-  let matchedAlias = null;
-  for (const alias of definition.textAliases) {
-    const normalized = alias.toLowerCase();
-    if (trimmed.toLowerCase() === normalized) {
-      matchedAlias = alias;
-      break;
-    }
-    if (trimmed.toLowerCase().startsWith(`${normalized} `) || trimmed.toLowerCase().startsWith(`${normalized}:`)) {
-      matchedAlias = alias;
-      break;
-    }
-  }
-  if (!matchedAlias) {
-    return null;
-  }
-  let rawArgs = trimmed.slice(matchedAlias.length).trim();
-  if (rawArgs.startsWith(":")) {
-    rawArgs = rawArgs.slice(1).trim();
-  }
-  const args = parseArgs(rawArgs, definition);
-  return {
-    key: definition.key,
-    canonical: definition.textAliases[0] ?? `/${definition.key}`,
-    args,
-    rawArgs: rawArgs || undefined
-  };
-}
-function parseArgs(rawArgs, definition) {
-  if (!rawArgs || !definition.acceptsArgs) {
-    return [];
-  }
-  const parsing = definition.argsParsing ?? "positional";
-  if (parsing === "none") {
-    return rawArgs ? [rawArgs] : [];
-  }
-  const args = [];
-  const argDefs = definition.args ?? [];
-  const tokens = tokenize(rawArgs);
-  for (let i = 0;i < tokens.length; i++) {
-    const argDef = argDefs[i];
-    if (argDef?.captureRemaining) {
-      args.push(tokens.slice(i).join(" "));
-      break;
-    }
-    args.push(tokens[i]);
-  }
-  return args;
-}
-function tokenize(input) {
-  const tokens = [];
-  let current = "";
-  let inQuote = false;
-  let quoteChar = "";
-  for (let i = 0;i < input.length; i++) {
-    const char = input[i];
-    if (inQuote) {
-      if (char === quoteChar) {
-        inQuote = false;
-        if (current) {
-          tokens.push(current);
-          current = "";
-        }
-      } else {
-        current += char;
-      }
-    } else if (char === '"' || char === "'") {
-      inQuote = true;
-      quoteChar = char;
-    } else if (/\s/.test(char)) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
-    }
-  }
-  if (current) {
-    tokens.push(current);
-  }
-  return tokens;
-}
-function normalizeCommandBody(text, botMention) {
-  let normalized = text.trim();
-  if (botMention) {
-    const mentionPattern = new RegExp(`^@${escapeRegExp(botMention)}\\s*`, "i");
-    normalized = normalized.replace(mentionPattern, "");
-  }
-  normalized = normalized.replace(/^(\/\w+):\s*/, "$1 ");
-  return normalized.trim();
-}
-function isCommandOnly(text) {
-  const detection = detectCommand(text);
-  if (!detection.isCommand || !detection.command) {
-    return false;
-  }
-  if (!detection.command.rawArgs) {
-    return true;
-  }
-  return detection.command.rawArgs.trim().length === 0;
-}
-function extractCommand(text) {
-  const detection = detectCommand(text);
-  if (!detection.isCommand || !detection.command) {
-    return null;
-  }
-  const { command } = detection;
-  if (!command.rawArgs) {
-    return { command, remainingText: "" };
-  }
-  return { command, remainingText: command.rawArgs };
-}
-
-// src/actions/commands-list.ts
-var commandsListAction = {
-  name: "COMMANDS_LIST",
-  description: "List all available commands with their aliases. Only activates for /commands or /cmds slash commands.",
-  similes: ["/commands", "/cmds"],
-  validate: async (runtime, message) => {
-    const textRaw = message.content?.text ?? "";
-    const text = textRaw.toLowerCase();
-    const hasKeyword = text.includes("/commands") || text.includes("/cmds") || text.includes("commands");
-    const hasRegex = /^(?:\/|!)\s*(?:commands|cmds)\b/i.test(textRaw);
-    const hasContext = Boolean(runtime?.agentId || message?.roomId || message?.content);
-    const hasInput = textRaw.trim().length > 0;
-    if (!(hasKeyword && hasRegex && hasContext && hasInput)) {
-      return false;
-    }
-    const detection = detectCommand(textRaw);
-    return detection.isCommand && detection.command?.key === "commands";
-  },
-  async handler(_runtime, _message, _state, _options, callback) {
-    const commands = getEnabledCommands();
-    const lines = [`**Commands (${commands.length}):**
-`];
-    for (const cmd of commands) {
-      const aliases = cmd.textAliases.join(", ");
-      const authNote = cmd.requiresAuth ? " [auth]" : "";
-      const elevatedNote = cmd.requiresElevated ? " [elevated]" : "";
-      lines.push(`• **${cmd.key}**: ${aliases}${authNote}${elevatedNote}`);
-    }
-    const replyText = lines.join(`
-`);
-    await callback?.({ text: replyText });
-    return {
-      success: true,
-      text: replyText,
-      data: { commandCount: commands.length }
-    };
-  },
-  examples: [
-    [
-      { name: "user", content: { text: "/commands" } },
-      {
-        name: "assistant",
-        content: {
-          text: `**Commands (15):**
-
-• **help**: /help, /h, /?
-• **status**: /status, /s...`
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/help.ts
-function formatCommandList(commands) {
-  const lines = [`**Available Commands:**
-`];
-  const categories = [
-    { key: "status", name: "Status" },
-    { key: "session", name: "Session" },
-    { key: "options", name: "Options" },
-    { key: "management", name: "Management" },
-    { key: "media", name: "Media" },
-    { key: "tools", name: "Tools" }
-  ];
-  for (const cat of categories) {
-    const catCommands = commands.filter((c) => c.category === cat.key);
-    if (catCommands.length === 0)
-      continue;
-    lines.push(`
-**${cat.name}:**`);
-    for (const cmd of catCommands) {
-      const aliases = cmd.textAliases.slice(0, 2).join(", ");
-      lines.push(`• ${aliases} - ${cmd.description}`);
-    }
-  }
-  const uncategorized = commands.filter((c) => !c.category);
-  if (uncategorized.length > 0) {
-    lines.push(`
-**Other:**`);
-    for (const cmd of uncategorized) {
-      const aliases = cmd.textAliases.slice(0, 2).join(", ");
-      lines.push(`• ${aliases} - ${cmd.description}`);
-    }
-  }
-  return lines.join(`
-`);
-}
-var helpAction = {
-  name: "HELP_COMMAND",
-  description: "Show available commands and their descriptions. Only activates for /help, /h, or /? slash commands.",
-  similes: ["/help", "/h", "/?"],
-  validate: async (runtime, message) => {
-    const textRaw = message.content?.text ?? "";
-    const text = textRaw.toLowerCase();
-    const hasKeyword = text.includes("/help") || text.includes("/h") || text.includes("/?");
-    const hasRegex = /^(?:\/|!)\s*(?:help|h|\?)(?:\s|$|:)/i.test(textRaw);
-    const hasContext = Boolean(runtime?.agentId || message?.roomId || message?.content);
-    const hasInput = textRaw.trim().length > 0;
-    if (!(hasKeyword && hasRegex && hasContext && hasInput)) {
-      return false;
-    }
-    const detection = detectCommand(textRaw);
-    return detection.isCommand && detection.command?.key === "help";
-  },
-  async handler(_runtime, message, _state, _options, callback) {
-    const detection = detectCommand(message?.content?.text ?? "");
-    if (!detection.isCommand || detection.command?.key !== "help") {
-      return { success: false, text: "" };
-    }
-    const commands = getEnabledCommands();
-    const helpText = formatCommandList(commands);
-    await callback?.({ text: helpText });
-    return {
-      success: true,
-      text: helpText,
-      data: { commandCount: commands.length }
-    };
-  },
-  examples: [
-    [
-      { name: "user", content: { text: "/help" } },
-      {
-        name: "assistant",
-        content: {
-          text: `**Available Commands:**
-
-**Status:**
-• /help - Show available commands...`
-        }
-      }
-    ],
-    [
-      { name: "user", content: { text: "/?" } },
-      {
-        name: "assistant",
-        content: {
-          text: `**Available Commands:**
-
-**Status:**
-• /help - Show available commands...`
-        }
-      }
-    ]
-  ]
-};
-
-// 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. Only activates for /models slash command.",
-  similes: ["/models"],
-  validate: async (runtime, message) => {
-    const textRaw = message.content?.text ?? "";
-    const text = textRaw.toLowerCase();
-    const hasKeyword = text.includes("/models") || text.includes("models");
-    const hasRegex = /^(?:\/|!)\s*models\b/i.test(textRaw);
-    const hasContext = Boolean(runtime?.agentId || message?.roomId || message?.content);
-    const hasInput = textRaw.trim().length > 0;
-    if (!(hasKeyword && hasRegex && hasContext && hasInput)) {
-      return false;
-    }
-    const detection = detectCommand(textRaw);
-    return detection.isCommand && detection.command?.key === "models";
-  },
-  async handler(runtime, _message, _state, _options, callback) {
-    const lines = [`**Available Models:**
-`];
-    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 {}
-      }
-      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(`
-
-_Use /model <provider/model> to switch models._`);
-    const replyText = lines.join(`
-`);
-    await callback?.({ text: replyText });
-    return {
-      success: true,
-      text: replyText
-    };
-  },
-  examples: [
-    [
-      { name: "user", content: { text: "/models" } },
-      {
-        name: "assistant",
-        content: {
-          text: "**Available Models:**\n\n**Registered Model Types:**\n• Text (Large) (`text_large`)\n• Text (Small) (`text_small`)..."
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/status.ts
-async function buildStatusReport(runtime, roomId) {
-  const lines = [`**Session Status:**
-`];
-  lines.push(`**Agent:** ${runtime.character.name ?? runtime.agentId}`);
-  lines.push(`**Room:** ${roomId}`);
-  try {
-    const directiveService = runtime.getService("directive-parser");
-    if (directiveService) {
-      const state = directiveService.getSessionState?.(roomId);
-      if (state) {
-        lines.push(`
-**Directives:**`);
-        lines.push(`• Thinking: ${state.thinking}`);
-        lines.push(`• Verbose: ${state.verbose}`);
-        lines.push(`• Reasoning: ${state.reasoning}`);
-        lines.push(`• Elevated: ${state.elevated}`);
-        if (state.model?.provider || state.model?.model) {
-          const modelStr = state.model.provider ? `${state.model.provider}/${state.model.model}` : state.model.model;
-          lines.push(`• Model: ${modelStr}`);
-        }
-      }
-    }
-  } catch {}
-  try {
-    const tasks = await runtime.getTasks({
-      roomId,
-      agentIds: [runtime.agentId]
-    });
-    if (tasks.length > 0) {
-      lines.push(`
-**Tasks:** ${tasks.length} pending`);
-    }
-  } catch {}
-  return lines.join(`
-`);
-}
-var statusAction = {
-  name: "STATUS_COMMAND",
-  description: "Show session directive settings via /status slash command. Only activates for /status or /s prefix.",
-  similes: ["/status", "/s"],
-  validate: async (runtime, message) => {
-    const textRaw = message.content?.text ?? "";
-    const text = textRaw.toLowerCase();
-    const hasKeyword = text.includes("/status") || text.includes("/s") || text.includes("status");
-    const hasRegex = /^(?:\/|!)\s*(?:status|s)\b/i.test(textRaw);
-    const hasContext = Boolean(runtime?.agentId || message?.roomId || message?.content);
-    const hasInput = textRaw.trim().length > 0;
-    if (!(hasKeyword && hasRegex && hasContext && hasInput)) {
-      return false;
-    }
-    const detection = detectCommand(textRaw);
-    return detection.isCommand && detection.command?.key === "status";
-  },
-  async handler(runtime, message, _state, _options, callback) {
-    const statusText = await buildStatusReport(runtime, message.roomId);
-    await callback?.({ text: statusText });
-    return {
-      success: true,
-      text: statusText
-    };
-  },
-  examples: [
-    [
-      { name: "user", content: { text: "/status" } },
-      {
-        name: "assistant",
-        content: {
-          text: `**Session Status:**
-
-**Agent:** Eliza
-**Room:** room-456
-
-**Directives:**
-• Thinking: low...`
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/stop.ts
-var import_core2 = require("@elizaos/core");
-var stopAction = {
-  name: "STOP_COMMAND",
-  description: "Stop current operation or abort running tasks. Triggered by /stop, /abort, or /cancel slash commands only.",
-  similes: ["/stop", "/abort", "/cancel"],
-  validate: async (runtime, message) => {
-    const textRaw = message.content?.text ?? "";
-    const text = textRaw.toLowerCase();
-    const hasKeyword = text.includes("/stop") || text.includes("/abort") || text.includes("/cancel") || text.includes("stop");
-    const hasRegex = /^(?:\/|!)\s*(?:stop|abort|cancel)\b/i.test(textRaw);
-    const hasContext = Boolean(runtime?.agentId || message?.roomId || message?.content);
-    const hasInput = textRaw.trim().length > 0;
-    if (!(hasKeyword && hasRegex && hasContext && hasInput)) {
-      return false;
-    }
-    const detection = detectCommand(textRaw);
-    return detection.isCommand && ["stop", "abort", "cancel"].includes(detection.command?.key ?? "");
-  },
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      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 (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 {
-      success: true,
-      text: replyText
-    };
-  },
-  examples: [
-    [
-      { name: "user", content: { text: "/stop" } },
-      {
-        name: "assistant",
-        content: {
-          text: "✓ Stop requested. Current operations will be cancelled."
-        }
-      }
-    ],
-    [
-      { name: "user", content: { text: "/abort" } },
-      {
-        name: "assistant",
-        content: {
-          text: "✓ Stop requested. Current operations will be cancelled."
-        }
-      }
-    ]
-  ]
-};
-
-// src/index.ts
-var commandRegistryProvider = {
-  name: "COMMAND_REGISTRY",
-  description: "Available chat commands and their descriptions",
-  dynamic: true,
-  async get(runtime, message, _state) {
-    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: commands.length,
-        isCommand: false
-      },
-      data: { isCommand: false }
-    };
-  }
-};
-function formatCommandResult(result) {
-  if (result.error) {
-    return `Error: ${result.error}`;
-  }
-  return result.reply ?? "Command executed";
-}
-function isAuthorized(context, command) {
-  if (!command.requiresAuth) {
-    return true;
-  }
-  return context.isAuthorized;
-}
-function isElevated(context, command) {
-  if (!command.requiresElevated) {
-    return true;
-  }
-  return context.isElevated;
-}
-var commandsPlugin = {
-  name: "commands",
-  description: "Chat command system with /help, /status, /reset, etc.",
-  providers: [commandRegistryProvider],
-  actions: [
-    helpAction,
-    statusAction,
-    stopAction,
-    modelsAction,
-    commandsListAction
-  ],
-  config: {
-    COMMANDS_ENABLED: "true",
-    COMMANDS_CONFIG_ENABLED: "false",
-    COMMANDS_DEBUG_ENABLED: "false",
-    COMMANDS_BASH_ENABLED: "false",
-    COMMANDS_RESTART_ENABLED: "true"
-  },
-  tests: [
-    {
-      name: "command-detection",
-      tests: [
-        {
-          name: "Detect command prefix",
-          fn: async (_runtime) => {
-            if (!hasCommand("/help")) {
-              throw new Error("Should detect /help command");
-            }
-            if (!hasCommand("/status test")) {
-              throw new Error("Should detect /status with args");
-            }
-            if (hasCommand("hello world")) {
-              throw new Error("Should not detect plain text as command");
-            }
-            import_core3.logger.success("Command prefix detection works correctly");
-          }
-        },
-        {
-          name: "Parse command with args",
-          fn: async (_runtime) => {
-            const detection = detectCommand("/think:high");
-            if (!detection.isCommand) {
-              throw new Error("Should detect think command");
-            }
-            if (detection.command?.key !== "think") {
-              throw new Error(`Expected key 'think', got '${detection.command?.key}'`);
-            }
-            if (detection.command?.args[0] !== "high") {
-              throw new Error(`Expected arg 'high', got '${detection.command?.args[0]}'`);
-            }
-            import_core3.logger.success("Command argument parsing works correctly");
-          }
-        },
-        {
-          name: "Normalize command body",
-          fn: async (_runtime) => {
-            const normalized1 = normalizeCommandBody("/status: test");
-            if (normalized1 !== "/status test") {
-              throw new Error(`Expected '/status test', got '${normalized1}'`);
-            }
-            const normalized2 = normalizeCommandBody("@bot /help", "bot");
-            if (normalized2 !== "/help") {
-              throw new Error(`Expected '/help', got '${normalized2}'`);
-            }
-            import_core3.logger.success("Command normalization works correctly");
-          }
-        },
-        {
-          name: "Find command by alias",
-          fn: async (_runtime) => {
-            const cmd = findCommandByAlias("/h");
-            if (!cmd) {
-              throw new Error("Should find help command by /h alias");
-            }
-            if (cmd.key !== "help") {
-              throw new Error(`Expected key 'help', got '${cmd.key}'`);
-            }
-            import_core3.logger.success("Command alias lookup works correctly");
-          }
-        },
-        {
-          name: "Find command by key",
-          fn: async (_runtime) => {
-            const cmd = findCommandByKey("status");
-            if (!cmd) {
-              throw new Error("Should find status command by key");
-            }
-            if (cmd.key !== "status") {
-              throw new Error(`Expected key 'status', got '${cmd.key}'`);
-            }
-            import_core3.logger.success("Command key lookup works correctly");
-          }
-        }
-      ]
-    },
-    {
-      name: "command-registry",
-      tests: [
-        {
-          name: "Get enabled commands",
-          fn: async (_runtime) => {
-            const commands = getEnabledCommands();
-            if (commands.length === 0) {
-              throw new Error("Should have enabled commands");
-            }
-            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_core3.logger.success("Command registry works correctly");
-          }
-        },
-        {
-          name: "Register custom command",
-          fn: async (_runtime) => {
-            const customCmd = {
-              key: "test-custom",
-              description: "Test custom command",
-              textAliases: ["/test-custom", "/tc"],
-              scope: "text"
-            };
-            registerCommand(customCmd);
-            const found = findCommandByKey("test-custom");
-            if (!found) {
-              throw new Error("Should find registered custom command");
-            }
-            unregisterCommand("test-custom");
-            const notFound = findCommandByKey("test-custom");
-            if (notFound) {
-              throw new Error("Should not find unregistered command");
-            }
-            import_core3.logger.success("Custom command registration works correctly");
-          }
-        },
-        {
-          name: "Get commands by category",
-          fn: async (_runtime) => {
-            const statusCommands = getCommandsByCategory("status");
-            if (statusCommands.length === 0) {
-              throw new Error("Should have status category commands");
-            }
-            const allStatus = statusCommands.every((c) => c.category === "status");
-            if (!allStatus) {
-              throw new Error("All returned commands should be in status category");
-            }
-            import_core3.logger.success("Command categorization works correctly");
-          }
-        }
-      ]
-    }
-  ],
-  async init(config, runtime) {
-    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;
-    }
-    const debugCmd = findCommandByKey("debug");
-    if (debugCmd) {
-      debugCmd.enabled = debugEnabled;
-    }
-    const bashCmd = findCommandByKey("bash");
-    if (bashCmd) {
-      bashCmd.enabled = bashEnabled;
-    }
-    const restartCmd = findCommandByKey("restart");
-    if (restartCmd) {
-      restartCmd.enabled = restartEnabled;
-    }
-    const enabledCount = getEnabledCommands().length;
-    import_core3.logger.log(`[plugin-commands] ${enabledCount} commands enabled for agent ${runtime.agentId}`);
-  }
-};
-var src_default = commandsPlugin;
-
-//# debugId=29584248BB32069264756E2164756E21