@od-oneapp/ai-platform 0.1.0

package/dist/grounding-proof-map.mjs

@@ -0,0 +1,26 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { a as checkStatus, c as editSchema, d as proofMapSchema, f as proofStatus, g as validateSafeEdits, h as applyPatch, i as checkSchema, l as getCriticalClaims, m as verificationSchema, n as verifyProof, o as claimSchema, p as stepSchema, r as chainSchema, s as criticalClaimsPass, t as runProofLoop, u as hasFailingChecks } from "./loop-BOYEtr2g.mjs";
+
+//#region src/grounding/proof-map/index.ts
+var proof_map_exports = /* @__PURE__ */ __exportAll({
+	applyPatch: () => applyPatch,
+	chainSchema: () => chainSchema,
+	checkSchema: () => checkSchema,
+	checkStatus: () => checkStatus,
+	claimSchema: () => claimSchema,
+	criticalClaimsPass: () => criticalClaimsPass,
+	editSchema: () => editSchema,
+	getCriticalClaims: () => getCriticalClaims,
+	hasFailingChecks: () => hasFailingChecks,
+	proofMapSchema: () => proofMapSchema,
+	proofStatus: () => proofStatus,
+	runProofLoop: () => runProofLoop,
+	stepSchema: () => stepSchema,
+	validateSafeEdits: () => validateSafeEdits,
+	verificationSchema: () => verificationSchema,
+	verifyProof: () => verifyProof
+});
+
+//#endregion
+export { applyPatch, chainSchema, checkSchema, checkStatus, claimSchema, criticalClaimsPass, editSchema, getCriticalClaims, hasFailingChecks, proofMapSchema, proofStatus, runProofLoop, stepSchema, proof_map_exports as t, validateSafeEdits, verificationSchema, verifyProof };
+//# sourceMappingURL=grounding-proof-map.mjs.map

package/dist/grounding-proof-map.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding-proof-map.mjs","names":[],"sources":["../src/grounding/proof-map/index.ts"],"sourcesContent":["/**\n * @fileoverview Proof Map Module.\n *\n * Exports proof map utilities for multi-model proof loops, patch application,\n * and schema definitions for proof map data structures.\n *\n * @module @od-oneapp/ai-platform/proof-map\n * @example\n * ```ts\n * import { createProofLoop } from \"@od-oneapp/ai-platform/proof-map\";\n *\n * const loop = createProofLoop({ maxDepth: 2 });\n * ```\n */\n\n/**\n * Patch application utilities for proof maps.\n * @example\n * ```ts\n * import { applyPatch } from \"@od-oneapp/ai-platform/proof-map\";\n * ```\n */\nexport * from './applyPatch';\n\n/**\n * Proof loop executor and helpers.\n * @example\n * ```ts\n * import { createProofLoop } from \"@od-oneapp/ai-platform/proof-map\";\n * ```\n */\nexport * from './loop';\n\n/**\n * Proof-map schema definitions.\n * @example\n * ```ts\n * import { proofMapSchema } from \"@od-oneapp/ai-platform/proof-map\";\n * ```\n */\nexport * from './schema';\n"],"mappings":""}

package/dist/grounding-rag.d.mts

@@ -0,0 +1,10 @@
+import "./schemas-DBOhxgW7.mjs";
+import { A as ResearchPipelineResult, C as PerplexityResponse, D as ReasoningGap, E as ReasoningClaim, F as VerificationOutput, I as VerificationTrace, M as ResearchStep, N as ResearchTier, O as ReasoningOutput, P as VerificationFlag, S as ContextExpansionResult, T as PipelineStageKind, _ as startStep, a as TraceStep, b as researchWithPerplexity, c as endStep, d as loadRun, f as loadStepArtifact, g as startRun, h as persistStep, i as TraceRun, j as ResearchRun, k as ResearchConfig, l as estimateCost, m as persistRunMeta, n as createResearchTool, o as TraceStepKind, p as persistRunIndex, r as DEFAULT_COST_RATES, s as endRun, t as ResearchInput, u as listRuns, v as executeResearchPipeline, w as PipelineModelConfig, x as verifyWithGPT5, y as reasonWithSonnet } from "./tool-Btbththq.mjs";
+
+//#region src/grounding/rag/index.d.ts
+declare namespace index_d_exports {
+  export { ContextExpansionResult, DEFAULT_COST_RATES, PerplexityResponse, PipelineModelConfig, PipelineStageKind, ReasoningClaim, ReasoningGap, ReasoningOutput, ResearchConfig, ResearchInput, ResearchPipelineResult, ResearchRun, ResearchStep, ResearchTier, TraceRun, TraceStep, TraceStepKind, VerificationFlag, VerificationOutput, VerificationTrace, createResearchTool, endRun, endStep, estimateCost, executeResearchPipeline, listRuns, loadRun, loadStepArtifact, persistRunIndex, persistRunMeta, persistStep, reasonWithSonnet, researchWithPerplexity, startRun, startStep, verifyWithGPT5 };
+}
+//#endregion
+export { type ContextExpansionResult, DEFAULT_COST_RATES, type PerplexityResponse, type PipelineModelConfig, type PipelineStageKind, type ReasoningClaim, type ReasoningGap, type ReasoningOutput, type ResearchConfig, type ResearchInput, type ResearchPipelineResult, type ResearchRun, type ResearchStep, type ResearchTier, type TraceRun, type TraceStep, type TraceStepKind, type VerificationFlag, type VerificationOutput, type VerificationTrace, createResearchTool, endRun, endStep, estimateCost, executeResearchPipeline, listRuns, loadRun, loadStepArtifact, persistRunIndex, persistRunMeta, persistStep, reasonWithSonnet, researchWithPerplexity, startRun, startStep, index_d_exports as t, verifyWithGPT5 };
+//# sourceMappingURL=grounding-rag.d.mts.map

package/dist/grounding-rag.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding-rag.d.mts","names":[],"sources":["../src/grounding/rag/index.ts"],"mappings":""}

package/dist/grounding-rag.mjs

@@ -0,0 +1,27 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { _ as verifyWithGPT5, a as estimateCost, c as loadStepArtifact, d as persistStep, f as startRun, g as researchWithPerplexity, h as reasonWithSonnet, i as endStep, l as persistRunIndex, m as executeResearchPipeline, n as DEFAULT_COST_RATES, o as listRuns, p as startStep, r as endRun, s as loadRun, t as createResearchTool, u as persistRunMeta } from "./tool-JSf8JXZ8.mjs";
+
+//#region src/grounding/rag/index.ts
+var rag_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_COST_RATES: () => DEFAULT_COST_RATES,
+	createResearchTool: () => createResearchTool,
+	endRun: () => endRun,
+	endStep: () => endStep,
+	estimateCost: () => estimateCost,
+	executeResearchPipeline: () => executeResearchPipeline,
+	listRuns: () => listRuns,
+	loadRun: () => loadRun,
+	loadStepArtifact: () => loadStepArtifact,
+	persistRunIndex: () => persistRunIndex,
+	persistRunMeta: () => persistRunMeta,
+	persistStep: () => persistStep,
+	reasonWithSonnet: () => reasonWithSonnet,
+	researchWithPerplexity: () => researchWithPerplexity,
+	startRun: () => startRun,
+	startStep: () => startStep,
+	verifyWithGPT5: () => verifyWithGPT5
+});
+
+//#endregion
+export { DEFAULT_COST_RATES, createResearchTool, endRun, endStep, estimateCost, executeResearchPipeline, listRuns, loadRun, loadStepArtifact, persistRunIndex, persistRunMeta, persistStep, reasonWithSonnet, researchWithPerplexity, startRun, startStep, rag_exports as t, verifyWithGPT5 };
+//# sourceMappingURL=grounding-rag.mjs.map

