fast-tavern 0.1.0

package/dist/index.cjs

@@ -0,0 +1,647 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/channels/gemini.ts
+function isGeminiContents(v) {
+  return Array.isArray(v) && v.every(
+    (x) => typeof x === "object" && x !== null && "role" in x && "parts" in x && Array.isArray(x.parts)
+  );
+}
+function toInternalFromGemini(input) {
+  return (input || []).map((m) => ({
+    role: m.role,
+    parts: (m.parts || []).map((p) => ({ text: p.text ?? "" }))
+  }));
+}
+function fromInternalToGemini(internal) {
+  return internal;
+}
+
+// src/core/channels/openai.ts
+function isOpenAIMessages(v) {
+  return Array.isArray(v) && v.every(
+    (x) => typeof x === "object" && x !== null && "role" in x && "content" in x && typeof x.content === "string"
+  );
+}
+function toInternalFromOpenAI(input) {
+  return (input || []).map((m) => ({
+    role: m.role === "assistant" ? "model" : m.role,
+    parts: [{ text: m.content ?? "" }]
+  }));
+}
+function fromInternalToOpenAI(internal) {
+  return (internal || []).map((m) => ({
+    role: m.role === "model" ? "assistant" : m.role,
+    content: (m.parts || []).map((p) => p.text ?? "").join("")
+  }));
+}
+
+// src/core/channels/simple.ts
+function isSimpleMessages(v) {
+  return Array.isArray(v) && v.every(
+    (x) => typeof x === "object" && x !== null && "role" in x && "text" in x && typeof x.text === "string"
+  );
+}
+function toInternalFromSimple(input) {
+  return (input || []).map((m) => ({
+    role: m.role === "assistant" || m.role === "model" ? "model" : m.role,
+    parts: [{ text: m.text ?? "" }]
+  }));
+}
+function fromInternalToSimple(internal) {
+  return (internal || []).map((m) => ({
+    role: m.role,
+    text: (m.parts || []).map((p) => p.text ?? "").join("")
+  }));
+}
+
+// src/core/channels/tagged.ts
+function isTaggedContents(v) {
+  return Array.isArray(v) && v.every(
+    (x) => typeof x === "object" && x !== null && "tag" in x && "target" in x && "text" in x
+  );
+}
+function toInternalFromTagged(input) {
+  return (input || []).map((m) => ({
+    role: m.role,
+    parts: [{ text: m.text ?? "" }]
+  }));
+}
+function fromInternalToTagged(_internal) {
+  throw new Error(
+    "fromInternalToTagged is not supported: tagged output should be produced by prompt assembly stage."
+  );
+}
+
+// src/core/channels/text.ts
+function isTextInput(v) {
+  return typeof v === "string" || Array.isArray(v) && v.every((x) => typeof x === "string");
+}
+function toInternalFromText(input) {
+  const text = Array.isArray(input) ? input.join("\n") : input ?? "";
+  return [{ role: "user", parts: [{ text }] }];
+}
+function fromInternalToText(internal) {
+  return (internal || []).map((m) => (m.parts || []).map((p) => p.text ?? "").join("")).join("\n");
+}
+
+// src/core/channels/detect.ts
+function detectMessageFormat(input) {
+  if (isTextInput(input)) return "text";
+  if (isGeminiContents(input)) return "gemini";
+  if (isOpenAIMessages(input)) return "openai";
+  if (isTaggedContents(input)) return "tagged";
+  if (isSimpleMessages(input)) return "simple";
+  return "simple";
+}
+
+// src/core/convert.ts
+function convertMessagesIn(input, format = "auto") {
+  const detected = format === "auto" ? detectMessageFormat(input) : format;
+  if (detected === "text") {
+    return { detected, internal: toInternalFromText(input) };
+  }
+  if (detected === "gemini") {
+    return { detected, internal: toInternalFromGemini(input) };
+  }
+  if (detected === "openai") {
+    return { detected, internal: toInternalFromOpenAI(input) };
+  }
+  if (detected === "tagged") {
+    return { detected, internal: toInternalFromTagged(input) };
+  }
+  return { detected, internal: toInternalFromSimple(input) };
+}
+function convertMessagesOut(internal, format) {
+  if (format === "gemini") return fromInternalToGemini(internal);
+  if (format === "openai") return fromInternalToOpenAI(internal);
+  if (format === "simple") return fromInternalToSimple(internal);
+  if (format === "text") return fromInternalToText(internal);
+  return internal;
+}
+
+// src/core/modules/history/factories.ts
+var History = {
+  gemini: (messages) => ({
+    format: "gemini",
+    messages
+  }),
+  openai: (messages) => ({
+    format: "openai",
+    messages
+  }),
+  simple: (messages) => ({
+    format: "simple",
+    messages
+  }),
+  tagged: (messages) => ({
+    format: "tagged",
+    messages
+  }),
+  text: (text) => ({
+    format: "text",
+    text
+  }),
+  auto: (input) => ({
+    format: "auto",
+    input
+  })
+};
+
+// src/core/modules/history/guards.ts
+function isHistoryInput(v) {
+  return typeof v === "object" && v !== null && "format" in v && typeof v.format === "string";
+}
+function normalizeHistoryFormat(format) {
+  return format ?? "auto";
+}
+
+// src/core/modules/worldbook/testCondition.ts
+function testCondition(condition, text) {
+  if (!condition || condition.trim() === "") return true;
+  const kwMatch = condition.match(/<<keywords:(.+)>>/i);
+  if (kwMatch?.[1]) {
+    const keywords = kwMatch[1].split(",").map((k) => k.trim());
+    return keywords.some((k) => k && text.includes(k));
+  }
+  try {
+    const regex = new RegExp(condition, "i");
+    return regex.test(text);
+  } catch {
+    return text.includes(condition);
+  }
+}
+
+// src/core/modules/inputs/normalizeRegexes.ts
+function isRegexRuleArray(v) {
+  return Array.isArray(v) && v.every((x) => typeof x === "object" && x !== null && "find_regex" in x);
+}
+function normalizeRegexes(input) {
+  if (!input) return [];
+  const files = [];
+  if (Array.isArray(input)) {
+    if (isRegexRuleArray(input)) {
+      files.push(input);
+    } else {
+      files.push(...input);
+    }
+  } else {
+    files.push(input);
+  }
+  const out = [];
+  for (const item of files) {
+    if (!item) continue;
+    if (isRegexRuleArray(item)) {
+      out.push(...item);
+      continue;
+    }
+    if (typeof item === "object" && item !== null && "find_regex" in item) {
+      out.push(item);
+      continue;
+    }
+    if (typeof item === "object" && item !== null && Array.isArray(item.regex_rules)) {
+      out.push(...item.regex_rules);
+      continue;
+    }
+    if (typeof item === "object" && item !== null && Array.isArray(item.rules)) {
+      out.push(...item.rules);
+      continue;
+    }
+  }
+  return out;
+}
+
+// src/core/modules/inputs/normalizeWorldbooks.ts
+function isWorldbookEntryArray(v) {
+  return Array.isArray(v) && v.every((x) => typeof x === "object" && x !== null && "content" in x);
+}
+function normalizeOne(item) {
+  const normalizeEntry = (e) => {
+    if (!e || typeof e !== "object") return null;
+    const position = e.position;
+    if (position !== "before_char" && position !== "after_char" && position !== "fixed") return null;
+    const role = e.role ?? "user";
+    const orderRaw = e.order;
+    const order = Number.isFinite(orderRaw) ? Number(orderRaw) : NaN;
+    if (!Number.isFinite(order)) return null;
+    if (position === "fixed") {
+      const depthRaw = e.depth;
+      const depth = Number.isFinite(depthRaw) ? Number(depthRaw) : NaN;
+      if (!Number.isFinite(depth)) return null;
+      return {
+        ...e,
+        role,
+        position,
+        order,
+        depth
+      };
+    }
+    return {
+      ...e,
+      role,
+      position,
+      order
+    };
+  };
+  const normalizeEntries = (entries) => {
+    return (entries || []).map(normalizeEntry).filter((x) => Boolean(x));
+  };
+  if (isWorldbookEntryArray(item)) return normalizeEntries(item);
+  if (typeof item === "object" && item !== null && Array.isArray(item.entries)) {
+    if (item.enabled === false) return [];
+    return normalizeEntries(item.entries);
+  }
+  return [];
+}
+function normalizeWorldbooks(input) {
+  if (!input) return [];
+  const files = [];
+  if (Array.isArray(input)) {
+    if (isWorldbookEntryArray(input)) {
+      files.push(input);
+    } else {
+      files.push(...input);
+    }
+  } else {
+    files.push(input);
+  }
+  const out = [];
+  for (const file of files) {
+    if (!file) continue;
+    out.push(...normalizeOne(file));
+  }
+  return out;
+}
+
+// src/core/modules/worldbook/getActiveEntries.ts
+function getActiveEntries(params) {
+  const { contextText = "", globalEntries = [], presetWorldbook, characterWorldbook } = params;
+  const filterEntry = (e) => {
+    if (e.enabled === false) return false;
+    if (e.mode === "always") return true;
+    if (e.mode === "conditional") return testCondition(e.condition, contextText);
+    return true;
+  };
+  const entries = [];
+  (globalEntries || []).filter(filterEntry).forEach((e, idx) => {
+    entries.push({ ...e, _source: `global-${idx}` });
+  });
+  const presetEntries = normalizeWorldbooks(presetWorldbook);
+  presetEntries.filter(filterEntry).forEach((e) => {
+    entries.push({ ...e, _source: "preset" });
+  });
+  const characterEntries = normalizeWorldbooks(characterWorldbook);
+  characterEntries.filter(filterEntry).forEach((e) => {
+    entries.push({ ...e, _source: "character" });
+  });
+  return entries.sort((a, b) => {
+    if (a.order !== b.order) return a.order - b.order;
+    const getPrio = (src) => {
+      if (src === "character") return 3;
+      if (src === "preset") return 2;
+      return 1;
+    };
+    return getPrio(a._source) - getPrio(b._source);
+  });
+}
+
+// src/core/modules/regex/applyRegex.ts
+function applyRegex(text, params) {
+  let result = text ?? "";
+  const { rules, target, view, placement } = params;
+  for (const rule of rules) {
+    if (!rule?.enabled) continue;
+    if (!(rule.views || []).includes(view)) continue;
+    if (placement && rule.placement !== placement) continue;
+    const mappedTarget = target === "model" || target === "chat_history" ? ["model", "chat_history", "assistant_response"] : [target];
+    const isMatch = (rule.targets || []).some((t) => mappedTarget.includes(t)) || target === "model" && (rule.targets || []).includes("chat_history") || target === "user" && (rule.targets || []).includes("chat_history");
+    if (!isMatch) continue;
+    try {
+      const re = new RegExp(rule.find_regex, "g");
+      result = result.replace(re, rule.replace_regex);
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
+
+// src/core/modules/regex/mergeRegexRules.ts
+function normalizeView(v) {
+  return v === "assistant_view" ? "model_view" : v;
+}
+function mergeRegexRules(params) {
+  const all = [];
+  all.push(...params.globalRules || []);
+  all.push(...params.presetRules || []);
+  all.push(...params.characterRules || []);
+  return all.map((r) => ({
+    ...r,
+    views: (r.views || []).map(normalizeView)
+  }));
+}
+
+// src/core/modules/macro/replaceMacros.ts
+function replaceMacros(text, macros) {
+  if (!text) return "";
+  let out = text;
+  if (macros.user !== void 0) {
+    out = out.replace(/<<user>>/g, String(macros.user));
+  }
+  out = out.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_m, key) => {
+    if (Object.prototype.hasOwnProperty.call(macros, key)) return String(macros[key]);
+    return _m;
+  });
+  return out;
+}
+
+// src/core/modules/assemble/assembleTaggedPromptList.ts
+function mapRole(role) {
+  return role;
+}
+function isFixedPromptBlock(b) {
+  return b.position === "fixed";
+}
+function isFixedWorldbookEntry(e) {
+  return e.position === "fixed";
+}
+function assembleTaggedPromptList(params) {
+  const {
+    presetBlocks,
+    activeEntries,
+    chatHistory,
+    positionMap = { before_char: "charBefore", after_char: "charAfter" }
+  } = params;
+  const result = [];
+  const enabledBlocks = (presetBlocks || []).filter((b) => b.enabled !== false);
+  const relativeBlocks = enabledBlocks.filter((b) => b.position === "relative");
+  for (const block of relativeBlocks) {
+    const slotEntries = (activeEntries || []).filter((e) => {
+      if (isFixedWorldbookEntry(e)) return false;
+      const mappedPos = positionMap[e.position] || e.position;
+      return mappedPos === block.identifier;
+    }).sort((a, b) => a.order - b.order);
+    for (const entry of slotEntries) {
+      result.push({
+        tag: `Worldbook: ${entry.name}`,
+        target: "world_book",
+        role: mapRole(entry.role),
+        text: entry.content
+      });
+    }
+    if (block.identifier === "chatHistory") {
+      let dialogueList = (chatHistory || []).map((node) => ({
+        tag: `History: ${node.role}`,
+        // system 属于聊天历史的一部分：这里用 chat_history 目标以便 regex 可覆盖
+        target: node.role === "user" ? "user" : node.role === "model" ? "model" : "chat_history",
+        role: node.role,
+        text: node.text
+      }));
+      const presetInjections = enabledBlocks.filter(
+        (b) => isFixedPromptBlock(b) && typeof b.depth === "number" && Number.isFinite(b.depth) && typeof b.order === "number" && Number.isFinite(b.order)
+      );
+      const worldbookInjections = (activeEntries || []).filter(
+        (e) => isFixedWorldbookEntry(e) && typeof e.depth === "number" && Number.isFinite(e.depth) && typeof e.order === "number" && Number.isFinite(e.order)
+      );
+      const allInjections = [
+        ...presetInjections.map((b) => ({
+          tag: `Preset: ${b.name}`,
+          target: "preset",
+          role: mapRole(b.role),
+          text: b.content || "",
+          depth: b.depth,
+          order: b.order
+        })),
+        ...worldbookInjections.map((e) => ({
+          tag: `Worldbook: ${e.name}`,
+          target: "world_book",
+          role: mapRole(e.role),
+          text: e.content,
+          depth: e.depth,
+          order: e.order
+        }))
+      ].sort((a, b) => {
+        if (a.depth !== b.depth) return a.depth - b.depth;
+        return a.order - b.order;
+      });
+      for (const item of allInjections) {
+        const targetIndex = Math.max(0, dialogueList.length - item.depth);
+        dialogueList.splice(targetIndex, 0, {
+          tag: item.tag,
+          target: item.target,
+          role: item.role,
+          text: item.text
+        });
+      }
+      result.push(...dialogueList);
+    } else if (block.content) {
+      result.push({
+        tag: `Preset: ${block.name}`,
+        target: "preset",
+        role: mapRole(block.role),
+        text: block.content
+      });
+    }
+  }
+  return result;
+}
+
+// src/core/modules/pipeline/processContentStages.ts
+function processContentStages(text, params) {
+  const raw = text ?? "";
+  const afterPreRegex = applyRegex(raw, {
+    rules: params.rules,
+    target: params.target,
+    view: params.view,
+    placement: "before_macro"
+  });
+  const afterMacro = replaceMacros(afterPreRegex, params.macros);
+  const afterPostRegex = applyRegex(afterMacro, {
+    rules: params.rules,
+    target: params.target,
+    view: params.view,
+    placement: "after_macro"
+  });
+  return { raw, afterPreRegex, afterMacro, afterPostRegex };
+}
+
+// src/core/modules/pipeline/compileTaggedStages.ts
+function compileTaggedStages(tagged, params) {
+  const perItem = [];
+  const raw = (tagged || []).map((i) => ({ ...i }));
+  const afterPreRegex = [];
+  const afterMacro = [];
+  const afterPostRegex = [];
+  for (const item of raw) {
+    const s = processContentStages(item.text, {
+      target: item.target,
+      view: params.view,
+      rules: params.rules,
+      macros: params.macros
+    });
+    perItem.push({
+      tag: item.tag,
+      role: item.role,
+      target: item.target,
+      ...s
+    });
+    afterPreRegex.push({ ...item, text: s.afterPreRegex });
+    afterMacro.push({ ...item, text: s.afterMacro });
+    afterPostRegex.push({ ...item, text: s.afterPostRegex });
+  }
+  return {
+    stages: { raw, afterPreRegex, afterMacro, afterPostRegex },
+    perItem
+  };
+}
+
+// src/core/modules/build/buildPrompt.ts
+function geminiContentsToChatHistory(contents) {
+  return (contents || []).map((m) => ({
+    role: m.role,
+    text: (m.parts || []).map((p) => p.text ?? "").join("")
+  }));
+}
+function taggedToGemini(tagged) {
+  return (tagged || []).map((item) => ({
+    role: item.role,
+    parts: [{ text: item.text ?? "" }]
+  }));
+}
+function applySystemRolePolicy(internal, policy) {
+  if (policy === "keep") return internal;
+  return (internal || []).map((m) => ({
+    ...m,
+    role: m.role === "system" ? "user" : m.role
+  }));
+}
+function buildPrompt(params) {
+  const { preset, character, globals, history, historyFormat, macros, view, options } = params;
+  const historyConv = (() => {
+    if (isHistoryInput(history)) {
+      if (history.format === "text") {
+        return convertMessagesIn(history.text, "text");
+      }
+      if (history.format === "auto") {
+        return convertMessagesIn(history.input, "auto");
+      }
+      return convertMessagesIn(history.messages, history.format);
+    }
+    return convertMessagesIn(history, normalizeHistoryFormat(historyFormat));
+  })();
+  const detectedHistoryFormat = historyConv.detected;
+  const internalHistory = historyConv.internal;
+  const chatHistory = geminiContentsToChatHistory(internalHistory);
+  const recentN = options?.recentHistoryForWorldbook ?? 5;
+  const recentHistoryText = chatHistory.slice(-recentN).map((n) => n.text).join("\n");
+  const globalWorldbookEntries = normalizeWorldbooks(globals?.worldbooks);
+  const activeEntries = getActiveEntries({
+    contextText: recentHistoryText,
+    globalEntries: globalWorldbookEntries,
+    presetWorldbook: preset.world_book,
+    characterWorldbook: character?.world_book
+  });
+  const tagged = assembleTaggedPromptList({
+    presetBlocks: preset.prompts,
+    activeEntries,
+    chatHistory,
+    positionMap: options?.positionMap
+  });
+  const globalRegexRules = normalizeRegexes(globals?.regexes);
+  const rules = mergeRegexRules({
+    globalRules: globalRegexRules,
+    presetRules: preset.regex_rules,
+    characterRules: character?.regex_rules
+  });
+  const compiled = compileTaggedStages(tagged, { view, rules, macros });
+  const taggedStages = compiled.stages;
+  const perItem = compiled.perItem;
+  const internalStages = {
+    raw: taggedToGemini(taggedStages.raw),
+    afterPreRegex: taggedToGemini(taggedStages.afterPreRegex),
+    afterMacro: taggedToGemini(taggedStages.afterMacro),
+    afterPostRegex: taggedToGemini(taggedStages.afterPostRegex)
+  };
+  const defaultOutputFormat = isHistoryInput(history) ? history.format === "auto" ? detectedHistoryFormat : history.format : detectedHistoryFormat;
+  const outputFormat = params.outputFormat ?? defaultOutputFormat;
+  const systemRolePolicy = params.systemRolePolicy ?? "keep";
+  const outputStages = outputFormat === "tagged" ? taggedStages : {
+    raw: convertMessagesOut(
+      applySystemRolePolicy(internalStages.raw, systemRolePolicy),
+      outputFormat
+    ),
+    afterPreRegex: convertMessagesOut(
+      applySystemRolePolicy(internalStages.afterPreRegex, systemRolePolicy),
+      outputFormat
+    ),
+    afterMacro: convertMessagesOut(
+      applySystemRolePolicy(internalStages.afterMacro, systemRolePolicy),
+      outputFormat
+    ),
+    afterPostRegex: convertMessagesOut(
+      applySystemRolePolicy(internalStages.afterPostRegex, systemRolePolicy),
+      outputFormat
+    )
+  };
+  return {
+    detectedHistoryFormat,
+    outputFormat,
+    systemRolePolicy,
+    activeWorldbookEntries: activeEntries,
+    mergedRegexRules: rules,
+    stages: {
+      tagged: taggedStages,
+      internal: internalStages,
+      output: outputStages,
+      perItem
+    }
+  };
+}
+
+// src/core/channels/index.ts
+var channels_exports = {};
+__export(channels_exports, {
+  detectMessageFormat: () => detectMessageFormat,
+  fromInternalToGemini: () => fromInternalToGemini,
+  fromInternalToOpenAI: () => fromInternalToOpenAI,
+  fromInternalToSimple: () => fromInternalToSimple,
+  fromInternalToTagged: () => fromInternalToTagged,
+  fromInternalToText: () => fromInternalToText,
+  isGeminiContents: () => isGeminiContents,
+  isOpenAIMessages: () => isOpenAIMessages,
+  isSimpleMessages: () => isSimpleMessages,
+  isTaggedContents: () => isTaggedContents,
+  isTextInput: () => isTextInput,
+  toInternalFromGemini: () => toInternalFromGemini,
+  toInternalFromOpenAI: () => toInternalFromOpenAI,
+  toInternalFromSimple: () => toInternalFromSimple,
+  toInternalFromTagged: () => toInternalFromTagged,
+  toInternalFromText: () => toInternalFromText
+});
+
+exports.Channels = channels_exports;
+exports.History = History;
+exports.applyRegex = applyRegex;
+exports.assembleTaggedPromptList = assembleTaggedPromptList;
+exports.buildPrompt = buildPrompt;
+exports.compileTaggedStages = compileTaggedStages;
+exports.convertMessagesIn = convertMessagesIn;
+exports.convertMessagesOut = convertMessagesOut;
+exports.detectMessageFormat = detectMessageFormat;
+exports.getActiveEntries = getActiveEntries;
+exports.isHistoryInput = isHistoryInput;
+exports.isTextInput = isTextInput;
+exports.mergeRegexRules = mergeRegexRules;
+exports.normalizeHistoryFormat = normalizeHistoryFormat;
+exports.normalizeRegexes = normalizeRegexes;
+exports.normalizeWorldbooks = normalizeWorldbooks;
+exports.processContentStages = processContentStages;
+exports.replaceMacros = replaceMacros;
+exports.testCondition = testCondition;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map