@devilsdev/rag-core 3.4.0 → 3.6.0

package/dist/index.cjs

@@ -1291,12 +1291,74 @@ var require_context_packing = __commonJS({
   }
 });
 
+// src/observability/scores.js
+var require_scores = __commonJS({
+  "src/observability/scores.js"(exports2, module2) {
+    "use strict";
+    var RETRIEVAL_METRICS = /* @__PURE__ */ new Set(["contextPrecision", "contextRecall"]);
+    var isScore = (v) => typeof v === "number" && Number.isFinite(v);
+    function evaluationScores(result, { explanations = false } = {}) {
+      if (!result || typeof result !== "object") return [];
+      const out = [];
+      const scores = result.evaluation && result.evaluation.scores ? result.evaluation.scores : {};
+      for (const [name, value] of Object.entries(scores)) {
+        if (!isScore(value)) continue;
+        out.push({
+          name,
+          value,
+          target: RETRIEVAL_METRICS.has(name) ? "retrieval" : "generation"
+        });
+      }
+      if (result.citations && isScore(result.citations.groundednessScore)) {
+        out.push({
+          name: "citationCoverage",
+          value: result.citations.groundednessScore,
+          target: "generation"
+        });
+      }
+      if (typeof result.grounded === "boolean" && isScore(result.groundedness)) {
+        const unsupported = Array.isArray(result.unsupported) ? result.unsupported : [];
+        out.push({
+          name: "groundedSentences",
+          value: result.groundedness,
+          target: "generation",
+          label: result.grounded ? "grounded" : "ungrounded",
+          ...explanations && unsupported.length > 0 && {
+            explanation: `Unsupported: ${unsupported.map((s) => JSON.stringify(s)).join(" ")}`
+          }
+        });
+      }
+      return out;
+    }
+    function toLangfuseScores(result, options = {}) {
+      const { observationId, sessionId, comments = false } = options;
+      const tel = result && result.telemetry || {};
+      const traceId = options.traceId || tel.traceId;
+      const fromSameTrace = !options.traceId || options.traceId === tel.traceId;
+      return evaluationScores(result, { explanations: comments }).map((s) => {
+        const observation = observationId || (fromSameTrace && tel.spans ? tel.spans[s.target] : void 0);
+        return {
+          name: s.name,
+          value: s.value,
+          dataType: "NUMERIC",
+          ...traceId && { traceId },
+          ...observation && { observationId: observation },
+          ...sessionId && { sessionId },
+          ...s.explanation && { comment: s.explanation },
+          ...s.label && { metadata: { label: s.label } }
+        };
+      });
+    }
+    module2.exports = { evaluationScores, toLangfuseScores };
+  }
+});
+
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@devilsdev/rag-pipeline-utils",
-      version: "3.4.0",
+      version: "3.6.0",
       description: "Composable retrieval-augmented generation (RAG) for Node.js: grounded citations, evaluation, guardrails, hybrid retrieval and a CLI.",
       main: "dist/index.cjs",
       type: "commonjs",