package/dist/grounding-rag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding-rag.mjs","names":[],"sources":["../src/grounding/rag/index.ts"],"sourcesContent":["/**\n * @fileoverview Multi-model research pipeline module.\n *\n * Production-ready three-stage research pipeline (context expansion → reasoning → verification).\n * All models are configurable via PipelineModelConfig.\n *\n * Features:\n * - Configurable model selection per stage via PipelineModelConfig\n * - Context expansion with Perplexity API or AI SDK fallback\n * - Full trace storage with cost/latency tracking\n * - Tool integration for AI SDK agents\n * - Compliance signal support\n *\n * @module @od-oneapp/ai-platform/research\n */\n\n// Core pipeline functions\nexport {\n  executeResearchPipeline,\n  reasonWithSonnet,\n  researchWithPerplexity,\n  verifyWithGPT5,\n} from './pipeline';\n\n// Tool for agent integration\nexport { createResearchTool, type ResearchInput } from './tool';\n\n// Trace storage and utilities\nexport {\n  DEFAULT_COST_RATES,\n  endRun,\n  endStep,\n  estimateCost,\n  listRuns,\n  loadRun,\n  loadStepArtifact,\n  persistRunIndex,\n  persistRunMeta,\n  persistStep,\n  startRun,\n  startStep,\n  type TraceRun,\n  type TraceStep,\n  type TraceStepKind,\n} from './trace';\n\n// Type definitions\nexport type {\n  ContextExpansionResult,\n  PerplexityResponse,\n  PipelineModelConfig,\n  PipelineStageKind,\n  ReasoningClaim,\n  ReasoningGap,\n  ReasoningOutput,\n  ResearchConfig,\n  ResearchPipelineResult,\n  ResearchRun,\n  ResearchStep,\n  ResearchTier,\n  VerificationFlag,\n  VerificationOutput,\n  VerificationTrace,\n} from './types';\n"],"mappings":""}

package/dist/grounding-verification.d.mts

@@ -0,0 +1,48 @@
+//#region src/grounding/verification/index.d.ts
+interface KnowledgeSource {
+  readonly id: string;
+  readonly content: string;
+  readonly reliability?: number;
+  readonly metadata?: {
+    url?: string;
+    title?: string;
+    author?: string;
+    date?: Date;
+    category?: string;
+  };
+}
+interface VerificationResult {
+  readonly claim: string;
+  readonly verified: boolean;
+  readonly confidence: number;
+  readonly verdict: 'supported' | 'refuted' | 'inconclusive' | 'no_evidence';
+  readonly sources: string[];
+  readonly evidence: VerificationEvidence[];
+  readonly metadata?: Record<string, unknown>;
+}
+interface VerificationEvidence {
+  readonly sourceId: string;
+  readonly excerpt: string;
+  readonly relevance: number;
+  readonly stance: 'supports' | 'refutes' | 'neutral';
+  readonly confidence: number;
+}
+interface VerificationConfig {
+  readonly minConfidence?: number;
+  readonly maxSources?: number;
+  readonly includeNeutral?: boolean;
+  readonly requireMultipleSources?: boolean;
+}
+interface FactVerifier {
+  addSource(source: KnowledgeSource): void;
+  removeSource(id: string): void;
+  getSources(): KnowledgeSource[];
+  verify(claim: string, config?: VerificationConfig): Promise<VerificationResult>;
+  verifyBatch(claims: string[], config?: VerificationConfig): Promise<VerificationResult[]>;
+  getConfig(): VerificationConfig;
+}
+declare function createFactVerifier(config?: VerificationConfig): FactVerifier;
+declare const verifyFact: (claim: string, config?: VerificationConfig) => Promise<VerificationResult>;
+//#endregion
+export { FactVerifier, KnowledgeSource, VerificationConfig, VerificationEvidence, VerificationResult, createFactVerifier, verifyFact };
+//# sourceMappingURL=grounding-verification.d.mts.map

package/dist/grounding-verification.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding-verification.d.mts","names":[],"sources":["../src/grounding/verification/index.ts"],"mappings":";UAmCiB,eAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA;EAAA,SACA,WAAA;EAAA,SACA,QAAA;IACP,GAAA;IACA,KAAA;IACA,MAAA;IACA,IAAA,GAAO,IAAA;IACP,QAAA;EAAA;AAAA;AAAA,UAKa,kBAAA;EAAA,SACN,KAAA;EAAA,SACA,QAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,oBAAA;EAAA,SACV,QAAA,GAAW,MAAA;AAAA;AAAA,UAIL,oBAAA;EAAA,SACN,QAAA;EAAA,SACA,OAAA;EAAA,SACA,SAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;AAAA;AAAA,UAIM,kBAAA;EAAA,SACN,aAAA;EAAA,SACA,UAAA;EAAA,SACA,cAAA;EAAA,SACA,sBAAA;AAAA;AAAA,UAIM,YAAA;EACf,SAAA,CAAU,MAAA,EAAQ,eAAA;EAClB,YAAA,CAAa,EAAA;EACb,UAAA,IAAc,eAAA;EACd,MAAA,CAAO,KAAA,UAAe,MAAA,GAAS,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EAC5D,WAAA,CAAY,MAAA,YAAkB,MAAA,GAAS,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EACpE,SAAA,IAAa,kBAAA;AAAA;AAAA,iBA4BC,kBAAA,CAAmB,MAAA,GAAQ,kBAAA,GAA0B,YAAA;AAAA,cAuGxD,UAAA,GACX,KAAA,UACA,MAAA,GAAS,kBAAA,KACR,OAAA,CAAQ,kBAAA"}

package/dist/grounding-verification.mjs

