@sciexpr/ai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,545 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AIPipeline: () => AIPipeline,
+  BUILTIN_PROMPTS: () => BUILTIN_PROMPTS,
+  BuiltinCompletionProvider: () => BuiltinCompletionProvider,
+  BuiltinFormatter: () => BuiltinFormatter,
+  BuiltinKnowledgeBase: () => BuiltinKnowledgeBase,
+  BuiltinNormalizer: () => BuiltinNormalizer,
+  PromptRegistry: () => PromptRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/fallback.ts
+var import_core = require("@sciexpr/core");
+var BUILTIN_SYMBOLS = [
+  // Greek lowercase
+  { text: "\\alpha", label: "\u03B1 alpha", category: "symbol", score: 100, description: "Greek alpha" },
+  { text: "\\beta", label: "\u03B2 beta", category: "symbol", score: 100, description: "Greek beta" },
+  { text: "\\gamma", label: "\u03B3 gamma", category: "symbol", score: 100, description: "Greek gamma" },
+  { text: "\\delta", label: "\u03B4 delta", category: "symbol", score: 100, description: "Greek delta" },
+  { text: "\\epsilon", label: "\u03B5 epsilon", category: "symbol", score: 100, description: "Greek epsilon" },
+  { text: "\\zeta", label: "\u03B6 zeta", category: "symbol", score: 100, description: "Greek zeta" },
+  { text: "\\eta", label: "\u03B7 eta", category: "symbol", score: 100, description: "Greek eta" },
+  { text: "\\theta", label: "\u03B8 theta", category: "symbol", score: 100, description: "Greek theta" },
+  { text: "\\iota", label: "\u03B9 iota", category: "symbol", score: 100, description: "Greek iota" },
+  { text: "\\kappa", label: "\u03BA kappa", category: "symbol", score: 100, description: "Greek kappa" },
+  { text: "\\lambda", label: "\u03BB lambda", category: "symbol", score: 100, description: "Greek lambda" },
+  { text: "\\mu", label: "\u03BC mu", category: "symbol", score: 100, description: "Greek mu" },
+  { text: "\\pi", label: "\u03C0 pi", category: "symbol", score: 100, description: "Greek pi" },
+  { text: "\\sigma", label: "\u03C3 sigma", category: "symbol", score: 100, description: "Greek sigma" },
+  { text: "\\tau", label: "\u03C4 tau", category: "symbol", score: 100, description: "Greek tau" },
+  { text: "\\phi", label: "\u03C6 phi", category: "symbol", score: 100, description: "Greek phi" },
+  { text: "\\omega", label: "\u03C9 omega", category: "symbol", score: 100, description: "Greek omega" },
+  // Greek uppercase
+  { text: "\\Gamma", label: "\u0393 Gamma", category: "symbol", score: 95, description: "Greek Gamma" },
+  { text: "\\Delta", label: "\u0394 Delta", category: "symbol", score: 95, description: "Greek Delta" },
+  { text: "\\Theta", label: "\u0398 Theta", category: "symbol", score: 95, description: "Greek Theta" },
+  { text: "\\Lambda", label: "\u039B Lambda", category: "symbol", score: 95, description: "Greek Lambda" },
+  { text: "\\Sigma", label: "\u03A3 Sigma", category: "symbol", score: 95, description: "Greek Sigma" },
+  { text: "\\Omega", label: "\u03A9 Omega", category: "symbol", score: 95, description: "Greek Omega" },
+  // Common commands
+  { text: "\\frac{}{}", label: "\\frac \u2014 Fraction", category: "command", score: 90, description: "Fraction: \\frac{num}{den}" },
+  { text: "\\sqrt{}", label: "\\sqrt \u2014 Square root", category: "command", score: 90, description: "Square root" },
+  { text: "\\sum", label: "\\sum \u2014 Summation", category: "command", score: 85, description: "Summation operator" },
+  { text: "\\prod", label: "\\prod \u2014 Product", category: "command", score: 85, description: "Product operator" },
+  { text: "\\int", label: "\\int \u2014 Integral", category: "command", score: 85, description: "Integral" },
+  { text: "\\lim", label: "\\lim \u2014 Limit", category: "command", score: 85, description: "Limit" },
+  { text: "\\infty", label: "\\infty \u2014 Infinity", category: "symbol", score: 90, description: "Infinity symbol" },
+  { text: "\\partial", label: "\\partial \u2014 Partial", category: "symbol", score: 90, description: "Partial derivative" },
+  { text: "\\nabla", label: "\\nabla \u2014 Nabla", category: "symbol", score: 90, description: "Nabla/del operator" },
+  // Common templates
+  { text: "\\frac{}{}", label: "Fraction", category: "template", score: 80 },
+  { text: "\\sqrt{}", label: "Square Root", category: "template", score: 80 },
+  { text: "\\sum_{}^{}", label: "Sum", category: "template", score: 80 },
+  { text: "\\int_{}^{}", label: "Integral", category: "template", score: 80 },
+  { text: "\\lim_{x \\to }{}", label: "Limit", category: "template", score: 75 },
+  { text: "\\begin{pmatrix} & \\\\ & \\end{pmatrix}", label: "Matrix 2x2", category: "template", score: 70 },
+  // Chemical
+  { text: "\\ce{H2O}", label: "H\u2082O \u2014 Water", category: "formula", score: 80, description: "Water" },
+  { text: "\\ce{H2SO4}", label: "H\u2082SO\u2084 \u2014 Sulfuric acid", category: "formula", score: 80, description: "Sulfuric acid" },
+  { text: "\\ce{NaOH}", label: "NaOH \u2014 Sodium hydroxide", category: "formula", score: 80, description: "Sodium hydroxide" },
+  { text: "\\ce{NaCl}", label: "NaCl \u2014 Salt", category: "formula", score: 80, description: "Table salt" },
+  { text: "\\ce{CO2}", label: "CO\u2082 \u2014 Carbon dioxide", category: "formula", score: 80, description: "Carbon dioxide" }
+];
+var BuiltinCompletionProvider = class {
+  id = "builtin-completion";
+  name = "Built-in Symbol Completion";
+  async complete(context) {
+    const beforeCursor = context.currentInput.slice(0, context.cursorPosition);
+    const lastToken = getLastToken(beforeCursor);
+    if (!lastToken) {
+      return { items: [], source: "local", latencyMs: 0 };
+    }
+    const matched = BUILTIN_SYMBOLS.filter((item) => item.text.startsWith(lastToken) || item.label.toLowerCase().includes(lastToken.toLowerCase())).sort((a, b) => b.score - a.score).slice(0, 10);
+    return {
+      items: matched,
+      source: "local",
+      latencyMs: 0
+    };
+  }
+};
+function getLastToken(input) {
+  const backslashIdx = input.lastIndexOf("\\");
+  if (backslashIdx !== -1) {
+    const afterBackslash = input.slice(backslashIdx);
+    const match2 = afterBackslash.match(/^\\[a-zA-Z]*$/);
+    if (match2) return match2[0];
+  }
+  const match = input.match(/([a-zA-Z_]+)$/);
+  return match ? match[1] : "";
+}
+var CHEMICAL_ELEMENTS = [
+  { symbol: "H", name: "\u6C22 / Hydrogen", atomicNumber: 1, atomicMass: 1.008, group: 1, period: 1, block: "s", electronegativity: 2.2, oxidationStates: [1, -1] },
+  { symbol: "He", name: "\u6C26 / Helium", atomicNumber: 2, atomicMass: 4.0026, group: 18, period: 1, block: "s" },
+  { symbol: "Li", name: "\u9502 / Lithium", atomicNumber: 3, atomicMass: 6.94, group: 1, period: 2, block: "s", electronegativity: 0.98, oxidationStates: [1] },
+  { symbol: "C", name: "\u78B3 / Carbon", atomicNumber: 6, atomicMass: 12.011, group: 14, period: 2, block: "p", electronegativity: 2.55, oxidationStates: [4, 2, -4] },
+  { symbol: "N", name: "\u6C2E / Nitrogen", atomicNumber: 7, atomicMass: 14.007, group: 15, period: 2, block: "p", electronegativity: 3.04, oxidationStates: [5, 3, -3] },
+  { symbol: "O", name: "\u6C27 / Oxygen", atomicNumber: 8, atomicMass: 15.999, group: 16, period: 2, block: "p", electronegativity: 3.44, oxidationStates: [-2] },
+  { symbol: "F", name: "\u6C1F / Fluorine", atomicNumber: 9, atomicMass: 18.998, group: 17, period: 2, block: "p", electronegativity: 3.98, oxidationStates: [-1] },
+  { symbol: "Na", name: "\u94A0 / Sodium", atomicNumber: 11, atomicMass: 22.99, group: 1, period: 3, block: "s", electronegativity: 0.93, oxidationStates: [1] },
+  { symbol: "Mg", name: "\u9541 / Magnesium", atomicNumber: 12, atomicMass: 24.305, group: 2, period: 3, block: "s", electronegativity: 1.31, oxidationStates: [2] },
+  { symbol: "Al", name: "\u94DD / Aluminium", atomicNumber: 13, atomicMass: 26.982, group: 13, period: 3, block: "p", electronegativity: 1.61, oxidationStates: [3] },
+  { symbol: "Si", name: "\u7845 / Silicon", atomicNumber: 14, atomicMass: 28.085, group: 14, period: 3, block: "p", electronegativity: 1.9, oxidationStates: [4] },
+  { symbol: "P", name: "\u78F7 / Phosphorus", atomicNumber: 15, atomicMass: 30.974, group: 15, period: 3, block: "p", electronegativity: 2.19, oxidationStates: [5, 3, -3] },
+  { symbol: "S", name: "\u786B / Sulfur", atomicNumber: 16, atomicMass: 32.06, group: 16, period: 3, block: "p", electronegativity: 2.58, oxidationStates: [6, 4, -2] },
+  { symbol: "Cl", name: "\u6C2F / Chlorine", atomicNumber: 17, atomicMass: 35.45, group: 17, period: 3, block: "p", electronegativity: 3.16, oxidationStates: [7, -1] },
+  { symbol: "K", name: "\u94BE / Potassium", atomicNumber: 19, atomicMass: 39.098, group: 1, period: 4, block: "s", electronegativity: 0.82, oxidationStates: [1] },
+  { symbol: "Ca", name: "\u9499 / Calcium", atomicNumber: 20, atomicMass: 40.078, group: 2, period: 4, block: "s", electronegativity: 1, oxidationStates: [2] },
+  { symbol: "Fe", name: "\u94C1 / Iron", atomicNumber: 26, atomicMass: 55.845, group: 8, period: 4, block: "d", electronegativity: 1.83, oxidationStates: [3, 2] },
+  { symbol: "Cu", name: "\u94DC / Copper", atomicNumber: 29, atomicMass: 63.546, group: 11, period: 4, block: "d", electronegativity: 1.9, oxidationStates: [2, 1] },
+  { symbol: "Zn", name: "\u950C / Zinc", atomicNumber: 30, atomicMass: 65.38, group: 12, period: 4, block: "d", electronegativity: 1.65, oxidationStates: [2] },
+  { symbol: "Ag", name: "\u94F6 / Silver", atomicNumber: 47, atomicMass: 107.87, group: 11, period: 5, block: "d", electronegativity: 1.93, oxidationStates: [1] },
+  { symbol: "Au", name: "\u91D1 / Gold", atomicNumber: 79, atomicMass: 196.97, group: 11, period: 6, block: "d", electronegativity: 2.54, oxidationStates: [3, 1] }
+];
+var elementMap = /* @__PURE__ */ new Map();
+for (const el of CHEMICAL_ELEMENTS) {
+  elementMap.set(el.symbol.toLowerCase(), el);
+}
+var BuiltinKnowledgeBase = class {
+  id = "builtin-kb";
+  name = "Built-in Knowledge Base";
+  async query(params) {
+    const result = { symbols: [], formulas: [], elements: [] };
+    const types = params.types ?? ["element", "symbol"];
+    if (types.includes("element")) {
+      result.elements = CHEMICAL_ELEMENTS.filter(
+        (el) => el.symbol.toLowerCase().includes(params.query.toLowerCase()) || el.name.toLowerCase().includes(params.query.toLowerCase())
+      ).slice(0, params.maxResults ?? 10);
+    }
+    if (types.includes("symbol")) {
+      const matchedSymbols = BUILTIN_SYMBOLS.filter(
+        (s) => s.text.toLowerCase().includes(params.query.toLowerCase()) || s.label.toLowerCase().includes(params.query.toLowerCase())
+      ).slice(0, params.maxResults ?? 10);
+      result.symbols = matchedSymbols.map((s) => ({
+        symbol: s.text,
+        name: s.label,
+        description: s.description ?? "",
+        category: s.category
+      }));
+    }
+    return result;
+  }
+  async searchSymbols(query, limit = 10) {
+    return BUILTIN_SYMBOLS.filter((s) => s.text.includes(query) || s.label.includes(query)).slice(0, limit).map((s) => ({ symbol: s.text, name: s.label, description: s.description ?? "", category: s.category }));
+  }
+  async searchFormulas(query, limit = 10) {
+    return BUILTIN_SYMBOLS.filter((s) => s.category === "formula" && (s.text.includes(query) || s.label.includes(query))).slice(0, limit).map((s) => ({ id: s.text, name: s.label, latex: s.text, description: s.description ?? "", category: s.category }));
+  }
+  async getElementInfo(symbol) {
+    return elementMap.get(symbol.toLowerCase()) ?? null;
+  }
+};
+var BuiltinNormalizer = class {
+  id = "builtin-normalizer";
+  name = "Built-in Regex Normalizer";
+  async normalize(input, targetFormat) {
+    let normalized = input;
+    const changes = [];
+    const displayBlock = /\\\[([\s\S]*?)\\\]/.test(normalized);
+    if (displayBlock) {
+      const before = normalized;
+      normalized = normalized.replace(/\\\[([\s\S]*?)\\\]/g, (_match, content) => `$$${content}$$`);
+      if (normalized !== before) {
+        changes.push({ type: "delimiter-fix", from: before, to: normalized, reason: "Convert \\[...\\] to $$...$$" });
+      }
+    }
+    const inlineBlock = /\\\(([\s\S]*?)\\\)/.test(normalized);
+    if (inlineBlock) {
+      const before = normalized;
+      normalized = normalized.replace(/\\\(([\s\S]*?)\\\)/g, (_match, content) => `$${content}$`);
+      if (normalized !== before) {
+        changes.push({ type: "delimiter-fix", from: before, to: normalized, reason: "Convert \\(...\\) to $...$" });
+      }
+    }
+    const unicodeGreekMap = {
+      "\u03B1": "\\alpha",
+      "\u03B2": "\\beta",
+      "\u03B3": "\\gamma",
+      "\u03B4": "\\delta",
+      "\u03B5": "\\epsilon",
+      "\u03B6": "\\zeta",
+      "\u03B7": "\\eta",
+      "\u03B8": "\\theta",
+      "\u03BB": "\\lambda",
+      "\u03BC": "\\mu",
+      "\u03C0": "\\pi",
+      "\u03C3": "\\sigma",
+      "\u03C6": "\\phi",
+      "\u03C9": "\\omega"
+    };
+    for (const [unicode, latex] of Object.entries(unicodeGreekMap)) {
+      if (normalized.includes(unicode) && targetFormat !== "unicode") {
+        const before = normalized;
+        normalized = normalized.replace(new RegExp(unicode, "g"), latex);
+        changes.push({ type: "unicode-convert", from: before, to: normalized, reason: `Convert ${unicode} to ${latex}` });
+      }
+    }
+    const subscriptMap = {
+      "\u2080": "_0",
+      "\u2081": "_1",
+      "\u2082": "_2",
+      "\u2083": "_3",
+      "\u2084": "_4",
+      "\u2085": "_5",
+      "\u2086": "_6",
+      "\u2087": "_7",
+      "\u2088": "_8",
+      "\u2089": "_9"
+    };
+    for (const [unicode, latex] of Object.entries(subscriptMap)) {
+      if (normalized.includes(unicode) && targetFormat !== "unicode") {
+        normalized = normalized.replace(new RegExp(unicode, "g"), latex);
+        changes.push({ type: "unicode-convert", from: input, to: normalized, reason: `Convert subscript ${unicode}` });
+      }
+    }
+    const root = (0, import_core.createRoot)(import_core.ExpressionKind.Math, [(0, import_core.createText)(normalized)]);
+    return {
+      normalized,
+      original: input,
+      confidence: changes.length > 0 ? 0.8 : 1,
+      changes,
+      ast: root
+    };
+  }
+  async detectAndFix(input) {
+    return this.normalize(input, "auto");
+  }
+};
+var BuiltinFormatter = class {
+  id = "builtin-formatter";
+  name = "Built-in Rule Formatter";
+  async format(ast, _style) {
+    return ast;
+  }
+};
+
+// src/pipeline.ts
+var AIPipeline = class {
+  completionProvider;
+  knowledgeBaseProvider;
+  normalizerProvider;
+  formatterProvider;
+  aiEnabled;
+  maxCompletions;
+  cache;
+  completionCache = /* @__PURE__ */ new Map();
+  kbCache = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.completionProvider = config.completionProvider ?? new BuiltinCompletionProvider();
+    this.knowledgeBaseProvider = config.knowledgeBaseProvider ?? new BuiltinKnowledgeBase();
+    this.normalizerProvider = config.normalizerProvider ?? new BuiltinNormalizer();
+    this.formatterProvider = config.formatterProvider ?? new BuiltinFormatter();
+    this.aiEnabled = config.aiEnabled ?? true;
+    this.maxCompletions = config.maxCompletions ?? 20;
+    this.cache = config.cache ?? { enabled: true, ttlMs: 6e4, maxSize: 500 };
+  }
+  // ==========================================================================
+  // Public API
+  // ==========================================================================
+  /**
+   * 获取智能补全（本地 + AI 混合）
+   */
+  async getCompletions(context) {
+    const cacheKey = `comp:${context.currentInput}:${context.cursorPosition}`;
+    const cached = this.getCached(this.completionCache, cacheKey);
+    if (cached) return cached;
+    const localResult = await new BuiltinCompletionProvider().complete(context);
+    if (!this.aiEnabled || this.completionProvider.id === "builtin-completion") {
+      return localResult;
+    }
+    try {
+      const aiResult = await this.completionProvider.complete(context);
+      if (aiResult.items.length > 0) {
+        const seen = new Set(localResult.items.map((i) => i.text));
+        const aiOnly = aiResult.items.filter((i) => !seen.has(i.text));
+        const merged = {
+          items: [...localResult.items, ...aiOnly].slice(0, this.maxCompletions),
+          source: "hybrid",
+          latencyMs: aiResult.latencyMs
+        };
+        this.setCache(this.completionCache, cacheKey, merged);
+        this.emit("aiComplete", merged);
+        return merged;
+      }
+    } catch {
+    }
+    this.setCache(this.completionCache, cacheKey, localResult);
+    return localResult;
+  }
+  /**
+   * 查询知识库
+   */
+  async queryKnowledge(params) {
+    const cacheKey = `kb:${params.query}:${params.types?.join(",") ?? "all"}`;
+    const cached = this.getCached(this.kbCache, cacheKey);
+    if (cached) return cached;
+    try {
+      const result = await this.knowledgeBaseProvider.query(params);
+      this.setCache(this.kbCache, cacheKey, result);
+      return result;
+    } catch {
+      return new BuiltinKnowledgeBase().query(params);
+    }
+  }
+  /**
+   * 规范化 AI 输出
+   */
+  async normalize(input, format = "auto") {
+    try {
+      return await this.normalizerProvider.normalize(input, format);
+    } catch {
+      return new BuiltinNormalizer().normalize(input, format);
+    }
+  }
+  /**
+   * 格式化表达式
+   */
+  async format(ast, style) {
+    const fullStyle = {
+      outputFormat: "latex",
+      domain: "general",
+      ...style
+    };
+    try {
+      return await this.formatterProvider.format(ast, fullStyle);
+    } catch {
+      return new BuiltinFormatter().format(ast, fullStyle);
+    }
+  }
+  /**
+   * 自然语言 → 公式
+   */
+  async naturalLanguageToFormula(query) {
+    if (!this.aiEnabled) return [];
+    if (this.completionProvider.naturalLanguageToFormula) {
+      try {
+        return await this.completionProvider.naturalLanguageToFormula(query);
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+  /**
+   * AI 纠错
+   */
+  async correct(input, error) {
+    if (!this.aiEnabled) return [];
+    if (this.completionProvider.correct) {
+      try {
+        return await this.completionProvider.correct(input, error);
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+  // ==========================================================================
+  // Configuration
+  // ==========================================================================
+  setEnabled(enabled) {
+    this.aiEnabled = enabled;
+  }
+  isEnabled() {
+    return this.aiEnabled;
+  }
+  getCacheStats() {
+    return {
+      hits: 0,
+      // Simplified — would need tracking
+      misses: 0,
+      completionSize: this.completionCache.size,
+      kbSize: this.kbCache.size
+    };
+  }
+  clearCache() {
+    this.completionCache.clear();
+    this.kbCache.clear();
+  }
+  // ==========================================================================
+  // Event System
+  // ==========================================================================
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  off(event, callback) {
+    this.eventListeners.get(event)?.delete(callback);
+  }
+  emit(event, ...args) {
+    this.eventListeners.get(event)?.forEach((cb) => cb(...args));
+  }
+  // ==========================================================================
+  // Private
+  // ==========================================================================
+  getCached(cache, key) {
+    if (!this.cache.enabled) return null;
+    const entry = cache.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.cache.ttlMs) {
+      cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  setCache(cache, key, value) {
+    if (!this.cache.enabled) return;
+    if (cache.size >= this.cache.maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) cache.delete(firstKey);
+    }
+    cache.set(key, { value, timestamp: Date.now() });
+  }
+};
+
+// src/prompts.ts
+var BUILTIN_PROMPTS = {
+  /** 公式自动补全 */
+  completion: {
+    name: "Formula Completion",
+    system: `You are a scientific expression completion assistant.
+Given a partially typed LaTeX expression, suggest completions.
+Return ONLY a JSON array of {text, label, description, category, score}.
+Categories: symbol, command, template, correction, formula.`,
+    user: `Complete the following expression at cursor position {{cursor}}:
+Expression: {{input}}
+Expression type: {{type}}
+Surrounding context: {{context}}`,
+    variables: ["input", "cursor", "type", "context"]
+  },
+  /** AI 输出规范化 */
+  normalization: {
+    name: "Formula Normalization",
+    system: `You are a LaTeX/math notation normalization expert.
+Standardize scientific expressions to consistent format.
+Rules:
+- Use $$...$$ for display math, $...$ for inline
+- Chemical formulas must use \\ce{...}
+- Greek letters must use LaTeX commands (\\alpha not \u03B1)
+Return JSON: {normalized, changes: [{type, from, to, reason}], confidence}.`,
+    user: `Normalize the following expression to standard {{targetFormat}} format:
+{{input}}`,
+    variables: ["input", "targetFormat"]
+  },
+  /** 自然语言 → 公式 */
+  "nl-to-formula": {
+    name: "Natural Language to Formula",
+    system: `Convert natural language descriptions to LaTeX scientific expressions.
+Return JSON: [{text: latex_code, label: display_name, description, category: "formula", score: 1}].`,
+    user: `Convert to {{type}} expression: {{query}}`,
+    variables: ["query", "type"]
+  },
+  /** 化学方程式验证 */
+  "chemistry-validation": {
+    name: "Chemistry Validation",
+    system: `You are a chemistry expert. Validate chemical equations.
+Check: element conservation, charge balance, physical possibility.
+Return JSON: {valid: boolean, errors: [{message, code}], warnings: [{message, code}]}.`,
+    user: `Validate this chemical equation:
+Reactants: {{reactants}}
+Products: {{products}}
+Arrow: {{arrow}}
+Conditions: {{conditions}}`,
+    variables: ["reactants", "products", "arrow", "conditions"]
+  }
+};
+var PromptRegistry = class {
+  templates;
+  constructor() {
+    this.templates = new Map(Object.entries(BUILTIN_PROMPTS));
+  }
+  /**
+   * 注册自定义 Prompt 模板（可覆盖内置）
+   */
+  register(template) {
+    this.templates.set(template.name, template);
+  }
+  /**
+   * 获取模板
+   */
+  get(name) {
+    return this.templates.get(name);
+  }
+  /**
+   * 渲染模板为 system + user 消息
+   */
+  render(name, variables) {
+    const template = this.templates.get(name);
+    if (!template) return null;
+    let system = template.system;
+    let user = template.user;
+    for (const [key, value] of Object.entries(variables)) {
+      const placeholder = `{{${key}}}`;
+      system = system.replaceAll(placeholder, value);
+      user = user.replaceAll(placeholder, value);
+    }
+    return { system, user };
+  }
+  /**
+   * 获取所有已注册模板名称
+   */
+  list() {
+    return Array.from(this.templates.keys());
+  }
+  /**
+   * 移除自定义模板（不能移除内置模板）
+   */
+  remove(name) {
+    if (name in BUILTIN_PROMPTS) return false;
+    return this.templates.delete(name);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIPipeline,
+  BUILTIN_PROMPTS,
+  BuiltinCompletionProvider,
+  BuiltinFormatter,
+  BuiltinKnowledgeBase,
+  BuiltinNormalizer,
+  PromptRegistry
+});