@elizaos/plugin-commands 2.0.3-beta.2 → 2.0.3-beta.4

package/dist/cjs/index.cjs

@@ -0,0 +1,1757 @@
+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,
+  setCommandSetting: () => setCommandSetting,
+  serializeCommand: () => serializeCommand,
+  runCommand: () => runCommand,
+  resolveSettingsSection: () => resolveSettingsSection,
+  resolveConnectorCommandAuth: () => resolveConnectorCommandAuth,
+  resolveCommand: () => resolveCommand,
+  resetCommands: () => resetCommands,
+  registerCommands: () => registerCommands,
+  registerCommand: () => registerCommand,
+  parseCommand: () => parseCommand,
+  normalizeCommandBody: () => normalizeCommandBody,
+  navigationCommandDefinitions: () => navigationCommandDefinitions,
+  naturalShortcuts: () => naturalShortcuts,
+  isElevated: () => isElevated,
+  isDeterministicCommand: () => isDeterministicCommand,
+  isCommandOnly: () => isCommandOnly,
+  isAuthorized: () => isAuthorized,
+  initForRuntime: () => initForRuntime,
+  hasCommand: () => hasCommand,
+  getSettingsSections: () => getSettingsSections,
+  getSettingsSectionChoices: () => getSettingsSectionChoices,
+  getEnabledCommandsForRuntime: () => getEnabledCommandsForRuntime,
+  getEnabledCommands: () => getEnabledCommands,
+  getConnectorCommands: () => getConnectorCommands,
+  getCommandsForRuntime: () => getCommandsForRuntime,
+  getCommandsByCategoryForRuntime: () => getCommandsByCategoryForRuntime,
+  getCommandsByCategory: () => getCommandsByCategory,
+  getCommands: () => getCommands,
+  getCommandSettings: () => getCommandSettings,
+  getCatalogCommands: () => getCatalogCommands,
+  gateConnectorCommandByName: () => gateConnectorCommandByName,
+  gateConnectorCommand: () => gateConnectorCommand,
+  formatCommandResult: () => formatCommandResult,
+  findCommandByKeyForRuntime: () => findCommandByKeyForRuntime,
+  findCommandByKey: () => findCommandByKey,
+  findCommandByAliasForRuntime: () => findCommandByAliasForRuntime,
+  findCommandByAlias: () => findCommandByAlias,
+  extractCommand: () => extractCommand,
+  explicitCommandShortcuts: () => explicitCommandShortcuts,
+  dispatchCommandMessage: () => dispatchCommandMessage,
+  detectCommand: () => detectCommand,
+  default: () => src_default,
+  createCommandShortcuts: () => createCommandShortcuts,
+  createCommandActions: () => createCommandActions,
+  commandsPlugin: () => commandsPlugin,
+  commandVisibleForView: () => commandVisibleForView,
+  commandVisibleForSurface: () => commandVisibleForSurface,
+  commandShortcuts: () => commandShortcuts,
+  commandRegistryProvider: () => commandRegistryProvider,
+  commandActions: () => commandActions,
+  clearCommandSettings: () => clearCommandSettings,
+  DETERMINISTIC_COMMAND_KEYS: () => DETERMINISTIC_COMMAND_KEYS,
+  DEFAULT_COMMANDS: () => DEFAULT_COMMANDS,
+  COMMAND_SETTING_CHOICES: () => COMMAND_SETTING_CHOICES
+});
+module.exports = __toCommonJS(exports_src);
+var import_core = 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,
+    requiresAuth: 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",
+        dynamicChoices: "models"
+      }
+    ]
+  },
+  {
+    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: "transcribe",
+    nativeName: "transcribe",
+    description: "Toggle long-form transcription mode (record-only; agent stays silent until an exit phrase)",
+    textAliases: ["/transcribe", "/transcription", "/dictate"],
+    scope: "both",
+    category: "media",
+    acceptsArgs: false
+  },
+  {
+    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) {
+  activeStore = storeForRuntime(agentId);
+}
+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;
+    }
+    const remainder = normalized.slice(alias.length);
+    if (normalized.startsWith(alias) && /^[\s:]/.test(remainder)) {
+      return command;
+    }
+  }
+  return;
+}
+function storeForRuntime(agentId) {
+  if (!agentId)
+    return fallbackStore;
+  return runtimeStores.get(agentId) ?? fallbackStore;
+}
+function getEnabledCommandsFromStore(store) {
+  return store.commands.filter((cmd) => cmd.enabled !== false);
+}
+function getCommandsByCategoryFromStore(store, category) {
+  return store.commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
+}
+function getAliasMapForStore(store) {
+  if (store.aliasMap)
+    return store.aliasMap;
+  store.aliasMap = new Map;
+  for (const command of store.commands) {
+    if (command.enabled === false)
+      continue;
+    for (const alias of command.textAliases) {
+      const normalized = alias.toLowerCase().trim();
+      if (!store.aliasMap.has(normalized)) {
+        store.aliasMap.set(normalized, command);
+      }
+    }
+  }
+  return store.aliasMap;
+}
+function getCommandsForRuntime(agentId) {
+  return [...storeForRuntime(agentId).commands];
+}
+function getEnabledCommandsForRuntime(agentId) {
+  return getEnabledCommandsFromStore(storeForRuntime(agentId));
+}
+function getCommandsByCategoryForRuntime(category, agentId) {
+  return getCommandsByCategoryFromStore(storeForRuntime(agentId), category);
+}
+function findCommandByAliasForRuntime(alias, agentId) {
+  return getAliasMapForStore(storeForRuntime(agentId)).get(alias.toLowerCase().trim());
+}
+function findCommandByKeyForRuntime(key, agentId) {
+  return storeForRuntime(agentId).commands.find((c) => c.key === key);
+}
+
+// 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;
+    }
+    const remainder = trimmed.slice(alias.length);
+    if (trimmed.toLowerCase().startsWith(normalized) && /^[\s:]/.test(remainder)) {
+      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);
+  const parsed = {
+    key: definition.key,
+    canonical: definition.textAliases[0] ?? `/${definition.key}`,
+    args
+  };
+  if (rawArgs) {
+    parsed.rawArgs = rawArgs;
+  }
+  return parsed;
+}
+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 (const [i, token] of tokens.entries()) {
+    const argDef = argDefs[i];
+    if (argDef?.captureRemaining) {
+      args.push(tokens.slice(i).join(" "));
+      break;
+    }
+    args.push(token);
+  }
+  return args;
+}
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  for (const char of input) {
+    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(/^([/!][^\s:]+):\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/command-settings.ts
+var COMMAND_SETTING_CHOICES = {
+  thinking: ["off", "minimal", "low", "medium", "high", "xhigh"],
+  verbose: ["off", "on", "full"],
+  reasoning: ["off", "on", "stream"],
+  queue: ["steer", "followup", "collect", "interrupt"],
+  elevated: ["off", "on", "ask", "full"],
+  model: null,
+  tts: ["on", "off"]
+};
+function cacheKey(roomId) {
+  return `command-settings:${roomId}`;
+}
+async function clearCommandSettings(runtime, roomId) {
+  return runtime.deleteCache(cacheKey(roomId));
+}
+async function getCommandSettings(runtime, roomId) {
+  const stored = await runtime.getCache(cacheKey(roomId));
+  return stored ?? {};
+}
+async function setCommandSetting(runtime, roomId, key, rawValue) {
+  const value = rawValue.trim().toLowerCase();
+  const choices = COMMAND_SETTING_CHOICES[key];
+  if (choices && !choices.includes(value)) {
+    return {
+      error: `Invalid ${key} value "${rawValue}". Choose one of: ${choices.join(", ")}.`
+    };
+  }
+  const normalized = choices ? value : rawValue.trim();
+  const current = await getCommandSettings(runtime, roomId);
+  await runtime.setCache(cacheKey(roomId), {
+    ...current,
+    [key]: normalized
+  });
+  return { value: normalized };
+}
+
+// src/actions/handlers.ts
+var DETERMINISTIC_COMMAND_KEYS = [
+  "help",
+  "commands",
+  "status",
+  "whoami",
+  "context",
+  "reset",
+  "new",
+  "compact",
+  "models",
+  "usage",
+  "think",
+  "verbose",
+  "reasoning",
+  "queue",
+  "elevated",
+  "model",
+  "tts"
+];
+var DETERMINISTIC_KEYS = new Set(DETERMINISTIC_COMMAND_KEYS);
+function isDeterministicCommand(key) {
+  return DETERMINISTIC_KEYS.has(key);
+}
+var CATEGORY_ORDER = [
+  "status",
+  "session",
+  "options",
+  "media",
+  "management",
+  "tools",
+  "docks",
+  "skills"
+];
+var OPTION_COMMANDS = {
+  think: { key: "thinking", label: "Thinking" },
+  verbose: { key: "verbose", label: "Verbose" },
+  reasoning: { key: "reasoning", label: "Reasoning" },
+  queue: { key: "queue", label: "Queue mode" },
+  elevated: { key: "elevated", label: "Elevated mode" },
+  model: { key: "model", label: "Model" },
+  tts: { key: "tts", label: "TTS" }
+};
+function reply(text) {
+  return { handled: true, reply: text, shouldContinue: false };
+}
+function authError() {
+  return reply("This command requires authorization.");
+}
+function formatCommandList(agentId) {
+  const lines = [];
+  for (const category of CATEGORY_ORDER) {
+    const commands = getCommandsByCategoryForRuntime(category, agentId);
+    if (commands.length === 0)
+      continue;
+    lines.push(`**${category}**`);
+    for (const command of commands) {
+      const alias = command.textAliases[0] ?? `/${command.key}`;
+      const auth = command.requiresAuth ? " (requires auth)" : "";
+      lines.push(`  ${alias} — ${command.description}${auth}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function resolveModelLabel(runtime) {
+  const fromSetting = runtime.getSetting("LARGE_MODEL") ?? runtime.getSetting("ANTHROPIC_LARGE_MODEL") ?? runtime.getSetting("OPENAI_LARGE_MODEL");
+  if (typeof fromSetting === "string" && fromSetting.trim()) {
+    return fromSetting.trim();
+  }
+  const fromCharacter = runtime.character?.settings?.model;
+  if (typeof fromCharacter === "string" && fromCharacter.trim()) {
+    return fromCharacter.trim();
+  }
+  return "default";
+}
+async function countRoomMessages(runtime, roomId) {
+  if (typeof runtime.countMemories !== "function")
+    return null;
+  try {
+    return await runtime.countMemories({
+      roomIds: [roomId],
+      tableName: "messages",
+      unique: false
+    });
+  } catch {
+    return null;
+  }
+}
+async function clearRoomMessages(runtime, roomId) {
+  const before = await countRoomMessages(runtime, roomId);
+  if (typeof runtime.deleteAllMemories !== "function")
+    return null;
+  await runtime.deleteAllMemories([roomId], "messages");
+  return before;
+}
+function findAction(runtime, name) {
+  return runtime.actions?.find((action) => action.name === name);
+}
+async function runCompactAction(runtime, message, callback) {
+  const action = findAction(runtime, "COMPACT_CONVERSATION");
+  if (!action || !message) {
+    return reply("Conversation compaction is not available in this runtime.");
+  }
+  const result = await action.handler(runtime, message, undefined, undefined, callback);
+  if (result?.text && result.text.trim().length > 0)
+    return reply(result.text);
+  return reply("Conversation compaction completed.");
+}
+async function setOptionCommand(runtime, roomId, parsed, option) {
+  const rawValue = parsed.rawArgs?.trim() ?? parsed.args[0]?.trim() ?? "";
+  if (!rawValue) {
+    const settings = await getCommandSettings(runtime, roomId);
+    const current = option.key === "model" ? settings.model ?? resolveModelLabel(runtime) : settings[option.key] ?? "default";
+    return reply(`${option.label} is ${current}.`);
+  }
+  const result = await setCommandSetting(runtime, roomId, option.key, rawValue);
+  if ("error" in result)
+    return reply(result.error);
+  return reply(`${option.label} set to ${result.value}.`);
+}
+async function runCommand(runtime, parsed, context) {
+  const agentId = runtime.agentId;
+  useRuntime(agentId);
+  const definition = findCommandByKeyForRuntime(parsed.key, agentId);
+  if (definition?.requiresAuth && !context.isAuthorized)
+    return authError();
+  if (definition?.requiresElevated && !context.isElevated) {
+    return reply("This command requires elevated permissions.");
+  }
+  const roomId = context.roomId;
+  switch (parsed.key) {
+    case "help":
+    case "commands":
+      return reply(`Available commands:
+${formatCommandList(agentId)}`);
+    case "status": {
+      const settings = await getCommandSettings(runtime, roomId);
+      const messageCount = await countRoomMessages(runtime, roomId);
+      const lines = [
+        `Agent: ${runtime.character?.name ?? runtime.agentId}`,
+        `Model: ${settings.model ?? resolveModelLabel(runtime)}`,
+        `Thinking: ${settings.thinking ?? "default"}`,
+        `Reasoning: ${settings.reasoning ?? "default"}`,
+        `Verbose: ${settings.verbose ?? "default"}`,
+        `Queue: ${settings.queue ?? "default"}`,
+        `TTS: ${settings.tts ?? "default"}`,
+        messageCount === null ? null : `Messages: ${messageCount}`,
+        `Commands enabled: ${getEnabledCommandsForRuntime(agentId).length}`
+      ].filter(Boolean);
+      return reply(lines.join(`
+`));
+    }
+    case "whoami": {
+      const who = context.senderName ?? context.senderId ?? "you";
+      return reply(`You are ${who}.
+Authorized: ${context.isAuthorized ? "yes" : "no"}
+Elevated: ${context.isElevated ? "yes" : "no"}`);
+    }
+    case "context": {
+      const settings = await getCommandSettings(runtime, roomId);
+      const lines = [
+        `Room: ${roomId}`,
+        context.channelId ? `Channel: ${context.channelId}` : null,
+        `Active settings: ${describeSettings(settings)}`
+      ].filter(Boolean);
+      return reply(lines.join(`
+`));
+    }
+    case "models":
+      return reply(`Current model: ${resolveModelLabel(runtime)}`);
+    case "usage": {
+      const usage = await runtime.getCache(`token-usage:${roomId}`);
+      if (!usage?.totalTokens) {
+        return reply("No token usage recorded for this conversation yet.");
+      }
+      return reply(`Token usage — prompt: ${usage.promptTokens ?? 0}, completion: ${usage.completionTokens ?? 0}, total: ${usage.totalTokens}.`);
+    }
+    case "think":
+    case "verbose":
+    case "reasoning":
+    case "queue":
+    case "elevated":
+    case "model":
+    case "tts":
+      return setOptionCommand(runtime, roomId, parsed, OPTION_COMMANDS[parsed.key]);
+    case "reset": {
+      await clearCommandSettings(runtime, roomId);
+      const deleted = await clearRoomMessages(runtime, roomId);
+      if (deleted === null) {
+        return reply("Reset command settings for this room. Message history is unchanged because memory deletion is unavailable.");
+      }
+      return reply(`Reset this room: cleared command settings and ${deleted} message(s).`);
+    }
+    case "new":
+      await clearCommandSettings(runtime, roomId);
+      return reply("Started a new conversation context for this room.");
+    case "compact":
+      return runCompactAction(runtime, context.message, context.callback);
+    default:
+      return { handled: false, shouldContinue: true };
+  }
+}
+function describeSettings(settings) {
+  const entries = Object.entries(settings).filter(([, v]) => v);
+  if (entries.length === 0)
+    return "none";
+  return entries.map(([k, v]) => `${k}=${v}`).join(", ");
+}
+
+// src/actions/dispatch.ts
+function buildContext(message, options) {
+  const content = message.content;
+  const context = {
+    senderId: message.entityId,
+    isAuthorized: options.isAuthorized ?? false,
+    isElevated: options.isElevated ?? false,
+    roomId: message.roomId,
+    message
+  };
+  if (options.senderName)
+    context.senderName = options.senderName;
+  if (options.callback)
+    context.callback = options.callback;
+  const channelId = content.channelId ?? content.source;
+  if (channelId)
+    context.channelId = channelId;
+  return context;
+}
+async function resolveCommand(runtime, message, options = {}) {
+  const text = message.content.text ?? "";
+  if (!hasCommand(text))
+    return { handled: false };
+  const detection = detectCommand(text);
+  if (!detection.isCommand || !detection.command)
+    return { handled: false };
+  const parsed = detection.command;
+  const definition = findCommandByKeyForRuntime(parsed.key, runtime.agentId);
+  if (definition?.target && definition.target.kind !== "agent") {
+    return { handled: false, command: parsed };
+  }
+  const deterministicOnly = options.deterministicOnly ?? options.gateSafeOnly ?? true;
+  if (deterministicOnly && !isDeterministicCommand(parsed.key)) {
+    return { handled: false, command: parsed };
+  }
+  const result = await runCommand(runtime, parsed, buildContext(message, options));
+  if (!result.handled)
+    return { handled: false, command: parsed };
+  const dispatched = { handled: true, command: parsed };
+  if (result.reply !== undefined)
+    dispatched.reply = result.reply;
+  return dispatched;
+}
+async function dispatchCommandMessage(runtime, message, callback, options = {}) {
+  const result = await resolveCommand(runtime, message, options);
+  if (!result.handled || result.reply === undefined)
+    return false;
+  await callback({ text: result.reply, source: "command" });
+  return true;
+}
+
+// src/actions/command-actions.ts
+var OWNER_SOURCES = new Set([
+  "client_chat",
+  "gui",
+  "tui",
+  "direct",
+  "dashboard"
+]);
+function resolveTrust(message) {
+  const source = message.content.source;
+  const trusted = !source || OWNER_SOURCES.has(source);
+  return { isAuthorized: trusted, isElevated: trusted };
+}
+function buildAction(key, _nativeName, description, aliases) {
+  return {
+    name: `${key.toUpperCase()}_COMMAND`,
+    description,
+    similes: aliases,
+    suppressEarlyReply: true,
+    suppressPostActionContinuation: true,
+    validate: async (_runtime, message) => {
+      const text = message.content.text ?? "";
+      if (!hasCommand(text))
+        return false;
+      const detection = detectCommand(text);
+      return detection.isCommand && detection.command?.key === key;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+      const result = await resolveCommand(runtime, message, {
+        ...resolveTrust(message),
+        deterministicOnly: true,
+        ...callback ? { callback } : {}
+      });
+      if (!result.handled || result.reply === undefined) {
+        return { success: false };
+      }
+      if (callback) {
+        await callback({ text: result.reply, source: "command" });
+      }
+      return { success: true, text: result.reply };
+    }
+  };
+}
+function createCommandActions(commandKeys) {
+  const actions = [];
+  for (const key of commandKeys) {
+    if (!isDeterministicCommand(key))
+      continue;
+    const definition = findCommandByKey(key);
+    if (!definition)
+      continue;
+    if (definition.target && definition.target.kind !== "agent")
+      continue;
+    actions.push(buildAction(key, definition.nativeName ?? key, definition.description, definition.textAliases));
+  }
+  return actions;
+}
+// src/actions/shortcuts.ts
+function createCommandShortcuts(commandKeys = DETERMINISTIC_COMMAND_KEYS) {
+  const shortcuts = [];
+  for (const key of commandKeys) {
+    const definition = findCommandByKey(key);
+    if (!definition)
+      continue;
+    if (definition.target && definition.target.kind !== "agent")
+      continue;
+    shortcuts.push({
+      id: `cmd:${key}`,
+      kind: "explicit",
+      aliases: definition.textAliases,
+      target: { kind: "action", name: `${key.toUpperCase()}_COMMAND` }
+    });
+  }
+  return shortcuts;
+}
+var explicitCommandShortcuts = createCommandShortcuts();
+var naturalShortcuts = [
+  {
+    id: "nl:commands",
+    kind: "natural",
+    patterns: [
+      {
+        regex: /^what commands (?:can i (?:use|run)|are (?:there|available)|do you (?:have|support))$/u
+      },
+      {
+        regex: /^(?:show|list|give|tell)(?: me)?(?: a list of| the list of| all(?: of)?| the| your| available)* commands$/u
+      },
+      { regex: /^what are(?: all)?(?: the| your| available)* commands$/u }
+    ],
+    target: { kind: "action", name: "COMMANDS_COMMAND" },
+    requiresAction: "COMMANDS_COMMAND",
+    confidence: 0.95
+  }
+];
+var commandShortcuts = [
+  ...explicitCommandShortcuts,
+  ...naturalShortcuts
+];
+
+// src/actions/index.ts
+var commandActions = createCommandActions([
+  ...DETERMINISTIC_COMMAND_KEYS
+]);
+// src/connector-bridge.ts
+function resolveConnectorCommandAuth(agentId, name) {
+  const definition = findCommandByKeyForRuntime(name, agentId);
+  return {
+    requiresAuth: definition?.requiresAuth ?? false,
+    requiresElevated: definition?.requiresElevated ?? false
+  };
+}
+function gateConnectorCommand(requirements, sender) {
+  if (requirements.requiresAuth && !sender.isAuthorized) {
+    return {
+      allowed: false,
+      reply: "This command requires authorization. Pair your account or ask an owner to run it."
+    };
+  }
+  if (requirements.requiresElevated && !sender.isElevated) {
+    return {
+      allowed: false,
+      reply: "This command requires elevated permissions."
+    };
+  }
+  return { allowed: true };
+}
+function gateConnectorCommandByName(agentId, name, sender) {
+  return gateConnectorCommand(resolveConnectorCommandAuth(agentId, name), sender);
+}
+// src/settings-sections.ts
+var SETTINGS_SECTIONS = [
+  {
+    id: "ai-model",
+    label: "AI Model & Providers",
+    aliases: ["model", "models", "providers", "provider", "llm"]
+  },
+  { id: "general", label: "General", aliases: ["basics"] },
+  { id: "agent", label: "Agent", aliases: ["character", "persona"] },
+  { id: "voice", label: "Voice", aliases: ["audio", "tts", "speech"] },
+  { id: "connectors", label: "Connectors", aliases: ["integrations"] },
+  { id: "skills", label: "Skills" },
+  { id: "memory", label: "Memory", aliases: ["knowledge"] },
+  { id: "permissions", label: "Permissions", aliases: ["security", "access"] },
+  { id: "billing", label: "Billing", aliases: ["plan", "subscription"] },
+  { id: "appearance", label: "Appearance", aliases: ["theme", "display"] },
+  { id: "notifications", label: "Notifications", aliases: ["alerts"] },
+  { id: "advanced", label: "Advanced", aliases: ["developer", "debug"] }
+];
+var lookup = null;
+function getLookup() {
+  if (lookup)
+    return lookup;
+  const map = new Map;
+  for (const section of SETTINGS_SECTIONS) {
+    map.set(section.id, section);
+    for (const alias of section.aliases ?? []) {
+      map.set(alias, section);
+    }
+  }
+  lookup = map;
+  return map;
+}
+function getSettingsSections() {
+  return [...SETTINGS_SECTIONS];
+}
+function getSettingsSectionChoices() {
+  return SETTINGS_SECTIONS.map((section) => section.id);
+}
+function resolveSettingsSection(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized)
+    return;
+  return getLookup().get(normalized)?.id;
+}
+
+// src/navigation-commands.ts
+var IN_APP_SURFACES = ["gui", "tui"];
+var NAVIGATE_COMMANDS = [
+  {
+    key: "settings",
+    nativeName: "settings",
+    description: "Open agent settings",
+    textAliases: ["/settings"],
+    scope: "both",
+    category: "docks",
+    icon: "settings",
+    target: { kind: "navigate", path: "/settings", tab: "settings" },
+    acceptsArgs: true,
+    args: [
+      {
+        name: "section",
+        description: "Settings section to open",
+        required: false,
+        choices: getSettingsSectionChoices(),
+        dynamicChoices: "settings-sections"
+      }
+    ]
+  },
+  {
+    key: "chat",
+    nativeName: "chat",
+    description: "Return to the chat",
+    textAliases: ["/chat"],
+    scope: "both",
+    category: "docks",
+    icon: "message-circle",
+    target: { kind: "navigate", path: "/chat", tab: "chat" }
+  },
+  {
+    key: "views",
+    nativeName: "views",
+    description: "Open the agent's views",
+    textAliases: ["/views"],
+    scope: "both",
+    category: "docks",
+    icon: "layout-grid",
+    target: { kind: "navigate", path: "/views", tab: "views" },
+    acceptsArgs: true,
+    args: [
+      {
+        name: "view",
+        description: "View to open",
+        required: false,
+        dynamicChoices: "views"
+      }
+    ]
+  },
+  {
+    key: "orchestrator",
+    nativeName: "orchestrator",
+    description: "Open the agent orchestrator",
+    textAliases: ["/orchestrator"],
+    scope: "both",
+    category: "docks",
+    icon: "workflow",
+    target: { kind: "navigate", path: "/orchestrator", viewId: "orchestrator" }
+  },
+  {
+    key: "character",
+    nativeName: "character",
+    description: "Open the character editor",
+    textAliases: ["/character"],
+    scope: "both",
+    category: "docks",
+    icon: "user",
+    target: { kind: "navigate", path: "/character", tab: "character" }
+  },
+  {
+    key: "knowledge",
+    nativeName: "knowledge",
+    description: "Open the knowledge base",
+    textAliases: ["/knowledge"],
+    scope: "both",
+    category: "docks",
+    icon: "book-open",
+    target: {
+      kind: "navigate",
+      path: "/character/documents",
+      tab: "documents"
+    }
+  },
+  {
+    key: "wallet",
+    nativeName: "wallet",
+    description: "Open the wallet & inventory",
+    textAliases: ["/wallet"],
+    scope: "both",
+    category: "docks",
+    icon: "wallet",
+    target: { kind: "navigate", path: "/wallet", tab: "inventory" }
+  },
+  {
+    key: "automations",
+    nativeName: "automations",
+    description: "Open automations",
+    textAliases: ["/automations"],
+    scope: "both",
+    category: "docks",
+    icon: "zap",
+    target: { kind: "navigate", path: "/automations", tab: "automations" }
+  },
+  {
+    key: "tasks",
+    nativeName: "tasks",
+    description: "Open tasks",
+    textAliases: ["/tasks"],
+    scope: "both",
+    category: "docks",
+    icon: "check-square",
+    target: { kind: "navigate", path: "/apps/tasks", tab: "tasks" }
+  },
+  {
+    key: "skills",
+    nativeName: "skills",
+    description: "Open the skills library",
+    textAliases: ["/skills"],
+    scope: "both",
+    category: "docks",
+    icon: "sparkles",
+    target: { kind: "navigate", path: "/apps/skills", tab: "skills" }
+  },
+  {
+    key: "plugins",
+    nativeName: "plugins",
+    description: "Open installed plugins",
+    textAliases: ["/plugins"],
+    scope: "both",
+    category: "docks",
+    icon: "plug",
+    target: { kind: "navigate", path: "/apps/plugins", tab: "plugins" }
+  },
+  {
+    key: "logs",
+    nativeName: "logs",
+    description: "Open the logs",
+    textAliases: ["/logs"],
+    scope: "both",
+    category: "docks",
+    icon: "scroll-text",
+    target: { kind: "navigate", path: "/apps/logs", tab: "logs" }
+  },
+  {
+    key: "database",
+    nativeName: "database",
+    description: "Open the database browser",
+    textAliases: ["/database"],
+    scope: "both",
+    category: "docks",
+    icon: "database",
+    target: { kind: "navigate", path: "/apps/database", tab: "database" }
+  }
+];
+var CLIENT_COMMANDS = [
+  {
+    key: "clear",
+    nativeName: "clear",
+    description: "Clear the current chat",
+    textAliases: ["/clear"],
+    scope: "both",
+    category: "docks",
+    icon: "eraser",
+    surfaces: IN_APP_SURFACES,
+    target: { kind: "client", clientAction: "clear-chat" }
+  },
+  {
+    key: "fullscreen",
+    nativeName: "fullscreen",
+    description: "Toggle full-screen chat",
+    textAliases: ["/fullscreen"],
+    scope: "both",
+    category: "docks",
+    icon: "maximize",
+    surfaces: IN_APP_SURFACES,
+    target: { kind: "client", clientAction: "toggle-fullscreen" }
+  },
+  {
+    key: "transcribe",
+    nativeName: "transcribe",
+    description: "Toggle long-form transcription mode (record-only; agent stays silent until an exit phrase)",
+    textAliases: ["/transcribe"],
+    scope: "both",
+    category: "docks",
+    icon: "mic",
+    surfaces: IN_APP_SURFACES,
+    target: { kind: "client", clientAction: "toggle-transcription" }
+  }
+];
+var VIEW_SCOPED_COMMANDS = [
+  {
+    key: "calendar-add",
+    nativeName: "calendar-add",
+    description: "Add a calendar event (in the calendar view)",
+    textAliases: ["/calendar-add"],
+    scope: "both",
+    category: "docks",
+    icon: "calendar-plus",
+    surfaces: IN_APP_SURFACES,
+    views: ["calendar"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [{ name: "event", description: "What to schedule", required: false }]
+  },
+  {
+    key: "todos-add",
+    nativeName: "todos-add",
+    description: "Add a to-do (in the todos view)",
+    textAliases: ["/todos-add"],
+    scope: "both",
+    category: "docks",
+    icon: "list-plus",
+    surfaces: IN_APP_SURFACES,
+    views: ["todos"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [{ name: "task", description: "What to do", required: false }]
+  },
+  {
+    key: "todos-done",
+    nativeName: "todos-done",
+    description: "Complete a to-do (in the todos view)",
+    textAliases: ["/todos-done"],
+    scope: "both",
+    category: "docks",
+    icon: "check",
+    surfaces: IN_APP_SURFACES,
+    views: ["todos"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [
+      { name: "task", description: "Which to-do to complete", required: false }
+    ]
+  },
+  {
+    key: "documents-search",
+    nativeName: "documents-search",
+    description: "Search the knowledge base (in the documents view)",
+    textAliases: ["/documents-search"],
+    scope: "both",
+    category: "docks",
+    icon: "search",
+    surfaces: IN_APP_SURFACES,
+    views: ["documents"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [
+      { name: "query", description: "What to search for", required: false }
+    ]
+  }
+];
+function navigationCommandDefinitions() {
+  return [...NAVIGATE_COMMANDS, ...CLIENT_COMMANDS, ...VIEW_SCOPED_COMMANDS];
+}
+
+// src/serialize.ts
+var DEFAULT_TARGET = { kind: "agent" };
+function commandVisibleForSurface(surfaces, surface) {
+  if (!surface)
+    return true;
+  if (!surfaces || surfaces.length === 0)
+    return true;
+  return surfaces.includes(surface);
+}
+function serializeArg(arg) {
+  const serialized = {
+    name: arg.name,
+    description: arg.description
+  };
+  if (arg.required)
+    serialized.required = true;
+  if (arg.captureRemaining)
+    serialized.captureRemaining = true;
+  if (arg.dynamicChoices)
+    serialized.dynamicChoices = arg.dynamicChoices;
+  if (Array.isArray(arg.choices) && arg.choices.length > 0) {
+    serialized.choices = arg.choices;
+  }
+  return serialized;
+}
+function serializeCommand(command, options = {}) {
+  const args = (command.args ?? []).map(serializeArg);
+  const serialized = {
+    key: command.key,
+    nativeName: command.nativeName ?? command.key,
+    description: command.description,
+    textAliases: command.textAliases,
+    scope: command.scope,
+    acceptsArgs: command.acceptsArgs ?? args.length > 0,
+    args,
+    requiresAuth: command.requiresAuth ?? false,
+    requiresElevated: command.requiresElevated ?? false,
+    target: command.target ?? DEFAULT_TARGET,
+    source: options.source ?? "builtin"
+  };
+  if (command.category)
+    serialized.category = command.category;
+  if (command.surfaces && command.surfaces.length > 0) {
+    serialized.surfaces = command.surfaces;
+  }
+  if (command.icon)
+    serialized.icon = command.icon;
+  if (command.views && command.views.length > 0) {
+    serialized.views = command.views;
+  }
+  return serialized;
+}
+
+// src/connector-catalog.ts
+var KNOWN_SURFACES = new Set([
+  "gui",
+  "tui",
+  "discord",
+  "telegram"
+]);
+function commandVisibleForView(views, activeViewId) {
+  if (!views || views.length === 0)
+    return true;
+  if (!activeViewId)
+    return false;
+  return views.includes(activeViewId);
+}
+function isConnectorScoped(command) {
+  return command.scope !== "text";
+}
+function commandName(command) {
+  return command.nativeName ?? command.key;
+}
+function unifiedDefinitions(agentId) {
+  const agentCommands = agentId ? getEnabledCommandsForRuntime(agentId) : DEFAULT_COMMANDS.filter((command) => command.enabled !== false);
+  const agent = agentCommands.filter(isConnectorScoped);
+  const navigation = navigationCommandDefinitions();
+  const navigationNames = new Set(navigation.map(commandName));
+  const agentOnly = agent.filter((command) => !navigationNames.has(commandName(command)));
+  return [...agentOnly, ...navigation];
+}
+function normalizeSurface(surface) {
+  return KNOWN_SURFACES.has(surface) ? surface : null;
+}
+function visibleDefinitions(surface, activeViewId, agentId) {
+  const normalized = normalizeSurface(surface);
+  return unifiedDefinitions(agentId).filter((command) => commandVisibleForSurface(command.surfaces, normalized)).filter((command) => commandVisibleForView(command.views, activeViewId));
+}
+function mapDefinitionArg(arg) {
+  return {
+    name: arg.name,
+    description: arg.description,
+    required: arg.required ?? false,
+    choices: Array.isArray(arg.choices) ? arg.choices : []
+  };
+}
+function toConnectorCommand(command) {
+  return {
+    name: commandName(command),
+    description: command.description,
+    target: command.target ?? { kind: "agent" },
+    options: (command.args ?? []).map(mapDefinitionArg),
+    ...command.views && command.views.length > 0 ? { views: command.views } : {}
+  };
+}
+function getConnectorCommands(surface, options = {}) {
+  return visibleDefinitions(surface, options.activeViewId, options.agentId).map(toConnectorCommand);
+}
+function getCatalogCommands(surface, options = {}) {
+  return visibleDefinitions(surface, options.activeViewId, options.agentId).map((command) => serializeCommand(command, options.source ? { source: options.source } : {}));
+}
+
+// src/index.ts
+var commandRegistryProvider = {
+  name: "COMMAND_REGISTRY",
+  description: "Available chat commands and their descriptions",
+  descriptionCompressed: "Available chat commands and descriptions.",
+  dynamic: true,
+  contexts: ["general", "automation"],
+  contextGate: { anyOf: ["general", "automation"] },
+  cacheStable: true,
+  cacheScope: "agent",
+  async get(runtime, message, _state) {
+    const text = message.content.text ?? "";
+    const isCommand = hasCommand(text);
+    const commands = getEnabledCommandsForRuntime(runtime.agentId);
+    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: commandActions,
+  shortcuts: commandShortcuts,
+  autoEnable: {
+    shouldEnable: (_env, config) => {
+      const f = config.features?.commands;
+      return f === true || typeof f === "object" && f !== null && f.enabled !== false;
+    }
+  },
+  config: {
+    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_core.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_core.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_core.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_core.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_core.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_core.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_core.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_core.logger.success("Command categorization works correctly");
+          }
+        }
+      ]
+    }
+  ],
+  async init(config, runtime) {
+    import_core.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_core.logger.log(`[plugin-commands] ${enabledCount} commands enabled for agent ${runtime.agentId}`);
+  }
+};
+var src_default = commandsPlugin;
+
+//# debugId=D816A7531DE8F68364756E2164756E21