@@ -0,0 +1,224 @@
+//#region src/grounding/verification/index.ts
+/**
+* Creates a fact verifier for checking claims against knowledge sources.
+*
+* @example
+* ```typescript
+* const verifier = createFactVerifier({
+*   minConfidence: 0.6,
+*   maxSources: 3,
+*   requireMultipleSources: true
+* });
+*
+* verifier.addSource({
+*   id: 'fact-db',
+*   content: 'Water boils at 100 degrees Celsius at sea level.',
+*   reliability: 0.99
+* });
+*
+* const result = await verifier.verify('Water boils at 100°C');
+* // result.verdict === 'supported'
+* ```
+*/
+function createFactVerifier(config = {}) {
+	const { minConfidence = .5, maxSources = 10, includeNeutral = false, requireMultipleSources = false } = config;
+	const sources = /* @__PURE__ */ new Map();
+	function addSource(source) {
+		sources.set(source.id, source);
+	}
+	function removeSource(id) {
+		sources.delete(id);
+	}
+	function getSources() {
+		return Array.from(sources.values());
+	}
+	async function verify(claim, overrideConfig) {
+		const effectiveConfig = {
+			...config,
+			...overrideConfig
+		};
+		const effectiveMaxSources = effectiveConfig.maxSources ?? maxSources;
+		const allEvidence = [];
+		for (const source of sources.values()) {
+			const evidence = findEvidence(claim, source);
+			if (evidence) allEvidence.push(evidence);
+			if (allEvidence.length >= effectiveMaxSources * 2) break;
+		}
+		allEvidence.sort((a, b) => b.relevance - a.relevance);
+		const relevantEvidence = allEvidence.slice(0, effectiveMaxSources).filter((e) => e.confidence >= (effectiveConfig.minConfidence ?? minConfidence));
+		const { verdict, confidence, verified } = computeVerdict(relevantEvidence, effectiveConfig);
+		const sourceIds = relevantEvidence.filter((e) => !includeNeutral ? e.stance !== "neutral" : true).map((e) => e.sourceId);
+		return {
+			claim,
+			verified,
+			confidence,
+			verdict,
+			sources: [...new Set(sourceIds)],
+			evidence: relevantEvidence
+		};
+	}
+	async function verifyBatch(claims, overrideConfig) {
+		return Promise.all(claims.map((claim) => verify(claim, overrideConfig)));
+	}
+	function getConfig() {
+		return {
+			minConfidence,
+			maxSources,
+			includeNeutral,
+			requireMultipleSources
+		};
+	}
+	return {
+		addSource,
+		removeSource,
+		getSources,
+		verify,
+		verifyBatch,
+		getConfig
+	};
+}
+/**
+* Verify a single fact claim.
+* @deprecated Use createFactVerifier() instead
+*/
+const verifyFact = async (claim, config) => {
+	return createFactVerifier(config).verify(claim);
+};
+/**
+* Find evidence for a claim within a source.
+*/
+function findEvidence(claim, source) {
+	const claimTokens = tokenize(claim);
+	if (claimTokens.length === 0) return null;
+	const excerpts = extractExcerpts(source.content, 150);
+	let bestExcerpt = "";
+	let bestRelevance = 0;
+	for (const excerpt of excerpts) {
+		const relevance = computeRelevance(claimTokens, excerpt);
+		if (relevance > bestRelevance) {
+			bestRelevance = relevance;
+			bestExcerpt = excerpt;
+		}
+	}
+	if (bestRelevance < .2) return null;
+	const stance = determineStance(claim, bestExcerpt);
+	const sourceReliability = source.reliability ?? .7;
+	const confidence = bestRelevance * sourceReliability;
+	return {
+		sourceId: source.id,
+		excerpt: bestExcerpt,
+		relevance: bestRelevance,
+		stance,
+		confidence
+	};
+}
+/**
+* Extract overlapping excerpts from text.
+*/
+function extractExcerpts(text, maxLength) {
+	const excerpts = [];
+	const sentences = text.match(/[^.!?]+[.!?]+/g) ?? [text];
+	let current = "";
+	for (const sentence of sentences) {
+		const trimmed = sentence.trim();
+		if (current.length + trimmed.length <= maxLength) current += (current ? " " : "") + trimmed;
+		else {
+			if (current) excerpts.push(current);
+			current = trimmed.length <= maxLength ? trimmed : trimmed.slice(0, maxLength);
+		}
+	}
+	if (current) excerpts.push(current);
+	return excerpts;
+}
+/**
+* Compute relevance between claim tokens and excerpt.
+*/
+function computeRelevance(claimTokens, excerpt) {
+	const excerptTokens = new Set(tokenize(excerpt));
+	if (excerptTokens.size === 0) return 0;
+	let matches = 0;
+	for (const token of claimTokens) if (excerptTokens.has(token)) matches++;
+	return claimTokens.length > 0 ? matches / claimTokens.length : 0;
+}
+/**
+* Determine if excerpt supports, refutes, or is neutral toward claim.
+*/
+function determineStance(claim, excerpt) {
+	const claimLower = claim.toLowerCase();
+	const excerptLower = excerpt.toLowerCase();
+	const negationPatterns = [
+		/\bnot\b/,
+		/\bnever\b/,
+		/\bno\b/,
+		/\bfalse\b/,
+		/\bincorrect\b/,
+		/\bwrong\b/,
+		/\buntrue\b/,
+		/\bdoes not\b/,
+		/\bdoesn't\b/,
+		/\bisn't\b/,
+		/\baren't\b/,
+		/\bwasn't\b/,
+		/\bweren't\b/
+	];
+	if (negationPatterns.some((p) => p.test(claimLower)) !== negationPatterns.some((p) => p.test(excerptLower))) return "refutes";
+	const claimTokens = new Set(tokenize(claim));
+	const excerptTokens = new Set(tokenize(excerpt));
+	let overlap = 0;
+	for (const token of claimTokens) if (excerptTokens.has(token)) overlap++;
+	const similarity = claimTokens.size > 0 ? overlap / claimTokens.size : 0;
+	if (similarity > .5) return "supports";
+	if (similarity > .2) return "neutral";
+	return "neutral";
+}
+/**
+* Compute overall verdict from evidence.
+*/
+function computeVerdict(evidence, config) {
+	if (evidence.length === 0) return {
+		verdict: "no_evidence",
+		confidence: 0,
+		verified: false
+	};
+	let supportScore = 0;
+	let refuteScore = 0;
+	let totalWeight = 0;
+	for (const e of evidence) {
+		const weight = e.confidence * e.relevance;
+		totalWeight += weight;
+		if (e.stance === "supports") supportScore += weight;
+		else if (e.stance === "refutes") refuteScore += weight;
+	}
+	if (config.requireMultipleSources && evidence.length < 2) return {
+		verdict: "inconclusive",
+		confidence: .3,
+		verified: false
+	};
+	const supportRatio = totalWeight > 0 ? supportScore / totalWeight : 0;
+	const refuteRatio = totalWeight > 0 ? refuteScore / totalWeight : 0;
+	if (supportRatio > .6) return {
+		verdict: "supported",
+		confidence: Math.min(.99, supportRatio * .9 + evidence.length * .05),
+		verified: true
+	};
+	if (refuteRatio > .6) return {
+		verdict: "refuted",
+		confidence: Math.min(.99, refuteRatio * .9 + evidence.length * .05),
+		verified: false
+	};
+	return {
+		verdict: "inconclusive",
+		confidence: evidence.reduce((s, e) => s + e.confidence, 0) / evidence.length * .5,
+		verified: false
+	};
+}
+/**
+* Tokenize text into lowercase words.
+*/
+function tokenize(text) {
+	return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2);
+}
+
+//#endregion
+export { createFactVerifier, verifyFact };
+//# sourceMappingURL=grounding-verification.mjs.map

