plugin-knowledge-base 1.1.1 → 1.1.4

package/dist/server/pipeline/vectorization.js

@@ -29,13 +29,17 @@ __export(vectorization_exports, {
   VectorizationPipeline: () => VectorizationPipeline
 });
 module.exports = __toCommonJS(vectorization_exports);
+var import_path = require("path");
+var import_promises = require("fs/promises");
 var import_text_splitter = require("./text-splitter");
+var import_simple_embeddings = require("./simple-embeddings");
 class VectorizationPipeline {
-  constructor(plugin) {
+  constructor(plugin, docpixieExtractor) {
     this.plugin = plugin;
+    this.docpixieExtractor = docpixieExtractor;
   }
   async processDocument(documentId, options) {
-    var _a;
+    var _a, _b;
     const docRepo = this.plugin.db.getRepository("aiKnowledgeBaseDocuments");
     await docRepo.update({
       filter: { id: documentId },
@@ -60,37 +64,54 @@ class VectorizationPipeline {
         throw new Error("Knowledge base has no vector store configured");
       }
       let rawText;
+      let docpixieDocumentId = null;
       if (textContent) {
         rawText = textContent;
       } else {
-        const aiPlugin = this.plugin.aiPlugin;
-        if ((_a = aiPlugin.documentLoaders) == null ? void 0 : _a.cached) {
-          const parseResult = await aiPlugin.documentLoaders.cached.load(file);
-          if (!parseResult.supported) {
-            throw new Error(`File type not supported: ${file.filename}`);
-          }
-          rawText = parseResult.text || "";
-        } else {
-          const fs = require("fs");
-          const path = require("path");
-          let filePath = file.path || file.url;
-          if (!filePath) {
-            throw new Error(`Cannot resolve file path for: ${file.filename}`);
-          }
-          if (filePath.startsWith("/storage/") || filePath.startsWith("storage/")) {
-            const storageBase = path.resolve(process.cwd(), "storage");
-            filePath = path.resolve(storageBase, filePath.replace(/^\/?(storage\/)?/, ""));
+        const resolvedPath = this.resolveLocalPath(file);
+        if (knowledgeBase.useDocpixie && ((_a = this.docpixieExtractor) == null ? void 0 : _a.isAvailable()) && resolvedPath) {
+          const filename = file.filename ?? doc.filename ?? "document";
+          const result = await this.docpixieExtractor.extractFromPath(
+            resolvedPath,
+            filename,
+            doc.uploadedById ?? void 0
+          );
+          if (result) {
+            rawText = result.text;
+            docpixieDocumentId = result.documentId;
+            this.plugin.app.logger.info(
+              `[Vectorization] DocPixie extraction: doc="${filename}" docpixie_id=${result.documentId} chars=${result.text.length}`
+            );
           }
-          if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found at: ${filePath}`);
+        }
+        if (!rawText) {
+          const aiPlugin = this.plugin.aiPlugin;
+          if ((_b = aiPlugin.documentLoaders) == null ? void 0 : _b.cached) {
+            const parseResult = await aiPlugin.documentLoaders.cached.load(file);
+            if (!parseResult.supported) {
+              throw new Error(`File type not supported: ${file.filename}`);
+            }
+            rawText = parseResult.text || "";
+          } else if (resolvedPath) {
+            try {
+              await (0, import_promises.access)(resolvedPath);
+            } catch {
+              throw new Error(`File not found at: ${resolvedPath}`);
+            }
+            rawText = await (0, import_promises.readFile)(resolvedPath, "utf-8");
+          } else {
+            throw new Error(`Cannot resolve file for: ${file.filename}`);
           }
-          rawText = fs.readFileSync(filePath, "utf-8");
         }
       }
       if (!rawText || rawText.trim().length === 0) {
         await docRepo.update({
           filter: { id: documentId },
-          values: { status: "success", chunkCount: 0 }
+          values: {
+            status: "success",
+            chunkCount: 0,
+            ...docpixieDocumentId ? { meta: { ...doc.meta ?? {}, docpixieDocumentId } } : {}
+          }
         });
         return { success: true, chunkCount: 0 };
       }
@@ -102,12 +123,18 @@ class VectorizationPipeline {
         source: (file == null ? void 0 : file.filename) ?? doc.filename ?? "pasted-text",
         // Permission metadata for vector-level filtering
         userId: doc.uploadedById ?? null,
-        accessLevel: knowledgeBase.accessLevel ?? "PUBLIC"
+        accessLevel: knowledgeBase.accessLevel ?? "PUBLIC",
+        // DocPixie reference for Stage 2 deep retrieval (null if not used)
+        ...docpixieDocumentId ? { docpixieDocumentId } : {}
       });
       if (chunks.length === 0) {
         await docRepo.update({
           filter: { id: documentId },
-          values: { status: "success", chunkCount: 0 }
+          values: {
+            status: "success",
+            chunkCount: 0,
+            ...docpixieDocumentId ? { meta: { ...doc.meta ?? {}, docpixieDocumentId } } : {}
+          }
         });
         return { success: true, chunkCount: 0 };
       }
@@ -120,9 +147,8 @@ class VectorizationPipeline {
         throw new Error(`LLM service "${vectorStore.llmService}" not found`);
       }
       const llmService = llmServiceRecord.toJSON();
-      const { SimpleHTTPEmbeddings } = require("./simple-embeddings");
       const serviceOpts = this.plugin.app.environment.renderJsonTemplate(llmService.options || {});
-      const embeddings = new SimpleHTTPEmbeddings({
+      const embeddings = new import_simple_embeddings.SimpleHTTPEmbeddings({
         baseURL: serviceOpts.baseURL || serviceOpts.baseUrl || "",
         apiKey: serviceOpts.apiKey || "",
         model: vectorStore.embeddingModel
@@ -138,39 +164,15 @@ class VectorizationPipeline {
         filter: { id: documentId },
         values: {
           status: "success",
-          chunkCount: chunks.length
+          chunkCount: chunks.length,
+          meta: {
+            ...doc.meta ?? {},
+            ...docpixieDocumentId ? { docpixieDocumentId } : {}
+          }
         }
       });
       if (knowledgeBase.deleteSourceFile && file) {
-        try {
-          const fs = require("fs");
-          const path = require("path");
-          let filePath = file.path || file.url;
-          if (filePath) {
-            if (filePath.startsWith("/storage/") || filePath.startsWith("storage/")) {
-              const storageBase = path.resolve(process.cwd(), "storage");
-              filePath = path.resolve(storageBase, filePath.replace(/^\/?(?:storage\/)?/, ""));
-            }
-            if (fs.existsSync(filePath)) {
-              fs.unlinkSync(filePath);
-            }
-          }
-          const fileRepo = this.plugin.db.getRepository("aiFiles");
-          if (file.id) {
-            await fileRepo.destroy({ filterByTk: file.id });
-          }
-          await this.plugin.db.sequelize.query(
-            `UPDATE "aiKnowledgeBaseDocuments" SET "fileId" = NULL WHERE id = $1`,
-            { bind: [documentId] }
-          );
-          this.plugin.app.logger.info(
-            `[Vectorization] Source file deleted for doc ${documentId}: ${file.filename}`
-          );
-        } catch (delErr) {
-          this.plugin.app.logger.warn(
-            `[Vectorization] Failed to delete source file for doc ${documentId}: ${delErr.message}`
-          );
-        }
+        await this.deleteSourceFile(documentId, file);
       }
       return { success: true, chunkCount: chunks.length };
     } catch (error) {
@@ -188,6 +190,67 @@ class VectorizationPipeline {
       };
     }
   }
+  // ── Helpers ───────────────────────────────────────────────────────────────
+  /**
+   * Delete a source file after successful vectorization.
+   * Uses async fs/promises instead of blocking sync calls.
+   */
+  async deleteSourceFile(documentId, file) {
+    try {
+      let filePath = file.path || file.url;
+      if (filePath) {
+        if (filePath.startsWith("/storage/") || filePath.startsWith("storage/")) {
+          const storageBase = (0, import_path.resolve)(process.cwd(), "storage");
+          filePath = (0, import_path.resolve)(storageBase, filePath.replace(/^\/?(?:storage\/)?/, ""));
+        }
+        try {
+          await (0, import_promises.access)(filePath);
+          await (0, import_promises.unlink)(filePath);
+        } catch {
+        }
+      }
+      const fileRepo = this.plugin.db.getRepository("aiFiles");
+      if (file.id) {
+        await fileRepo.destroy({ filterByTk: file.id });
+      }
+      await this.plugin.db.getRepository("aiKnowledgeBaseDocuments").update({
+        filter: { id: documentId },
+        values: { fileId: null }
+      });
+      this.plugin.app.logger.info(
+        `[Vectorization] Source file deleted for doc ${documentId}: ${file.filename}`
+      );
+    } catch (delErr) {
+      this.plugin.app.logger.warn(
+        `[Vectorization] Failed to delete source file for doc ${documentId}: ${delErr.message}`
+      );
+    }
+  }
+  /**
+   * Resolve a storage-relative or absolute path from a file record.
+   * Returns null if the path cannot be resolved to a local file
+   * (e.g., remote S3 URL).
+   *
+   * Fix #5: The allowed root is now `storage/uploads` — not the entire CWD —
+   * to prevent path traversal attacks that could read source files or configs.
+   */
+  resolveLocalPath(file) {
+    let filePath = file.path || file.url || "";
+    if (!filePath) return null;
+    if (filePath.startsWith("http://") || filePath.startsWith("https://")) return null;
+    if (filePath.startsWith("/storage/") || filePath.startsWith("storage/")) {
+      const storageBase = (0, import_path.resolve)(process.cwd(), "storage");
+      filePath = (0, import_path.resolve)(storageBase, filePath.replace(/^\/?(?:storage\/)?/, ""));
+    }
+    const allowedRoot = (0, import_path.resolve)(process.cwd(), "storage", "uploads");
+    if (!filePath.startsWith(allowedRoot + import_path.sep) && filePath !== allowedRoot) {
+      this.plugin.app.logger.warn(
+        `[Vectorization] Blocked path traversal attempt: "${filePath}" is outside storage/uploads`
+      );
+      return null;
+    }
+    return filePath;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/plugin.js

@@ -47,7 +47,9 @@ var import_vector_database_impl = require("./features/vector-database-impl");
 var import_vector_database_provider_impl = require("./features/vector-database-provider-impl");
 var import_vector_store_provider_impl = require("./features/vector-store-provider-impl");
 var import_pgvector = require("./providers/pgvector");
+var import_external_rag = require("./providers/external-rag");
 var import_vectorization = require("./pipeline/vectorization");
+var import_docpixie_extractor = require("./services/docpixie-extractor");
 var import_ai_knowledge_base = __toESM(require("./resources/ai-knowledge-base"));
 var import_ai_knowledge_base_documents = __toESM(require("./resources/ai-knowledge-base-documents"));
 var import_ai_vector_stores = __toESM(require("./resources/ai-vector-stores"));
@@ -56,6 +58,29 @@ var import_add_document = require("./actions/add-document");
 var import_request_context = __toESM(require("./request-context"));
 class PluginKnowledgeBaseServer extends import_server.Plugin {
   vectorizationPipeline;
+  docpixieExtractor;
+  /**
+   * The VectorStore provider registry exposed publicly so that other plugins can
+   * register additional vector store backends (e.g., a custom embedding plugin).
+   *
+   * Usage from another plugin:
+   *   const kb = this.pm.get(PluginKnowledgeBaseServer) as PluginKnowledgeBaseServer;
+   *   kb.registerVectorStoreProvider(myProvider);
+   */
+  vectorStoreProvider;
+  /**
+   * Registry for external / custom RAG search strategies.
+   *
+   * A strategy is invoked for Knowledge Bases of type 'EXTERNAL_RAG' whose
+   * options.ragProvider matches the registered name.
+   *
+   * Usage from another plugin:
+   *   kb.registerRagSearchStrategy('my-rag', async (query, kbRecord, opts) => {
+   *     // call your custom RAG backend and return results
+   *     return [{ content: '...', score: 0.9 }];
+   *   });
+   */
+  ragSearchStrategies = /* @__PURE__ */ new Map();
   _aiPlugin;
   get aiPlugin() {
     if (!this._aiPlugin) {
@@ -63,6 +88,42 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
     }
     return this._aiPlugin;
   }
+  // ── Public extension API ────────────────────────────────────────────────────
+  /**
+   * Register a custom VectorStoreProvider so it can be selected as a provider
+   * when creating Vector Stores in the admin UI.
+   *
+   * Example (from another plugin's load()):
+   *   const kb = this.pm.get(PluginKnowledgeBaseServer) as PluginKnowledgeBaseServer;
+   *   kb.registerVectorStoreProvider({
+   *     providerName: 'my-vector-store',
+   *     async createVectorStoreService(props) { ... },
+   *   });
+   */
+  registerVectorStoreProvider(provider) {
+    if (!this.vectorStoreProvider) {
+      throw new Error("registerVectorStoreProvider() must be called after plugin-knowledge-base has loaded");
+    }
+    this.vectorStoreProvider.register(provider);
+  }
+  /**
+   * Register a RAG search strategy for Knowledge Bases of type 'EXTERNAL_RAG'.
+   *
+   * The strategy name must match the value stored in kb.options.ragProvider.
+   * The built-in 'external-http' strategy is always pre-registered and handles
+   * generic HTTP-based RAG services.
+   *
+   * Example:
+   *   kb.registerRagSearchStrategy('pinecone', async (query, kbRecord, opts) => {
+   *     const { ragApiKey, ragNamespace } = kbRecord.options;
+   *     const results = await pineconeQuery(ragApiKey, ragNamespace, query, opts.topK);
+   *     return results.map(r => ({ content: r.text, score: r.score }));
+   *   });
+   */
+  registerRagSearchStrategy(name, strategy) {
+    this.ragSearchStrategies.set(name, strategy);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
   async afterAdd() {
   }
   async beforeLoad() {
@@ -70,7 +131,9 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
   async load() {
     const vdbProvider = new import_vector_database_provider_impl.VectorDatabaseProviderImpl();
     vdbProvider.register(import_pgvector.pgVectorProviderInfo);
-    const vectorStoreProvider = new import_vector_store_provider_impl.VectorStoreProviderImpl(this, this.aiPlugin);
+    this.vectorStoreProvider = new import_vector_store_provider_impl.VectorStoreProviderImpl(this, this.aiPlugin);
+    const vectorStoreProvider = this.vectorStoreProvider;
+    this.ragSearchStrategies.set(import_external_rag.EXTERNAL_HTTP_RAG_PROVIDER, import_external_rag.externalHttpRagStrategy);
     const vectorDatabase = new import_vector_database_impl.VectorDatabaseFeatureImpl(this);
     const knowledgeBase = new import_knowledge_base_impl.KnowledgeBaseFeatureImpl(this);
     this.aiPlugin.features.enableFeatures({
@@ -79,7 +142,11 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
       vectorStoreProvider,
       knowledgeBase
     });
-    this.vectorizationPipeline = new import_vectorization.VectorizationPipeline(this);
+    this.docpixieExtractor = new import_docpixie_extractor.DocPixieExtractor(
+      this.db,
+      () => this.getDocpixiePlugin()
+    );
+    this.vectorizationPipeline = new import_vectorization.VectorizationPipeline(this, this.docpixieExtractor);
     this.defineResources();
     this.app.resourceManager.use(async (ctx, next) => {
       var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -102,7 +169,16 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
           const storageName = (_a = ctx.action.params) == null ? void 0 : _a.storageRule;
           if (storageName) {
             const collection = ctx.db.getCollection("aiFiles");
-            collection.options.storage = storageName;
+            if (collection) {
+              const prevStorage = collection.options.storage;
+              collection.options.storage = storageName;
+              try {
+                await next();
+              } finally {
+                collection.options.storage = prevStorage;
+              }
+              return;
+            }
           }
         }
         await next();
@@ -111,6 +187,15 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
     );
     this.registerKnowledgeBaseWorkContext(vectorStoreProvider, knowledgeBase);
   }
+  /** Returns the plugin-docpixie instance if it is loaded and has an active service, else null */
+  getDocpixiePlugin() {
+    try {
+      const p = this.pm.get("@nocobase/plugin-docpixie");
+      return (p == null ? void 0 : p.service) ? p : null;
+    } catch {
+      return null;
+    }
+  }
   defineResources() {
     this.app.resourceManager.define(import_ai_knowledge_base.default);
     this.app.resourceManager.define(import_ai_knowledge_base_documents.default);
@@ -130,7 +215,7 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
         return `[Knowledge Base: ${contextItem.title || contextItem.uid}]`;
       },
       background: async (ctx, aiMessages, workContextItems) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const kbIds = [...new Set(workContextItems.map((item) => item.uid).filter(Boolean))];
         if (!kbIds.length) return "";
         const userId = (_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id;
@@ -138,8 +223,8 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
         const isAdmin = roles.includes("root") || roles.includes("admin");
         let filteredIds = kbIds;
         if (!isAdmin) {
-          const kbRepo = plugin.db.getRepository("aiKnowledgeBases");
-          const accessibleKBs = await kbRepo.find({
+          const kbRepo2 = plugin.db.getRepository("aiKnowledgeBases");
+          const accessibleKBs = await kbRepo2.find({
             filter: {
               id: { $in: kbIds },
               enabled: true,
@@ -155,19 +240,55 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
           if (!filteredIds.length) return "";
         }
         const lastUserMsg = [...aiMessages].reverse().find((m) => m.role === "user");
-        const queryString = typeof ((_d = lastUserMsg == null ? void 0 : lastUserMsg.content) == null ? void 0 : _d.content) === "string" ? lastUserMsg.content.content : "";
+        let queryString = "";
+        if (lastUserMsg) {
+          const c = lastUserMsg.content;
+          if (typeof c === "string") {
+            queryString = c;
+          } else if (c && typeof c === "object") {
+            if (typeof c.content === "string") {
+              queryString = c.content;
+            } else if (c.content && typeof c.content === "object" && typeof c.content.content === "string") {
+              queryString = c.content.content;
+            } else if (typeof c.text === "string") {
+              queryString = c.text;
+            }
+          }
+        }
+        plugin.app.logger.info(`[KB WorkContext] lastUserMsg content type: ${typeof (lastUserMsg == null ? void 0 : lastUserMsg.content)}, queryString length: ${queryString.length}, queryString: "${queryString.substring(0, 100)}"`);
         if (!queryString) return "";
-        let knowledgeBaseGroup;
-        try {
-          knowledgeBaseGroup = await knowledgeBaseFeature.getKnowledgeBaseGroup(filteredIds);
-        } catch (err) {
-          plugin.app.logger.error("[KB WorkContext] Failed to get KB group:", err);
-          return "";
+        const kbRepo = plugin.db.getRepository("aiKnowledgeBases");
+        const allKbRecords = await kbRepo.find({
+          filter: { id: { $in: filteredIds }, enabled: true },
+          fields: ["id", "name", "type", "options"]
+        });
+        const externalRagIds = /* @__PURE__ */ new Set();
+        const externalRagKbs = [];
+        for (const rec of allKbRecords) {
+          const kbData2 = rec.toJSON ? rec.toJSON() : rec;
+          if (kbData2.type === import_external_rag.EXTERNAL_RAG_KB_TYPE) {
+            externalRagIds.add(String(kbData2.id));
+            externalRagKbs.push(kbData2);
+          }
         }
-        if (!(knowledgeBaseGroup == null ? void 0 : knowledgeBaseGroup.length)) return "";
+        const standardIds = filteredIds.filter((id) => !externalRagIds.has(String(id)));
+        let knowledgeBaseGroup = [];
+        if (standardIds.length > 0) {
+          try {
+            knowledgeBaseGroup = await knowledgeBaseFeature.getKnowledgeBaseGroup(standardIds);
+          } catch (err) {
+            plugin.app.logger.error("[KB WorkContext] Failed to get KB group:", err);
+          }
+        }
+        plugin.app.logger.info(
+          `[KB WorkContext] Found ${knowledgeBaseGroup.length} local KB groups, ${externalRagKbs.length} external RAG KBs: ${JSON.stringify(knowledgeBaseGroup.map((g) => {
+            var _a2, _b2, _c2;
+            return { type: g.knowledgeBaseType, provider: (_a2 = g.vectorStoreConfig) == null ? void 0 : _a2.vectorStoreProvider, configId: (_b2 = g.vectorStoreConfig) == null ? void 0 : _b2.vectorStoreConfigId, kbCount: (_c2 = g.knowledgeBaseList) == null ? void 0 : _c2.length };
+          }))}`
+        );
         const allDocs = [];
-        const topK = 3;
-        const score = "0.6";
+        const topK = 5;
+        const score = "0.3";
         for (const entry of knowledgeBaseGroup) {
           const { vectorStoreConfig, knowledgeBaseType, knowledgeBaseList } = entry;
           if (!(knowledgeBaseList == null ? void 0 : knowledgeBaseList.length)) continue;
@@ -184,6 +305,10 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
                 score,
                 filter: { knowledgeBaseOuterId: { in: knowledgeBaseOuterIds } }
               });
+              plugin.app.logger.info(`[KB WorkContext] LOCAL search: ${result.length} results, scores: ${result.map((r) => {
+                var _a2;
+                return (_a2 = r.score) == null ? void 0 : _a2.toFixed(3);
+              }).join(", ")}`);
               allDocs.push(...result);
             } else {
               for (const kb of knowledgeBaseList) {
@@ -192,6 +317,10 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
                   kb.vectorStoreProps
                 );
                 const result = await vectorStoreService.search(queryString, { topK, score });
+                plugin.app.logger.info(`[KB WorkContext] ${knowledgeBaseType} search (${kb.name}): ${result.length} results, scores: ${result.map((r) => {
+                  var _a2;
+                  return (_a2 = r.score) == null ? void 0 : _a2.toFixed(3);
+                }).join(", ")}`);
                 allDocs.push(...result);
               }
             }
@@ -199,8 +328,60 @@ class PluginKnowledgeBaseServer extends import_server.Plugin {
             plugin.app.logger.error(`[KB WorkContext] Vector search failed for type=${knowledgeBaseType}:`, err);
           }
         }
+        for (const kb of externalRagKbs) {
+          const providerName = ((_d = kb.options) == null ? void 0 : _d.ragProvider) ?? import_external_rag.EXTERNAL_HTTP_RAG_PROVIDER;
+          const strategy = plugin.ragSearchStrategies.get(providerName);
+          if (!strategy) {
+            plugin.app.logger.warn(
+              `[KB WorkContext] No RAG strategy registered for provider "${providerName}" (KB: ${kb.name ?? kb.id})`
+            );
+            continue;
+          }
+          try {
+            const results = await strategy(queryString, kb, {
+              topK,
+              scoreThreshold: parseFloat(score)
+            });
+            plugin.app.logger.info(
+              `[KB WorkContext] EXTERNAL_RAG (${kb.name}, provider=${providerName}): ${results.length} results`
+            );
+            allDocs.push(...results);
+          } catch (err) {
+            plugin.app.logger.error(
+              `[KB WorkContext] External RAG search failed (${kb.name}, provider=${providerName}):`,
+              err
+            );
+          }
+        }
         if (!allDocs.length) return "";
-        const kbData = allDocs.map((doc) => doc.content).join("\n");
+        let deepContext = "";
+        const docpixiePlugin = plugin.getDocpixiePlugin();
+        if ((_e = docpixiePlugin == null ? void 0 : docpixiePlugin.service) == null ? void 0 : _e.isReady()) {
+          const docpixieIds = [
+            ...new Set(
+              allDocs.map((d) => {
+                var _a2;
+                return (_a2 = d.metadata) == null ? void 0 : _a2.docpixieDocumentId;
+              }).filter((id) => typeof id === "number")
+            )
+          ].slice(0, 3);
+          if (docpixieIds.length > 0) {
+            try {
+              deepContext = await plugin.docpixieExtractor.buildDeepContext(docpixieIds);
+              plugin.app.logger.info(
+                `[KB WorkContext] Stage 2 DocPixie deep retrieval: ${docpixieIds.length} doc(s), context length=${deepContext.length}`
+              );
+            } catch (err) {
+              plugin.app.logger.warn("[KB WorkContext] Stage 2 DocPixie retrieval failed:", err);
+            }
+          }
+        }
+        const chunkData = allDocs.map((doc) => doc.content).join("\n");
+        const kbData = deepContext ? `${deepContext}
+
+<kb_chunks>
+${chunkData}
+</kb_chunks>` : chunkData;
         return `<knowledgeBase>From knowledge base:
 ${kbData}
 answer user's question using this information.</knowledgeBase>`;
@@ -220,6 +401,10 @@ answer user's question using this information.</knowledgeBase>`;
     this.app.acl.allow("aiKnowledgeBase", "list", "loggedIn");
     this.app.acl.allow("aiKnowledgeBase", "get", "loggedIn");
     this.app.acl.allow("aiKnowledgeBase", "addDocument", "loggedIn");
+    this.app.acl.allow("aiKnowledgeBaseDoc", "list", "loggedIn");
+    this.app.acl.allow("aiKnowledgeBaseDoc", "create", "loggedIn");
+    this.app.acl.allow("aiKnowledgeBaseDoc", "destroy", "loggedIn");
+    this.app.acl.allow("aiKnowledgeBaseDoc", "reprocess", "loggedIn");
   }
   async install() {
   }