@digilogiclabs/platform-core 1.1.1 → 1.2.0

package/dist/testing.mjs

@@ -1,3 +1,1018 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/interfaces/IAI.ts
+var MemoryAI;
+var init_IAI = __esm({
+  "src/interfaces/IAI.ts"() {
+    "use strict";
+    MemoryAI = class {
+      constructor(config = {}) {
+        this.config = config;
+        this.models = config.models || [
+          {
+            modelId: "gpt-4",
+            provider: "openai",
+            capabilities: ["chat", "completion"],
+            maxContextTokens: 128e3,
+            maxOutputTokens: 4096,
+            inputCostPer1K: 0.03,
+            outputCostPer1K: 0.06,
+            supportsStreaming: true,
+            supportsTools: true,
+            supportsVision: true
+          },
+          {
+            modelId: "claude-3-opus",
+            provider: "anthropic",
+            capabilities: ["chat"],
+            maxContextTokens: 2e5,
+            maxOutputTokens: 4096,
+            inputCostPer1K: 0.015,
+            outputCostPer1K: 0.075,
+            supportsStreaming: true,
+            supportsTools: true,
+            supportsVision: true
+          },
+          {
+            modelId: "text-embedding-3-small",
+            provider: "openai",
+            capabilities: ["embedding"],
+            maxContextTokens: 8191,
+            maxOutputTokens: 0,
+            inputCostPer1K: 2e-5,
+            outputCostPer1K: 0,
+            supportsStreaming: false,
+            supportsTools: false,
+            supportsVision: false
+          }
+        ];
+      }
+      models = [];
+      responses = /* @__PURE__ */ new Map();
+      embeddings = /* @__PURE__ */ new Map();
+      requestLog = [];
+      // ─────────────────────────────────────────────────────────────
+      // Test Helpers
+      // ─────────────────────────────────────────────────────────────
+      setResponse(key, response) {
+        this.responses.set(key, response);
+      }
+      setEmbedding(text, embedding) {
+        this.embeddings.set(text, embedding);
+      }
+      getRequestLog() {
+        return [...this.requestLog];
+      }
+      clearRequestLog() {
+        this.requestLog = [];
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Chat Operations
+      // ─────────────────────────────────────────────────────────────
+      async chat(request) {
+        this.requestLog.push({ type: "chat", request, timestamp: /* @__PURE__ */ new Date() });
+        const model = request.model || this.config.defaultChatModel || "gpt-4";
+        const lastMessage = request.messages[request.messages.length - 1];
+        const key = `${model}:${lastMessage?.content}`;
+        if (this.responses.has(key)) {
+          return this.responses.get(key);
+        }
+        const response = {
+          id: `chatcmpl-${Date.now()}`,
+          model,
+          provider: "openai",
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: "assistant",
+                content: `Mock response to: ${lastMessage?.content || "empty"}`
+              },
+              finishReason: "stop"
+            }
+          ],
+          usage: {
+            promptTokens: this.estimateTokensSync(
+              request.messages.map((m) => m.content).join(" ")
+            ),
+            completionTokens: 20,
+            totalTokens: 0,
+            estimatedCostUsd: 0
+          },
+          created: /* @__PURE__ */ new Date(),
+          finishReason: "stop"
+        };
+        response.usage.totalTokens = response.usage.promptTokens + response.usage.completionTokens;
+        response.usage.estimatedCostUsd = this.calculateCost(model, response.usage);
+        return response;
+      }
+      async *chatStream(request) {
+        this.requestLog.push({
+          type: "chatStream",
+          request,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        const model = request.model || this.config.defaultChatModel || "gpt-4";
+        const lastMessage = request.messages[request.messages.length - 1];
+        const responseText = `Mock streaming response to: ${lastMessage?.content || "empty"}`;
+        const words = responseText.split(" ");
+        for (let i = 0; i < words.length; i++) {
+          yield {
+            id: `chatcmpl-${Date.now()}`,
+            model,
+            provider: "openai",
+            delta: {
+              content: (i > 0 ? " " : "") + words[i],
+              role: i === 0 ? "assistant" : void 0
+            },
+            finishReason: i === words.length - 1 ? "stop" : void 0
+          };
+        }
+      }
+      async chatWithCallback(request, callback) {
+        let fullContent = "";
+        for await (const chunk of this.chatStream(request)) {
+          await callback(chunk);
+          if (chunk.delta.content) {
+            fullContent += chunk.delta.content;
+          }
+        }
+        const model = request.model || this.config.defaultChatModel || "gpt-4";
+        return {
+          id: `chatcmpl-${Date.now()}`,
+          model,
+          provider: "openai",
+          choices: [
+            {
+              index: 0,
+              message: { role: "assistant", content: fullContent },
+              finishReason: "stop"
+            }
+          ],
+          usage: {
+            promptTokens: this.estimateTokensSync(
+              request.messages.map((m) => m.content).join(" ")
+            ),
+            completionTokens: this.estimateTokensSync(fullContent),
+            totalTokens: 0,
+            estimatedCostUsd: 0
+          },
+          created: /* @__PURE__ */ new Date(),
+          finishReason: "stop"
+        };
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Completion Operations
+      // ─────────────────────────────────────────────────────────────
+      async complete(request) {
+        this.requestLog.push({ type: "complete", request, timestamp: /* @__PURE__ */ new Date() });
+        const model = request.model || this.config.defaultCompletionModel || "gpt-4";
+        const key = `completion:${model}:${request.prompt}`;
+        if (this.responses.has(key)) {
+          return this.responses.get(key);
+        }
+        const response = {
+          id: `cmpl-${Date.now()}`,
+          model,
+          provider: "openai",
+          text: `Mock completion of: ${request.prompt.substring(0, 50)}...`,
+          usage: {
+            promptTokens: this.estimateTokensSync(request.prompt),
+            completionTokens: 20,
+            totalTokens: 0,
+            estimatedCostUsd: 0
+          },
+          created: /* @__PURE__ */ new Date(),
+          finishReason: "stop"
+        };
+        response.usage.totalTokens = response.usage.promptTokens + response.usage.completionTokens;
+        response.usage.estimatedCostUsd = this.calculateCost(model, response.usage);
+        return response;
+      }
+      async *completeStream(request) {
+        this.requestLog.push({
+          type: "completeStream",
+          request,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        const model = request.model || this.config.defaultCompletionModel || "gpt-4";
+        const responseText = `Mock streaming completion of: ${request.prompt.substring(0, 30)}...`;
+        const words = responseText.split(" ");
+        for (let i = 0; i < words.length; i++) {
+          yield {
+            id: `cmpl-${Date.now()}`,
+            model,
+            provider: "openai",
+            delta: {
+              content: (i > 0 ? " " : "") + words[i]
+            },
+            finishReason: i === words.length - 1 ? "stop" : void 0
+          };
+        }
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Embedding Operations
+      // ─────────────────────────────────────────────────────────────
+      async embed(request) {
+        this.requestLog.push({ type: "embed", request, timestamp: /* @__PURE__ */ new Date() });
+        const model = request.model || this.config.defaultEmbeddingModel || "text-embedding-3-small";
+        const inputs = Array.isArray(request.input) ? request.input : [request.input];
+        const dimensions = request.dimensions || 1536;
+        const embeddings = inputs.map((text) => {
+          if (this.embeddings.has(text)) {
+            return this.embeddings.get(text);
+          }
+          return this.generateMockEmbedding(text, dimensions);
+        });
+        return {
+          id: `emb-${Date.now()}`,
+          model,
+          provider: "openai",
+          embeddings,
+          usage: {
+            promptTokens: inputs.reduce(
+              (sum, t) => sum + this.estimateTokensSync(t),
+              0
+            ),
+            completionTokens: 0,
+            totalTokens: 0,
+            estimatedCostUsd: 0
+          },
+          created: /* @__PURE__ */ new Date()
+        };
+      }
+      async similarity(text1, text2, model) {
+        const response = await this.embed({ input: [text1, text2], model });
+        const [emb1, emb2] = response.embeddings;
+        return this.cosineSimilarity(emb1, emb2);
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Model Management
+      // ─────────────────────────────────────────────────────────────
+      async listModels() {
+        return [...this.models];
+      }
+      async getModel(modelId) {
+        return this.models.find((m) => m.modelId === modelId) || null;
+      }
+      async supportsCapability(modelId, capability) {
+        const model = await this.getModel(modelId);
+        return model?.capabilities.includes(capability) ?? false;
+      }
+      async estimateTokens(text, _model) {
+        return this.estimateTokensSync(text);
+      }
+      async estimateCost(request) {
+        let model;
+        let inputTokens;
+        if ("messages" in request) {
+          model = request.model || this.config.defaultChatModel || "gpt-4";
+          inputTokens = this.estimateTokensSync(
+            request.messages.map((m) => m.content).join(" ")
+          );
+        } else if ("prompt" in request) {
+          model = request.model || this.config.defaultCompletionModel || "gpt-4";
+          inputTokens = this.estimateTokensSync(request.prompt);
+        } else {
+          model = request.model || this.config.defaultEmbeddingModel || "text-embedding-3-small";
+          const inputs = Array.isArray(request.input) ? request.input : [request.input];
+          inputTokens = inputs.reduce(
+            (sum, t) => sum + this.estimateTokensSync(t),
+            0
+          );
+        }
+        const modelConfig = await this.getModel(model);
+        if (!modelConfig) return 0;
+        const estimatedOutputTokens = "messages" in request || "prompt" in request ? 100 : 0;
+        return inputTokens / 1e3 * modelConfig.inputCostPer1K + estimatedOutputTokens / 1e3 * modelConfig.outputCostPer1K;
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Health & Status
+      // ─────────────────────────────────────────────────────────────
+      async healthCheck() {
+        return {
+          healthy: true,
+          providers: {
+            openai: { available: true, latencyMs: 50 },
+            anthropic: { available: true, latencyMs: 60 },
+            google: { available: true, latencyMs: 55 },
+            azure: { available: false, error: "Not configured" },
+            bedrock: { available: false, error: "Not configured" },
+            custom: { available: false, error: "Not configured" }
+          }
+        };
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Private Helpers
+      // ─────────────────────────────────────────────────────────────
+      estimateTokensSync(text) {
+        return Math.ceil(text.length / 4);
+      }
+      calculateCost(modelId, usage) {
+        const model = this.models.find((m) => m.modelId === modelId);
+        if (!model) return 0;
+        return usage.promptTokens / 1e3 * model.inputCostPer1K + usage.completionTokens / 1e3 * model.outputCostPer1K;
+      }
+      generateMockEmbedding(text, dimensions) {
+        const embedding = [];
+        let hash = 0;
+        for (let i = 0; i < text.length; i++) {
+          hash = (hash << 5) - hash + text.charCodeAt(i);
+          hash = hash & hash;
+        }
+        for (let i = 0; i < dimensions; i++) {
+          const seed = hash + i * 31;
+          embedding.push(Math.sin(seed) * 0.5);
+        }
+        const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
+        return embedding.map((v) => v / magnitude);
+      }
+      cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          dotProduct += a[i] * b[i];
+          normA += a[i] * a[i];
+          normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+      }
+    };
+  }
+});
+
+// src/interfaces/IRAG.ts
+var ChunkingPresets, MemoryRAG;
+var init_IRAG = __esm({
+  "src/interfaces/IRAG.ts"() {
+    "use strict";
+    ChunkingPresets = {
+      default: {
+        strategy: "recursive",
+        chunkSize: 512,
+        chunkOverlap: 50,
+        minChunkSize: 100,
+        separators: ["\n\n", "\n", ". ", " "]
+      },
+      small: {
+        strategy: "sentence",
+        chunkSize: 256,
+        chunkOverlap: 25,
+        minChunkSize: 50
+      },
+      large: {
+        strategy: "paragraph",
+        chunkSize: 1024,
+        chunkOverlap: 100,
+        minChunkSize: 200
+      },
+      code: {
+        strategy: "recursive",
+        chunkSize: 1e3,
+        chunkOverlap: 100,
+        separators: ["\n\nclass ", "\n\nfunction ", "\n\ndef ", "\n\n", "\n"]
+      }
+    };
+    MemoryRAG = class {
+      constructor(config = {}) {
+        this.config = config;
+      }
+      collections = /* @__PURE__ */ new Map();
+      documents = /* @__PURE__ */ new Map();
+      chunks = /* @__PURE__ */ new Map();
+      pipelines = /* @__PURE__ */ new Map();
+      embeddings = /* @__PURE__ */ new Map();
+      // ─────────────────────────────────────────────────────────────
+      // Collection Management
+      // ─────────────────────────────────────────────────────────────
+      async createCollection(options) {
+        const now = /* @__PURE__ */ new Date();
+        const collection = {
+          name: options.name,
+          description: options.description,
+          embeddingModel: options.embeddingModel || this.config.defaultEmbeddingModel || "text-embedding-3-small",
+          dimensions: options.dimensions || 1536,
+          distanceMetric: options.distanceMetric || "cosine",
+          chunkingConfig: {
+            ...ChunkingPresets.default,
+            ...this.config.defaultChunkingConfig,
+            ...options.chunkingConfig
+          },
+          documentCount: 0,
+          chunkCount: 0,
+          totalTokens: 0,
+          createdAt: now,
+          updatedAt: now
+        };
+        this.collections.set(options.name, collection);
+        return collection;
+      }
+      async getCollection(name) {
+        return this.collections.get(name) || null;
+      }
+      async listCollections(tenantId) {
+        const collections = Array.from(this.collections.values());
+        return collections;
+      }
+      async deleteCollection(name) {
+        for (const [id, doc] of this.documents) {
+          if (doc.collection === name) {
+            for (const [chunkId, chunk] of this.chunks) {
+              if (chunk.documentId === id) {
+                this.chunks.delete(chunkId);
+              }
+            }
+            this.documents.delete(id);
+          }
+        }
+        this.collections.delete(name);
+      }
+      async getCollectionStats(name) {
+        const collection = await this.getCollection(name);
+        if (!collection) {
+          throw new Error(`Collection not found: ${name}`);
+        }
+        const docs = Array.from(this.documents.values()).filter(
+          (d) => d.collection === name
+        );
+        const docChunks = Array.from(this.chunks.values()).filter(
+          (c) => c.collection === name
+        );
+        const totalTokens = docChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+        return {
+          documentCount: docs.length,
+          chunkCount: docChunks.length,
+          totalTokens,
+          averageChunkSize: docChunks.length > 0 ? totalTokens / docChunks.length : 0,
+          storageBytes: docChunks.reduce((sum, c) => sum + c.content.length, 0)
+        };
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Document Management
+      // ─────────────────────────────────────────────────────────────
+      async ingest(collection, documents, options) {
+        const startTime = Date.now();
+        const results = [];
+        for (const doc of documents) {
+          const result = await this.ingestOne(
+            collection,
+            doc,
+            options
+          );
+          results.push(result);
+        }
+        return {
+          total: documents.length,
+          successful: results.filter((r) => r.status === "indexed").length,
+          failed: results.filter((r) => r.status === "failed").length,
+          results,
+          totalProcessingTimeMs: Date.now() - startTime
+        };
+      }
+      async ingestOne(collection, document, options) {
+        const startTime = Date.now();
+        const docId = `doc_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        const now = /* @__PURE__ */ new Date();
+        try {
+          const col = await this.getCollection(collection);
+          if (!col) {
+            throw new Error(`Collection not found: ${collection}`);
+          }
+          const doc = {
+            ...document,
+            id: docId,
+            collection,
+            status: "processing",
+            tenantId: options?.tenantId || document.tenantId,
+            metadata: { ...document.metadata, ...options?.metadata },
+            createdAt: now,
+            updatedAt: now
+          };
+          this.documents.set(docId, doc);
+          const chunkingConfig = { ...col.chunkingConfig, ...options?.chunking };
+          const docChunks = this.chunkDocument(doc, chunkingConfig);
+          if (options?.generateEmbeddings !== false) {
+            for (const chunk of docChunks) {
+              chunk.embedding = await this.generateMockEmbedding(
+                chunk.content,
+                col.dimensions
+              );
+              this.embeddings.set(chunk.id, chunk.embedding);
+            }
+          }
+          for (const chunk of docChunks) {
+            this.chunks.set(chunk.id, chunk);
+          }
+          doc.status = "indexed";
+          doc.chunkCount = docChunks.length;
+          doc.tokenCount = docChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+          this.documents.set(docId, doc);
+          col.documentCount++;
+          col.chunkCount += docChunks.length;
+          col.totalTokens += doc.tokenCount;
+          col.updatedAt = /* @__PURE__ */ new Date();
+          return {
+            documentId: docId,
+            status: "indexed",
+            chunkCount: doc.chunkCount,
+            tokenCount: doc.tokenCount,
+            processingTimeMs: Date.now() - startTime
+          };
+        } catch (error) {
+          const doc = this.documents.get(docId);
+          if (doc) {
+            doc.status = "failed";
+            doc.error = error instanceof Error ? error.message : "Unknown error";
+          }
+          return {
+            documentId: docId,
+            status: "failed",
+            chunkCount: 0,
+            tokenCount: 0,
+            error: error instanceof Error ? error.message : "Unknown error",
+            processingTimeMs: Date.now() - startTime
+          };
+        }
+      }
+      async getDocument(documentId) {
+        return this.documents.get(documentId) || null;
+      }
+      async listDocuments(collection, options) {
+        let docs = Array.from(this.documents.values()).filter(
+          (d) => d.collection === collection
+        );
+        if (options?.tenantId) {
+          docs = docs.filter((d) => d.tenantId === options.tenantId);
+        }
+        if (options?.status) {
+          docs = docs.filter((d) => d.status === options.status);
+        }
+        const total = docs.length;
+        const offset = options?.offset || 0;
+        const limit = options?.limit || 50;
+        return {
+          documents: docs.slice(offset, offset + limit),
+          total
+        };
+      }
+      async deleteDocument(documentId) {
+        const doc = await this.getDocument(documentId);
+        if (doc) {
+          for (const [chunkId, chunk] of this.chunks) {
+            if (chunk.documentId === documentId) {
+              this.chunks.delete(chunkId);
+              this.embeddings.delete(chunkId);
+            }
+          }
+          const collection = await this.getCollection(doc.collection);
+          if (collection) {
+            collection.documentCount--;
+            collection.chunkCount -= doc.chunkCount || 0;
+            collection.totalTokens -= doc.tokenCount || 0;
+          }
+          this.documents.delete(documentId);
+        }
+      }
+      async reprocessDocument(documentId, options) {
+        const doc = await this.getDocument(documentId);
+        if (!doc) {
+          throw new Error(`Document not found: ${documentId}`);
+        }
+        for (const [chunkId, chunk] of this.chunks) {
+          if (chunk.documentId === documentId) {
+            this.chunks.delete(chunkId);
+            this.embeddings.delete(chunkId);
+          }
+        }
+        return this.ingestOne(
+          doc.collection,
+          {
+            source: doc.source,
+            type: doc.type,
+            content: doc.content,
+            title: doc.title,
+            metadata: doc.metadata,
+            tenantId: doc.tenantId
+          },
+          options
+        );
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Chunk Management
+      // ─────────────────────────────────────────────────────────────
+      async getChunks(documentId) {
+        return Array.from(this.chunks.values()).filter((c) => c.documentId === documentId).sort((a, b) => a.index - b.index);
+      }
+      async getChunk(chunkId) {
+        return this.chunks.get(chunkId) || null;
+      }
+      async updateChunkMetadata(chunkId, metadata) {
+        const chunk = await this.getChunk(chunkId);
+        if (!chunk) {
+          throw new Error(`Chunk not found: ${chunkId}`);
+        }
+        chunk.metadata = { ...chunk.metadata, ...metadata };
+        this.chunks.set(chunkId, chunk);
+        return chunk;
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Search & Retrieval
+      // ─────────────────────────────────────────────────────────────
+      async search(query) {
+        const startTime = Date.now();
+        const mode = query.mode || this.config.defaultSearchMode || "vector";
+        const limit = query.limit || this.config.defaultLimit || 10;
+        const queryEmbedding = await this.generateMockEmbedding(query.query, 1536);
+        let chunks = Array.from(this.chunks.values()).filter(
+          (c) => c.collection === query.collection
+        );
+        if (query.tenantId) {
+          chunks = chunks.filter((c) => c.tenantId === query.tenantId);
+        }
+        if (query.filters) {
+          chunks = chunks.filter(
+            (c) => this.matchesFilters(c.metadata, query.filters)
+          );
+        }
+        let results = chunks.map((chunk) => {
+          const embedding = this.embeddings.get(chunk.id) || [];
+          const vectorScore = embedding.length > 0 ? this.cosineSimilarity(queryEmbedding, embedding) : 0;
+          const keywordScore = this.keywordScore(query.query, chunk.content);
+          let score;
+          switch (mode) {
+            case "vector":
+              score = vectorScore;
+              break;
+            case "keyword":
+              score = keywordScore;
+              break;
+            case "hybrid":
+              score = 0.7 * vectorScore + 0.3 * keywordScore;
+              break;
+            default:
+              score = vectorScore;
+          }
+          return { chunk, score };
+        });
+        if (query.minScore) {
+          results = results.filter((r) => r.score >= query.minScore);
+        }
+        results.sort((a, b) => b.score - a.score);
+        if (query.rerank) {
+          const candidates = results.slice(0, query.rerankCandidates || limit * 3);
+          results = candidates.sort((a, b) => {
+            const aRelevance = this.keywordScore(query.query, a.chunk.content);
+            const bRelevance = this.keywordScore(query.query, b.chunk.content);
+            return b.score + bRelevance - (a.score + aRelevance);
+          });
+        }
+        results = results.slice(0, limit);
+        if (query.includeDocumentContent) {
+          for (const result of results) {
+            result.document = await this.getDocument(result.chunk.documentId) || void 0;
+          }
+        }
+        for (const result of results) {
+          result.highlights = this.generateHighlights(
+            query.query,
+            result.chunk.content
+          );
+        }
+        return {
+          results,
+          query: query.query,
+          totalMatches: results.length,
+          searchTimeMs: Date.now() - startTime,
+          mode
+        };
+      }
+      async findSimilar(chunkId, options) {
+        const chunk = await this.getChunk(chunkId);
+        if (!chunk) {
+          throw new Error(`Chunk not found: ${chunkId}`);
+        }
+        const embedding = this.embeddings.get(chunkId);
+        if (!embedding) {
+          return [];
+        }
+        const collection = options?.collection || chunk.collection;
+        let chunks = Array.from(this.chunks.values()).filter(
+          (c) => c.collection === collection && c.id !== chunkId
+        );
+        const results = chunks.map((c) => {
+          const otherEmbedding = this.embeddings.get(c.id) || [];
+          const score = otherEmbedding.length > 0 ? this.cosineSimilarity(embedding, otherEmbedding) : 0;
+          return { chunk: c, score };
+        });
+        let filteredResults = results;
+        if (options?.minScore) {
+          filteredResults = results.filter((r) => r.score >= options.minScore);
+        }
+        filteredResults.sort((a, b) => b.score - a.score);
+        return filteredResults.slice(0, options?.limit || 10);
+      }
+      async multiSearch(queries) {
+        return Promise.all(queries.map((q) => this.search(q)));
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Context Assembly
+      // ─────────────────────────────────────────────────────────────
+      async assembleContext(results, config) {
+        const resultArray = "results" in results ? results.results : results;
+        const maxTokens = config?.maxTokens || 4e3;
+        const chunkTemplate = config?.chunkTemplate || "{{content}}";
+        const contextTemplate = config?.contextTemplate || "{{chunks}}";
+        let chunks = [];
+        let totalTokens = 0;
+        const sources = [];
+        const seenDocs = /* @__PURE__ */ new Set();
+        let processedResults = resultArray;
+        if (config?.deduplicate) {
+          const threshold = config.dedupeThreshold || 0.9;
+          processedResults = this.deduplicateResults(resultArray, threshold);
+        }
+        if (config?.sortBy) {
+          processedResults = [...processedResults].sort((a, b) => {
+            switch (config.sortBy) {
+              case "score":
+                return b.score - a.score;
+              case "document":
+                return a.chunk.documentId.localeCompare(b.chunk.documentId);
+              case "position":
+                return a.chunk.index - b.chunk.index;
+              default:
+                return 0;
+            }
+          });
+        }
+        let truncated = false;
+        for (const result of processedResults) {
+          if (totalTokens + result.chunk.tokenCount > maxTokens) {
+            truncated = true;
+            break;
+          }
+          chunks.push(result.chunk);
+          totalTokens += result.chunk.tokenCount;
+          if (!seenDocs.has(result.chunk.documentId)) {
+            seenDocs.add(result.chunk.documentId);
+            const doc = await this.getDocument(result.chunk.documentId);
+            sources.push({
+              documentId: result.chunk.documentId,
+              title: doc?.title,
+              source: doc?.source || ""
+            });
+          }
+        }
+        const formattedChunks = chunks.map((chunk, i) => {
+          let formatted = chunkTemplate.replace("{{content}}", chunk.content).replace("{{index}}", String(i + 1)).replace("{{documentId}}", chunk.documentId);
+          if (config?.includeCitations) {
+            formatted = `[${i + 1}] ${formatted}`;
+          }
+          return formatted;
+        });
+        let context = contextTemplate.replace(
+          "{{chunks}}",
+          formattedChunks.join("\n\n")
+        );
+        if (config?.includeCitations && sources.length > 0) {
+          const citations = sources.map((s, i) => `[${i + 1}] ${s.title || s.source}`).join("\n");
+          context += `
+
+Sources:
+${citations}`;
+        }
+        return {
+          context,
+          chunks,
+          tokenCount: totalTokens,
+          sources,
+          truncated
+        };
+      }
+      async queryWithContext(query, contextConfig) {
+        const searchResponse = await this.search(query);
+        const context = await this.assembleContext(searchResponse, contextConfig);
+        return { searchResponse, context };
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Embedding Management
+      // ─────────────────────────────────────────────────────────────
+      async embed(texts, model) {
+        const textArray = Array.isArray(texts) ? texts : [texts];
+        return Promise.all(
+          textArray.map((text) => this.generateMockEmbedding(text, 1536))
+        );
+      }
+      async reembed(collection, model, batchSize) {
+        const col = await this.getCollection(collection);
+        if (!col) {
+          throw new Error(`Collection not found: ${collection}`);
+        }
+        let updated = 0;
+        let errors = 0;
+        const chunks = Array.from(this.chunks.values()).filter(
+          (c) => c.collection === collection
+        );
+        for (const chunk of chunks) {
+          try {
+            const embedding = await this.generateMockEmbedding(
+              chunk.content,
+              col.dimensions
+            );
+            chunk.embedding = embedding;
+            this.embeddings.set(chunk.id, embedding);
+            updated++;
+          } catch {
+            errors++;
+          }
+        }
+        return { updated, errors };
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Pipeline Management
+      // ─────────────────────────────────────────────────────────────
+      async createPipeline(pipeline) {
+        const id = `pipeline_${Date.now()}`;
+        const now = /* @__PURE__ */ new Date();
+        const newPipeline = {
+          ...pipeline,
+          id,
+          createdAt: now,
+          updatedAt: now
+        };
+        this.pipelines.set(id, newPipeline);
+        return newPipeline;
+      }
+      async getPipeline(pipelineId) {
+        return this.pipelines.get(pipelineId) || null;
+      }
+      async runPipeline(pipelineId, documentIds) {
+        const pipeline = await this.getPipeline(pipelineId);
+        if (!pipeline) {
+          throw new Error(`Pipeline not found: ${pipelineId}`);
+        }
+        const results = [];
+        for (const docId of documentIds) {
+          const result = await this.reprocessDocument(docId);
+          results.push(result);
+        }
+        return {
+          total: documentIds.length,
+          successful: results.filter((r) => r.status === "indexed").length,
+          failed: results.filter((r) => r.status === "failed").length,
+          results,
+          totalProcessingTimeMs: results.reduce(
+            (sum, r) => sum + r.processingTimeMs,
+            0
+          )
+        };
+      }
+      // ─────────────────────────────────────────────────────────────
+      // Private Helpers
+      // ─────────────────────────────────────────────────────────────
+      chunkDocument(doc, config) {
+        const chunks = [];
+        const content = doc.content;
+        const chunkSize = config.chunkSize;
+        const overlap = config.chunkOverlap;
+        let startOffset = 0;
+        let index = 0;
+        while (startOffset < content.length) {
+          const endOffset = Math.min(startOffset + chunkSize * 4, content.length);
+          const chunkContent = content.slice(startOffset, endOffset);
+          chunks.push({
+            id: `chunk_${doc.id}_${index}`,
+            documentId: doc.id,
+            index,
+            content: chunkContent,
+            metadata: config.includeMetadata ? doc.metadata : {},
+            startOffset,
+            endOffset,
+            tokenCount: Math.ceil(chunkContent.length / 4),
+            collection: doc.collection,
+            tenantId: doc.tenantId
+          });
+          startOffset = endOffset - overlap * 4;
+          index++;
+        }
+        return chunks;
+      }
+      async generateMockEmbedding(text, dimensions) {
+        const embedding = [];
+        let hash = 0;
+        for (let i = 0; i < text.length; i++) {
+          hash = (hash << 5) - hash + text.charCodeAt(i);
+          hash = hash & hash;
+        }
+        for (let i = 0; i < dimensions; i++) {
+          const seed = hash + i * 31;
+          embedding.push(Math.sin(seed) * 0.5);
+        }
+        const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
+        return embedding.map((v) => v / magnitude);
+      }
+      cosineSimilarity(a, b) {
+        if (a.length !== b.length) return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          dotProduct += a[i] * b[i];
+          normA += a[i] * a[i];
+          normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator > 0 ? dotProduct / denominator : 0;
+      }
+      keywordScore(query, content) {
+        const queryWords = query.toLowerCase().split(/\s+/);
+        const contentLower = content.toLowerCase();
+        let matches = 0;
+        for (const word of queryWords) {
+          if (contentLower.includes(word)) {
+            matches++;
+          }
+        }
+        return queryWords.length > 0 ? matches / queryWords.length : 0;
+      }
+      matchesFilters(metadata, filters) {
+        for (const filter of filters) {
+          const value = metadata[filter.field];
+          switch (filter.operator) {
+            case "eq":
+              if (value !== filter.value) return false;
+              break;
+            case "ne":
+              if (value === filter.value) return false;
+              break;
+            case "gt":
+              if (typeof value !== "number" || typeof filter.value !== "number" || value <= filter.value)
+                return false;
+              break;
+            case "gte":
+              if (typeof value !== "number" || typeof filter.value !== "number" || value < filter.value)
+                return false;
+              break;
+            case "lt":
+              if (typeof value !== "number" || typeof filter.value !== "number" || value >= filter.value)
+                return false;
+              break;
+            case "lte":
+              if (typeof value !== "number" || typeof filter.value !== "number" || value > filter.value)
+                return false;
+              break;
+            case "in":
+              if (!Array.isArray(filter.value) || !filter.value.includes(value))
+                return false;
+              break;
+            case "nin":
+              if (!Array.isArray(filter.value) || filter.value.includes(value))
+                return false;
+              break;
+            case "contains":
+              if (typeof value !== "string" || typeof filter.value !== "string" || !value.includes(filter.value))
+                return false;
+              break;
+          }
+        }
+        return true;
+      }
+      generateHighlights(query, content) {
+        const words = query.toLowerCase().split(/\s+/);
+        const highlights = [];
+        for (const word of words) {
+          const index = content.toLowerCase().indexOf(word);
+          if (index !== -1) {
+            const start = Math.max(0, index - 30);
+            const end = Math.min(content.length, index + word.length + 30);
+            highlights.push(`...${content.slice(start, end)}...`);
+          }
+        }
+        return highlights.slice(0, 3);
+      }
+      deduplicateResults(results, threshold) {
+        const deduplicated = [];
+        for (const result of results) {
+          const isDuplicate = deduplicated.some((r) => {
+            const embedding1 = this.embeddings.get(result.chunk.id);
+            const embedding2 = this.embeddings.get(r.chunk.id);
+            if (!embedding1 || !embedding2) return false;
+            return this.cosineSimilarity(embedding1, embedding2) > threshold;
+          });
+          if (!isDuplicate) {
+            deduplicated.push(result);
+          }
+        }
+        return deduplicated;
+      }
+    };
+  }
+});
+
 // src/adapters/memory/MemoryDatabase.ts
 var MemoryDatabase = class {
   tables = /* @__PURE__ */ new Map();
@@ -1259,6 +2274,8 @@ var EmailProviderSchema = z.enum(["memory", "console", "smtp", "resend"]);
 var QueueProviderSchema = z.enum(["memory", "bullmq"]);
 var TracingProviderSchema = z.enum(["noop", "memory", "otlp"]);
 var LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
+var AIProviderSchema = z.enum(["memory", "openai", "anthropic", "google"]);
+var RAGProviderSchema = z.enum(["memory", "pinecone", "weaviate"]);
 var DatabaseConfigSchema = z.object({
   provider: DatabaseProviderSchema.default("memory"),
   url: z.string().optional().describe("PostgreSQL connection URL"),
@@ -1371,6 +2388,51 @@ var QueueConfigSchema = z.object({
     message: "BullMQ requires redisUrl"
   }
 );
+var AIConfigSchema = z.object({
+  enabled: z.boolean().default(false).describe("Enable AI capabilities"),
+  provider: AIProviderSchema.default("memory"),
+  apiKey: z.string().optional().describe("API key for the AI provider"),
+  model: z.string().optional().describe("Default model to use"),
+  maxTokens: z.number().int().min(1).max(2e5).default(4096).describe("Default max tokens"),
+  temperature: z.number().min(0).max(2).default(0.7).describe("Default temperature"),
+  timeout: z.number().int().min(1e3).max(3e5).default(6e4).describe("Request timeout in ms"),
+  baseUrl: z.string().url().optional().describe("Custom base URL for API")
+}).refine(
+  (data) => {
+    if (data.enabled && data.provider !== "memory") {
+      return data.apiKey;
+    }
+    return true;
+  },
+  {
+    message: "Production AI providers require an API key"
+  }
+);
+var RAGConfigSchema = z.object({
+  enabled: z.boolean().default(false).describe("Enable RAG capabilities"),
+  provider: RAGProviderSchema.default("memory"),
+  apiKey: z.string().optional().describe("API key for the RAG provider"),
+  environment: z.string().optional().describe("Pinecone environment"),
+  indexName: z.string().optional().describe("Pinecone index name or Weaviate class"),
+  namespace: z.string().optional().describe("Default namespace"),
+  host: z.string().url().optional().describe("Weaviate host URL"),
+  embeddingProvider: AIProviderSchema.default("memory").describe("Provider for generating embeddings"),
+  embeddingApiKey: z.string().optional().describe("API key for embedding provider"),
+  embeddingModel: z.string().optional().describe("Model for generating embeddings")
+}).refine(
+  (data) => {
+    if (data.enabled && data.provider === "pinecone") {
+      return data.apiKey && data.indexName;
+    }
+    if (data.enabled && data.provider === "weaviate") {
+      return data.host;
+    }
+    return true;
+  },
+  {
+    message: "Pinecone requires apiKey and indexName; Weaviate requires host"
+  }
+);
 var RetryConfigSchema = z.object({
   enabled: z.boolean().default(true).describe("Enable retry for failed operations"),
   maxAttempts: z.number().int().min(1).max(10).default(3).describe("Maximum retry attempts"),
@@ -1457,6 +2519,9 @@ var PlatformConfigSchema = z.object({
   storage: StorageConfigSchema.default({ provider: "memory" }),
   email: EmailConfigSchema.default({ provider: "memory" }),
   queue: QueueConfigSchema.default({ provider: "memory" }),
+  // AI configurations
+  ai: AIConfigSchema.default({ enabled: false }),
+  rag: RAGConfigSchema.default({ enabled: false }),
   // Resilience configuration
   resilience: ResilienceConfigSchema.default({}),
   // Observability configuration
@@ -1512,6 +2577,28 @@ function loadConfig() {
       concurrency: process.env.QUEUE_CONCURRENCY ? parseInt(process.env.QUEUE_CONCURRENCY) : void 0,
       maxRetries: process.env.QUEUE_MAX_RETRIES ? parseInt(process.env.QUEUE_MAX_RETRIES) : void 0
     },
+    ai: {
+      enabled: process.env.AI_ENABLED === "true",
+      provider: process.env.AI_PROVIDER || "memory",
+      apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GOOGLE_AI_API_KEY,
+      model: process.env.AI_MODEL,
+      maxTokens: process.env.AI_MAX_TOKENS ? parseInt(process.env.AI_MAX_TOKENS) : void 0,
+      temperature: process.env.AI_TEMPERATURE ? parseFloat(process.env.AI_TEMPERATURE) : void 0,
+      timeout: process.env.AI_TIMEOUT ? parseInt(process.env.AI_TIMEOUT) : void 0,
+      baseUrl: process.env.AI_BASE_URL
+    },
+    rag: {
+      enabled: process.env.RAG_ENABLED === "true",
+      provider: process.env.RAG_PROVIDER || "memory",
+      apiKey: process.env.PINECONE_API_KEY,
+      environment: process.env.PINECONE_ENVIRONMENT,
+      indexName: process.env.PINECONE_INDEX || process.env.RAG_INDEX_NAME,
+      namespace: process.env.RAG_NAMESPACE,
+      host: process.env.WEAVIATE_HOST,
+      embeddingProvider: process.env.EMBEDDING_PROVIDER || "memory",
+      embeddingApiKey: process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY,
+      embeddingModel: process.env.EMBEDDING_MODEL
+    },
     resilience: {
       retry: {
         enabled: process.env.RESILIENCE_RETRY_ENABLED !== "false",
@@ -2079,6 +3166,8 @@ var NoopMetrics = class {
 };
 
 // src/factory.ts
+init_IAI();
+init_IRAG();
 function createLogger(config) {
   if (!config.observability.logging) {
     return new NoopLogger();
@@ -2097,7 +3186,7 @@ function createMetrics(config) {
 }
 function createPlatform(config) {
   const finalConfig = config ? deepMerge(loadConfig(), config) : loadConfig();
-  const hasProductionAdapters = finalConfig.database.provider !== "memory" || finalConfig.cache.provider !== "memory" || finalConfig.storage.provider !== "memory" || finalConfig.email.provider !== "memory" && finalConfig.email.provider !== "console" || finalConfig.observability.tracing.provider === "otlp";
+  const hasProductionAdapters = finalConfig.database.provider !== "memory" || finalConfig.cache.provider !== "memory" || finalConfig.storage.provider !== "memory" || finalConfig.email.provider !== "memory" && finalConfig.email.provider !== "console" || finalConfig.observability.tracing.provider === "otlp" || finalConfig.ai.enabled && finalConfig.ai.provider !== "memory" || finalConfig.rag.enabled && finalConfig.rag.provider !== "memory";
   if (hasProductionAdapters) {
     console.warn(
       "createPlatform() is synchronous and cannot initialize production adapters. Use createPlatformAsync() for production adapters, or use memory/console adapters."
@@ -2111,10 +3200,12 @@ function createPlatform(config) {
   const logger = createLogger(finalConfig);
   const metrics = createMetrics(finalConfig);
   const tracing = finalConfig.observability.tracing.provider === "memory" ? new MemoryTracing() : new NoopTracing();
-  return createPlatformFromAdapters(db, cache, storage, email, queue, logger, metrics, tracing);
+  const ai = finalConfig.ai.enabled ? new MemoryAI() : null;
+  const rag = finalConfig.rag.enabled ? new MemoryRAG() : null;
+  return createPlatformFromAdapters(db, cache, storage, email, queue, logger, metrics, tracing, ai, rag);
 }
-function createPlatformFromAdapters(db, cache, storage, email, queue, logger, metrics, tracing) {
-  return {
+function createPlatformFromAdapters(db, cache, storage, email, queue, logger, metrics, tracing, ai, rag) {
+  const platform = {
     db,
     cache,
     storage,
@@ -2149,6 +3240,13 @@ function createPlatformFromAdapters(db, cache, storage, email, queue, logger, me
       await Promise.all([db.close(), cache.close(), queue.close(), tracing.close()]);
     }
   };
+  if (ai) {
+    platform.ai = ai;
+  }
+  if (rag) {
+    platform.rag = rag;
+  }
+  return platform;
 }
 function deepMerge(target, source) {
   const result = { ...target };