package/dist/grounding-verification.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding-verification.mjs","names":[],"sources":["../src/grounding/verification/index.ts"],"sourcesContent":["/**\n * Fact Verification\n *\n * Verifies factual claims against knowledge sources and assigns\n * confidence scores for truthfulness assessment.\n *\n * @module @od-oneapp/ai-platform/grounding/verification\n *\n * @example\n * ```typescript\n * import { createFactVerifier } from '@od-oneapp/ai-platform/grounding/verification';\n *\n * const verifier = createFactVerifier({\n *   minConfidence: 0.7,\n *   maxSources: 5\n * });\n *\n * // Add knowledge sources\n * verifier.addSource({\n *   id: 'wiki-1',\n *   content: 'The Earth orbits the Sun.',\n *   reliability: 0.95\n * });\n *\n * // Verify a claim\n * const result = await verifier.verify('Earth revolves around the Sun.');\n * console.log(`Verified: ${result.verified}, Confidence: ${result.confidence}`);\n * ```\n */\n\n// -----------------------------------------------------------------------------\n// Types\n// -----------------------------------------------------------------------------\n\n/** Knowledge source for verification */\nexport interface KnowledgeSource {\n  readonly id: string;\n  readonly content: string;\n  readonly reliability?: number; // 0-1, source trustworthiness\n  readonly metadata?: {\n    url?: string;\n    title?: string;\n    author?: string;\n    date?: Date;\n    category?: string;\n  };\n}\n\n/** Verification result for a claim */\nexport interface VerificationResult {\n  readonly claim: string;\n  readonly verified: boolean;\n  readonly confidence: number; // 0-1\n  readonly verdict: 'supported' | 'refuted' | 'inconclusive' | 'no_evidence';\n  readonly sources: string[]; // Source IDs that support/refute\n  readonly evidence: VerificationEvidence[];\n  readonly metadata?: Record<string, unknown>;\n}\n\n/** Evidence from a source */\nexport interface VerificationEvidence {\n  readonly sourceId: string;\n  readonly excerpt: string;\n  readonly relevance: number; // 0-1\n  readonly stance: 'supports' | 'refutes' | 'neutral';\n  readonly confidence: number;\n}\n\n/** Verifier configuration */\nexport interface VerificationConfig {\n  readonly minConfidence?: number;\n  readonly maxSources?: number;\n  readonly includeNeutral?: boolean;\n  readonly requireMultipleSources?: boolean;\n}\n\n/** Fact verifier interface */\nexport interface FactVerifier {\n  addSource(source: KnowledgeSource): void;\n  removeSource(id: string): void;\n  getSources(): KnowledgeSource[];\n  verify(claim: string, config?: VerificationConfig): Promise<VerificationResult>;\n  verifyBatch(claims: string[], config?: VerificationConfig): Promise<VerificationResult[]>;\n  getConfig(): VerificationConfig;\n}\n\n// -----------------------------------------------------------------------------\n// Implementation\n// -----------------------------------------------------------------------------\n\n/**\n * Creates a fact verifier for checking claims against knowledge sources.\n *\n * @example\n * ```typescript\n * const verifier = createFactVerifier({\n *   minConfidence: 0.6,\n *   maxSources: 3,\n *   requireMultipleSources: true\n * });\n *\n * verifier.addSource({\n *   id: 'fact-db',\n *   content: 'Water boils at 100 degrees Celsius at sea level.',\n *   reliability: 0.99\n * });\n *\n * const result = await verifier.verify('Water boils at 100°C');\n * // result.verdict === 'supported'\n * ```\n */\nexport function createFactVerifier(config: VerificationConfig = {}): FactVerifier {\n  const {\n    minConfidence = 0.5,\n    maxSources = 10,\n    includeNeutral = false,\n    requireMultipleSources = false,\n  } = config;\n\n  const sources = new Map<string, KnowledgeSource>();\n\n  function addSource(source: KnowledgeSource): void {\n    sources.set(source.id, source);\n  }\n\n  function removeSource(id: string): void {\n    sources.delete(id);\n  }\n\n  function getSources(): KnowledgeSource[] {\n    return Array.from(sources.values());\n  }\n\n  async function verify(\n    claim: string,\n    overrideConfig?: VerificationConfig,\n  ): Promise<VerificationResult> {\n    const effectiveConfig = { ...config, ...overrideConfig };\n    const effectiveMaxSources = effectiveConfig.maxSources ?? maxSources;\n\n    // Find relevant evidence from sources\n    const allEvidence: VerificationEvidence[] = [];\n\n    for (const source of sources.values()) {\n      const evidence = findEvidence(claim, source);\n      if (evidence) {\n        allEvidence.push(evidence);\n      }\n\n      // Limit sources checked\n      if (allEvidence.length >= effectiveMaxSources * 2) break;\n    }\n\n    // Sort by relevance and limit\n    allEvidence.sort((a, b) => b.relevance - a.relevance);\n    const topEvidence = allEvidence.slice(0, effectiveMaxSources);\n\n    // Filter by minimum confidence\n    const relevantEvidence = topEvidence.filter(\n      e => e.confidence >= (effectiveConfig.minConfidence ?? minConfidence),\n    );\n\n    // Determine verdict\n    const { verdict, confidence, verified } = computeVerdict(relevantEvidence, effectiveConfig);\n\n    // Get supporting source IDs\n    const sourceIds = relevantEvidence\n      .filter(e => (!includeNeutral ? e.stance !== 'neutral' : true))\n      .map(e => e.sourceId);\n\n    return {\n      claim,\n      verified,\n      confidence,\n      verdict,\n      sources: [...new Set(sourceIds)],\n      evidence: relevantEvidence,\n    };\n  }\n\n  async function verifyBatch(\n    claims: string[],\n    overrideConfig?: VerificationConfig,\n  ): Promise<VerificationResult[]> {\n    return Promise.all(claims.map(claim => verify(claim, overrideConfig)));\n  }\n\n  function getConfig(): VerificationConfig {\n    return {\n      minConfidence,\n      maxSources,\n      includeNeutral,\n      requireMultipleSources,\n    };\n  }\n\n  return {\n    addSource,\n    removeSource,\n    getSources,\n    verify,\n    verifyBatch,\n    getConfig,\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Legacy API (backwards compatibility)\n// -----------------------------------------------------------------------------\n\n/**\n * Verify a single fact claim.\n * @deprecated Use createFactVerifier() instead\n */\nexport const verifyFact = async (\n  claim: string,\n  config?: VerificationConfig,\n): Promise<VerificationResult> => {\n  const verifier = createFactVerifier(config);\n  return verifier.verify(claim);\n};\n\n// -----------------------------------------------------------------------------\n// Evidence Finding\n// -----------------------------------------------------------------------------\n\n/**\n * Find evidence for a claim within a source.\n */\nfunction findEvidence(claim: string, source: KnowledgeSource): VerificationEvidence | null {\n  const claimTokens = tokenize(claim);\n  if (claimTokens.length === 0) return null;\n\n  // Find best matching excerpt\n  const excerpts = extractExcerpts(source.content, 150);\n  let bestExcerpt = '';\n  let bestRelevance = 0;\n\n  for (const excerpt of excerpts) {\n    const relevance = computeRelevance(claimTokens, excerpt);\n    if (relevance > bestRelevance) {\n      bestRelevance = relevance;\n      bestExcerpt = excerpt;\n    }\n  }\n\n  // Skip if not relevant enough\n  if (bestRelevance < 0.2) return null;\n\n  // Determine stance (supports, refutes, neutral)\n  const stance = determineStance(claim, bestExcerpt);\n\n  // Compute confidence based on relevance and source reliability\n  const sourceReliability = source.reliability ?? 0.7;\n  const confidence = bestRelevance * sourceReliability;\n\n  return {\n    sourceId: source.id,\n    excerpt: bestExcerpt,\n    relevance: bestRelevance,\n    stance,\n    confidence,\n  };\n}\n\n/**\n * Extract overlapping excerpts from text.\n */\nfunction extractExcerpts(text: string, maxLength: number): string[] {\n  const excerpts: string[] = [];\n  const sentences = text.match(/[^.!?]+[.!?]+/g) ?? [text];\n\n  let current = '';\n  for (const sentence of sentences) {\n    const trimmed = sentence.trim();\n    if (current.length + trimmed.length <= maxLength) {\n      current += (current ? ' ' : '') + trimmed;\n    } else {\n      if (current) excerpts.push(current);\n      current = trimmed.length <= maxLength ? trimmed : trimmed.slice(0, maxLength);\n    }\n  }\n  if (current) excerpts.push(current);\n\n  return excerpts;\n}\n\n/**\n * Compute relevance between claim tokens and excerpt.\n */\nfunction computeRelevance(claimTokens: string[], excerpt: string): number {\n  const excerptTokens = new Set(tokenize(excerpt));\n  if (excerptTokens.size === 0) return 0;\n\n  let matches = 0;\n  for (const token of claimTokens) {\n    if (excerptTokens.has(token)) matches++;\n  }\n\n  return claimTokens.length > 0 ? matches / claimTokens.length : 0;\n}\n\n/**\n * Determine if excerpt supports, refutes, or is neutral toward claim.\n */\nfunction determineStance(claim: string, excerpt: string): 'supports' | 'refutes' | 'neutral' {\n  const claimLower = claim.toLowerCase();\n  const excerptLower = excerpt.toLowerCase();\n\n  // Check for negation patterns\n  const negationPatterns = [\n    /\\bnot\\b/,\n    /\\bnever\\b/,\n    /\\bno\\b/,\n    /\\bfalse\\b/,\n    /\\bincorrect\\b/,\n    /\\bwrong\\b/,\n    /\\buntrue\\b/,\n    /\\bdoes not\\b/,\n    /\\bdoesn't\\b/,\n    /\\bisn't\\b/,\n    /\\baren't\\b/,\n    /\\bwasn't\\b/,\n    /\\bweren't\\b/,\n  ];\n\n  const claimHasNegation = negationPatterns.some(p => p.test(claimLower));\n  const excerptHasNegation = negationPatterns.some(p => p.test(excerptLower));\n\n  // If negation differs, likely refutes\n  if (claimHasNegation !== excerptHasNegation) {\n    return 'refutes';\n  }\n\n  // Check for semantic similarity\n  const claimTokens = new Set(tokenize(claim));\n  const excerptTokens = new Set(tokenize(excerpt));\n\n  let overlap = 0;\n  for (const token of claimTokens) {\n    if (excerptTokens.has(token)) overlap++;\n  }\n\n  const similarity = claimTokens.size > 0 ? overlap / claimTokens.size : 0;\n\n  if (similarity > 0.5) return 'supports';\n  if (similarity > 0.2) return 'neutral';\n  return 'neutral';\n}\n\n// -----------------------------------------------------------------------------\n// Verdict Computation\n// -----------------------------------------------------------------------------\n\n/**\n * Compute overall verdict from evidence.\n */\nfunction computeVerdict(\n  evidence: VerificationEvidence[],\n  config: VerificationConfig,\n): { verdict: VerificationResult['verdict']; confidence: number; verified: boolean } {\n  if (evidence.length === 0) {\n    return { verdict: 'no_evidence', confidence: 0, verified: false };\n  }\n\n  // Count stances weighted by confidence\n  let supportScore = 0;\n  let refuteScore = 0;\n  let totalWeight = 0;\n\n  for (const e of evidence) {\n    const weight = e.confidence * e.relevance;\n    totalWeight += weight;\n\n    if (e.stance === 'supports') {\n      supportScore += weight;\n    } else if (e.stance === 'refutes') {\n      refuteScore += weight;\n    }\n  }\n\n  // Check multiple sources requirement\n  if (config.requireMultipleSources && evidence.length < 2) {\n    return { verdict: 'inconclusive', confidence: 0.3, verified: false };\n  }\n\n  // Determine verdict\n  const supportRatio = totalWeight > 0 ? supportScore / totalWeight : 0;\n  const refuteRatio = totalWeight > 0 ? refuteScore / totalWeight : 0;\n\n  if (supportRatio > 0.6) {\n    const confidence = Math.min(0.99, supportRatio * 0.9 + evidence.length * 0.05);\n    return { verdict: 'supported', confidence, verified: true };\n  }\n\n  if (refuteRatio > 0.6) {\n    const confidence = Math.min(0.99, refuteRatio * 0.9 + evidence.length * 0.05);\n    return { verdict: 'refuted', confidence, verified: false };\n  }\n\n  // Inconclusive\n  const avgConfidence = evidence.reduce((s, e) => s + e.confidence, 0) / evidence.length;\n  return { verdict: 'inconclusive', confidence: avgConfidence * 0.5, verified: false };\n}\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\n/**\n * Tokenize text into lowercase words.\n */\nfunction tokenize(text: string): string[] {\n  return text\n    .toLowerCase()\n    .replace(/[^\\w\\s]/g, ' ')\n    .split(/\\s+/)\n    .filter(w => w.length > 2);\n}\n"],"mappings":"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"}

