@elizaos/plugin-eliza-classic 2.0.0-alpha.7 → 2.0.11-beta.7

package/dist/cjs/index.node.cjs

@@ -1,1413 +0,0 @@
-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
-    });
-};
-
-// index.node.ts
-var exports_index_node = {};
-__export(exports_index_node, {
-  handleTextSmall: () => handleTextSmall,
-  handleTextLarge: () => handleTextLarge,
-  getElizaGreeting: () => getElizaGreeting,
-  generateElizaResponse: () => generateElizaResponse,
-  elizaClassicPlugin: () => elizaClassicPlugin
-});
-module.exports = __toCommonJS(exports_index_node);
-// ../shared/doctor.json
-var doctor_default = {
-  greetings: [
-    "Hello, how are you feeling today?",
-    "How do you do? Please tell me your problem"
-  ],
-  goodbyes: [
-    "Goodbye",
-    "Till next time",
-    "Hope to see you again soon"
-  ],
-  default: [
-    "I am not sure I understand you fully",
-    "Please go on",
-    "What does that suggest to you?",
-    "Do you feel strongly about discussing such things?"
-  ],
-  reflections: {
-    dont: "don't",
-    cant: "can't",
-    wont: "won't",
-    i: "you",
-    am: "are",
-    were: "was",
-    dreamed: "dreamt",
-    dreams: "dream",
-    your: "my",
-    me: "you",
-    "you're": "I am",
-    myself: "yourself",
-    yourself: "myself",
-    mom: "mother",
-    dad: "father",
-    my: "your",
-    you: "I"
-  },
-  substitutions: {
-    dont: "don't",
-    cant: "can't",
-    wont: "won't",
-    dreamed: "dreamt",
-    dreams: "dream",
-    were: "was",
-    mom: "mother",
-    dad: "father",
-    "you're": "i'm",
-    "i'm": "you're",
-    am: "are",
-    are: "am",
-    my: "your",
-    your: "my",
-    me: "you",
-    you: "i",
-    myself: "yourself",
-    yourself: "myself"
-  },
-  groups: {
-    belief: [
-      "feel",
-      "think",
-      "believe",
-      "wish"
-    ],
-    family: [
-      "mother",
-      "father",
-      "sister",
-      "brother",
-      "wife",
-      "children"
-    ],
-    noun: [
-      "mother",
-      "father"
-    ]
-  },
-  keywords: [
-    {
-      keyword: ["sorry"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "Please don't apologize",
-            "Apologies are not necessary",
-            "What feelings do you have when you apologize?",
-            "I've told you that apologies are not required"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["remember"],
-      precedence: 5,
-      rules: [
-        {
-          decomposition: "* you remember *",
-          reassembly: [
-            "Do you often think of $4?",
-            "Does thinking of $4 bring anything else to mind?",
-            "What else do you remember?",
-            "Why do you remember $4 just now?",
-            "What in the present situation reminds you of $4?",
-            "What is the connection between me and $4?"
-          ]
-        },
-        {
-          decomposition: "* do i remember *",
-          reassembly: [
-            "Did you think I would forget $5?",
-            "Why do you think I should recall $5 now?",
-            "What about $5?",
-            "=what",
-            "You mentioned $5"
-          ]
-        },
-        {
-          decomposition: "*",
-          reassembly: [
-            ":newkey"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["if"],
-      precedence: 3,
-      rules: [
-        {
-          decomposition: "* if *",
-          reassembly: [
-            "Do you think it's likely that $3?",
-            "Do you wish that $3?",
-            "What do you think about $3?",
-            "Really, $2 $3?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["dreamt", "dreamed"],
-      precedence: 4,
-      rules: [
-        {
-          decomposition: "* you dreamt *",
-          reassembly: [
-            "Really, $4?",
-            "Have you ever fantasied $4 while you were awake?",
-            "Have you dreamt $4 before?",
-            "=dream",
-            ":newkey"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["dream", "dreams"],
-      precedence: 3,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "What does that dream suggest to you?",
-            "Do you dream often?",
-            "What people appear in your dreams?",
-            "Don't you believe that dream has something to do with your problem?",
-            ":newkey"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["perhaps", "maybe"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "You don't seem quite certain",
-            "Why the uncertain tone?",
-            "Can't you be more positive?",
-            "You aren't sure...",
-            "Don't you know?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["name"],
-      precedence: 15,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "I am not interested in names",
-            "I've told you before, I don't care about names --- Please continue"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["xfremd", "deutsch", "français", "italiano", "español"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "I am sorry, I speak only English"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["hello"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "How do you do? Please state your problem"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["computer", "machine", "machines", "computers"],
-      precedence: 50,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "Do computers worry you?",
-            "Why do you mention computers?",
-            "What do you think machines have to do with your problem?",
-            "Don't you think computers can help people?",
-            "What about machines worries you?",
-            "What do you think about machines?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["am"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* are you *",
-          reassembly: [
-            "Do you believe you are $4?",
-            "Would you want to be $4?",
-            "You wish I would tell you you are $4",
-            "What would it mean if you were $4?",
-            "=what"
-          ]
-        },
-        {
-          decomposition: "*",
-          reassembly: [
-            "Why do you say 'am'?",
-            "I don't understand that"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["are"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* are i *",
-          reassembly: [
-            "Why are you interested in whether I am $4 or not?",
-            "Would you prefer if I weren't $4?",
-            "Perhaps I am $4 in your fantasies",
-            "Do you sometimes think I am $4?",
-            "=what"
-          ]
-        },
-        {
-          decomposition: "* are *",
-          reassembly: [
-            "Did you think they might not be $3?",
-            "Would you like it if they were not $3?",
-            "What if they were not $3?",
-            "Possibly they are $3"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["your"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* my *",
-          reassembly: [
-            "Why are you concerned over my $3?",
-            "What about your own $3?",
-            "Are you worried about someone else's $3?",
-            "Really, my $3?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["was", "were"],
-      precedence: 2,
-      rules: [
-        {
-          decomposition: "* was you *",
-          reassembly: [
-            "What if you were $4?",
-            "Do you think you were $4?",
-            "Were you $4?",
-            "What would it mean if you were $4?",
-            "What does '$4' suggest to you?",
-            "=what"
-          ]
-        },
-        {
-          decomposition: "* you was *",
-          reassembly: [
-            "Were you really?",
-            "Why do you tell me you were $4 now?",
-            "Perhaps I already knew you were $4"
-          ]
-        },
-        {
-          decomposition: "* was i *",
-          reassembly: [
-            "Would you like to believe I was $4?",
-            "What suggests that I was $4?",
-            "What do you think?",
-            "Perhaps I was $4",
-            "What if I had been $4?"
-          ]
-        },
-        {
-          decomposition: "*",
-          reassembly: [
-            ":newkey"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["you're"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* i'm *",
-          reassembly: [
-            ":pre I ARE $3 (=you)"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["i'm"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* you're *",
-          reassembly: [
-            ":pre YOU ARE $3 (=i)"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["i"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* you [want need] *",
-          reassembly: [
-            "What would it mean to you if you got $4?",
-            "Why do you want $4?",
-            "Suppose you got $4 soon",
-            "What if you never got $4",
-            "What would getting $4 mean to you?",
-            "What does wanting $4 have to do with this discussion?"
-          ]
-        },
-        {
-          decomposition: "* you are * [sad unhappy depressed sick] *",
-          reassembly: [
-            "I am sorry to hear you are $5",
-            "Do you think coming here will help you not to be $5?",
-            "I'm sure its not pleasant to be $5",
-            "Can you explain what made you $5"
-          ]
-        },
-        {
-          decomposition: "* you are * [happy elated glad better] *",
-          reassembly: [
-            "How have I helped you to be $5?",
-            "Has your treatment made you $5?",
-            "What makes you $5 just now?",
-            "Can you explain why you are suddenly $5?"
-          ]
-        },
-        {
-          decomposition: "* you was *",
-          reassembly: [
-            "=was"
-          ]
-        },
-        {
-          decomposition: "* you @belief you *",
-          reassembly: [
-            "Do you really think so?",
-            "But you are not sure you $5",
-            "Do you really doubt you $5?"
-          ]
-        },
-        {
-          decomposition: "* you * @belief * I *",
-          reassembly: [
-            "=you"
-          ]
-        },
-        {
-          decomposition: "* you are *",
-          reassembly: [
-            "Is it because you are $4 that you came to me?",
-            "How long have you been $4?",
-            "Do you believe it normal to be $4?",
-            "Do you enjoy being $4?"
-          ]
-        },
-        {
-          decomposition: "* you [can't cannot] *",
-          reassembly: [
-            "How do you know you can't $4?",
-            "Have you tried?",
-            "Perhaps you could $4 now",
-            "Do you really want to be able to $4?"
-          ]
-        },
-        {
-          decomposition: "* you don't *",
-          reassembly: [
-            "Don't you really $4?",
-            "Why don't you $4?",
-            "Do you wish to be able to $4?",
-            "Does that trouble you?"
-          ]
-        },
-        {
-          decomposition: "* you feel *",
-          reassembly: [
-            "Tell me more about such feelings",
-            "Do you often feel $4?",
-            "Do you enjoy feeling $4?",
-            "Of what does feeling $4 remind you?"
-          ]
-        },
-        {
-          decomposition: "* you * i *",
-          reassembly: [
-            "Perhaps in your fantasy we $3 each other",
-            "Do you wish to $3 me?",
-            "You seem to need to $3 me",
-            "Do you $3 anyone else?"
-          ]
-        },
-        {
-          decomposition: "*",
-          reassembly: [
-            "You say $1",
-            "Can you elaborate on that?",
-            "Do you say $1 for some special reason?",
-            "That's quite interesting"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["you"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* i remind you of *",
-          reassembly: [
-            "=dit"
-          ]
-        },
-        {
-          decomposition: "* i are *",
-          reassembly: [
-            "What makes you think I am $4?",
-            "Does it please you to believe I am $4?",
-            "Do you sometimes wish you were $4?",
-            "Perhaps you would like to be $4"
-          ]
-        },
-        {
-          decomposition: "* i * you",
-          reassembly: [
-            "Why do you think I $3 you?",
-            "You like to think I $3 you --- don't you",
-            "What makes you think I $3 you?",
-            "Really, I $3 you?",
-            "Do you wish to believe I $3 you?",
-            "Suppose I did $3 to you --- What would that mean?",
-            "Does someone else believe I $3 you?"
-          ]
-        },
-        {
-          decomposition: "* i *",
-          reassembly: [
-            "We were discussing you --- not me",
-            "Oh, I $3",
-            "You're not really talking about me, are you?",
-            "What are your feelings now?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["yes", "certainly"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "You seem quite positive",
-            "You are sure",
-            "I see",
-            "I understand"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["no"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "Are you saying 'no' just to be negative?",
-            "You are being a bit negative",
-            "Why not?",
-            "why 'no'?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["my"],
-      precedence: 2,
-      rules: [
-        {
-          decomposition: "* your * @family *",
-          reassembly: [
-            "Tell me more about your family",
-            "Who else in your family $5?",
-            "Your $4",
-            "What else comes to mind when you think of your $4?"
-          ]
-        },
-        {
-          decomposition: "* your *",
-          reassembly: [
-            "Your $3",
-            "Why do you say your $3?",
-            "Does that suggest anything else which belongs to you?",
-            "Is it important to you that $1 your $3?"
-          ]
-        }
-      ],
-      memory: [
-        {
-          decomposition: "* your *",
-          reassembly: [
-            "Let's discuss further why your $3",
-            "Earlier you said your $3",
-            "But your $3",
-            "Does that have anything to do with the fact that your $3?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["can"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* can i *",
-          reassembly: [
-            "You believe I can $4 don't you?",
-            "=what",
-            "You want me to be able to $4",
-            "Perhaps you would like to be able to $4 yourself"
-          ]
-        },
-        {
-          decomposition: "* can you *",
-          reassembly: [
-            "Whether or not you can $4 depends on you more than me",
-            "Do you want to be able to $4?",
-            "Perhaps you don't want to $4",
-            "=what"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["what", "how", "when"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "Why do you ask?",
-            "Does that question interest you?",
-            "What is it you really want to know?",
-            "Are such questions much on your mind?",
-            "What answer would please you most?",
-            "What do you think?",
-            "What comes to your mind when you ask that?",
-            "Have you asked such question before?",
-            "Have you asked anyone else?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["because"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "Is that the real reason?",
-            "Don't any other reasons come to mind?",
-            "Does that reason seem to explain anything else?",
-            "What other reasons might there be?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["why"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "* why don't i *",
-          reassembly: [
-            "Do you believe I don't $5?",
-            "Perhaps I will $5 in good time",
-            "Should you $5 yourself?",
-            "You want me to $5",
-            "=what"
-          ]
-        },
-        {
-          decomposition: "* why can't you *",
-          reassembly: [
-            "Do you think you should be able to $5?",
-            "Do you want to be able to $5?",
-            "Do you believe this will help you to $5?",
-            "Have you any idea why you can't $5?",
-            "=what"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["everyone", "everybody", "nobody", "noone"],
-      precedence: 2,
-      rules: [
-        {
-          decomposition: "* [everyone everybody nobody noone] *",
-          reassembly: [
-            "Really, $2?",
-            "Surely not $2",
-            "Can you think of anyone in particular?",
-            "Who, for example?",
-            "You are thinking of a very special person",
-            "Who, may I ask?",
-            "Someone special perhaps",
-            "You have a particular person in mind, don't you?",
-            "Who do you think you're talking about?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["always"],
-      precedence: 1,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "Can you think of a specific example?",
-            "When?",
-            "What incident are you thinking of?",
-            "Really, always?"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["like"],
-      precedence: 10,
-      rules: [
-        {
-          decomposition: "* [am is are was] * like *",
-          reassembly: [
-            "=dit"
-          ]
-        },
-        {
-          decomposition: "*",
-          reassembly: [
-            ":newkey"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["alike", "same"],
-      precedence: 10,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "=dit"
-          ]
-        }
-      ]
-    },
-    {
-      keyword: ["dit"],
-      precedence: 0,
-      rules: [
-        {
-          decomposition: "*",
-          reassembly: [
-            "In what way?",
-            "What resemblance do you see?",
-            "What does that similarity suggest to you?",
-            "What other connections do you see?",
-            "What do you suppose that resemblance means?",
-            "What is the connection, do you suppose?",
-            "Could there really be some connection?",
-            "How?"
-          ]
-        }
-      ]
-    }
-  ]
-};
-
-// models/text.ts
-var script = doctor_default;
-var substitutions = script.substitutions ?? {};
-var sessionStateByRuntime = new WeakMap;
-var defaultStandaloneSession = {
-  limit: 1,
-  memories: [],
-  reassemblyIndex: new Map
-};
-function getOrCreateSession(runtime) {
-  const existing = sessionStateByRuntime.get(runtime);
-  if (existing)
-    return existing;
-  const created = {
-    limit: 1,
-    memories: [],
-    reassemblyIndex: new Map
-  };
-  sessionStateByRuntime.set(runtime, created);
-  return created;
-}
-function normalizeRawInput(input) {
-  return input.trim().replace(/[!?;:]+/g, " ").replace(/[\u2018\u2019]/g, "'").replace(/\s+/g, " ");
-}
-function tokenizeWords(text) {
-  const cleaned = normalizeRawInput(text).replace(/[.,"()]/g, " ").toLowerCase().replace(/\s+/g, " ").trim();
-  if (!cleaned)
-    return [];
-  const canonicalizationKeys = new Set(["dont", "cant", "wont", "dreamed", "dreams", "mom", "dad"]);
-  return cleaned.split(" ").filter((w) => w.length > 0).map((w) => canonicalizationKeys.has(w) ? substitutions[w] ?? script.reflections[w] ?? w : w);
-}
-function reflectWords(words) {
-  return words.map((w) => script.reflections[w] ?? w);
-}
-function reflectText(text) {
-  return reflectWords(tokenizeWords(text)).join(" ");
-}
-function substituteWordsForMatching(words) {
-  const out = [];
-  for (const w of words) {
-    const mapped = substitutions[w] ?? script.reflections[w];
-    if (!mapped) {
-      out.push(w.toLowerCase());
-      continue;
-    }
-    const parts = mapped.toLowerCase().split(/\s+/g).filter((p) => p.length > 0);
-    if (parts.length === 0)
-      out.push(w.toLowerCase());
-    else
-      out.push(...parts);
-  }
-  return out;
-}
-function tokenizeForScan(input) {
-  const cleaned = normalizeRawInput(input).replace(/[.,]/g, " | ").replace(/["()]/g, " ").toLowerCase().replace(/\s+/g, " ").trim();
-  if (!cleaned)
-    return [];
-  const canonicalizationKeys = new Set(["dont", "cant", "wont", "dreamed", "dreams", "mom", "dad"]);
-  return cleaned.split(" ").filter((w) => w.length > 0).map((w) => canonicalizationKeys.has(w) ? substitutions[w] ?? script.reflections[w] ?? w : w);
-}
-function splitIntoClauses(words) {
-  const clauses = [];
-  let current = [];
-  for (const w of words) {
-    if (w === "|" || w === "but") {
-      if (current.length > 0)
-        clauses.push(current);
-      current = [];
-      continue;
-    }
-    current.push(w);
-  }
-  if (current.length > 0)
-    clauses.push(current);
-  return clauses;
-}
-function buildKeywordIndex(keywords) {
-  const map = new Map;
-  for (const entry of keywords) {
-    for (const k of entry.keyword) {
-      map.set(k.toLowerCase(), entry);
-    }
-  }
-  return map;
-}
-var keywordIndex = buildKeywordIndex(script.keywords);
-function findKeywordsInClause(words) {
-  const found = [];
-  for (let i = 0;i < words.length; i++) {
-    const w = words[i];
-    const entry = keywordIndex.get(w);
-    if (!entry)
-      continue;
-    found.push({ entry, keyword: w, position: i });
-  }
-  return found;
-}
-function selectKeywordStack(words) {
-  const clauses = splitIntoClauses(words);
-  for (const clause of clauses) {
-    const found = findKeywordsInClause(clause);
-    if (found.length === 0)
-      continue;
-    const stack = [...found].sort((a, b) => {
-      if (b.entry.precedence !== a.entry.precedence)
-        return b.entry.precedence - a.entry.precedence;
-      return a.position - b.position;
-    });
-    return { stack, clauseWords: clause };
-  }
-  return { stack: [], clauseWords: [] };
-}
-function parseDecomposition(pattern) {
-  const raw = pattern.trim().replace(/\s+/g, " ").toLowerCase();
-  if (!raw)
-    return [];
-  const tokens = [];
-  let i = 0;
-  while (i < raw.length) {
-    while (i < raw.length && raw[i] === " ")
-      i++;
-    if (i >= raw.length)
-      break;
-    const ch = raw[i];
-    if (ch === "*") {
-      tokens.push({ kind: "wildcard" });
-      i++;
-      continue;
-    }
-    if (ch === "@") {
-      let j2 = i + 1;
-      while (j2 < raw.length && raw[j2] !== " ")
-        j2++;
-      const groupName = raw.slice(i + 1, j2).trim();
-      if (groupName.length > 0)
-        tokens.push({ kind: "group", groupName });
-      i = j2;
-      continue;
-    }
-    if (ch === "[") {
-      const close = raw.indexOf("]", i + 1);
-      if (close === -1) {
-        const rest = raw.slice(i).trim();
-        if (rest.length > 0)
-          tokens.push({ kind: "literal", value: rest });
-        break;
-      }
-      const inside = raw.slice(i + 1, close).trim();
-      const options = inside.length > 0 ? inside.split(/\s+/g) : [];
-      tokens.push({ kind: "alt", options });
-      i = close + 1;
-      continue;
-    }
-    let j = i;
-    while (j < raw.length && raw[j] !== " ")
-      j++;
-    const word = raw.slice(i, j).trim();
-    if (word.length > 0)
-      tokens.push({ kind: "literal", value: word });
-    i = j;
-  }
-  return tokens;
-}
-function tokenMatchesWord(token, word) {
-  if (token.kind === "literal")
-    return token.value === word;
-  if (token.kind === "alt")
-    return token.options.includes(word);
-  if (token.kind === "group") {
-    const groupWords = script.groups[token.groupName];
-    if (!groupWords)
-      return false;
-    return groupWords.includes(word);
-  }
-  return false;
-}
-function matchDecomposition(tokens, words) {
-  const parts = new Array(tokens.length).fill("");
-  function backtrack(ti, wi) {
-    if (ti === tokens.length)
-      return wi === words.length;
-    const token = tokens[ti];
-    if (token.kind === "wildcard") {
-      for (let end = wi;end <= words.length; end++) {
-        parts[ti] = words.slice(wi, end).join(" ").trim();
-        if (backtrack(ti + 1, end))
-          return true;
-      }
-      return false;
-    }
-    if (wi >= words.length)
-      return false;
-    const w = words[wi];
-    if (!tokenMatchesWord(token, w))
-      return false;
-    parts[ti] = w;
-    return backtrack(ti + 1, wi + 1);
-  }
-  if (!backtrack(0, 0))
-    return null;
-  return { parts };
-}
-function applyReassembly(template, parts) {
-  return template.replace(/\$(\d+)/g, (_m, nRaw) => {
-    const n = Number.parseInt(nRaw, 10);
-    if (!Number.isFinite(n) || n <= 0)
-      return "";
-    const part = parts[n - 1] ?? "";
-    return reflectText(part);
-  });
-}
-function stableKeyForRule(keyword, rule, ruleIndex) {
-  return `${keyword}::${ruleIndex}::${rule.decomposition}`;
-}
-function pickNextReassembly(session, keyword, rule, ruleIndex) {
-  const key = stableKeyForRule(keyword, rule, ruleIndex);
-  const current = session.reassemblyIndex.get(key) ?? 0;
-  const idx = current % rule.reassembly.length;
-  session.reassemblyIndex.set(key, (current + 1) % Math.max(1, rule.reassembly.length));
-  return rule.reassembly[idx] ?? "";
-}
-function computeWordHash(word) {
-  let h = 0;
-  for (let i = 0;i < word.length; i++) {
-    h = h * 31 + word.charCodeAt(i) >>> 0;
-  }
-  return h;
-}
-function chooseDefaultResponse(session) {
-  if (session.limit === 4 && session.memories.length > 0) {
-    const m = session.memories.shift();
-    if (m)
-      return m;
-  }
-  const idx = (session.reassemblyIndex.get("__default__") ?? 0) % script.default.length;
-  session.reassemblyIndex.set("__default__", idx + 1);
-  return script.default[idx] ?? script.default[0] ?? "Please go on.";
-}
-function isGoodbye(words) {
-  if (words.length === 0)
-    return false;
-  const first = words[0];
-  return script.goodbyes.some((g) => tokenizeWords(g)[0] === first);
-}
-function resolveRedirectKeyword(s) {
-  const trimmed = s.trim();
-  if (!trimmed.startsWith("="))
-    return null;
-  const k = trimmed.slice(1).trim().toLowerCase();
-  return k.length > 0 ? k : null;
-}
-function parsePreDirective(s) {
-  const m = s.trim().match(/^:pre\s+(.+?)\s+\(=\s*([^)]+)\s*\)\s*$/i);
-  if (!m)
-    return null;
-  const preText = m[1]?.trim() ?? "";
-  const redirect = m[2]?.trim().toLowerCase() ?? "";
-  if (!preText || !redirect)
-    return null;
-  return { preText, redirect };
-}
-function isNewKeyDirective(s) {
-  return s.trim().toLowerCase() === ":newkey" || s.trim().toLowerCase() === "newkey";
-}
-function tryRulesForKeyword(session, keyword, entry, words) {
-  for (let i = 0;i < entry.rules.length; i++) {
-    const rule = entry.rules[i];
-    const tokens = parseDecomposition(rule.decomposition);
-    const match = matchDecomposition(tokens, words);
-    if (!match)
-      continue;
-    const picked = pickNextReassembly(session, keyword, rule, i);
-    if (isNewKeyDirective(picked))
-      return { kind: "newkey" };
-    const pre = parsePreDirective(picked);
-    if (pre)
-      return {
-        kind: "pre",
-        preText: pre.preText,
-        redirect: pre.redirect,
-        parts: match.parts
-      };
-    const redirect = resolveRedirectKeyword(picked);
-    if (redirect)
-      return { kind: "redirect", keyword: redirect };
-    return {
-      kind: "response",
-      text: applyReassembly(picked, match.parts).replace(/\s+/g, " ").trim()
-    };
-  }
-  return { kind: "no_match" };
-}
-function maybeRecordMemory(session, entry, words) {
-  const memoryRules = entry.memory;
-  if (!memoryRules || memoryRules.length === 0)
-    return;
-  const last = words.length > 0 ? words[words.length - 1] : "";
-  const chosenIdx = computeWordHash(last) % memoryRules.length;
-  const chosen = memoryRules[chosenIdx];
-  if (!chosen)
-    return;
-  const tokens = parseDecomposition(chosen.decomposition);
-  const match = matchDecomposition(tokens, words);
-  if (!match)
-    return;
-  const responseIdx = computeWordHash(last) % Math.max(1, chosen.reassembly.length);
-  const template = chosen.reassembly[responseIdx] ?? chosen.reassembly[0] ?? "";
-  const response = applyReassembly(template, match.parts).replace(/\s+/g, " ").trim();
-  if (response.length > 0)
-    session.memories.push(response);
-}
-function generateElizaResponse(arg1, arg2) {
-  const runtime = typeof arg1 === "string" ? null : arg1;
-  const input = typeof arg1 === "string" ? arg1 : arg2 ?? "";
-  const session = runtime ? getOrCreateSession(runtime) : defaultStandaloneSession;
-  session.limit = session.limit === 4 ? 1 : session.limit + 1;
-  const scanWords = tokenizeForScan(input);
-  const words = tokenizeWords(input);
-  if (words.length === 0)
-    return chooseDefaultResponse(session);
-  if (isGoodbye(words)) {
-    return script.goodbyes[0] ?? "Goodbye.";
-  }
-  const { stack: keywordStack, clauseWords } = selectKeywordStack(scanWords);
-  if (keywordStack.length === 0 || clauseWords.length === 0) {
-    return chooseDefaultResponse(session);
-  }
-  const matchWords = substituteWordsForMatching(clauseWords);
-  for (const found of keywordStack) {
-    maybeRecordMemory(session, found.entry, matchWords);
-    const result = tryRulesForKeyword(session, found.keyword, found.entry, matchWords);
-    if (result.kind === "no_match")
-      continue;
-    if (result.kind === "newkey")
-      continue;
-    if (result.kind === "pre") {
-      const preApplied = applyReassembly(result.preText, result.parts).replace(/\s+/g, " ").trim();
-      const preWords = tokenizeWords(preApplied);
-      const redirectedEntry = keywordIndex.get(result.redirect);
-      if (!redirectedEntry)
-        continue;
-      const redirected = tryRulesForKeyword(session, result.redirect, redirectedEntry, preWords);
-      if (redirected.kind === "response")
-        return redirected.text;
-      continue;
-    }
-    if (result.kind === "redirect") {
-      const redirectedEntry = keywordIndex.get(result.keyword);
-      if (!redirectedEntry)
-        continue;
-      const redirected = tryRulesForKeyword(session, result.keyword, redirectedEntry, matchWords);
-      if (redirected.kind === "response")
-        return redirected.text;
-      continue;
-    }
-    if (result.kind === "response")
-      return result.text;
-  }
-  return chooseDefaultResponse(session);
-}
-function getElizaGreeting() {
-  return script.greetings[1] ?? script.greetings[0] ?? "How do you do. Please tell me your problem.";
-}
-function extractUserMessage(prompt) {
-  const match = prompt.match(/(?:User|Human|You):\s*(.+?)(?:\n|$)/i);
-  return match ? match[1].trim() : prompt.trim();
-}
-async function handleTextLarge(_runtime, params) {
-  const input = extractUserMessage(params.prompt);
-  return generateElizaResponse(_runtime, input);
-}
-async function handleTextSmall(runtime, params) {
-  return handleTextLarge(runtime, params);
-}
-// plugin.ts
-var import_core2 = require("@elizaos/core");
-
-// actions/generateResponse.ts
-var import_core = require("@elizaos/core");
-
-// generated/specs/specs.ts
-var coreActionsSpec = {
-  version: "1.0.0",
-  actions: [
-    {
-      name: "generate-response",
-      description: "Generate an ELIZA response for user input using classic pattern matching.",
-      similes: ["ELIZA_RESPOND", "ELIZA_CHAT", "CLASSIC_ELIZA"],
-      parameters: []
-    }
-  ]
-};
-var allActionsSpec = {
-  version: "1.0.0",
-  actions: [
-    {
-      name: "generate-response",
-      description: "Generate an ELIZA response for user input using classic pattern matching.",
-      similes: ["ELIZA_RESPOND", "ELIZA_CHAT", "CLASSIC_ELIZA"],
-      parameters: []
-    }
-  ]
-};
-var coreProvidersSpec = {
-  version: "1.0.0",
-  providers: [
-    {
-      name: "eliza-greeting",
-      description: "",
-      dynamic: true
-    }
-  ]
-};
-var allProvidersSpec = {
-  version: "1.0.0",
-  providers: [
-    {
-      name: "eliza-greeting",
-      description: "",
-      dynamic: true
-    }
-  ]
-};
-var coreEvaluatorsSpec = {
-  version: "1.0.0",
-  evaluators: []
-};
-var allEvaluatorsSpec = {
-  version: "1.0.0",
-  evaluators: []
-};
-var coreActionDocs = coreActionsSpec.actions;
-var allActionDocs = allActionsSpec.actions;
-var coreProviderDocs = coreProvidersSpec.providers;
-var allProviderDocs = allProvidersSpec.providers;
-var coreEvaluatorDocs = coreEvaluatorsSpec.evaluators;
-var allEvaluatorDocs = allEvaluatorsSpec.evaluators;
-
-// generated/specs/spec-helpers.ts
-var coreActionMap = new Map(coreActionDocs.map((doc) => [doc.name, doc]));
-var allActionMap = new Map(allActionDocs.map((doc) => [doc.name, doc]));
-var coreProviderMap = new Map(coreProviderDocs.map((doc) => [doc.name, doc]));
-var allProviderMap = new Map(allProviderDocs.map((doc) => [doc.name, doc]));
-var coreEvaluatorMap = new Map(coreEvaluatorDocs.map((doc) => [doc.name, doc]));
-var allEvaluatorMap = new Map(allEvaluatorDocs.map((doc) => [doc.name, doc]));
-function getActionSpec(name) {
-  return coreActionMap.get(name) ?? allActionMap.get(name);
-}
-function requireActionSpec(name) {
-  const spec = getActionSpec(name);
-  if (!spec) {
-    throw new Error(`Action spec not found: ${name}`);
-  }
-  return spec;
-}
-function getProviderSpec(name) {
-  return coreProviderMap.get(name) ?? allProviderMap.get(name);
-}
-function requireProviderSpec(name) {
-  const spec = getProviderSpec(name);
-  if (!spec) {
-    throw new Error(`Provider spec not found: ${name}`);
-  }
-  return spec;
-}
-
-// actions/generateResponse.ts
-var spec = requireActionSpec("generate-response");
-var generateResponseAction = {
-  name: spec.name,
-  similes: spec.similes ? [...spec.similes] : [],
-  description: spec.description,
-  validate: async (_runtime, _message, _state) => {
-    return true;
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const userInput = typeof message.content === "object" && message.content !== null ? message.content.text || "" : String(message.content || "");
-    if (!userInput.trim()) {
-      if (callback) {
-        await callback({
-          text: "I need something to respond to. What would you like to talk about?",
-          source: message.content.source
-        });
-      }
-      return { success: false, error: "No user input provided" };
-    }
-    try {
-      const response = await runtime.useModel(import_core.ModelType.TEXT_LARGE, {
-        prompt: userInput
-      });
-      if (callback) {
-        await callback({
-          text: response,
-          source: message.content.source
-        });
-      }
-      return { success: true, text: response };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (callback) {
-        await callback({
-          text: "I encountered an issue. Please try again.",
-          source: message.content.source
-        });
-      }
-      return { success: false, error: errorMessage };
-    }
-  },
-  examples: spec.examples ?? []
-};
-// providers/elizaGreeting.ts
-var spec2 = requireProviderSpec("eliza-greeting");
-var elizaGreetingProvider = {
-  name: spec2.name,
-  dynamic: true,
-  get: async (_runtime, _message, _state) => {
-    const greeting = getElizaGreeting();
-    return {
-      data: {
-        greeting
-      },
-      values: {
-        greeting
-      },
-      text: greeting
-    };
-  }
-};
-// plugin.ts
-var elizaClassicPlugin = {
-  name: "eliza-classic",
-  description: "Classic ELIZA pattern matching psychotherapist - no LLM required",
-  priority: 100,
-  actions: [generateResponseAction],
-  providers: [elizaGreetingProvider],
-  models: {
-    [import_core2.ModelType.TEXT_LARGE]: async (runtime, params) => {
-      return handleTextLarge(runtime, params);
-    },
-    [import_core2.ModelType.TEXT_SMALL]: async (runtime, params) => {
-      return handleTextSmall(runtime, params);
-    }
-  },
-  async init(_config, _runtime) {
-    import_core2.logger.info({ src: "plugin:eliza-classic" }, "ELIZA pattern matching initialized");
-  },
-  tests: [
-    {
-      name: "eliza_classic_plugin_tests",
-      tests: [
-        {
-          name: "eliza_test_greeting",
-          fn: async (runtime) => {
-            const response = await runtime.useModel(import_core2.ModelType.TEXT_LARGE, {
-              prompt: "hello"
-            });
-            if (typeof response !== "string" || response.length === 0) {
-              throw new Error("Greeting should return non-empty string");
-            }
-            import_core2.logger.info(`[ELIZA Test] Greeting: "${response}"`);
-          }
-        },
-        {
-          name: "eliza_test_feeling_sad",
-          fn: async (runtime) => {
-            const response = await runtime.useModel(import_core2.ModelType.TEXT_LARGE, {
-              prompt: "I am sad today"
-            });
-            if (typeof response !== "string" || response.length === 0) {
-              throw new Error("Response should be non-empty string");
-            }
-            import_core2.logger.info(`[ELIZA Test] Sad response: "${response}"`);
-          }
-        },
-        {
-          name: "eliza_test_family",
-          fn: async (runtime) => {
-            const response = await runtime.useModel(import_core2.ModelType.TEXT_LARGE, {
-              prompt: "My mother is very kind"
-            });
-            if (typeof response !== "string" || response.length === 0) {
-              throw new Error("Response should be non-empty string");
-            }
-            import_core2.logger.info(`[ELIZA Test] Family response: "${response}"`);
-          }
-        },
-        {
-          name: "eliza_test_computer",
-          fn: async (runtime) => {
-            const response = await runtime.useModel(import_core2.ModelType.TEXT_LARGE, {
-              prompt: "I think computers are fascinating"
-            });
-            if (typeof response !== "string" || response.length === 0) {
-              throw new Error("Response should be non-empty string");
-            }
-            import_core2.logger.info(`[ELIZA Test] Computer response: "${response}"`);
-          }
-        },
-        {
-          name: "eliza_test_text_small",
-          fn: async (runtime) => {
-            const response = await runtime.useModel(import_core2.ModelType.TEXT_SMALL, {
-              prompt: "Can you help me?"
-            });
-            if (typeof response !== "string" || response.length === 0) {
-              throw new Error("TEXT_SMALL should return non-empty string");
-            }
-            import_core2.logger.info(`[ELIZA Test] TEXT_SMALL: "${response}"`);
-          }
-        }
-      ]
-    }
-  ]
-};
-
-//# debugId=272EE8A7F46C9E0E64756E2164756E21
-//# sourceMappingURL=index.node.cjs.map