@nice-tools/fake-llm 1.3.0

package/dist/index.mjs

@@ -0,0 +1,899 @@
+import { CosmosClient } from '@azure/cosmos';
+import { BlobServiceClient } from '@azure/storage-blob';
+import { Storage } from '@google-cloud/storage';
+import * as fs from 'fs';
+import * as path3 from 'path';
+import nlp from 'compromise';
+
+// src/adapters/base.adapter.ts
+var BaseAdapter = class {
+  buildWhereClause(filters) {
+    if (!filters || Object.keys(filters).length === 0) {
+      return "";
+    }
+    const conditions = Object.entries(filters).map(([key, value]) => {
+      if (typeof value === "string") {
+        return `c.${key} = '${value}'`;
+      }
+      return `c.${key} = ${value}`;
+    });
+    return "WHERE " + conditions.join(" AND ");
+  }
+};
+var CosmosAdapter = class extends BaseAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.client = new CosmosClient({
+      endpoint: options.endpoint,
+      key: options.key
+    });
+    this.database = this.client.database(options.databaseId);
+  }
+  options;
+  client;
+  database;
+  async query(params) {
+    const container = this.database.container(params.source);
+    let sql = `SELECT * FROM c`;
+    const whereClause = this.buildWhereClause(params.filters || {});
+    if (whereClause) {
+      sql += ` ${whereClause}`;
+    }
+    if (params.orderBy) {
+      sql += ` ORDER BY c.${params.orderBy}`;
+    }
+    if (params.limit) {
+      sql += ` OFFSET 0 LIMIT ${params.limit}`;
+    }
+    const { resources } = await container.items.query(sql).fetchAll();
+    return resources;
+  }
+  async getById(id) {
+    throw new Error("getById requires container specification");
+  }
+};
+var BlobAdapter = class extends BaseAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+    if (options.connectionString) {
+      this.blobServiceClient = BlobServiceClient.fromConnectionString(options.connectionString);
+    } else if (options.sasToken && options.accountName) {
+      const blobSasUrl = `https://${options.accountName}.blob.core.windows.net${options.sasToken}`;
+      this.blobServiceClient = new BlobServiceClient(blobSasUrl);
+    } else {
+      throw new Error("BlobAdapter requires connectionString or sasToken + accountName");
+    }
+  }
+  options;
+  blobServiceClient;
+  async query(params) {
+    const containerClient = this.blobServiceClient.getContainerClient(params.source);
+    const results = [];
+    for await (const blob of containerClient.listBlobsFlat()) {
+      if (blob.name.endsWith(".json")) {
+        const blobClient = containerClient.getBlobClient(blob.name);
+        const downloadResponse = await blobClient.download();
+        const content = await this.readDownloadResponse(downloadResponse);
+        const data = JSON.parse(content);
+        if (this.matchesFilters(data, params.filters || {})) {
+          results.push(data);
+        }
+      }
+    }
+    return results;
+  }
+  async getById(id) {
+    throw new Error("getById not implemented for BlobAdapter");
+  }
+  matchesFilters(data, filters) {
+    return Object.entries(filters).every(([key, value]) => data[key] === value);
+  }
+  /**
+   * Reads blob download response content as a UTF-8 string.
+   *
+   * The Azure Blob SDK exposes different properties depending on the runtime:
+   * - Browser: `blobBody` (`Promise<Blob>`) — uses `Blob.text()`.
+   * - Node.js: `readableStreamBody` (`NodeJS.ReadableStream`) — uses stream events.
+   */
+  async readDownloadResponse(response) {
+    if (response.blobBody) {
+      const blob = await response.blobBody;
+      return blob.text();
+    }
+    const stream = response.readableStreamBody;
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      stream.on("error", reject);
+      stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    });
+  }
+};
+var GCSAdapter = class extends BaseAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.storage = new Storage({
+      projectId: options.projectId,
+      keyFilename: options.keyFilePath
+    });
+  }
+  options;
+  storage;
+  async query(params) {
+    const bucket = this.storage.bucket(params.source);
+    const [files] = await bucket.getFiles();
+    const results = [];
+    for (const file of files) {
+      if (file.name.endsWith(".json")) {
+        const [content] = await file.download();
+        const data = JSON.parse(content.toString("utf8"));
+        if (this.matchesFilters(data, params.filters || {})) {
+          results.push(data);
+        }
+      }
+    }
+    return results;
+  }
+  async getById(id) {
+    throw new Error("getById not implemented for GCSAdapter");
+  }
+  matchesFilters(data, filters) {
+    return Object.entries(filters).every(([key, value]) => data[key] === value);
+  }
+};
+var MockCosmosAdapter = class extends BaseAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  options;
+  async query(params) {
+    const parts = params.source.split("/");
+    const containerPath = path3.join(this.options.basePath, ...parts);
+    let items = [];
+    if (fs.existsSync(containerPath) && fs.statSync(containerPath).isDirectory()) {
+      const files = fs.readdirSync(containerPath).filter((f) => f.endsWith(".json"));
+      items = files.map((file) => {
+        const content = fs.readFileSync(path3.join(containerPath, file), "utf8");
+        return JSON.parse(content);
+      });
+    } else {
+      const filePath = containerPath + ".json";
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(content);
+        items = Array.isArray(parsed) ? parsed : [parsed];
+      } else {
+        console.warn(`MockCosmosAdapter: Path not found: ${containerPath}`);
+        return [];
+      }
+    }
+    if (params.filters && Object.keys(params.filters).length > 0) {
+      items = items.filter((item) => this.matchesFilters(item, params.filters));
+    }
+    if (params.limit) {
+      items = items.slice(0, params.limit);
+    }
+    return items;
+  }
+  async getById(id) {
+    throw new Error("getById requires source specification in MockCosmosAdapter");
+  }
+  matchesFilters(item, filters) {
+    return Object.entries(filters).every(([key, value]) => {
+      const itemValue = this.getNestedValue(item, key);
+      return itemValue === value;
+    });
+  }
+  getNestedValue(obj, path4) {
+    return path4.split(".").reduce((current, key) => current?.[key], obj);
+  }
+};
+var ImageAdapter = class {
+  async readImage(imagePath) {
+    try {
+      if (!fs.existsSync(imagePath)) {
+        return {
+          format: "unknown",
+          size: 0,
+          error: "File not found"
+        };
+      }
+      const buffer = fs.readFileSync(imagePath);
+      const ext = path3.extname(imagePath).toLowerCase();
+      return {
+        format: ext.substring(1),
+        size: buffer.length,
+        base64: buffer.toString("base64")
+      };
+    } catch (error) {
+      return {
+        format: "unknown",
+        size: 0,
+        error: error.message
+      };
+    }
+  }
+  async analyzeImage(imagePath) {
+    const result = await this.readImage(imagePath);
+    if (result.error) {
+      return `Cannot analyze image: ${result.error}`;
+    }
+    return `Image format: ${result.format}, Size: ${Math.round(result.size / 1024)}KB`;
+  }
+};
+
+// src/adapters/http-mock.adapter.ts
+var HttpMockAdapter = class extends BaseAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  options;
+  async query(params) {
+    if (params.source.includes("..") || params.source.startsWith("/") || params.source.includes("://")) {
+      throw new Error(`HttpMockAdapter: Invalid source path '${params.source}'`);
+    }
+    const base = this.options.baseUrl.replace(/\/$/, "");
+    const url = `${base}/${params.source}.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      if (response.status === 404) return [];
+      throw new Error(`HttpMockAdapter: Failed to fetch ${url} (${response.status})`);
+    }
+    const data = await response.json();
+    let items = Array.isArray(data) ? data : [data];
+    if (params.filters && Object.keys(params.filters).length > 0) {
+      items = items.filter((item) => this.matchesFilters(item, params.filters));
+    }
+    if (params.limit) {
+      items = items.slice(0, params.limit);
+    }
+    return items;
+  }
+  async getById(_id) {
+    throw new Error("HttpMockAdapter.getById is not supported \u2014 use query() with a filters object");
+  }
+  matchesFilters(item, filters) {
+    return Object.entries(filters).every(([key, value]) => {
+      const itemValue = this.getNestedValue(item, key);
+      return itemValue === value;
+    });
+  }
+  getNestedValue(obj, path4) {
+    return path4.split(".").reduce((current, key) => current?.[key], obj);
+  }
+};
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "could",
+  "let",
+  "make",
+  "why",
+  "what",
+  "how",
+  "when",
+  "where",
+  "who",
+  "which",
+  "that",
+  "this",
+  "these",
+  "those",
+  "it",
+  "its",
+  "my",
+  "your",
+  "his",
+  "her",
+  "our",
+  "their",
+  "me",
+  "him",
+  "us",
+  "them",
+  "and",
+  "or",
+  "but",
+  "if",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "about",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "just",
+  "also",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "yet",
+  "both",
+  "either"
+]);
+var NLPMatcher = class {
+  parseQuery(query) {
+    const cleanQuery = query.replace(/[?!.,;:'"]/g, " ").trim();
+    const doc = nlp(cleanQuery);
+    const action = this.extractAction(query);
+    const keywords = this.extractKeywords(doc, cleanQuery);
+    const filters = this.extractFilters(query);
+    const confidence = keywords.length > 0 ? 0.8 : 0.3;
+    return { action, keywords, filters, confidence };
+  }
+  extractAction(query) {
+    const q = query.toLowerCase();
+    if (q.includes("compare") || q.includes("difference")) return "compare";
+    if (q.includes("diff") || q.includes("what changed")) return "diff";
+    if (q.includes("find") || q.includes("search") || q.includes("which")) return "find";
+    if (q.includes("explain") || q.includes("what is") || q.includes("tell me about") || q.startsWith("why")) return "explain";
+    return "list";
+  }
+  extractKeywords(doc, cleanQuery) {
+    const nouns = doc.nouns().out("array");
+    const adjectives = doc.adjectives().out("array");
+    const allTerms = [];
+    for (const term of [...nouns, ...adjectives]) {
+      const parts = term.toLowerCase().split(/\s+/);
+      allTerms.push(...parts);
+    }
+    const queryWords = cleanQuery.toLowerCase().split(/\s+/);
+    allTerms.push(...queryWords);
+    return [...new Set(allTerms)].map((w) => w.toLowerCase().replace(/[^a-z0-9-]/g, "")).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+  }
+  extractFilters(query) {
+    const filters = {};
+    const questionWords = /* @__PURE__ */ new Set(["why", "what", "how", "when", "where", "who", "which"]);
+    const pattern = /(?:where|with)\s+(\w+)\s+(?:is|=|equals?)\s+['"]?([^'"\s]+)['"]?/gi;
+    let match;
+    while ((match = pattern.exec(query)) !== null) {
+      const [, key, value] = match;
+      if (key && value && !questionWords.has(key.toLowerCase())) {
+        filters[key] = value;
+      }
+    }
+    return filters;
+  }
+};
+
+// src/engine/keyword-resolver.ts
+var KeywordResolver = class {
+  constructor(keywords) {
+    this.keywords = keywords;
+  }
+  keywords;
+  resolve(term) {
+    const lowerTerm = term.toLowerCase();
+    let match = this.keywords.find((kw) => kw.keyword.toLowerCase() === lowerTerm);
+    if (!match) {
+      match = this.keywords.find(
+        (kw) => kw.aliases.some((alias) => alias.toLowerCase() === lowerTerm)
+      );
+    }
+    if (!match) {
+      match = this.keywords.find(
+        (kw) => kw.keyword.length > 2 && lowerTerm.includes(kw.keyword.toLowerCase())
+      );
+    }
+    return match;
+  }
+  /**
+   * Resolves a list of NLP-extracted terms AND also checks the full original query
+   * against all keyword aliases (to handle multi-word alias phrases).
+   */
+  resolveAll(terms, fullQuery) {
+    const resolved = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      const kw = this.resolve(term);
+      if (kw) resolved.set(kw.keyword, kw);
+    }
+    if (fullQuery) {
+      const lowerQuery = fullQuery.toLowerCase().replace(/[?!.,;:'"]/g, " ");
+      for (const kw of this.keywords) {
+        if (!resolved.has(kw.keyword)) {
+          const aliasMatch = kw.aliases.some((alias) => {
+            const lowerAlias = alias.toLowerCase();
+            return lowerAlias.length > 3 && lowerQuery.includes(lowerAlias);
+          });
+          if (aliasMatch) resolved.set(kw.keyword, kw);
+        }
+      }
+    }
+    return Array.from(resolved.values());
+  }
+  getRelatedKeywords(keyword) {
+    return this.keywords.filter(
+      (kw) => kw.category === keyword.category && kw.keyword !== keyword.keyword
+    );
+  }
+};
+
+// src/engine/story-resolver.ts
+var STORY_THRESHOLD = 0.1;
+var StoryResolver = class {
+  constructor(stories) {
+    this.stories = stories;
+  }
+  stories;
+  scoreAll(intent, resolvedKeywords) {
+    return this.stories.map((story) => {
+      const score = this.scoreStory(story, intent, resolvedKeywords);
+      const matchedKeywords = resolvedKeywords.filter((kw) => story.keywords.includes(kw.keyword)).map((kw) => kw.keyword);
+      const storyId = story.story_id || story.id || "";
+      return { storyId, score, matchedKeywords, storyKeywords: story.keywords };
+    }).sort((a, b) => b.score - a.score);
+  }
+  findBestStory(intent, resolvedKeywords) {
+    const matches = this.stories.map((story) => {
+      const score = this.scoreStory(story, intent, resolvedKeywords);
+      const matchedKeywords = resolvedKeywords.filter((kw) => story.keywords.includes(kw.keyword)).map((kw) => kw.keyword);
+      return { story, score, matchedKeywords };
+    });
+    matches.sort((a, b) => b.score - a.score);
+    const best = matches[0];
+    return best && best.score > STORY_THRESHOLD ? best : void 0;
+  }
+  scoreStory(story, intent, resolvedKeywords) {
+    let score = 0;
+    const keywordNames = resolvedKeywords.map((kw) => kw.keyword);
+    const overlap = story.keywords.filter((kw) => keywordNames.includes(kw)).length;
+    const keywordScore = overlap / Math.max(story.keywords.length, keywordNames.length, 1);
+    score += keywordScore * 0.7;
+    if (intent.action === "compare" && story.resolution_steps.some((s) => s.action === "compare")) score += 0.2;
+    if (intent.action === "diff" && story.resolution_steps.some((s) => s.action === "diff")) score += 0.2;
+    if (overlap === story.keywords.length) score += 0.1;
+    return Math.min(score, 1);
+  }
+};
+
+// src/engine/query-builder.ts
+var QueryBuilder = class {
+  buildQuery(step, intent) {
+    return {
+      source: step.from_source || "",
+      filters: { ...intent.filters }
+    };
+  }
+  buildQueryPreview(step, intent, resolvedKeywords = []) {
+    const filters = intent.filters || {};
+    const where = Object.entries(filters).map(
+      ([key, value]) => typeof value === "string" ? `c.${key} = '${value}'` : `c.${key} = ${value}`
+    ).join(" AND ");
+    const generatedQuery = where ? `SELECT * FROM c WHERE ${where}` : `SELECT * FROM c /* ${step.from_source || "source"} */`;
+    const terms = [.../* @__PURE__ */ new Set([...step.keyword ? [step.keyword] : [], ...resolvedKeywords])];
+    const searchPattern = terms.length > 0 ? `MATCH ${terms.map((term) => `"${term}"`).join(" OR ")}` : `MATCH ${step.from_source || "source"}*`;
+    return { generatedQuery, searchPattern };
+  }
+  buildSQLWhere(filters) {
+    if (!filters || Object.keys(filters).length === 0) return "";
+    const conditions = Object.entries(filters).map(
+      ([key, value]) => typeof value === "string" ? `c.${key} = '${value}'` : `c.${key} = ${value}`
+    );
+    return "WHERE " + conditions.join(" AND ");
+  }
+};
+
+// src/engine/response-builder.ts
+var ResponseBuilder = class {
+  buildAnswer(intent, story, results, executionTime, source) {
+    return {
+      intent,
+      story,
+      results,
+      summary: this.buildSummary(intent, results),
+      metadata: {
+        execution_time_ms: executionTime,
+        source
+      }
+    };
+  }
+  buildSummary(intent, results) {
+    if (results.length === 0) return "I couldn't find any results for your question.";
+    if (results.length === 1 && results[0]?.answer) {
+      return results[0].answer;
+    }
+    if (intent.action === "explain") {
+      const withAnswer = results.find((r) => r.answer);
+      if (withAnswer) return withAnswer.answer;
+      return Object.entries(results[0]).filter(([key]) => !key.startsWith("_") && key !== "id").map(([key, value]) => `${key}: ${value}`).join(", ");
+    }
+    if (intent.action === "compare") return `Comparing ${results.length} items.`;
+    const answers = results.filter((r) => r.answer).map((r) => r.answer);
+    if (answers.length > 0) return answers.join(" | ");
+    return `Found ${results.length} result(s).`;
+  }
+};
+
+// src/config/fetch-loader.ts
+var FetchConfigLoader = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async loadKeywords() {
+    const response = await fetch(this.options.keywordsUrl);
+    if (!response.ok) {
+      throw new Error(
+        `FetchConfigLoader: Failed to fetch keywords from ${this.options.keywordsUrl} (${response.status})`
+      );
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : [data];
+  }
+  async loadStories() {
+    const response = await fetch(this.options.storiesUrl);
+    if (!response.ok) {
+      throw new Error(
+        `FetchConfigLoader: Failed to fetch stories from ${this.options.storiesUrl} (${response.status})`
+      );
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : [data];
+  }
+};
+
+// src/mock-llm-engine.ts
+var MockLLMEngine = class {
+  constructor(keywords, stories, adapter, fallbackLLM) {
+    this.keywords = keywords;
+    this.stories = stories;
+    this.adapter = adapter;
+    this.fallbackLLM = fallbackLLM;
+    this.nlpMatcher = new NLPMatcher();
+    this.queryBuilder = new QueryBuilder();
+    this.responseBuilder = new ResponseBuilder();
+    this.keywordResolver = new KeywordResolver(keywords);
+    this.storyResolver = new StoryResolver(stories);
+  }
+  keywords;
+  stories;
+  adapter;
+  fallbackLLM;
+  nlpMatcher;
+  keywordResolver;
+  storyResolver;
+  queryBuilder;
+  responseBuilder;
+  // ─── Introspection API ───────────────────────────────────────────────────────
+  getKeywords() {
+    return this.keywords;
+  }
+  getStories() {
+    return this.stories;
+  }
+  listDataSources() {
+    const sources = /* @__PURE__ */ new Set();
+    for (const kw of this.keywords) {
+      if (kw.data_source) sources.add(kw.data_source);
+    }
+    for (const story of this.stories) {
+      if (story.contract?.sources) {
+        for (const source of story.contract.sources) {
+          if (source) sources.add(source);
+        }
+      }
+      for (const step of story.resolution_steps) {
+        if (step.from_source) sources.add(step.from_source);
+      }
+    }
+    return Array.from(sources);
+  }
+  async getDataSourceSnapshot(source, limit = 50) {
+    return this.adapter.query({ source, limit });
+  }
+  // ─── Query ───────────────────────────────────────────────────────────────────
+  async query(userQuery, opts = { debug: true }) {
+    const includeDebug = opts.debug !== false;
+    const startTime = Date.now();
+    const intent = this.nlpMatcher.parseQuery(userQuery);
+    const nlpTerms = intent.keywords;
+    const resolvedKeywords = this.keywordResolver.resolveAll(nlpTerms, userQuery);
+    const unresolvedTerms = nlpTerms.filter(
+      (term) => !resolvedKeywords.some(
+        (kw) => kw.keyword.toLowerCase() === term.toLowerCase() || kw.aliases.some((a) => a.toLowerCase() === term.toLowerCase())
+      )
+    );
+    const storyCandidates = this.storyResolver.scoreAll(intent, resolvedKeywords);
+    const storyMatch = storyCandidates.find((c) => c.score > STORY_THRESHOLD);
+    const matchedStory = storyMatch ? this.stories.find((s) => (s.story_id || s.id) === storyMatch.storyId) : void 0;
+    const debugSteps = [];
+    if (!matchedStory && this.fallbackLLM?.enabled) {
+      const debugInfo = includeDebug ? {
+        rawQuery: userQuery,
+        intent,
+        resolvedKeywords,
+        unresolvedTerms,
+        storyCandidates,
+        selectedStory: void 0,
+        threshold: STORY_THRESHOLD,
+        decision: "no-story-fallback-llm",
+        steps: [],
+        totals: { results: 0, durationMs: Date.now() - startTime }
+      } : void 0;
+      const ans = await this.queryFallbackLLM(userQuery, intent, startTime);
+      if (includeDebug && debugInfo) {
+        debugInfo.totals.durationMs = Date.now() - startTime;
+        debugInfo.decision = ans.metadata.source === "fallback-llm" && ans.results.length > 0 ? "no-story-fallback-llm" : "fallback-llm-error";
+        ans.debug = debugInfo;
+      }
+      return ans;
+    }
+    if (!matchedStory) {
+      const answer2 = this.responseBuilder.buildAnswer(intent, void 0, [], Date.now() - startTime, "mock-llm");
+      if (includeDebug) {
+        answer2.debug = {
+          rawQuery: userQuery,
+          intent,
+          resolvedKeywords,
+          unresolvedTerms,
+          storyCandidates,
+          selectedStory: void 0,
+          threshold: STORY_THRESHOLD,
+          decision: "no-story-no-results",
+          steps: [],
+          totals: { results: 0, durationMs: Date.now() - startTime }
+        };
+      }
+      return answer2;
+    }
+    let results = [];
+    let stepIndex = 0;
+    for (const step of matchedStory.resolution_steps) {
+      if (step.action === "fetch") {
+        const queryParams = this.queryBuilder.buildQuery(step, intent);
+        const builtFilter = this.queryBuilder.buildSQLWhere(queryParams.filters || {});
+        const preview = this.queryBuilder.buildQueryPreview(step, intent, resolvedKeywords.map((kw) => kw.keyword));
+        const data = await this.adapter.query(queryParams);
+        if (includeDebug) {
+          debugSteps.push({
+            step: step.step ?? ++stepIndex,
+            action: step.action,
+            source: queryParams.source,
+            queryParams,
+            builtFilter: builtFilter || `GET ${queryParams.source}/*`,
+            generatedQuery: preview.generatedQuery,
+            searchPattern: preview.searchPattern,
+            rowsReturned: data.length,
+            sampleRows: data.slice(0, 3)
+          });
+        }
+        results = [...results, ...data];
+      }
+    }
+    const answer = this.responseBuilder.buildAnswer(intent, matchedStory, results, Date.now() - startTime, "mock-llm");
+    if (includeDebug) {
+      answer.debug = {
+        rawQuery: userQuery,
+        intent,
+        resolvedKeywords,
+        unresolvedTerms,
+        storyCandidates,
+        selectedStory: { storyId: storyMatch.storyId, score: storyMatch.score },
+        threshold: STORY_THRESHOLD,
+        decision: "matched-story",
+        steps: debugSteps,
+        totals: { results: results.length, durationMs: Date.now() - startTime }
+      };
+    }
+    return answer;
+  }
+  async queryFallbackLLM(userQuery, intent, startTime) {
+    const llmConfig = this.fallbackLLM;
+    try {
+      const response = await fetch(llmConfig.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${llmConfig.apiKey}`
+        },
+        body: JSON.stringify({
+          model: llmConfig.model,
+          messages: [{ role: "user", content: userQuery }]
+        })
+      });
+      const data = await response.json();
+      const llmAnswer = data.choices?.[0]?.message?.content || "No response from LLM";
+      return {
+        intent,
+        story: void 0,
+        results: [{ answer: llmAnswer }],
+        summary: llmAnswer,
+        metadata: { execution_time_ms: Date.now() - startTime, source: "fallback-llm" }
+      };
+    } catch (error) {
+      return {
+        intent,
+        story: void 0,
+        results: [],
+        summary: `Fallback LLM error: ${error.message}`,
+        metadata: { execution_time_ms: Date.now() - startTime, source: "fallback-llm" }
+      };
+    }
+  }
+};
+var ConfigLoader = class {
+  constructor(source, connections) {
+    this.source = source;
+    this.connections = connections;
+  }
+  source;
+  connections;
+  async loadKeywords() {
+    if (this.source.type === "local") {
+      return this.loadLocalKeywords();
+    }
+    throw new Error(`Unsupported config source: ${this.source.type}`);
+  }
+  async loadStories() {
+    if (this.source.type === "local") {
+      return this.loadLocalStories();
+    }
+    throw new Error(`Unsupported config source: ${this.source.type}`);
+  }
+  loadLocalKeywords() {
+    const keywordsPath = path3.join(this.source.location.path, "keywords");
+    const files = fs.readdirSync(keywordsPath).filter((f) => f.endsWith(".json"));
+    const results = [];
+    for (const file of files) {
+      const content = fs.readFileSync(path3.join(keywordsPath, file), "utf8");
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        results.push(...parsed);
+      } else {
+        results.push(parsed);
+      }
+    }
+    return results;
+  }
+  loadLocalStories() {
+    const storiesPath = path3.join(this.source.location.path, "stories");
+    const files = fs.readdirSync(storiesPath).filter((f) => f.endsWith(".json"));
+    const results = [];
+    for (const file of files) {
+      const content = fs.readFileSync(path3.join(storiesPath, file), "utf8");
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        results.push(...parsed);
+      } else {
+        results.push(parsed);
+      }
+    }
+    return results;
+  }
+};
+
+// src/mock-llm.ts
+var MockLLM = class {
+  constructor(options) {
+    this.options = options;
+    this.configLoader = new ConfigLoader(options.configSource, options.connections);
+  }
+  options;
+  configLoader;
+  engine;
+  async initialize() {
+    const [keywords, stories] = await Promise.all([
+      this.configLoader.loadKeywords(),
+      this.configLoader.loadStories()
+    ]);
+    let adapter;
+    if (this.options.connections.mockCosmos) {
+      adapter = new MockCosmosAdapter(this.options.connections.mockCosmos);
+    } else if (this.options.connections.cosmos) {
+      adapter = new CosmosAdapter({
+        endpoint: this.options.connections.cosmos.endpoint,
+        key: this.options.connections.cosmos.key,
+        databaseId: "default"
+      });
+    } else {
+      throw new Error("No data adapter configured");
+    }
+    const fallbackLLM = this.options.connections.fallbackLLM?.enabled ? this.options.connections.fallbackLLM : void 0;
+    this.engine = new MockLLMEngine(keywords, stories, adapter, fallbackLLM);
+  }
+  // ─── Introspection API ───────────────────────────────────────────────────────
+  getKeywords() {
+    return this.engine.getKeywords();
+  }
+  getStories() {
+    return this.engine.getStories();
+  }
+  listDataSources() {
+    return this.engine.listDataSources();
+  }
+  async getDataSourceSnapshot(source, limit = 50) {
+    return this.engine.getDataSourceSnapshot(source, limit);
+  }
+  // ─── Query ───────────────────────────────────────────────────────────────────
+  async query(userQuery, opts = { debug: true }) {
+    return this.engine.query(userQuery, opts);
+  }
+};
+
+// src/browser-mock-llm.ts
+var BrowserMockLLM = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engine;
+  async initialize() {
+    const loader = new FetchConfigLoader({
+      keywordsUrl: this.options.keywordsUrl,
+      storiesUrl: this.options.storiesUrl
+    });
+    const [keywords, stories] = await Promise.all([
+      loader.loadKeywords(),
+      loader.loadStories()
+    ]);
+    const adapter = new HttpMockAdapter({ baseUrl: this.options.dataBaseUrl });
+    const fallbackLLM = this.options.fallbackLLM?.enabled ? this.options.fallbackLLM : void 0;
+    this.engine = new MockLLMEngine(keywords, stories, adapter, fallbackLLM);
+  }
+  // ─── Introspection API (mirrors MockLLM) ─────────────────────────────────────
+  getKeywords() {
+    return this.engine.getKeywords();
+  }
+  getStories() {
+    return this.engine.getStories();
+  }
+  listDataSources() {
+    return this.engine.listDataSources();
+  }
+  async getDataSourceSnapshot(source, limit = 50) {
+    return this.engine.getDataSourceSnapshot(source, limit);
+  }
+  // ─── Query ───────────────────────────────────────────────────────────────────
+  async query(userQuery, opts = { debug: true }) {
+    return this.engine.query(userQuery, opts);
+  }
+};
+
+export { BaseAdapter, BlobAdapter, BrowserMockLLM, CosmosAdapter, FetchConfigLoader, GCSAdapter, HttpMockAdapter, ImageAdapter, KeywordResolver, MockCosmosAdapter, MockLLM, MockLLMEngine, NLPMatcher, QueryBuilder, ResponseBuilder, STORY_THRESHOLD, StoryResolver };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map