package/dist/grounding.d.mts

@@ -0,0 +1,24 @@
+import "./ai-runtime-DIwOEc6g.mjs";
+import "./schemas-DBOhxgW7.mjs";
+import { AttributionEntry, AttributionReport, AttributionSource, AttributionTracker, AttributionTrackerConfig, Claim, createAttributionTracker, generateAttributionReport } from "./grounding-attribution.mjs";
+import { a as RetrievalConfig, i as GroundingSource, n as GroundedResponse, o as Retriever, r as GroundingConfig, s as VectorStore, t as Citation } from "./types-D3zJb59_.mjs";
+import { a as verifyClaims, i as generateCitations, n as CitationGeneratorOptions, r as formatAsFootnotes, t as CitationFormat } from "./citation-generator-CDSymDs_.mjs";
+import "./safe-context-BynhkTKR.mjs";
+import { t as index_d_exports } from "./grounding-context.mjs";
+import { a as RerankPipelineConfig, c as calculateMRR, d as createCrossEncoderReranker, f as createRerankPipeline, i as RerankOptions, l as calculateNDCG, m as vectorResultsToDocuments, n as CrossEncoderConfig, o as RerankProvider, p as reciprocalRankFusion, r as RerankDocument, s as RerankResult, t as CohereRerankConfig, u as createCohereReranker } from "./reranking-BpWYhYzl.mjs";
+import { ChunkMetadata, Chunker, ChunkingConfig, ChunkingStrategy, Embedder, EmbeddingModel, RAGContext, RAGPipeline, SearchOptions, SearchResult, TextChunk, calculateTextSimilarity, cosineSimilarity, createChunker, createEmbedder, createInMemoryVectorStore, createRAGPipeline, embedBatch, embedText } from "./grounding-embed.mjs";
+import { Claim as Claim$1, ClaimVerificationResult, HallucinationDetectorOptions, HallucinationResult, calculateJaccardSimilarity, createHallucinationDetector, extractClaims, verifyClaim } from "./grounding-hallucination.mjs";
+import { A as FilterOptions, B as formatAsBibliography, C as createActiveToolsSelector, D as createToolMasker, E as createProgressiveDisclosure, F as ValidationOptions, G as sourcesToContext, H as groupSources, I as createSourceRegistry, J as InMemoryVectorStore, K as validateSource, L as deduplicateSources, M as SourceRegistryConfig, N as SourceValidationResult, O as DeduplicationOptions, P as SourceWithProvenance, R as filterByMetadata, S as ToolMaskRule, T as createPhasedToolActivation, U as mergeSources, V as formatAsInlineCitations, W as selectTopSources, _ as createMemoryManager, a as RecoveryResult, b as ToolMaskContext, c as createErrorRecovery, d as MemoryManagerConfig, f as MemoryMessage, g as createKVCachePreservingContext, h as createImmutableContextBuilder, i as RecoveryAction, j as SourceRegistry, k as DeduplicationStrategy, l as InMemoryStore, m as createCompactingMemory, n as AIErrorType, o as RecoveryStrategy, p as MemoryStore, q as validateSources, r as DefaultRecoveryStrategies, s as classifyError, t as AIError, u as MemoryEntry, v as createSlidingWindowContext, w as createContextualToolActivation, x as ToolMaskResult, y as MaskingRules, z as filterByScore } from "./index-DOqe5r9G.mjs";
+import { FactVerifier, KnowledgeSource, VerificationConfig, VerificationEvidence, VerificationResult, createFactVerifier, verifyFact } from "./grounding-verification.mjs";
+import "./tool-Btbththq.mjs";
+import { t as index_d_exports$2 } from "./grounding-rag.mjs";
+import "./loop-C-tBBOqi.mjs";
+import { t as index_d_exports$1 } from "./grounding-proof-map.mjs";
+
+//#region src/grounding/index.d.ts
+declare namespace index_d_exports$3 {
+  export { AIError, AIErrorType, Claim as AttributionClaim, AttributionEntry, AttributionReport, AttributionSource, AttributionTracker, AttributionTrackerConfig, ChunkMetadata, Chunker, ChunkingConfig, ChunkingStrategy, Citation, CitationFormat, CitationGeneratorOptions, Claim$1 as Claim, ClaimVerificationResult, CohereRerankConfig, CrossEncoderConfig, DeduplicationOptions, DeduplicationStrategy, DefaultRecoveryStrategies, Embedder, EmbeddingModel, FactVerifier, FilterOptions, GroundedResponse, GroundingConfig, GroundingSource, HallucinationDetectorOptions, HallucinationResult, InMemoryStore, InMemoryVectorStore, KnowledgeSource, MaskingRules, MemoryEntry, MemoryManagerConfig, MemoryMessage, MemoryStore, RAGContext, RAGPipeline, RecoveryAction, RecoveryResult, RecoveryStrategy, RerankDocument, RerankOptions, RerankPipelineConfig, RerankProvider, RerankResult, RetrievalConfig, Retriever, SearchOptions, SearchResult, SourceRegistry, SourceRegistryConfig, SourceValidationResult, SourceWithProvenance, TextChunk, ToolMaskContext, ToolMaskResult, ToolMaskRule, ValidationOptions, VectorStore, VerificationConfig, VerificationEvidence, VerificationResult, calculateJaccardSimilarity, calculateMRR, calculateNDCG, calculateTextSimilarity, classifyError, index_d_exports as context, cosineSimilarity, createActiveToolsSelector, createAttributionTracker, createChunker, createCohereReranker, createCompactingMemory, createContextualToolActivation, createCrossEncoderReranker, createEmbedder, createErrorRecovery, createFactVerifier, createHallucinationDetector, createImmutableContextBuilder, createInMemoryVectorStore, createKVCachePreservingContext, createMemoryManager, createPhasedToolActivation, createProgressiveDisclosure, createRAGPipeline, createRerankPipeline, createSlidingWindowContext, createSourceRegistry, createToolMasker, deduplicateSources, embedBatch, embedText, extractClaims, filterByMetadata, filterByScore, formatAsBibliography, formatAsFootnotes, formatAsInlineCitations, generateAttributionReport, generateCitations, groupSources, mergeSources, index_d_exports$1 as proofMap, index_d_exports$2 as rag, reciprocalRankFusion, selectTopSources, sourcesToContext, validateSource, validateSources, vectorResultsToDocuments, verifyClaim, verifyClaims, verifyFact };
+}
+//#endregion
+export { AIError, AIErrorType, type Claim as AttributionClaim, type AttributionEntry, type AttributionReport, type AttributionSource, type AttributionTracker, type AttributionTrackerConfig, ChunkMetadata, Chunker, ChunkingConfig, ChunkingStrategy, type Citation, type CitationFormat, type CitationGeneratorOptions, type Claim$1 as Claim, type ClaimVerificationResult, CohereRerankConfig, CrossEncoderConfig, DeduplicationOptions, DeduplicationStrategy, DefaultRecoveryStrategies, Embedder, EmbeddingModel, FactVerifier, FilterOptions, type GroundedResponse, type GroundingConfig, type GroundingSource, type HallucinationDetectorOptions, type HallucinationResult, InMemoryStore, InMemoryVectorStore, KnowledgeSource, MaskingRules, MemoryEntry, MemoryManagerConfig, MemoryMessage, MemoryStore, RAGContext, RAGPipeline, RecoveryAction, RecoveryResult, RecoveryStrategy, RerankDocument, RerankOptions, RerankPipelineConfig, RerankProvider, RerankResult, type RetrievalConfig, type Retriever, SearchOptions, SearchResult, SourceRegistry, SourceRegistryConfig, SourceValidationResult, SourceWithProvenance, TextChunk, ToolMaskContext, ToolMaskResult, ToolMaskRule, ValidationOptions, type VectorStore, VerificationConfig, VerificationEvidence, VerificationResult, calculateJaccardSimilarity, calculateMRR, calculateNDCG, calculateTextSimilarity, classifyError, index_d_exports as context, cosineSimilarity, createActiveToolsSelector, createAttributionTracker, createChunker, createCohereReranker, createCompactingMemory, createContextualToolActivation, createCrossEncoderReranker, createEmbedder, createErrorRecovery, createFactVerifier, createHallucinationDetector, createImmutableContextBuilder, createInMemoryVectorStore, createKVCachePreservingContext, createMemoryManager, createPhasedToolActivation, createProgressiveDisclosure, createRAGPipeline, createRerankPipeline, createSlidingWindowContext, createSourceRegistry, createToolMasker, deduplicateSources, embedBatch, embedText, extractClaims, filterByMetadata, filterByScore, formatAsBibliography, formatAsFootnotes, formatAsInlineCitations, generateAttributionReport, generateCitations, groupSources, mergeSources, index_d_exports$1 as proofMap, index_d_exports$2 as rag, reciprocalRankFusion, selectTopSources, sourcesToContext, index_d_exports$3 as t, validateSource, validateSources, vectorResultsToDocuments, verifyClaim, verifyClaims, verifyFact };
+//# sourceMappingURL=grounding.d.mts.map

