@devilsdev/rag-core 0.0.0-stage → 3.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ali Kahwaji
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,19 @@
-# Temporary Holding Version
+# @devilsdev/rag-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+createRagPipeline and its building blocks: retrieval, reranking, caching, cost tracking and model routing.
+
+Part of [@devilsdev/rag-pipeline-utils](https://www.npmjs.com/package/@devilsdev/rag-pipeline-utils), split into packages so you install only what you use. The objects are the same ones the full package exports; versions move in lockstep.
+
+```bash
+npm install @devilsdev/rag-core
+```
+
+Exports: `createRagPipeline`, `createPipeline`, `packContext`, `createError`, `wrapError`, `ERROR_CODES`, `retry`, `withRetry`, `ChunkingEngine`, `BM25Search`, `reciprocalRankFusion`, `HybridRetriever`, `ScoringReranker`, `EmbeddingReranker`, `CascadeReranker`, `MemoryCache`, `RedisCache`, `CostCalculator`, `PRICING_METADATA`, `CostTracker`, `TokenBudget`, `createModelRouter`, `classifyQuery`, `MemoryRetriever`, `BaseConnector`.
+
+Documentation: https://devilsdev.github.io/rag-pipeline-utils/
+
+The other packages:
+
+- [`@devilsdev/rag-connectors`](https://www.npmjs.com/package/@devilsdev/rag-connectors)
+- [`@devilsdev/rag-eval`](https://www.npmjs.com/package/@devilsdev/rag-eval)
+- [`@devilsdev/rag-guardrails`](https://www.npmjs.com/package/@devilsdev/rag-guardrails)

package/all-types.d.ts

@@ -0,0 +1 @@
+export * from "./dist/all";

package/dist/all.d.ts

@@ -0,0 +1,498 @@
+/**
+ * RAG Pipeline Utils - TypeScript Definitions
+ * @module rag-pipeline-utils
+ */
+
+// =============================================================================
+// Pipeline
+// =============================================================================
+
+/** Options for {@link createRagPipeline}. */
+export interface RagPipelineConfig {
+  /** Resolves plugin names given as strings; defaults to the shared {@link pluginRegistry}. */
+  registry?: PluginRegistry;
+  /** Called with no arguments at the start of every run; its result is ignored. */
+  loader?: string | LoaderPlugin;
+  /** Embeds the query when `run()` gets a `query` and no `queryVector`. */
+  embedder?: string | EmbedderPlugin;
+  /** Finds the documents for a query. Without one, every run retrieves nothing. */
+  retriever?: string | RetrieverPlugin;
+  /** Writes the answer. Without one the pipeline is retrieval-only and `answer` is null. */
+  llm?: string | LLMPlugin;
+  /** Reorders the retrieved documents before generation. */
+  reranker?: string | RerankerPlugin;
+  /**
+   * Cache query embeddings, retrieval results and answers. `true` caches
+   * all three in memory; a CacheBackend (MemoryCache, RedisCache, your own)
+   * caches all three in it; or configure each layer.
+   */
+  cache?: boolean | CacheBackend | CacheOptions;
+  /**
+   * OpenTelemetry spans for every run and stage. `true` uses the global
+   * tracer provider. Needs the optional peer dependency `@opentelemetry/api`.
+   */
+  telemetry?: boolean | TelemetryOptions;
+  /** Other keys are ignored. */
+  [key: string]: any;
+}
+
+/**
+ * A tracer that can start active spans, such as an OpenTelemetry `Tracer`.
+ * Declared here so the types don't depend on the optional peer dependency.
+ */
+export interface TelemetryTracer {
+  startActiveSpan(...args: any[]): any;
+}
+
+/** The `telemetry` option of createRagPipeline. */
+export interface TelemetryOptions {
+  /** Default: `trace.getTracer("@devilsdev/rag-pipeline-utils", version)`. */
+  tracer?: TelemetryTracer;
+  /** The @opentelemetry/api module, for @devilsdev/rag-pipeline-utils/edge, which cannot load it itself. */
+  api?: any;
+  /** Also record the query text and the retrieved document ids and scores. Default false. */
+  recordContent?: boolean;
+}
+
+/** A cache store: get / set / delete, optionally stats. */
+export interface CacheBackend {
+  /** Resolves the stored value, or undefined when the key is missing or expired. */
+  get(key: string): Promise<unknown | undefined>;
+  /** Stores a value, expiring it after `ttlSeconds` when given. */
+  set(key: string, value: unknown, options?: { ttlSeconds?: number }): Promise<void>;
+  /** Removes a key. */
+  delete?(key: string): Promise<void>;
+  /** Backend-specific counters, such as size or hits. */
+  stats?(): Promise<Record<string, number>>;
+}
+
+/** Per-layer cache settings: `true` for memory, a CacheBackend, or false/omitted for none. */
+export interface CacheOptions {
+  embeddings?: boolean | CacheBackend;
+  retrieval?: boolean | CacheBackend;
+  generation?: boolean | CacheBackend;
+  /** Defaults: embeddings 30 days, retrieval 1 hour, generation 24 hours. */
+  ttlSeconds?: { embeddings?: number; retrieval?: number; generation?: number };
+}
+
+/** What a cache layer did for one run: served it, stored it, or was not used. */
+export type CacheOutcome = "hit" | "miss" | "skip";
+
+/** Counts for one cache layer since the pipeline was created. */
+export interface CacheLayerStats {
+  hits: number;
+  misses: number;
+  skipped: number;
+}
+
+/** The argument of {@link Pipeline.run}. Give a `query`, a `queryVector`, or both. */
+export interface PipelineRunOptions {
+  /** The question. Embedded by the embedder unless `queryVector` is given. */
+  query?: string;
+  /** A precomputed query embedding; skips the embedder. */
+  queryVector?: number[];
+  /** Per-run options. The whole object is also passed to `llm.generate`. */
+  options?: {
+    /** Documents to retrieve. Default 3. */
+    topK?: number;
+    /** Abort the run after this many milliseconds; it resolves `{ success: false, error: "Execution timeout" }`. */
+    timeout?: number;
+    /** Cancel the run; it resolves `{ success: false, error: "Execution aborted" }`. */
+    signal?: AbortSignal;
+    /** Resolve to an async iterable of {@link StreamChunk} instead of a result. */
+    stream?: boolean;
+    /** Attribute the answer's sentences to the retrieved documents (see CitationTracker). */
+    citations?: boolean;
+    citationOptions?: Record<string, any>;
+    /** Score the run (see PipelineEvaluator). */
+    evaluate?: boolean;
+    evaluateOptions?: Record<string, any>;
+    /** Ground-truth answer, used by evaluation for context recall. */
+    referenceAnswer?: string;
+    /** Filter or transform the retrieved documents before reranking. */
+    filterResults?: (docs: SearchResult[]) => SearchResult[] | Promise<SearchResult[]>;
+    /**
+     * Fit the documents the LLM sees into this many tokens (see packContext).
+     * `results` is then the packed list, and `packing` says what was cut.
+     */
+    maxContextTokens?: number;
+    /** Token counter for `maxContextTokens` (default: about four characters per token). */
+    countTokens?: (text: string) => number;
+    [key: string]: any;
+  };
+}
+
+/**
+ * What {@link Pipeline.run} resolves to without streaming. A failed, timed-out
+ * or aborted run resolves `{ success: false, error }`; `run` never rejects.
+ */
+export interface PipelineRunResult {
+  success: boolean;
+  query?: string;
+  /** The retrieved (filtered, reranked) documents; with `maxContextTokens`, the packed ones the LLM saw. */
+  results?: SearchResult[];
+  /** The LLM's answer; null when the pipeline has no llm. */
+  answer?: string | null;
+  /** Present when `options.citations` was set and there is an answer. */
+  citations?: any;
+  /** Present when `options.evaluate` was set. */
+  evaluation?: any;
+  /** The error message when `success` is false. */
+  error?: string;
+  /** Per-layer cache outcome; present when the pipeline has a cache. */
+  cache?: {
+    embeddings?: CacheOutcome;
+    retrieval?: CacheOutcome;
+    generation?: CacheOutcome;
+  };
+  /** What `maxContextTokens` kept and cut; present when it was set. */
+  packing?: ContextPacking;
+  /** How long the run took, from the start of run(); on successful results. */
+  timing?: { totalMs: number };
+  /** The model router's decision, when the llm is a createModelRouter() and was called. */
+  route?: RouteDecision;
+}
+
+/** Which model a createModelRouter() chose for a run. */
+export interface RouteDecision {
+  /** The query class from the router's classifier. */
+  class: string;
+  /** The model that answered. */
+  model: string;
+  /** Estimated cost in USD of the chosen model for this query. */
+  estimatedCost: number;
+  /** Models that failed before `model` answered (with `fallback: true`). */
+  fallbackFrom?: string[];
+}
+
+/** When a streamed answer started and finished, from the start of run(). */
+export interface StreamTiming {
+  /** When the first non-empty token arrived; null when none did. */
+  firstTokenMs: number | null;
+  totalMs: number;
+}
+
+/** How the documents were fitted into `maxContextTokens`. */
+export interface ContextPacking {
+  /** Tokens used by the kept documents, wrappers included. */
+  tokens: number;
+  maxTokens: number;
+  /** Ids (or positions) of the documents passed to the LLM, in order. */
+  kept: Array<string | number>;
+  /** Ids of the documents left out because they didn't fit. */
+  dropped: Array<string | number>;
+  /** Ids of documents cut to fit (marked `metadata.truncated`). */
+  truncated: Array<string | number>;
+}
+
+/**
+ * One chunk of a streamed answer. The last chunk has `done: true` and, when
+ * requested, the run's `citations` and `evaluation`. Without an llm the
+ * stream is a single done chunk carrying `results`.
+ */
+export interface StreamChunk {
+  token: string;
+  done: boolean;
+  results?: SearchResult[];
+  citations?: any;
+  evaluation?: any;
+  /** On the last chunk, when `maxContextTokens` was set. */
+  packing?: ContextPacking;
+  /** On the last chunk: time to first token and total time. */
+  timing?: StreamTiming;
+  /** On the last chunk, when the llm is a createModelRouter(). */
+  route?: RouteDecision;
+}
+
+/** A pipeline returned by {@link createRagPipeline}. */
+export interface Pipeline {
+  /**
+   * Answer one query: (embed) → retrieve → (filter) → (rerank) → generate →
+   * (citations, evaluation). Resolves a {@link PipelineRunResult}, or with
+   * `options.stream` an async iterable of {@link StreamChunk}.
+   */
+  run(options: PipelineRunOptions & { options: { stream: true } }): Promise<PipelineRunResult | AsyncIterable<StreamChunk>>;
+  /** Answer one query; see the streaming overload above. */
+  run(options?: PipelineRunOptions & { options?: { stream?: false } }): Promise<PipelineRunResult>;
+  /** Answer one query; with `options.stream` it may resolve a stream. */
+  run(options?: PipelineRunOptions): Promise<PipelineRunResult | AsyncIterable<StreamChunk>>;
+  /** Does nothing; kept for compatibility. */
+  cleanup(): void;
+  /** Hits, misses and skips per cache layer; null without a cache. */
+  cacheStats(): {
+    embeddings?: CacheLayerStats;
+    retrieval?: CacheLayerStats;
+    generation?: CacheLayerStats;
+  } | null;
+}
+
+// =============================================================================
+// Documents and results
+// =============================================================================
+
+/** A document as stored in a retriever. */
+export interface Document {
+  id: string;
+  content: string;
+  metadata?: Record<string, any>;
+  /** The document's embedding (the built-in stores call it `vector`). */
+  vector?: number[];
+}
+
+/** A retrieved document, as the built-in retrievers return it. */
+export interface SearchResult {
+  id: string;
+  /** Similarity; higher is closer. */
+  score: number;
+  content?: string;
+  metadata?: Record<string, any>;
+  [key: string]: any;
+}
+
+/** What the pipeline passes to {@link RetrieverPlugin.retrieve}. */
+export interface RetrieveOptions {
+  query?: string;
+  queryVector?: number[];
+  topK: number;
+  signal?: AbortSignal;
+}
+
+// =============================================================================
+// Plugin contracts: what createRagPipeline calls on each component
+// =============================================================================
+
+/** A loader. To register it with pluginRegistry it needs `metadata: { name, version, type: "loader" }`. */
+export interface LoaderPlugin {
+  /** The pipeline calls `load()` with no arguments at the start of each run and ignores the result. */
+  load(source?: string, options?: any): unknown;
+}
+
+/** An embedding returned by an embedder: a vector, a batch whose first vector is used, or `[{ values | vector | embedding }]`. */
+export type EmbeddingOutput =
+  | number[]
+  | number[][]
+  | Array<{ values?: number[]; vector?: number[]; embedding?: number[] }>;
+
+/** An embedder. To register it with pluginRegistry it needs `metadata: { name, version, type: "embedder" }`. */
+export interface EmbedderPlugin {
+  /** Embeds one text. Used for the query when `embedQuery` is absent. */
+  embed(text: string, options?: { signal?: AbortSignal; [key: string]: any }): EmbeddingOutput | Promise<EmbeddingOutput>;
+  /** Embeds a query; preferred over `embed` when present. */
+  embedQuery?(text: string, options?: { signal?: AbortSignal; [key: string]: any }): EmbeddingOutput | Promise<EmbeddingOutput>;
+}
+
+/** A retriever. To register it with pluginRegistry it needs `store()` and `metadata: { name, version, type: "retriever" }`. */
+export interface RetrieverPlugin {
+  /** Returns up to `topK` documents for the query, closest first. */
+  retrieve(options: RetrieveOptions): SearchResult[] | Promise<SearchResult[]>;
+  /** Adds documents with their embeddings. Not called by the pipeline; required by pluginRegistry and the CLI. */
+  store?(documents: Array<Document & { vector: number[] }>): unknown;
+}
+
+/** An LLM. To register it with pluginRegistry it needs `metadata: { name, version, type: "llm" }`. */
+export interface LLMPlugin {
+  /**
+   * Answers the query from the retrieved documents. Must resolve to the
+   * answer text: the pipeline converts the result with `String()`.
+   * `options` is the run's `options` plus its AbortSignal.
+   */
+  generate(query: string, documents: SearchResult[], options?: { signal?: AbortSignal; [key: string]: any }): string | Promise<string>;
+  /** Streams the answer; used with `options.stream` when present, otherwise `generate` is yielded as one chunk. */
+  generateStream?(query: string, documents: SearchResult[], options?: { signal?: AbortSignal; [key: string]: any }): AsyncIterable<string | { token: string; done?: boolean }>;
+}
+
+/** A reranker. To register it with pluginRegistry it needs `metadata: { name, version, type: "reranker" }`. */
+export interface RerankerPlugin {
+  /** Reorders (and may trim) the retrieved documents for the query. */
+  rerank(query: string, documents: SearchResult[], options?: { topK?: number; signal?: AbortSignal }): SearchResult[] | Promise<SearchResult[]>;
+}
+
+/** The interface of {@link pluginRegistry}. */
+export interface PluginRegistry {
+  /**
+   * Registers a plugin after checking it against its type's contract and,
+   * when signature verification is enabled, its signed manifest.
+   * Types: loader, embedder, retriever, reranker, llm, evaluator.
+   */
+  register(type: string, name: string, implementation: any, manifest?: any, options?: { content?: any }): Promise<PluginRegistry>;
+  /** Returns a registered plugin; throws when it is not registered. */
+  get(type: string, name: string): any;
+  /** The names registered for a type. */
+  list(type: string): string[];
+}
+
+/** The interface of the `logger` export's methods and of `logger.logger`. */
+export interface Logger {
+  /** Logs at info level; `meta` may be an object, an Error or a value. */
+  info(message: string, meta?: any): void;
+  /** Logs at error level. */
+  error(message: string, meta?: any): void;
+  /** Logs at warn level. */
+  warn(message: string, meta?: any): void;
+  /** Logs at debug level. */
+  debug(message: string, meta?: any): void;
+}
+
+/** An error created by {@link createError} or {@link wrapError}. */
+export interface EnhancedError extends Error {
+  code: string;
+  context: Record<string, any>;
+  suggestions: string[];
+  documentation?: string;
+  originalError?: Error | null;
+  timestamp: string;
+}
+
+// =============================================================================
+// Pipeline factory and errors
+// =============================================================================
+
+/**
+ * Creates a RAG pipeline from components: plugin objects, or names
+ * registered in the registry. A name that is not registered throws here.
+ */
+export function createRagPipeline(config?: RagPipelineConfig): Pipeline;
+export { createRagPipeline as createPipeline };
+
+/**
+ * Creates an error whose message and suggestions come from the code's
+ * template, with `{placeholders}` filled from `context`.
+ * @param code - One of {@link ERROR_CODES}
+ * @param context - Values for the message template's placeholders
+ * @param originalError - The underlying error, kept as `originalError`
+ */
+export function createError(code: string, context?: Record<string, any>, originalError?: Error | null): EnhancedError;
+
+/**
+ * Wraps an error in an EnhancedError with the given code, keeping the
+ * original as `originalError` and its message as `context.originalMessage`.
+ * @param error - The error to wrap
+ * @param code - One of {@link ERROR_CODES}
+ * @param context - Values for the message template's placeholders
+ */
+export function wrapError(error: Error, code: string, context?: Record<string, any>): EnhancedError;
+
+/** The error codes {@link createError} accepts; each key equals its value. */
+export const ERROR_CODES: Record<string, string>;
+
+/** The DAG class under its older name. */
+export { DAG as DAGEngine } from "./types/dag/dag-engine";
+
+/** The same function as loadRagConfig. */
+export { loadRagConfig as loadConfig } from "./types/config/load-config";
+
+// =============================================================================
+// Declarations generated from JSDoc (scripts/generate-types.js)
+// =============================================================================
+export { packContext } from "./types/core/context-packing";
+export { loadRagConfig } from "./types/config/load-config";
+export { validateRagrc } from "./types/config/enhanced-ragrc-schema";
+export { normalizeConfig } from "./types/config/normalize-config";
+import pluginRegistry = require("./types/core/plugin-registry");
+export { pluginRegistry };
+export { validatePlugin } from "./types/core/validate-plugin";
+import logger = require("./types/utils/logger");
+export { logger };
+import errorFormatter = require("./types/utils/error-formatter");
+export { errorFormatter };
+export { BatchProcessor } from "./types/utils/batch-processor";
+import RateLimiter = require("./types/utils/rate-limiter");
+export { RateLimiter };
+export { retry } from "./types/utils/retry";
+export { withRetry } from "./types/utils/retry";
+export { ConnectionPoolManager } from "./types/utils/connection-pool";
+export { JWTValidator } from "./types/security/jwt-validator";
+export { PluginSignatureVerifier } from "./types/security/plugin-signature-verifier";
+export { validateInput } from "./types/security/validator";
+export { DAG } from "./types/dag/dag-engine";
+export { evaluateRagDataset } from "./types/evaluate/evaluator";
+export { scoreAnswer } from "./types/evaluate/scoring";
+export { computeBLEU } from "./types/evaluate/scoring";
+export { computeROUGE } from "./types/evaluate/scoring";
+export { checkNumericConsistency } from "./types/evaluate/scoring";
+export { extractNumbers } from "./types/evaluate/scoring";
+export { computeFaithfulness } from "./types/evaluate/faithfulness";
+export { computeSemanticSimilarity } from "./types/evaluate/semantic-similarity";
+export { validateDataset } from "./types/evaluate/dataset";
+export { generateSyntheticDataset } from "./types/evaluate/synthetic";
+export { runEvaluation } from "./types/evaluate/compare";
+export { compareConfigurations } from "./types/evaluate/compare";
+export { evaluationVerdict } from "./types/evaluate/report";
+export { renderEvaluationReport } from "./types/evaluate/report";
+export { computeAnswerRelevance } from "./types/evaluate/relevance";
+export { computeContextPrecision } from "./types/evaluate/context-metrics";
+export { computeContextRecall } from "./types/evaluate/context-metrics";
+export { computeGroundedness } from "./types/evaluate/groundedness";
+export { PipelineEvaluator } from "./types/evaluate/pipeline-evaluator";
+export { ChunkingEngine } from "./types/chunking/chunking-engine";
+export { CitationTracker } from "./types/citation/citation-tracker";
+export { checkAnswer } from "./types/grounding/check-answer";
+export { normalizeSources } from "./types/grounding/check-answer";
+export { createAiSdkAdapter } from "./types/adapters/ai-sdk";
+export { MemoryCache } from "./types/cache/memory-cache";
+export { RedisCache } from "./types/cache/redis-cache";
+export { mapSentenceToSources } from "./types/citation/source-mapper";
+export { buildIDFWeights } from "./types/citation/source-mapper";
+export { detectHallucinations } from "./types/citation/hallucination-detector";
+export { BM25Search } from "./types/retrieval/bm25-search";
+export { reciprocalRankFusion } from "./types/retrieval/rank-fusion";
+export { HybridRetriever } from "./types/retrieval/hybrid-retriever";
+export { FileVectorStore } from "./types/retrieval/file-vector-store";
+export { PreRetrievalGuard } from "./types/guardrails/pre-retrieval-guard";
+export { detectInjection } from "./types/guardrails/injection-detector";
+export { RetrievalGuard } from "./types/guardrails/retrieval-guard";
+export { PostGenerationGuard } from "./types/guardrails/post-generation-guard";
+export { GuardrailsPipeline } from "./types/guardrails/guardrails-pipeline";
+export { QueryPlanner } from "./types/agentic/query-planner";
+export { IterativeRetriever } from "./types/agentic/iterative-retriever";
+export { SelfCritiqueChecker } from "./types/agentic/self-critique";
+export { AgenticPipeline } from "./types/agentic/agentic-pipeline";
+export { CostCalculator } from "./types/cost/cost-calculator";
+export { PRICING_METADATA } from "./types/cost/cost-calculator";
+export { CostTracker } from "./types/cost/cost-tracker";
+export { TokenBudget } from "./types/cost/token-budget";
+export { createModelRouter } from "./types/cost/model-router";
+export { classifyQuery } from "./types/cost/model-router";
+export { ExecutionTracer } from "./types/debug/execution-tracer";
+export { TraceInspector } from "./types/debug/trace-inspector";
+export { MCPServer } from "./types/mcp/mcp-server";
+export { MCPToolBuilder } from "./types/mcp/mcp-tool-builder";
+export { ProjectScaffolder } from "./types/templates/scaffold";
+export { TemplateRegistry } from "./types/templates/template-registry";
+export { SSEAdapter } from "./types/streaming/sse-adapter";
+export { WebSocketAdapter } from "./types/streaming/websocket-adapter";
+export { StreamRouter } from "./types/streaming/stream-router";
+export { BaseConnector } from "./types/connectors/base-connector";
+export { OllamaConnector } from "./types/connectors/ollama-connector";
+export { LocalEmbedder } from "./types/connectors/local-embedder";
+export { MemoryRetriever } from "./types/connectors/memory-retriever";
+export { PgVectorRetriever } from "./types/retrieval/pgvector-retriever";
+export { QdrantRetriever } from "./types/retrieval/qdrant-retriever";
+export { OpenAIConnector } from "./types/connectors/openai-connector";
+export { AnthropicConnector } from "./types/connectors/anthropic-connector";
+export { CohereConnector } from "./types/connectors/cohere-connector";
+export { StreamingEmbedder } from "./types/streaming/streaming-embedder";
+export { createEmbeddingStream } from "./types/streaming/embedding-stream";
+export { ScoringReranker } from "./types/reranker/scoring-reranker";
+export { EmbeddingReranker } from "./types/reranker/embedding-reranker";
+export { CascadeReranker } from "./types/reranker/cascade-reranker";
+export { KnowledgeGraph } from "./types/graph/knowledge-graph";
+export { EntityExtractor } from "./types/graph/entity-extractor";
+export { GraphRetriever } from "./types/graph/graph-retriever";
+export { GraphIndex } from "./types/graph/graph-index";
+export { DashboardGenerator } from "./types/dashboard/dashboard-generator";
+export { MetricsAggregator } from "./types/dashboard/metrics-aggregator";
+import ParallelProcessor = require("./types/core/performance/parallel-processor");
+export { ParallelProcessor };
+import eventLogger = require("./types/core/observability/event-logger");
+export { eventLogger };
+import metrics = require("./types/core/observability/metrics");
+export { metrics };
+export { AuditLogger } from "./types/enterprise/audit-logging";
+export { PluginHub } from "./types/ecosystem/plugin-hub";
+export { PluginAnalytics } from "./types/ecosystem/plugin-hub";
+export { PluginAnalyticsDashboard } from "./types/ecosystem/plugin-analytics-dashboard";
+export { HotReloadManager } from "./types/dev/hot-reload";
+export { createHotReloadManager } from "./types/dev/hot-reload";
+export { DevServer } from "./types/dev/dev-server";
+export { createDevServer } from "./types/dev/dev-server";