@elizaos/plugin-directives 1.0.0

package/dist/cjs/index.cjs

@@ -0,0 +1,696 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  setDirectiveState: () => setDirectiveState,
+  parseDirectives: () => parseDirectives,
+  normalizeVerboseLevel: () => normalizeVerboseLevel,
+  normalizeThinkLevel: () => normalizeThinkLevel,
+  normalizeReasoningLevel: () => normalizeReasoningLevel,
+  normalizeExecSecurity: () => normalizeExecSecurity,
+  normalizeExecHost: () => normalizeExecHost,
+  normalizeExecAsk: () => normalizeExecAsk,
+  normalizeElevatedLevel: () => normalizeElevatedLevel,
+  getDirectiveState: () => getDirectiveState,
+  formatDirectiveState: () => formatDirectiveState,
+  formatDirectiveAcknowledgment: () => formatDirectiveAcknowledgment,
+  extractVerboseDirective: () => extractVerboseDirective,
+  extractThinkDirective: () => extractThinkDirective,
+  extractStatusDirective: () => extractStatusDirective,
+  extractReasoningDirective: () => extractReasoningDirective,
+  extractModelDirective: () => extractModelDirective,
+  extractExecDirective: () => extractExecDirective,
+  extractElevatedDirective: () => extractElevatedDirective,
+  directivesPlugin: () => directivesPlugin,
+  directiveStateProvider: () => directiveStateProvider,
+  default: () => src_default,
+  clearDirectiveState: () => clearDirectiveState,
+  applyDirectives: () => applyDirectives
+});
+module.exports = __toCommonJS(exports_src);
+var import_core = require("@elizaos/core");
+
+// src/parsers.ts
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function matchLevelDirective(body, names) {
+  const namePattern = names.map(escapeRegExp).join("|");
+  const match = body.match(new RegExp(`(?:^|\\s)\\/(?:${namePattern})(?=$|\\s|:)`, "i"));
+  if (!match || match.index === undefined) {
+    return null;
+  }
+  const start = match.index;
+  let end = match.index + match[0].length;
+  let i = end;
+  while (i < body.length && /\s/.test(body[i])) {
+    i += 1;
+  }
+  if (body[i] === ":") {
+    i += 1;
+    while (i < body.length && /\s/.test(body[i])) {
+      i += 1;
+    }
+  }
+  const argStart = i;
+  while (i < body.length && /[A-Za-z0-9-]/.test(body[i])) {
+    i += 1;
+  }
+  const rawLevel = i > argStart ? body.slice(argStart, i) : undefined;
+  end = i;
+  return { start, end, rawLevel };
+}
+function extractLevelDirective(body, names, normalize) {
+  const match = matchLevelDirective(body, names);
+  if (!match) {
+    return { cleaned: body.trim(), hasDirective: false };
+  }
+  const rawLevel = match.rawLevel;
+  const level = normalize(rawLevel);
+  const cleaned = body.slice(0, match.start).concat(" ").concat(body.slice(match.end)).replace(/\s+/g, " ").trim();
+  return {
+    cleaned,
+    level,
+    rawLevel,
+    hasDirective: true
+  };
+}
+function extractSimpleDirective(body, names) {
+  const namePattern = names.map(escapeRegExp).join("|");
+  const match = body.match(new RegExp(`(?:^|\\s)\\/(?:${namePattern})(?=$|\\s|:)(?:\\s*:\\s*)?`, "i"));
+  const cleaned = match ? body.replace(match[0], " ").replace(/\s+/g, " ").trim() : body.trim();
+  return {
+    cleaned,
+    hasDirective: Boolean(match)
+  };
+}
+function normalizeThinkLevel(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if (["off"].includes(key))
+    return "off";
+  if (["on", "enable", "enabled"].includes(key))
+    return "low";
+  if (["min", "minimal"].includes(key))
+    return "minimal";
+  if (["low", "thinkhard", "think-hard", "think_hard"].includes(key))
+    return "low";
+  if (["mid", "med", "medium", "thinkharder", "think-harder", "harder"].includes(key))
+    return "medium";
+  if ([
+    "high",
+    "ultra",
+    "ultrathink",
+    "think-hard",
+    "thinkhardest",
+    "highest",
+    "max"
+  ].includes(key))
+    return "high";
+  if (["xhigh", "x-high", "x_high"].includes(key))
+    return "xhigh";
+  if (["think"].includes(key))
+    return "minimal";
+  return;
+}
+function normalizeVerboseLevel(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if (["off", "false", "no", "0"].includes(key))
+    return "off";
+  if (["full", "all", "everything"].includes(key))
+    return "full";
+  if (["on", "minimal", "true", "yes", "1"].includes(key))
+    return "on";
+  return;
+}
+function normalizeReasoningLevel(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if ([
+    "off",
+    "false",
+    "no",
+    "0",
+    "hide",
+    "hidden",
+    "disable",
+    "disabled"
+  ].includes(key))
+    return "off";
+  if (["on", "true", "yes", "1", "show", "visible", "enable", "enabled"].includes(key))
+    return "on";
+  if (["stream", "streaming", "draft", "live"].includes(key))
+    return "stream";
+  return;
+}
+function normalizeElevatedLevel(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if (["off", "false", "no", "0"].includes(key))
+    return "off";
+  if (["full", "auto", "auto-approve", "autoapprove"].includes(key))
+    return "full";
+  if (["ask", "prompt", "approval", "approve"].includes(key))
+    return "ask";
+  if (["on", "true", "yes", "1"].includes(key))
+    return "on";
+  return;
+}
+function normalizeExecHost(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if (["sandbox", "sb"].includes(key))
+    return "sandbox";
+  if (["gateway", "gw", "local"].includes(key))
+    return "gateway";
+  if (["node", "remote"].includes(key))
+    return "node";
+  return;
+}
+function normalizeExecSecurity(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if (["deny", "none", "off"].includes(key))
+    return "deny";
+  if (["allowlist", "allow", "list"].includes(key))
+    return "allowlist";
+  if (["full", "all", "any"].includes(key))
+    return "full";
+  return;
+}
+function normalizeExecAsk(raw) {
+  if (!raw)
+    return;
+  const key = raw.toLowerCase();
+  if (["off", "never", "no"].includes(key))
+    return "off";
+  if (["on-miss", "miss", "fallback"].includes(key))
+    return "on-miss";
+  if (["always", "on", "yes"].includes(key))
+    return "always";
+  return;
+}
+function extractThinkDirective(body) {
+  if (!body)
+    return { cleaned: "", hasDirective: false };
+  const extracted = extractLevelDirective(body, ["thinking", "think", "t"], normalizeThinkLevel);
+  return {
+    cleaned: extracted.cleaned,
+    thinkLevel: extracted.level,
+    rawLevel: extracted.rawLevel,
+    hasDirective: extracted.hasDirective
+  };
+}
+function extractVerboseDirective(body) {
+  if (!body)
+    return { cleaned: "", hasDirective: false };
+  const extracted = extractLevelDirective(body, ["verbose", "v"], normalizeVerboseLevel);
+  return {
+    cleaned: extracted.cleaned,
+    verboseLevel: extracted.level,
+    rawLevel: extracted.rawLevel,
+    hasDirective: extracted.hasDirective
+  };
+}
+function extractReasoningDirective(body) {
+  if (!body)
+    return { cleaned: "", hasDirective: false };
+  const extracted = extractLevelDirective(body, ["reasoning", "reason"], normalizeReasoningLevel);
+  return {
+    cleaned: extracted.cleaned,
+    reasoningLevel: extracted.level,
+    rawLevel: extracted.rawLevel,
+    hasDirective: extracted.hasDirective
+  };
+}
+function extractElevatedDirective(body) {
+  if (!body)
+    return { cleaned: "", hasDirective: false };
+  const extracted = extractLevelDirective(body, ["elevated", "elev"], normalizeElevatedLevel);
+  return {
+    cleaned: extracted.cleaned,
+    elevatedLevel: extracted.level,
+    rawLevel: extracted.rawLevel,
+    hasDirective: extracted.hasDirective
+  };
+}
+function extractStatusDirective(body) {
+  if (!body)
+    return { cleaned: "", hasDirective: false };
+  return extractSimpleDirective(body, ["status"]);
+}
+function extractModelDirective(body, options) {
+  if (!body)
+    return { cleaned: "", hasDirective: false };
+  const modelMatch = body.match(/(?:^|\s)\/model(?:\s*:\s*|\s+)([a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9._-]+)?(?:@[a-zA-Z0-9_-]+)?)/i);
+  if (modelMatch) {
+    const fullMatch = modelMatch[1];
+    const atIndex = fullMatch.indexOf("@");
+    const rawModel = atIndex >= 0 ? fullMatch.slice(0, atIndex) : fullMatch;
+    const rawProfile = atIndex >= 0 ? fullMatch.slice(atIndex + 1) : undefined;
+    const cleaned = body.replace(modelMatch[0], " ").replace(/\s+/g, " ").trim();
+    return { cleaned, rawModel, rawProfile, hasDirective: true };
+  }
+  const simpleMatch = body.match(/(?:^|\s)\/model(?=$|\s|:)/i);
+  if (simpleMatch) {
+    const cleaned = body.replace(simpleMatch[0], " ").replace(/\s+/g, " ").trim();
+    return { cleaned, hasDirective: true };
+  }
+  if (options?.aliases?.length) {
+    for (const alias of options.aliases) {
+      const aliasPattern = new RegExp(`(?:^|\\s)/${escapeRegExp(alias)}(?=$|\\s)`, "i");
+      const aliasMatch = body.match(aliasPattern);
+      if (aliasMatch) {
+        const cleaned = body.replace(aliasMatch[0], " ").replace(/\s+/g, " ").trim();
+        return { cleaned, rawModel: alias, hasDirective: true };
+      }
+    }
+  }
+  return { cleaned: body.trim(), hasDirective: false };
+}
+function extractExecDirective(body) {
+  if (!body) {
+    return {
+      cleaned: "",
+      hasExecOptions: false,
+      invalidHost: false,
+      invalidSecurity: false,
+      invalidAsk: false,
+      invalidNode: false,
+      hasDirective: false
+    };
+  }
+  const execMatch = body.match(/(?:^|\s)\/exec(?:\s+([^\/\n]+))?(?=$|\s|\/)/i);
+  if (!execMatch) {
+    return {
+      cleaned: body.trim(),
+      hasExecOptions: false,
+      invalidHost: false,
+      invalidSecurity: false,
+      invalidAsk: false,
+      invalidNode: false,
+      hasDirective: false
+    };
+  }
+  const args = execMatch[1]?.trim() ?? "";
+  const cleaned = body.replace(execMatch[0], " ").replace(/\s+/g, " ").trim();
+  let rawExecHost;
+  let rawExecSecurity;
+  let rawExecAsk;
+  let rawExecNode;
+  const kvPattern = /(\w+)\s*=\s*([^\s]+)/g;
+  let match;
+  while ((match = kvPattern.exec(args)) !== null) {
+    const key = match[1].toLowerCase();
+    const value = match[2];
+    if (key === "host")
+      rawExecHost = value;
+    else if (key === "security")
+      rawExecSecurity = value;
+    else if (key === "ask")
+      rawExecAsk = value;
+    else if (key === "node")
+      rawExecNode = value;
+  }
+  const execHost = normalizeExecHost(rawExecHost);
+  const execSecurity = normalizeExecSecurity(rawExecSecurity);
+  const execAsk = normalizeExecAsk(rawExecAsk);
+  return {
+    cleaned,
+    execHost,
+    execSecurity,
+    execAsk,
+    execNode: rawExecNode,
+    rawExecHost,
+    rawExecSecurity,
+    rawExecAsk,
+    rawExecNode,
+    hasExecOptions: Boolean(rawExecHost || rawExecSecurity || rawExecAsk || rawExecNode),
+    invalidHost: Boolean(rawExecHost && !execHost),
+    invalidSecurity: Boolean(rawExecSecurity && !execSecurity),
+    invalidAsk: Boolean(rawExecAsk && !execAsk),
+    invalidNode: false,
+    hasDirective: true
+  };
+}
+
+// src/index.ts
+var sessionStates = new Map;
+function getDefaultState() {
+  return {
+    thinking: "low",
+    verbose: "off",
+    reasoning: "off",
+    elevated: "off",
+    exec: {},
+    model: {}
+  };
+}
+function getDirectiveState(roomId) {
+  return sessionStates.get(roomId) ?? getDefaultState();
+}
+function setDirectiveState(roomId, state) {
+  sessionStates.set(roomId, state);
+}
+function clearDirectiveState(roomId) {
+  sessionStates.delete(roomId);
+}
+function parseDirectives(body, options) {
+  const {
+    cleaned: thinkCleaned,
+    thinkLevel,
+    rawLevel: rawThinkLevel,
+    hasDirective: hasThinkDirective
+  } = extractThinkDirective(body);
+  const {
+    cleaned: verboseCleaned,
+    verboseLevel,
+    rawLevel: rawVerboseLevel,
+    hasDirective: hasVerboseDirective
+  } = extractVerboseDirective(thinkCleaned);
+  const {
+    cleaned: reasoningCleaned,
+    reasoningLevel,
+    rawLevel: rawReasoningLevel,
+    hasDirective: hasReasoningDirective
+  } = extractReasoningDirective(verboseCleaned);
+  const {
+    cleaned: elevatedCleaned,
+    elevatedLevel,
+    rawLevel: rawElevatedLevel,
+    hasDirective: hasElevatedDirective
+  } = options?.disableElevated ? {
+    cleaned: reasoningCleaned,
+    elevatedLevel: undefined,
+    rawLevel: undefined,
+    hasDirective: false
+  } : extractElevatedDirective(reasoningCleaned);
+  const {
+    cleaned: execCleaned,
+    execHost,
+    execSecurity,
+    execAsk,
+    execNode,
+    rawExecHost,
+    rawExecSecurity,
+    rawExecAsk,
+    rawExecNode,
+    hasExecOptions,
+    invalidHost: invalidExecHost,
+    invalidSecurity: invalidExecSecurity,
+    invalidAsk: invalidExecAsk,
+    invalidNode: invalidExecNode,
+    hasDirective: hasExecDirective
+  } = extractExecDirective(elevatedCleaned);
+  const allowStatusDirective = options?.allowStatusDirective !== false;
+  const { cleaned: statusCleaned, hasDirective: hasStatusDirective } = allowStatusDirective ? extractStatusDirective(execCleaned) : { cleaned: execCleaned, hasDirective: false };
+  const {
+    cleaned: modelCleaned,
+    rawModel,
+    rawProfile,
+    hasDirective: hasModelDirective
+  } = extractModelDirective(statusCleaned, {
+    aliases: options?.modelAliases
+  });
+  const hasAnyDirective = hasThinkDirective || hasVerboseDirective || hasReasoningDirective || hasElevatedDirective || hasExecDirective || hasModelDirective;
+  const directivesOnly = hasAnyDirective && modelCleaned.trim().length === 0;
+  return {
+    cleanedText: modelCleaned,
+    directivesOnly,
+    hasThinkDirective,
+    thinkLevel,
+    rawThinkLevel,
+    hasVerboseDirective,
+    verboseLevel,
+    rawVerboseLevel,
+    hasReasoningDirective,
+    reasoningLevel,
+    rawReasoningLevel,
+    hasElevatedDirective,
+    elevatedLevel,
+    rawElevatedLevel,
+    hasExecDirective,
+    execHost,
+    execSecurity,
+    execAsk,
+    execNode,
+    rawExecHost,
+    rawExecSecurity,
+    rawExecAsk,
+    rawExecNode,
+    hasExecOptions,
+    invalidExecHost,
+    invalidExecSecurity,
+    invalidExecAsk,
+    invalidExecNode,
+    hasStatusDirective,
+    hasModelDirective,
+    rawModelDirective: rawModel,
+    rawModelProfile: rawProfile
+  };
+}
+function applyDirectives(roomId, directives, persist = true) {
+  const current = getDirectiveState(roomId);
+  const updated = { ...current };
+  if (directives.hasThinkDirective && directives.thinkLevel) {
+    updated.thinking = directives.thinkLevel;
+  }
+  if (directives.hasVerboseDirective && directives.verboseLevel) {
+    updated.verbose = directives.verboseLevel;
+  }
+  if (directives.hasReasoningDirective && directives.reasoningLevel) {
+    updated.reasoning = directives.reasoningLevel;
+  }
+  if (directives.hasElevatedDirective && directives.elevatedLevel) {
+    updated.elevated = directives.elevatedLevel;
+  }
+  if (directives.hasExecDirective) {
+    updated.exec = {
+      ...updated.exec,
+      ...directives.execHost && { host: directives.execHost },
+      ...directives.execSecurity && { security: directives.execSecurity },
+      ...directives.execAsk && { ask: directives.execAsk },
+      ...directives.execNode && { node: directives.execNode }
+    };
+  }
+  if (directives.hasModelDirective && directives.rawModelDirective) {
+    const parts = directives.rawModelDirective.split("/");
+    if (parts.length === 2) {
+      updated.model = {
+        provider: parts[0],
+        model: parts[1],
+        authProfile: directives.rawModelProfile
+      };
+    } else {
+      updated.model = {
+        model: directives.rawModelDirective,
+        authProfile: directives.rawModelProfile
+      };
+    }
+  }
+  if (persist) {
+    setDirectiveState(roomId, updated);
+  }
+  return updated;
+}
+function formatDirectiveState(state) {
+  const lines = [];
+  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}${state.model.authProfile ? ` @${state.model.authProfile}` : ""}`);
+  }
+  return lines.join(`
+`);
+}
+function formatDirectiveAcknowledgment(directives) {
+  const changes = [];
+  if (directives.hasThinkDirective) {
+    changes.push(`Thinking: ${directives.thinkLevel ?? "status"}`);
+  }
+  if (directives.hasVerboseDirective) {
+    changes.push(`Verbose: ${directives.verboseLevel ?? "status"}`);
+  }
+  if (directives.hasReasoningDirective) {
+    changes.push(`Reasoning: ${directives.reasoningLevel ?? "status"}`);
+  }
+  if (directives.hasElevatedDirective) {
+    changes.push(`Elevated: ${directives.elevatedLevel ?? "status"}`);
+  }
+  if (directives.hasModelDirective) {
+    changes.push(`Model: ${directives.rawModelDirective ?? "status"}`);
+  }
+  return changes.length > 0 ? `✓ ${changes.join(", ")}` : "No changes applied";
+}
+var directiveStateProvider = {
+  name: "DIRECTIVE_STATE",
+  description: "Current directive levels (thinking, verbose, model, etc.)",
+  async get(runtime, message, _state) {
+    const roomId = message.roomId;
+    const directives = getDirectiveState(roomId);
+    return {
+      text: formatDirectiveState(directives),
+      values: {
+        thinkingLevel: directives.thinking,
+        verboseLevel: directives.verbose,
+        reasoningLevel: directives.reasoning,
+        elevatedLevel: directives.elevated,
+        modelProvider: directives.model.provider ?? "",
+        modelName: directives.model.model ?? "",
+        isElevated: directives.elevated !== "off"
+      },
+      data: { directives }
+    };
+  }
+};
+var directivesPlugin = {
+  name: "directives",
+  description: "Inline directive parsing (@think, @model, @verbose, etc.) for controlling agent behavior",
+  providers: [directiveStateProvider],
+  config: {
+    DEFAULT_THINKING: "low",
+    DEFAULT_VERBOSE: "off",
+    ALLOW_ELEVATED: "true",
+    ALLOW_EXEC: "false"
+  },
+  tests: [
+    {
+      name: "directive-parsing",
+      tests: [
+        {
+          name: "Parse think directive",
+          fn: async (_runtime) => {
+            const result = parseDirectives("/think:high hello world");
+            if (!result.hasThinkDirective) {
+              throw new Error("Should detect think directive");
+            }
+            if (result.thinkLevel !== "high") {
+              throw new Error(`Expected 'high', got '${result.thinkLevel}'`);
+            }
+            if (result.cleanedText !== "hello world") {
+              throw new Error(`Expected 'hello world', got '${result.cleanedText}'`);
+            }
+            import_core.logger.success("Think directive parsed correctly");
+          }
+        },
+        {
+          name: "Parse verbose directive",
+          fn: async (_runtime) => {
+            const result = parseDirectives("/v on test message");
+            if (!result.hasVerboseDirective) {
+              throw new Error("Should detect verbose directive");
+            }
+            if (result.verboseLevel !== "on") {
+              throw new Error(`Expected 'on', got '${result.verboseLevel}'`);
+            }
+            import_core.logger.success("Verbose directive parsed correctly");
+          }
+        },
+        {
+          name: "Parse model directive",
+          fn: async (_runtime) => {
+            const result = parseDirectives("/model anthropic/claude-3-opus what is 2+2");
+            if (!result.hasModelDirective) {
+              throw new Error("Should detect model directive");
+            }
+            if (result.rawModelDirective !== "anthropic/claude-3-opus") {
+              throw new Error(`Expected 'anthropic/claude-3-opus', got '${result.rawModelDirective}'`);
+            }
+            import_core.logger.success("Model directive parsed correctly");
+          }
+        },
+        {
+          name: "Detect directive-only message",
+          fn: async (_runtime) => {
+            const result = parseDirectives("/think:high /verbose on");
+            if (!result.directivesOnly) {
+              throw new Error("Should detect directive-only message");
+            }
+            import_core.logger.success("Directive-only detection works correctly");
+          }
+        },
+        {
+          name: "Parse multiple directives",
+          fn: async (_runtime) => {
+            const result = parseDirectives("/think:medium /v full /elevated on hello");
+            if (!result.hasThinkDirective || !result.hasVerboseDirective || !result.hasElevatedDirective) {
+              throw new Error("Should detect all directives");
+            }
+            if (result.thinkLevel !== "medium") {
+              throw new Error(`Expected 'medium', got '${result.thinkLevel}'`);
+            }
+            if (result.verboseLevel !== "full") {
+              throw new Error(`Expected 'full', got '${result.verboseLevel}'`);
+            }
+            if (result.elevatedLevel !== "on") {
+              throw new Error(`Expected 'on', got '${result.elevatedLevel}'`);
+            }
+            if (result.cleanedText !== "hello") {
+              throw new Error(`Expected 'hello', got '${result.cleanedText}'`);
+            }
+            import_core.logger.success("Multiple directives parsed correctly");
+          }
+        },
+        {
+          name: "Session state management",
+          fn: async (_runtime) => {
+            const roomId = "test-room-123";
+            clearDirectiveState(roomId);
+            const directives = parseDirectives("/think:high /verbose on");
+            applyDirectives(roomId, directives);
+            const state = getDirectiveState(roomId);
+            if (state.thinking !== "high") {
+              throw new Error(`Expected thinking 'high', got '${state.thinking}'`);
+            }
+            if (state.verbose !== "on") {
+              throw new Error(`Expected verbose 'on', got '${state.verbose}'`);
+            }
+            clearDirectiveState(roomId);
+            import_core.logger.success("Session state management works correctly");
+          }
+        }
+      ]
+    }
+  ],
+  async init(_config, runtime) {
+    import_core.logger.log("[plugin-directives] Initializing directive parser");
+  }
+};
+var src_default = directivesPlugin;
+
+//# debugId=DB05CA1BBD0B951464756E2164756E21