package/dist/grounding.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding.d.mts","names":[],"sources":["../src/grounding/index.ts"],"mappings":""}

package/dist/grounding.mjs

@@ -0,0 +1,77 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { a as createRerankPipeline, i as createCrossEncoderReranker, n as calculateNDCG, o as reciprocalRankFusion, r as createCohereReranker, s as vectorResultsToDocuments, t as calculateMRR } from "./reranking-Ck8aKZW7.mjs";
+import { calculateTextSimilarity, cosineSimilarity, createChunker, createEmbedder, createInMemoryVectorStore, createRAGPipeline, embedBatch, embedText } from "./grounding-embed.mjs";
+import { C as groupSources, D as validateSource, E as sourcesToContext, O as validateSources, S as formatAsInlineCitations, T as selectTopSources, _ as createSourceRegistry, a as InMemoryStore, b as filterByScore, c as createKVCachePreservingContext, d as MaskingRules, f as createActiveToolsSelector, g as createToolMasker, h as createProgressiveDisclosure, i as createErrorRecovery, k as InMemoryVectorStore, l as createMemoryManager, m as createPhasedToolActivation, n as DefaultRecoveryStrategies, o as createCompactingMemory, p as createContextualToolActivation, r as classifyError, s as createImmutableContextBuilder, t as AIError, u as createSlidingWindowContext, v as deduplicateSources, w as mergeSources, x as formatAsBibliography, y as filterByMetadata } from "./error-handling-DNVkm6RY.mjs";
+import { n as generateCitations, r as verifyClaims, t as formatAsFootnotes } from "./citation-generator-C-9RpbHq.mjs";
+import { calculateJaccardSimilarity, createHallucinationDetector, extractClaims, verifyClaim } from "./grounding-hallucination.mjs";
+import { createFactVerifier, verifyFact } from "./grounding-verification.mjs";
+import { createAttributionTracker, generateAttributionReport } from "./grounding-attribution.mjs";
+import { t as context_exports } from "./grounding-context.mjs";
+import { t as rag_exports } from "./grounding-rag.mjs";
+import { t as proof_map_exports } from "./grounding-proof-map.mjs";
+
+//#region src/grounding/index.ts
+var grounding_exports = /* @__PURE__ */ __exportAll({
+	AIError: () => AIError,
+	DefaultRecoveryStrategies: () => DefaultRecoveryStrategies,
+	InMemoryStore: () => InMemoryStore,
+	InMemoryVectorStore: () => InMemoryVectorStore,
+	MaskingRules: () => MaskingRules,
+	calculateJaccardSimilarity: () => calculateJaccardSimilarity,
+	calculateMRR: () => calculateMRR,
+	calculateNDCG: () => calculateNDCG,
+	calculateTextSimilarity: () => calculateTextSimilarity,
+	classifyError: () => classifyError,
+	context: () => context_exports,
+	cosineSimilarity: () => cosineSimilarity,
+	createActiveToolsSelector: () => createActiveToolsSelector,
+	createAttributionTracker: () => createAttributionTracker,
+	createChunker: () => createChunker,
+	createCohereReranker: () => createCohereReranker,
+	createCompactingMemory: () => createCompactingMemory,
+	createContextualToolActivation: () => createContextualToolActivation,
+	createCrossEncoderReranker: () => createCrossEncoderReranker,
+	createEmbedder: () => createEmbedder,
+	createErrorRecovery: () => createErrorRecovery,
+	createFactVerifier: () => createFactVerifier,
+	createHallucinationDetector: () => createHallucinationDetector,
+	createImmutableContextBuilder: () => createImmutableContextBuilder,
+	createInMemoryVectorStore: () => createInMemoryVectorStore,
+	createKVCachePreservingContext: () => createKVCachePreservingContext,
+	createMemoryManager: () => createMemoryManager,
+	createPhasedToolActivation: () => createPhasedToolActivation,
+	createProgressiveDisclosure: () => createProgressiveDisclosure,
+	createRAGPipeline: () => createRAGPipeline,
+	createRerankPipeline: () => createRerankPipeline,
+	createSlidingWindowContext: () => createSlidingWindowContext,
+	createSourceRegistry: () => createSourceRegistry,
+	createToolMasker: () => createToolMasker,
+	deduplicateSources: () => deduplicateSources,
+	embedBatch: () => embedBatch,
+	embedText: () => embedText,
+	extractClaims: () => extractClaims,
+	filterByMetadata: () => filterByMetadata,
+	filterByScore: () => filterByScore,
+	formatAsBibliography: () => formatAsBibliography,
+	formatAsFootnotes: () => formatAsFootnotes,
+	formatAsInlineCitations: () => formatAsInlineCitations,
+	generateAttributionReport: () => generateAttributionReport,
+	generateCitations: () => generateCitations,
+	groupSources: () => groupSources,
+	mergeSources: () => mergeSources,
+	proofMap: () => proof_map_exports,
+	rag: () => rag_exports,
+	reciprocalRankFusion: () => reciprocalRankFusion,
+	selectTopSources: () => selectTopSources,
+	sourcesToContext: () => sourcesToContext,
+	validateSource: () => validateSource,
+	validateSources: () => validateSources,
+	vectorResultsToDocuments: () => vectorResultsToDocuments,
+	verifyClaim: () => verifyClaim,
+	verifyClaims: () => verifyClaims,
+	verifyFact: () => verifyFact
+});
+
+//#endregion
+export { AIError, DefaultRecoveryStrategies, InMemoryStore, InMemoryVectorStore, MaskingRules, calculateJaccardSimilarity, calculateMRR, calculateNDCG, calculateTextSimilarity, classifyError, context_exports as context, cosineSimilarity, createActiveToolsSelector, createAttributionTracker, createChunker, createCohereReranker, createCompactingMemory, createContextualToolActivation, createCrossEncoderReranker, createEmbedder, createErrorRecovery, createFactVerifier, createHallucinationDetector, createImmutableContextBuilder, createInMemoryVectorStore, createKVCachePreservingContext, createMemoryManager, createPhasedToolActivation, createProgressiveDisclosure, createRAGPipeline, createRerankPipeline, createSlidingWindowContext, createSourceRegistry, createToolMasker, deduplicateSources, embedBatch, embedText, extractClaims, filterByMetadata, filterByScore, formatAsBibliography, formatAsFootnotes, formatAsInlineCitations, generateAttributionReport, generateCitations, groupSources, mergeSources, proof_map_exports as proofMap, rag_exports as rag, reciprocalRankFusion, selectTopSources, sourcesToContext, grounding_exports as t, validateSource, validateSources, vectorResultsToDocuments, verifyClaim, verifyClaims, verifyFact };
+//# sourceMappingURL=grounding.mjs.map