@@ -1314,6 +1376,7 @@ var require_package = __commonJS({
       exports: {
         ".": {
           types: "./dist/index.d.ts",
+          workerd: "./dist/index.cjs",
           require: "./dist/index.cjs",
           import: "./dist/index.mjs"
         },
@@ -1342,6 +1405,8 @@ var require_package = __commonJS({
       scripts: {
         build: "node scripts/build-packages.js --bundles && node scripts/build.js && node scripts/generate-types.js && node scripts/build-packages.js --types && node scripts/check-type-exports.js",
         "test:packages": "node scripts/test-packages.js",
+        "test:consumer": "node scripts/consumer-journeys.js",
+        "test:templates": "node scripts/test-templates.js",
         prepack: "npm run build && node scripts/pin-readme-assets.js",
         postpack: "node scripts/pin-readme-assets.js --restore",
         "docs:validate": "node scripts/validate-docs-examples.js",
@@ -1392,6 +1457,12 @@ var require_package = __commonJS({
         "benchmark:full": "node scripts/benchmark.js --iterations=500 --verbose",
         "bench:speed": "node benchmarks/speed.js",
         "bench:quality": "node benchmarks/quality.js",
+        "bench:guardrails": "node benchmarks/guardrails.js",
+        "bench:judge": "node benchmarks/judge.js",
+        "bench:claude-citations": "node benchmarks/claude-citations.js",
+        "bench:judge-more": "node benchmarks/judge-more.js",
+        "bench:claude-latency": "node benchmarks/claude-latency.js",
+        "claude:usage": "node scripts/claude-usage-report.js && node benchmarks/render.js",
         dev: "node scripts/dev-tools.js menu",
         "dev:health": "node scripts/dev-tools.js health",
         "dev:setup": "node scripts/dev-tools.js setup",
@@ -1410,6 +1481,7 @@ var require_package = __commonJS({
         "tests:ci": "jest --maxWorkers=50% --reporters=default --json --outputFile=test-results-current.json",
         "test:unit": "jest __tests__/unit",
         "test:integration": "jest __tests__/integration",
+        "test:live": "jest --config jest.live.config.js --runInBand",
         "test:simple": "jest --maxWorkers=1 --no-coverage",
         "verify:pack": "node scripts/verify-npm-pack.js",
         "smoke:pack": "node scripts/smoke-test-pack.js",
@@ -1489,6 +1561,8 @@ var require_package = __commonJS({
         "**/*.{json,md,mdx,yml,yaml,css,scss,html}": "prettier --write --ignore-unknown"
       },
       devDependencies: {
+        "@ai-sdk/anthropic": "3.0.138",
+        "@ai-sdk/anthropic-v4": "npm:@ai-sdk/anthropic@4.0.97",
         "@babel/core": "^7.26.10",
         "@babel/preset-env": "^7.26.9",
         "@docusaurus/core": "3.10.2",
@@ -1499,12 +1573,14 @@ var require_package = __commonJS({
         "@fontsource/jetbrains-mono": "5.3.0",
         "@octokit/rest": "^21.1.1",
         "@opentelemetry/api": "^1.9.1",
+        "@opentelemetry/api-logs": "^0.223.0",
         "@opentelemetry/auto-instrumentations-node": "^0.52.1",
         "@opentelemetry/context-async-hooks": "^2.12.0",
         "@opentelemetry/exporter-jaeger": "^1.26.0",
         "@opentelemetry/exporter-prometheus": "^0.53.0",
         "@opentelemetry/exporter-trace-otlp-http": "^0.53.0",
         "@opentelemetry/resources": "^1.26.0",
+        "@opentelemetry/sdk-logs": "^0.223.0",
         "@opentelemetry/sdk-metrics": "^1.26.0",
         "@opentelemetry/sdk-node": "^0.53.0",
         "@opentelemetry/sdk-trace-base": "^2.12.0",
@@ -1550,10 +1626,10 @@ var require_package = __commonJS({
         "why-is-node-running": "^3.2.2"
       },
       dependencies: {
-        "@devilsdev/rag-connectors": "3.4.0",
-        "@devilsdev/rag-core": "3.4.0",
-        "@devilsdev/rag-eval": "3.4.0",
-        "@devilsdev/rag-guardrails": "3.4.0",
+        "@devilsdev/rag-connectors": "3.6.0",
+        "@devilsdev/rag-core": "3.6.0",
+        "@devilsdev/rag-eval": "3.6.0",
+        "@devilsdev/rag-guardrails": "3.6.0",
         ajv: "^8.17.1",
         axios: "^1.21.0",
         chokidar: "^4.0.3",
@@ -1623,12 +1699,18 @@ var require_optional_peer = __commonJS({
         throw error;
       }
     }
+    function missingPeer(error, name, hint) {
+      if (!isMissing(error, name)) return error;
+      const err = new Error(hint);
+      err.code = "MISSING_DEPENDENCY";
+      return err;
+    }
     function isMissing(error, name) {
       if (!error || error.code !== "MODULE_NOT_FOUND") return false;
       const message = String(error.message || "");
       return message.startsWith(`Cannot find module '${name}'`) || message.startsWith(`Cannot find module "${name}"`);
     }
-    module2.exports = { loadOptionalPeer };
+    module2.exports = { loadOptionalPeer, missingPeer };
   }
 });
 
@@ -1636,24 +1718,28 @@ var require_optional_peer = __commonJS({
 var require_otel = __commonJS({
   "src/observability/otel.js"(exports2, module2) {
     "use strict";
+    var { evaluationScores } = require_scores();
     var { version: LIBRARY_VERSION } = require_package();
-    var { loadOptionalPeer } = require_optional_peer();
+    var { missingPeer } = require_optional_peer();
     var TRACER_NAME = "@devilsdev/rag-pipeline-utils";
     var PROVIDERS = /* @__PURE__ */ new Set(["openai", "anthropic", "cohere", "ollama"]);
     function loadOtelApi() {
-      return loadOptionalPeer(
-        "@opentelemetry/api",
-        () => require("@opentelemetry/api"),
-        // eslint-disable-line global-require
-        'telemetry needs the "@opentelemetry/api" package, an optional peer dependency: npm install @opentelemetry/api (with @devilsdev/rag-pipeline-utils/edge, pass it: telemetry: { api })'
-      );
+      try {
+        return require("@opentelemetry/api");
+      } catch (error) {
+        throw missingPeer(
+          error,
+          "@opentelemetry/api",
+          'telemetry needs the "@opentelemetry/api" package, an optional peer dependency: npm install @opentelemetry/api (with @devilsdev/rag-pipeline-utils/edge, pass it: telemetry: { api })'
+        );
+      }
     }
     function createTelemetry(option) {
       if (!option) return null;
       const opts = option === true ? {} : option;
       if (typeof opts !== "object") {
         throw new TypeError(
-          "telemetry must be true or { tracer?, api?, recordContent? }"
+          "telemetry must be true or { tracer?, api?, logs?, logger?, recordContent? }"
         );
       }
       const api = opts.api || loadOtelApi();
@@ -1666,7 +1752,33 @@ var require_otel = __commonJS({
       if (!tracer || typeof tracer.startActiveSpan !== "function") {
         throw new TypeError("telemetry.tracer must be an OpenTelemetry Tracer");
       }
-      return { api, tracer, recordContent: Boolean(opts.recordContent) };
+      let logger = opts.logger || null;
+      if (logger && typeof logger.emit !== "function") {
+        throw new TypeError("telemetry.logger must be an OpenTelemetry Logger");
+      }
+      if (!logger) {
+        if (opts.logs && !(opts.logs.logs && typeof opts.logs.logs.getLogger === "function")) {
+          throw new TypeError(
+            'telemetry.logs must be the @opentelemetry/api-logs module (import * as logs from "@opentelemetry/api-logs")'
+          );
+        }
+        const source = [opts.logs, api].find(
+          (m) => m && m.logs && typeof m.logs.getLogger === "function"
+        );
+        if (source) logger = source.logs.getLogger(TRACER_NAME, LIBRARY_VERSION);
+      }
+      return {
+        api,
+        tracer,
+        logger,
+        // Holds the spans of one run, so its scores find them under concurrency
+        runKey: api.createContextKey("rag.pipeline.run"),
+        recordContent: Boolean(opts.recordContent)
+      };
+    }
+    function recordStage(tel, stage, span) {
+      const run = tel.api.context.active().getValue(tel.runKey);
+      if (run) run[stage] = span.spanContext();
     }
     function providerOf(component) {
       const name = component && component.name;
@@ -1749,8 +1861,8 @@ var require_otel = __commonJS({
         retriever(method, [params = {}]) {
           const source = component.collection || (typeof component.table === "string" ? component.table.replace(/"/g, "") : void 0);
           return {
-            name: source ? `retrieval ${source}` : "retrieval",
-            kind: SpanKind.CLIENT,
+            name: "retrieval",
+            kind: SpanKind.INTERNAL,
             attributes: clean({
               "gen_ai.operation.name": "retrieval",
               "gen_ai.data_source.id": source,
@@ -1808,6 +1920,7 @@ var require_otel = __commonJS({
           };
         }
       };
+      const STAGES = { retriever: "retrieval", llm: "generation" };
       const METHODS = {
         embedder: ["embed", "embedQuery"],
         retriever: ["retrieve"],
@@ -1821,8 +1934,10 @@ var require_otel = __commonJS({
           return (...args) => {
             const spec = spanFor[kind](prop, args);
             const options = { kind: spec.kind, attributes: spec.attributes };
+            const stage = STAGES[kind];
             if (prop === "generateStream") {
               return tel.tracer.startActiveSpan(spec.name, options, (span) => {
+                if (stage) recordStage(tel, stage, span);
                 const startedAt = performance.now();
                 let source;
                 try {
@@ -1836,6 +1951,7 @@ var require_otel = __commonJS({
               });
             }
             return inSpan(tel, spec.name, options, async (span) => {
+              if (stage) recordStage(tel, stage, span);
               const out = await value.apply(target, args);
               spec.after(span, out);
               return out;
@@ -1890,32 +2006,49 @@ var require_otel = __commonJS({
           "rag.pipeline.run",
           { kind: SpanKind.INTERNAL, attributes },
           async (span) => {
+            const stages = {};
+            const runContext = tel.api.context.active().setValue(tel.runKey, stages);
             let result;
             try {
-              result = await run(params);
+              result = await tel.api.context.with(runContext, () => run(params));
             } catch (error) {
               markError(tel, span, error);
               span.end();
               throw error;
             }
             if (result && typeof result[Symbol.asyncIterator] === "function") {
+              const iterator = result[Symbol.asyncIterator]();
               return (async function* tracedStream() {
+                let finished = false;
                 try {
-                  for await (const chunk of result) {
+                  for (; ; ) {
+                    const step = await tel.api.context.with(
+                      runContext,
+                      () => iterator.next()
+                    );
+                    if (step.done) break;
+                    const chunk = step.value;
                     if (chunk && chunk.done) {
                       span.setAttributes(runAttributes(tel, chunk));
+                      finishRun(tel, span, stages, chunk);
                     }
                     yield chunk;
                   }
+                  finished = true;
                 } catch (error) {
+                  finished = true;
                   markError(tel, span, error);
                   throw error;
                 } finally {
+                  if (!finished && typeof iterator.return === "function") {
+                    await iterator.return();
+                  }
                   span.end();
                 }
               })();
             }
             span.setAttributes(runAttributes(tel, result));
+            finishRun(tel, span, stages, result);
             if (!result || result.success === false) {
               const message = result && result.error || "run failed";
               span.setAttribute("error.type", errorType(message));
@@ -1927,6 +2060,33 @@ var require_otel = __commonJS({
         );
       };
     }
+    function finishRun(tel, span, stages, result) {
+      if (!result || typeof result !== "object") return;
+      const own = span.spanContext();
+      result.telemetry = {
+        traceId: own.traceId,
+        spanId: own.spanId,
+        spans: Object.fromEntries(
+          Object.entries(stages).map(([stage, ctx]) => [stage, ctx.spanId])
+        )
+      };
+      if (!tel.logger) return;
+      for (const score of evaluationScores(result, {
+        explanations: tel.recordContent
+      })) {
+        const parent = stages[score.target] || own;
+        tel.logger.emit({
+          eventName: "gen_ai.evaluation.result",
+          context: tel.api.trace.setSpanContext(tel.api.context.active(), parent),
+          attributes: clean({
+            "gen_ai.evaluation.name": score.name,
+            "gen_ai.evaluation.score.value": score.value,
+            "gen_ai.evaluation.score.label": score.label,
+            "gen_ai.evaluation.explanation": score.explanation
+          })
+        });
+      }
+    }
     function errorType(message) {
       if (message === "Execution timeout") return "timeout";
       if (message === "Execution aborted") return "aborted";
@@ -2437,17 +2597,114 @@ var require_scoring = __commonJS({
       return { values, parts: [...values, ...parts] };
     }
     function checkNumericConsistency(claimText, docText) {
-      const claimNumbers = [...new Set(extractNumbers(claimText).values)];
+      const claimNumbers = [
+        ...new Set(extractNumbers(withoutReferences(claimText)).values),
+        ...claimMonths(claimText).map((m) => `month:${m}`),
+        ...identifiers(claimText)
+      ];
       if (claimNumbers.length === 0) {
         return { consistent: true, claimNumbers, missing: [] };
       }
-      const docNumbers = new Set(extractNumbers(docText).parts);
+      const docNumbers = /* @__PURE__ */ new Set([
+        ...extractNumbers(docText).parts,
+        ...docMonths(docText).map((m) => `month:${m}`),
+        ...identifiers(docText)
+      ]);
       const missing = claimNumbers.filter((n) => !docNumbers.has(n));
       return { consistent: missing.length === 0, claimNumbers, missing };
     }
+    var REFERENCE_WORDS = "document|documents|doc|docs|source|sources|table|tables|figure|figures|fig|section|sections|step|steps|study|studies|appendix|chapter|page|pages|claim|claims|passage|passages|item|items|reference|ref|part|exhibit|equation|eq|line|row|column|note|footnote|paragraph";
+    var REFERENCE_RE = new RegExp(
+      `\\b(${REFERENCE_WORDS})\\.?\\s+\\d+[a-z]?\\b`,
+      "giu"
+    );
+    var IDENTIFIER_RE = new RegExp("(\\p{L}[\\p{L}\\p{N}]*)-(\\d+)\\b", "gu");
+    function identifiers(text) {
+      if (!text || typeof text !== "string") return [];
+      return [
+        ...new Set(
+          [...text.matchAll(IDENTIFIER_RE)].map((m) => `id:${m[0].toLowerCase()}`)
+        )
+      ];
+    }
+    function withoutReferences(text) {
+      if (!text || typeof text !== "string") return text;
+      return text.replace(REFERENCE_RE, " ").replace(IDENTIFIER_RE, (_, word) => word);
+    }
+    var MONTHS = [
+      ["january", "jan"],
+      ["february", "feb"],
+      ["march", "mar"],
+      ["april", "apr"],
+      ["may"],
+      ["june", "jun"],
+      ["july", "jul"],
+      ["august", "aug"],
+      ["september", "sep", "sept"],
+      ["october", "oct"],
+      ["november", "nov"],
+      ["december", "dec"]
+    ];
+    var MONTH_OF = new Map(
+      MONTHS.flatMap((names, i) => names.map((n) => [n, i + 1]))
+    );
+    function claimMonths(text) {
+      const words = String(text || "").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+      const out = [];
+      words.forEach((w, i) => {
+        const m = MONTH_OF.get(w);
+        if (!m) return;
+        const near = [words[i - 1], words[i + 1]].some(
+          (x) => /^\d+$/.test(x || "")
+        );
+        if (near) out.push(m);
+      });
+      return [...new Set(out)];
+    }
+    function docMonths(text) {
+      const t = String(text || "");
+      const out = /* @__PURE__ */ new Set();
+      for (const w of t.toLowerCase().split(/[^\p{L}]+/u)) {
+        const m = MONTH_OF.get(w);
+        if (m) out.add(m);
+      }
+      for (const [, a, b] of t.matchAll(
+        /\b(\d{1,2})[/.-](\d{1,2})[/.-]\d{2,4}\b/g
+      )) {
+        for (const v of [Number(a), Number(b)]) if (v >= 1 && v <= 12) out.add(v);
+      }
+      for (const [, mm] of t.matchAll(/\b\d{4}-(\d{1,2})-\d{1,2}\b/g)) {
+        const v = Number(mm);
+        if (v >= 1 && v <= 12) out.add(v);
+      }
+      return [...out];
+    }
     var NEGATION_WORDS = new Set(
-      "not no never none nobody nothing nowhere neither nor cannot without dont doesnt didnt isnt arent wasnt werent wont wouldnt shouldnt couldnt cant hasnt havent hadnt mustnt neednt".split(" ")
+      "not no never none nobody nothing nowhere neither nor cannot without dont doesnt didnt isnt arent wasnt werent wont wouldnt shouldnt couldnt cant hasnt havent hadnt mustnt neednt nicht kein keine keinen keinem keiner keines nie niemals nunca jam\xE1s jamas nadie nada tampoco ni pas jamais rien aucun aucune".split(" ")
     );
+    var CLAUSE_BOUNDARY_WORDS = new Set(
+      "but whereas although though while however yet and or except unlike".split(
+        " "
+      )
+    );
+    function clauseTokens(text) {
+      const out = [];
+      for (const part of String(text || "").split(/[,;:()[\]]+/)) {
+        let current = [];
+        for (const t of tokenize(part)) {
+          if (CLAUSE_BOUNDARY_WORDS.has(t)) {
+            if (current.length) out.push(current);
+            current = [];
+          } else {
+            current.push(t);
+          }
+        }
+        if (current.length) out.push(current);
+      }
+      return out;
+    }
+    var stem = (t) => t.length > 4 ? t.replace(/(ing|ed|es|s|e)$/, "") : t;
+    var CONTINUING_NEGATIONS = /* @__PURE__ */ new Set(["nor", "ni"]);
     var NON_NEGATING_NEXT = {
       not: /* @__PURE__ */ new Set(["only", "just", "merely"]),
       no: /* @__PURE__ */ new Set(["doubt", "matter"]),
@@ -2458,6 +2715,7 @@ var require_scoring = __commonJS({
       for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
         if (!NEGATION_WORDS.has(t)) continue;
+        if (CONTINUING_NEGATIONS.has(t) && count > 0) continue;
         if (NON_NEGATING_NEXT[t] && NON_NEGATING_NEXT[t].has(tokens[i + 1])) {
           continue;
         }
@@ -2466,38 +2724,62 @@ var require_scoring = __commonJS({
       return count % 2 === 1;
     }
     function checkPolarityConsistency(claimText, docText) {
-      const claimTokens = tokenize(claimText);
-      const claimNegated = isNegated(claimTokens);
-      const claimWords = [
+      const words = (tokens) => [
         ...new Set(
-          contentTokens(claimTokens.filter((t) => !NEGATION_WORDS.has(t)))
+          contentTokens(tokens.filter((t) => !NEGATION_WORDS.has(t))).map(stem)
         )
       ];
-      if (claimWords.length === 0) {
-        return { consistent: true, claimNegated, sourceSentence: null };
-      }
-      const candidates = splitSentences(docText).map((sentence) => {
-        const tokens = tokenize(sentence);
-        const set = new Set(tokens);
-        const support = claimWords.filter((t) => set.has(t)).length / claimWords.length;
-        return { sentence, tokens, support };
-      }).filter((c) => c.support > 0).sort((a, b) => b.support - a.support);
-      if (candidates.length === 0) {
+      const claimClauses = clauseTokens(claimText).map((tokens) => ({ tokens, words: words(tokens) })).filter((c) => c.words.length > 0);
+      const claimNegated = claimClauses.some((c) => isNegated(c.tokens));
+      if (claimClauses.length === 0) {
         return { consistent: true, claimNegated, sourceSentence: null };
       }
-      const best = candidates[0].support;
-      const compared = candidates.filter((c) => c.support === best);
-      const match = compared.find((c) => isNegated(c.tokens) === claimNegated);
-      return {
-        consistent: Boolean(match),
-        claimNegated,
-        sourceSentence: (match || compared[0]).sentence
+      const sentences = splitSentences(docText).map((sentence) => {
+        const clauses = clauseTokens(sentence).map((tokens) => ({
+          negated: isNegated(tokens),
+          stems: new Set(tokens.map(stem))
+        }));
+        const stems = new Set(clauses.flatMap((c) => [...c.stems]));
+        return { sentence, clauses, stems };
+      });
+      const agrees = (clause, sentence) => {
+        const negated = isNegated(clause.tokens);
+        const distinctive = clause.words.map((w) => sentence.clauses.filter((c) => c.stems.has(w))).filter((owners) => owners.length === 1).map((owners) => owners[0]);
+        if (distinctive.length > 0) {
+          return distinctive.every((c) => c.negated === negated);
+        }
+        const ranked = sentence.clauses.map((c) => ({
+          c,
+          support: clause.words.filter((w) => c.stems.has(w)).length
+        })).filter((r) => r.support > 0).sort((a, b) => b.support - a.support);
+        if (ranked.length === 0) return true;
+        const best = ranked[0].support;
+        return ranked.filter((r) => r.support === best).some((r) => r.c.negated === negated);
       };
+      let consistent = true;
+      let sourceSentence = null;
+      for (const clause of claimClauses) {
+        const candidates = sentences.map((s) => ({
+          ...s,
+          support: clause.words.filter((w) => s.stems.has(w)).length / clause.words.length
+        })).filter((s) => s.support > 0).sort((a, b) => b.support - a.support);
+        if (candidates.length === 0) continue;
+        const best = candidates[0].support;
+        const compared = candidates.filter((s) => s.support === best);
+        const match = compared.find((s) => agrees(clause, s));
+        if (!match) consistent = false;
+        if (sourceSentence === null || !match) {
+          sourceSentence = (match || compared[0]).sentence;
+        }
+      }
+      return { consistent, claimNegated, sourceSentence };
     }
     var POLARITY_MISMATCH_FACTOR = 0.4;
     var NUMERIC_MISMATCH_FACTOR = 0.4;
     function computeSupportScore(claimTokens, docTokens, idfWeights = null, options = {}) {
-      const claim = [...new Set(contentTokens(claimTokens))];
+      const rawClaim = options && options.claimText;
+      const fromText = typeof rawClaim === "string" && rawClaim !== withoutReferences(rawClaim) ? tokenize(withoutReferences(rawClaim)) : claimTokens;
+      const claim = [...new Set(contentTokens(fromText))];
       if (claim.length === 0) return 0;
       const docSet = docTokens instanceof Set ? docTokens : new Set(docTokens);
       let matched = 0;
@@ -5101,7 +5383,79 @@ var require_connector_utils = __commonJS({
         reader.releaseLock();
       }
     }
+    function toConnectorError(err, provider) {
+      if (!err || typeof err !== "object" || err.isAxiosError !== true) {
+        return err;
+      }
+      if (isAbortError(err)) {
+        const aborted = new Error("The operation was aborted");
+        aborted.name = "AbortError";
+        aborted.code = "ABORT_ERR";
+        return aborted;
+      }
+      const response = err.response;
+      let message;
+      if (response) {
+        const data = response.data;
+        const apiError = data && typeof data === "object" && typeof data.pipe !== "function" ? data.error : void 0;
+        let detail = "";
+        if (apiError && typeof apiError === "object") {
+          detail = [apiError.type, apiError.message].filter(Boolean).join(": ");
+        } else if (typeof apiError === "string") {
+          detail = apiError;
+        } else if (data && typeof data === "object" && typeof data.message === "string") {
+          detail = data.message;
+        }
+        message = `${provider} API error ${response.status}${detail ? `: ${detail}` : ""}`;
+      } else {
+        message = `${provider} request failed: ${err.message}`;
+      }
+      const error = new Error(message);
+      if (err.code) error.code = err.code;
+      if (response) {
+        error.status = response.status;
+        error.response = {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers,
+          data: response.data
+        };
+      }
+      return error;
+    }
+    async function readErrorBody(stream) {
+      const chunks = [];
+      let size = 0;
+      try {
+        for await (const chunk of stream) {
+          size += chunk.length;
+          if (size > 65536) break;
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        }
+      } catch {
+      } finally {
+        if (typeof stream.destroy === "function") stream.destroy();
+      }
+      const text = Buffer.concat(chunks).toString("utf8");
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text || void 0;
+      }
+    }
+    function cleanAxiosErrors(client, provider) {
+      client.interceptors.response.use(void 0, async (err) => {
+        const data = err && err.response && err.response.data;
+        if (data && typeof data.pipe === "function") {
+          err.response.data = await readErrorBody(data);
+        }
+        throw toConnectorError(err, provider);
+      });
+      return client;
+    }
     module2.exports = {
+      toConnectorError,
+      cleanAxiosErrors,
       textChunks,
       createAbortError,
       isAbortError,
@@ -5640,6 +5994,23 @@ var require_cost_calculator = __commonJS({
         source: "https://platform.claude.com/docs/en/about-claude/pricing",
         asOf: "2026-11-01"
       },
+      // $0.10 / $0.50 per million input / output tokens, for prompts up to
+      // 100,000 tokens ($0.50 / $2.50 above; this table has one price per model).
+      "claude-haiku-5.5": {
+        input: 1e-4,
+        output: 5e-4,
+        unit: 1e3,
+        source: "https://platform.claude.com/docs/en/about-claude/pricing",
+        asOf: "2026-11-05"
+      },
+      // $10 / $50 per million input / output tokens.
+      "claude-fable-5.1": {
+        input: 0.01,
+        output: 0.05,
+        unit: 1e3,
+        source: "https://platform.claude.com/docs/en/about-claude/pricing",
+        asOf: "2026-11-05"
+      },
       "cohere-command": {
         input: 1e-3,
         output: 2e-3,
@@ -6032,6 +6403,8 @@ var require_cost_tracker = __commonJS({
       budgetOptions: {}
     };
     var CHARS_PER_TOKEN = 4;
+    var PROMPT_OVERHEAD_CHARS = 600;
+    var PASSAGE_WRAPPER_CHARS = 40;
     var CostTracker = class extends EventEmitter {
       /**
        * @param {object} [options]
@@ -6071,9 +6444,18 @@ var require_cost_tracker = __commonJS({
         }
         const inputText = result.input || result.query || result.prompt || "";
         const outputText = result.output || result.answer || result.response || "";
+        const passages = Array.isArray(result.results) ? result.results : [];
+        const passageChars = passages.reduce((n, doc) => {
+          const text = typeof doc === "string" ? doc : doc && (doc.content || doc.text) || "";
+          return n + String(text).length + PASSAGE_WRAPPER_CHARS;
+        }, 0);
+        const promptChars = passages.length > 0 ? PROMPT_OVERHEAD_CHARS : 0;
         return {
-          inputTokens: Math.ceil(String(inputText).length / CHARS_PER_TOKEN),
-          outputTokens: Math.ceil(String(outputText).length / CHARS_PER_TOKEN)
+          inputTokens: Math.ceil(
+            (String(inputText).length + passageChars + promptChars) / CHARS_PER_TOKEN
+          ),
+          outputTokens: Math.ceil(String(outputText).length / CHARS_PER_TOKEN),
+          estimated: true
         };
       }
       /**
@@ -6096,7 +6478,7 @@ var require_cost_tracker = __commonJS({
               tracker.startSession({ autoStarted: true });
             }
             const result = await pipeline.run(...args);
-            const { inputTokens, outputTokens } = tracker._extractUsage(result);
+            const { inputTokens, outputTokens, estimated } = tracker._extractUsage(result);
             const model = result.model || result.route && result.route.model || tracker.config.model;
             const costEstimate = tracker.calculator.estimate(
               model,
@@ -6123,8 +6505,14 @@ var require_cost_tracker = __commonJS({
               inputTokens,
               outputTokens,
               estimatedCost: costEstimate.totalCost,
+              // The price-table entry used (as before), and the model the run
+              // asked for, which can differ in form (claude-haiku-4-5 is priced
+              // as claude-haiku-4.5)
               model: costEstimate.model,
-              currency: "USD"
+              requestedModel: model,
+              currency: "USD",
+              // Token counts estimated from text length (no usage reported)
+              ...estimated && { tokensEstimated: true }
             };
             const entry = {
               timestamp: Date.now(),
@@ -6811,9 +7199,15 @@ var require_core = __commonJS({
     var { createModelRouter, classifyQuery } = require_model_router();
     var { MemoryRetriever } = require_memory_retriever();
     var { BaseConnector } = require_base_connector();
+    var {
+      evaluationScores,
+      toLangfuseScores
+    } = require_scores();
     module2.exports = {
       createRagPipeline,
       createPipeline: createRagPipeline,
+      evaluationScores,
+      toLangfuseScores,
       packContext,
       createError: errorFormatter.createError,
       wrapError: errorFormatter.wrapError,
@@ -6873,6 +7267,7 @@ var modules = {
   "evaluate/relevance.js": () => require_relevance(),
   "evaluate/scoring.js": () => require_scoring(),
   "observability/otel.js": () => require_otel(),
+  "observability/scores.js": () => require_scores(),
   "packages/core.js": () => require_core(),
   "reranker/cascade-reranker.js": () => require_cascade_reranker(),
   "reranker/embedding-reranker.js": () => require_embedding_reranker(),