package/dist/grounding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding.mjs","names":[],"sources":["../src/grounding/index.ts"],"sourcesContent":["/**\n * @fileoverview Grounding Module\n * @module @od-oneapp/ai-platform/grounding\n *\n * RAG, embeddings, and response verification:\n * - Embeddings and vector stores\n * - RAG pipelines with reranking\n * - Context engineering\n * - Hallucination detection\n * - Citation generation\n * - Source attribution\n *\n * @module grounding\n */\n\n// Types\nexport type {\n  GroundingSource,\n  Citation,\n  GroundedResponse,\n  RetrievalConfig,\n  GroundingConfig,\n  Retriever,\n  VectorStore,\n} from './types';\n\n// Embeddings and RAG\nexport * from \"./embed\";\n\n// Retrieval\nexport { InMemoryVectorStore } from './retrieval/in-memory-store';\n\n// Citation generation\nexport {\n  generateCitations,\n  formatAsFootnotes,\n  verifyClaims,\n  type CitationFormat,\n  type CitationGeneratorOptions,\n} from './citation/citation-generator';\n\n// Hallucination detection\nexport {\n  type Claim,\n  type ClaimVerificationResult,\n  type HallucinationResult,\n  type HallucinationDetectorOptions,\n  extractClaims,\n  calculateJaccardSimilarity,\n  verifyClaim,\n  createHallucinationDetector,\n} from \"./hallucination\";\n\n// Source verification\nexport * from \"./verification\";\n\n// Sources management\nexport * from \"./sources\";\n\n// Attribution reporting\nexport {\n  type AttributionSource,\n  type Claim as AttributionClaim,\n  type AttributionEntry,\n  type AttributionReport,\n  type AttributionTrackerConfig,\n  type AttributionTracker,\n  createAttributionTracker,\n  generateAttributionReport,\n} from \"./attribution\";\n\n// Context engineering\nexport * from \"./context-engineering\";\n\n// Identity and request context management\nexport * as context from \"./context\";\n\n// Multi-model research pipeline (Perplexity → Sonnet → GPT)\nexport * as rag from \"./rag\";\n\n// Proof map loop and patch utilities\nexport * as proofMap from \"./proof-map\";\n"],"mappings":""}

package/dist/hitl-active-learning.d.mts

@@ -0,0 +1,41 @@
+//#region src/hitl/active-learning/index.d.ts
+type SelectionStrategy = 'uncertainty' | 'diversity' | 'query-by-committee' | 'expected-improvement' | 'random';
+interface Sample<T = unknown> {
+  readonly id: string;
+  readonly data: T;
+  readonly prediction?: {
+    label: string;
+    confidence: number;
+    probabilities?: Record<string, number>;
+  };
+  readonly embedding?: number[];
+  readonly metadata?: Record<string, unknown>;
+}
+interface SelectionResult<T = unknown> {
+  readonly selected: Sample<T>[];
+  readonly scores: Map<string, number>;
+  readonly strategy: SelectionStrategy;
+  readonly metadata?: Record<string, unknown>;
+}
+interface ActiveLearnerConfig {
+  readonly strategy: SelectionStrategy;
+  readonly batchSize?: number;
+  readonly uncertaintyThreshold?: number;
+  readonly diversityWeight?: number;
+  readonly randomSeed?: number;
+}
+interface ActiveLearner<T = unknown> {
+  selectSamples(samples: Sample<T>[], count?: number): Promise<SelectionResult<T>>;
+  updateStrategy(strategy: SelectionStrategy): void;
+  getConfig(): ActiveLearnerConfig;
+}
+declare function createActiveLearner<T = unknown>(config: ActiveLearnerConfig): ActiveLearner<T>;
+declare function createSample<T>(id: string, data: T, options?: {
+  prediction?: Sample['prediction'];
+  embedding?: number[];
+  metadata?: Record<string, unknown>;
+}): Sample<T>;
+declare function createSamples<T>(items: T[], idPrefix?: string): Sample<T>[];
+//#endregion
+export { ActiveLearner, ActiveLearnerConfig, Sample, SelectionResult, SelectionStrategy, createActiveLearner, createSample, createSamples };
+//# sourceMappingURL=hitl-active-learning.d.mts.map

package/dist/hitl-active-learning.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitl-active-learning.d.mts","names":[],"sources":["../src/hitl/active-learning/index.ts"],"mappings":";KA2BY,iBAAA;AAAA,UAQK,MAAA;EAAA,SACN,EAAA;EAAA,SACA,IAAA,EAAM,CAAA;EAAA,SACN,UAAA;IACP,KAAA;IACA,UAAA;IACA,aAAA,GAAgB,MAAA;EAAA;EAAA,SAET,SAAA;EAAA,SACA,QAAA,GAAW,MAAA;AAAA;AAAA,UAIL,eAAA;EAAA,SACN,QAAA,EAAU,MAAA,CAAO,CAAA;EAAA,SACjB,MAAA,EAAQ,GAAA;EAAA,SACR,QAAA,EAAU,iBAAA;EAAA,SACV,QAAA,GAAW,MAAA;AAAA;AAAA,UAIL,mBAAA;EAAA,SACN,QAAA,EAAU,iBAAA;EAAA,SACV,SAAA;EAAA,SACA,oBAAA;EAAA,SACA,eAAA;EAAA,SACA,UAAA;AAAA;AAAA,UAIM,aAAA;EACf,aAAA,CAAc,OAAA,EAAS,MAAA,CAAO,CAAA,KAAM,KAAA,YAAiB,OAAA,CAAQ,eAAA,CAAgB,CAAA;EAC7E,cAAA,CAAe,QAAA,EAAU,iBAAA;EACzB,SAAA,IAAa,mBAAA;AAAA;AAAA,iBA8HC,mBAAA,aAAA,CAAiC,MAAA,EAAQ,mBAAA,GAAsB,aAAA,CAAc,CAAA;AAAA,iBA+G7E,YAAA,GAAA,CACd,EAAA,UACA,IAAA,EAAM,CAAA,EACN,OAAA;EACE,UAAA,GAAa,MAAA;EACb,SAAA;EACA,QAAA,GAAW,MAAA;AAAA,IAEZ,MAAA,CAAO,CAAA;AAAA,iBAaM,aAAA,GAAA,CAAiB,KAAA,EAAO,CAAA,IAAK,QAAA,YAA8B,MAAA,CAAO,CAAA"}