@agenticmail/enterprise 0.5.327 → 0.5.328

package/src/engine/knowledge-import/provider-url.ts

@@ -1,218 +0,0 @@
-/**
- * Knowledge Import — URL / Web Crawler Provider
- *
- * Imports documentation from any public URL.
- * Supports: single pages, sitemaps, and shallow crawls.
- * No authentication required.
- */
-
-import type { ImportProvider, ImportDocument, ImportConfigField } from './types.js';
-
-const MAX_PAGES = 200;
-const MAX_PAGE_SIZE = 2_000_000; // 2MB per page
-
-export class UrlImportProvider implements ImportProvider {
-  type = 'url' as const;
-
-  getConfigFields(): ImportConfigField[] {
-    return [
-      { name: 'url', label: 'Documentation URL', type: 'url', placeholder: 'https://docs.example.com', required: true, helpText: 'Starting URL for the documentation site' },
-      {
-        name: 'crawlMode', label: 'Import Mode', type: 'select', required: true,
-        options: [
-          { value: 'single', label: 'Single Page — import just this URL' },
-          { value: 'sitemap', label: 'Sitemap — find and import from sitemap.xml' },
-          { value: 'crawl', label: 'Crawl — follow internal links (max 50 pages)' },
-        ]
-      },
-      { name: 'maxPages', label: 'Max Pages', type: 'text', placeholder: '50', helpText: 'Maximum pages to import (default 50)' },
-      { name: 'urlPattern', label: 'URL Pattern', type: 'text', placeholder: '/docs/', helpText: 'Only import pages whose URL contains this pattern (e.g. /docs/ or /api/)' },
-    ];
-  }
-
-  async validate(config: Record<string, any>): Promise<{ valid: boolean; error?: string }> {
-    if (!config.url) return { valid: false, error: 'URL is required' };
-    try {
-      new URL(config.url);
-    } catch {
-      return { valid: false, error: 'Invalid URL format' };
-    }
-
-    try {
-      const resp = await fetch(config.url, { method: 'HEAD', redirect: 'follow' });
-      if (!resp.ok) return { valid: false, error: `URL returned HTTP ${resp.status}. Ensure the page is publicly accessible.` };
-      return { valid: true };
-    } catch (e: any) {
-      return { valid: false, error: `Cannot reach URL: ${e.message}` };
-    }
-  }
-
-  async *discover(config: Record<string, any>): AsyncGenerator<ImportDocument> {
-    const mode = config.crawlMode || 'single';
-    const maxPages = Math.min(parseInt(config.maxPages) || 50, MAX_PAGES);
-    const urlPattern = config.urlPattern || '';
-
-    if (mode === 'single') {
-      const doc = await fetchPage(config.url);
-      if (doc) yield doc;
-    } else if (mode === 'sitemap') {
-      yield* this.discoverSitemap(config.url, maxPages, urlPattern);
-    } else if (mode === 'crawl') {
-      yield* this.crawlSite(config.url, maxPages, urlPattern);
-    }
-  }
-
-  private async *discoverSitemap(baseUrl: string, maxPages: number, urlPattern: string): AsyncGenerator<ImportDocument> {
-    const origin = new URL(baseUrl).origin;
-    const sitemapUrls = [
-      `${origin}/sitemap.xml`,
-      `${origin}/sitemap_index.xml`,
-      `${baseUrl.replace(/\/$/, '')}/sitemap.xml`,
-    ];
-
-    const pageUrls: string[] = [];
-
-    for (const sitemapUrl of sitemapUrls) {
-      try {
-        const resp = await fetch(sitemapUrl);
-        if (!resp.ok) continue;
-        const xml = await resp.text();
-
-        // Extract URLs from sitemap XML
-        const urlMatches = xml.matchAll(/<loc>\s*(.*?)\s*<\/loc>/gi);
-        for (const m of urlMatches) {
-          const url = m[1].trim();
-          // Check if it's a sub-sitemap
-          if (url.endsWith('.xml')) {
-            try {
-              const subResp = await fetch(url);
-              if (subResp.ok) {
-                const subXml = await subResp.text();
-                const subUrls = subXml.matchAll(/<loc>\s*(.*?)\s*<\/loc>/gi);
-                for (const su of subUrls) {
-                  if (!su[1].endsWith('.xml')) pageUrls.push(su[1].trim());
-                }
-              }
-            } catch { /* skip bad sub-sitemaps */ }
-          } else {
-            pageUrls.push(url);
-          }
-        }
-        if (pageUrls.length > 0) break; // found a working sitemap
-      } catch { continue; }
-    }
-
-    // Filter by pattern and limit
-    let filtered = urlPattern
-      ? pageUrls.filter(u => u.includes(urlPattern))
-      : pageUrls;
-    filtered = filtered.slice(0, maxPages);
-
-    let count = 0;
-    for (const url of filtered) {
-      const doc = await fetchPage(url);
-      if (doc) {
-        yield doc;
-        count++;
-        if (count >= maxPages) break;
-      }
-      await sleep(200);
-    }
-  }
-
-  private async *crawlSite(startUrl: string, maxPages: number, urlPattern: string): AsyncGenerator<ImportDocument> {
-    const origin = new URL(startUrl).origin;
-    const visited = new Set<string>();
-    const queue: string[] = [startUrl];
-    let count = 0;
-
-    while (queue.length > 0 && count < maxPages) {
-      const url = queue.shift()!;
-      const normalized = url.split('#')[0].split('?')[0].replace(/\/$/, '');
-      if (visited.has(normalized)) continue;
-      visited.add(normalized);
-
-      if (urlPattern && !url.includes(urlPattern)) continue;
-
-      const doc = await fetchPage(url);
-      if (!doc) continue;
-
-      yield doc;
-      count++;
-
-      // Extract internal links from content
-      const linkRegex = /href="([^"]*?)"/gi;
-      let match;
-      while ((match = linkRegex.exec(doc.content)) !== null) {
-        let href = match[1];
-        try {
-          if (href.startsWith('/')) href = origin + href;
-          else if (!href.startsWith('http')) continue;
-          const hrefNorm = href.split('#')[0].split('?')[0].replace(/\/$/, '');
-          if (hrefNorm.startsWith(origin) && !visited.has(hrefNorm)) {
-            queue.push(href);
-          }
-        } catch { /* bad URL */ }
-      }
-
-      await sleep(200);
-    }
-  }
-}
-
-// ─── Helpers ──────────────────────────────────────────
-
-async function fetchPage(url: string): Promise<ImportDocument | null> {
-  try {
-    const resp = await fetch(url, {
-      redirect: 'follow',
-      headers: { 'User-Agent': 'AgenticMail-KnowledgeImport/1.0' },
-    });
-    if (!resp.ok) return null;
-
-    const contentType = resp.headers.get('content-type') || '';
-    if (!contentType.includes('text/html') && !contentType.includes('text/plain') && !contentType.includes('text/markdown')) {
-      return null;
-    }
-
-    const html = await resp.text();
-    if (html.length > MAX_PAGE_SIZE) return null;
-
-    // Extract title
-    const titleMatch = html.match(/<title[^>]*>(.*?)<\/title>/si);
-    const h1Match = html.match(/<h1[^>]*>(.*?)<\/h1>/si);
-    const title = (h1Match?.[1] || titleMatch?.[1] || url.split('/').pop() || 'Untitled')
-      .replace(/<[^>]+>/g, '').trim();
-
-    // Extract main content
-    const mainContent = extractMainContent(html);
-
-    if (!mainContent || mainContent.length < 50) return null;
-
-    return {
-      id: `url-${Buffer.from(url).toString('base64url').slice(0, 20)}`,
-      sourceType: 'url',
-      sourcePath: new URL(url).pathname,
-      sourceUrl: url,
-      title,
-      content: contentType.includes('html') ? mainContent : html,
-      contentType: contentType.includes('html') ? 'html' : contentType.includes('markdown') ? 'markdown' : 'text',
-      metadata: { url, contentType },
-      size: html.length,
-    };
-  } catch {
-    return null;
-  }
-}
-
-/** Extract main content, stripping nav/header/footer/scripts. */
-function extractMainContent(html: string): string {
-  return html
-    .replace(/<(script|style|nav|header|footer|aside)[^>]*>[\s\S]*?<\/\1>/gi, '')
-    .replace(/<(main|article)[^>]*>([\s\S]*?)<\/\1>/gi, '$2')
-    || html;
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}

package/src/engine/knowledge-import/routes.ts

@@ -1,94 +0,0 @@
-/**
- * Knowledge Import — API Routes
- *
- * Endpoints:
- *   GET    /sources                — List available import sources
- *   GET    /sources/:type          — Get config fields for a source
- *   POST   /validate               — Validate source config (dry run)
- *   POST   /start                  — Start an import job
- *   GET    /jobs                   — List import jobs for org
- *   GET    /jobs/:id               — Get job status + progress
- *   POST   /jobs/:id/cancel        — Cancel a running job
- *   POST   /upload                 — Upload files for file-upload import
- */
-
-import { Hono } from 'hono';
-import type { KnowledgeImportManager } from './import-manager.js';
-
-export function createKnowledgeImportRoutes(manager: KnowledgeImportManager) {
-  const router = new Hono();
-
-  // List available import sources
-  router.get('/sources', (c) => {
-    return c.json({ sources: manager.getSources() });
-  });
-
-  // Get config for a specific source
-  router.get('/sources/:type', (c) => {
-    const source = manager.getSourceConfig(c.req.param('type') as any);
-    if (!source) return c.json({ error: 'Unknown source type' }, 404);
-    return c.json({ source });
-  });
-
-  // Validate source config (dry run)
-  router.post('/validate', async (c) => {
-    try {
-      const body = await c.req.json();
-      if (!body.sourceType) return c.json({ error: 'sourceType is required' }, 400);
-      const result = await manager.validateSource(body.sourceType, body.config || {});
-      return c.json(result);
-    } catch (err: any) {
-      return c.json({ error: err.message }, 500);
-    }
-  });
-
-  // Start an import job
-  router.post('/start', async (c) => {
-    try {
-      const body = await c.req.json();
-      const userId = c.req.header('X-User-Id') || 'admin';
-      if (!body.orgId) return c.json({ error: 'orgId is required' }, 400);
-      if (!body.baseId) return c.json({ error: 'baseId is required (target knowledge base)' }, 400);
-      if (!body.sourceType) return c.json({ error: 'sourceType is required' }, 400);
-      if (!body.config) return c.json({ error: 'config is required' }, 400);
-
-      const job = await manager.startImport({
-        orgId: body.orgId,
-        baseId: body.baseId,
-        sourceType: body.sourceType,
-        sourceConfig: body.config,
-        createdBy: userId,
-        categoryId: body.categoryId,
-      });
-
-      return c.json({ job }, 201);
-    } catch (err: any) {
-      return c.json({ error: err.message }, 400);
-    }
-  });
-
-  // List jobs
-  router.get('/jobs', (c) => {
-    const orgId = c.req.query('orgId');
-    if (!orgId) return c.json({ error: 'orgId query parameter is required' }, 400);
-    const limit = parseInt(c.req.query('limit') || '50');
-    const jobs = manager.listJobs(orgId, limit);
-    return c.json({ jobs });
-  });
-
-  // Get single job
-  router.get('/jobs/:id', (c) => {
-    const job = manager.getJob(c.req.param('id'));
-    if (!job) return c.json({ error: 'Job not found' }, 404);
-    return c.json({ job });
-  });
-
-  // Cancel job
-  router.post('/jobs/:id/cancel', (c) => {
-    const ok = manager.cancelJob(c.req.param('id'));
-    if (!ok) return c.json({ error: 'Job not found or not running' }, 400);
-    return c.json({ ok: true });
-  });
-
-  return router;
-}

package/src/engine/knowledge-import/types.ts

@@ -1,92 +0,0 @@
-/**
- * Knowledge Import System — Shared Types
- *
- * Common interfaces for all import sources (GitHub, SharePoint, Google Sites, etc.)
- */
-
-export type ImportSourceType = 'github' | 'sharepoint' | 'google-sites' | 'confluence' | 'notion' | 'url' | 'file-upload';
-
-export type ImportStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
-
-export interface ImportSource {
-  type: ImportSourceType;
-  label: string;
-  description: string;
-  icon: string;
-  requiresAuth: boolean;
-  configFields: ImportConfigField[];
-}
-
-export interface ImportConfigField {
-  name: string;
-  label: string;
-  type: 'text' | 'url' | 'password' | 'select' | 'checkbox' | 'textarea';
-  placeholder?: string;
-  required?: boolean;
-  options?: Array<{ value: string; label: string }>;
-  helpText?: string;
-}
-
-export interface ImportJob {
-  id: string;
-  orgId: string;
-  baseId: string;           // target knowledge base
-  sourceType: ImportSourceType;
-  sourceConfig: Record<string, any>;
-  status: ImportStatus;
-  progress: ImportProgress;
-  createdBy: string;
-  createdAt: string;
-  startedAt?: string;
-  completedAt?: string;
-  error?: string;
-}
-
-export interface ImportProgress {
-  totalItems: number;
-  processedItems: number;
-  importedItems: number;
-  skippedItems: number;
-  failedItems: number;
-  currentItem?: string;     // name of file/page currently being processed
-  phase: 'discovering' | 'fetching' | 'processing' | 'importing' | 'done';
-}
-
-export interface ImportDocument {
-  id: string;
-  sourceType: ImportSourceType;
-  sourcePath: string;       // e.g. "docs/getting-started.md" or SharePoint URL
-  sourceUrl?: string;
-  title: string;
-  content: string;          // raw content (markdown, HTML, etc.)
-  contentType: 'markdown' | 'html' | 'text' | 'pdf';
-  metadata: Record<string, any>;
-  lastModified?: string;
-  size: number;
-}
-
-export interface ImportChunk {
-  documentId: string;
-  title: string;
-  content: string;
-  summary: string;
-  tags: string[];
-  categoryId: string;
-  confidence: number;
-  sourceUrl?: string;
-  sourcePath: string;
-}
-
-/** Interface that every import provider must implement. */
-export interface ImportProvider {
-  type: ImportSourceType;
-
-  /** Validate the source config before starting import. */
-  validate(config: Record<string, any>): Promise<{ valid: boolean; error?: string }>;
-
-  /** Discover all importable documents from the source. */
-  discover(config: Record<string, any>): AsyncGenerator<ImportDocument>;
-
-  /** Get the list of config fields this provider needs. */
-  getConfigFields(): ImportConfigField[];
-}

package/src/engine/knowledge-routes.ts

@@ -1,231 +0,0 @@
-/**
- * Knowledge Base Routes
- * Mounted at / on the engine sub-app (routes define /knowledge-bases/*).
- */
-
-import { Hono } from 'hono';
-import type { KnowledgeBaseEngine } from './knowledge.js';
-
-export function createKnowledgeRoutes(knowledgeBase: KnowledgeBaseEngine) {
-  const router = new Hono();
-
-  // ─── Knowledge Base ─────────────────────────────────────
-
-  router.post('/knowledge-bases', async (c) => {
-    const { orgId, name, description, agentIds, config, clientOrgId } = await c.req.json();
-    const kb = knowledgeBase.createKnowledgeBase(orgId, { name, description, agentIds, config });
-    if (clientOrgId) (kb as any).clientOrgId = clientOrgId;
-    // Persist clientOrgId to DB
-    if (clientOrgId && (knowledgeBase as any).db) {
-      try {
-        await (knowledgeBase as any).db.execute(
-          'UPDATE knowledge_bases SET client_org_id = $1 WHERE id = $2', [clientOrgId, kb.id]
-        );
-      } catch { /* column may not exist */ }
-    }
-    return c.json({ knowledgeBase: kb }, 201);
-  });
-
-  router.get('/knowledge-bases', (c) => {
-    const orgId = c.req.query('orgId');
-    const agentId = c.req.query('agentId');
-    if (agentId) {
-      const clientOrgId = c.req.query('clientOrgId');
-      const bases = knowledgeBase.getKnowledgeBasesForAgent(agentId);
-      // If agent has a clientOrgId, only show KBs belonging to that org (or explicitly assigned)
-      if (clientOrgId) {
-        const filtered = bases.filter((kb: any) => kb.clientOrgId === clientOrgId || (Array.isArray(kb.agentIds) && kb.agentIds.includes(agentId)));
-        return c.json({ knowledgeBases: filtered });
-      }
-      return c.json({ knowledgeBases: bases });
-    }
-    if (orgId) return c.json({ knowledgeBases: knowledgeBase.getKnowledgeBasesByOrg(orgId) });
-    // No filter = return all (admin dashboard context)
-    return c.json({ knowledgeBases: knowledgeBase.getAllKnowledgeBases() });
-  });
-
-  router.get('/knowledge-bases/:id', (c) => {
-    const kb = knowledgeBase.getKnowledgeBase(c.req.param('id'));
-    if (!kb) return c.json({ error: 'Knowledge base not found' }, 404);
-    return c.json({ knowledgeBase: kb });
-  });
-
-  router.post('/knowledge-bases/:id/documents', async (c) => {
-    const { name, content, sourceType, sourceUrl, mimeType, metadata } = await c.req.json();
-    try {
-      const doc = await knowledgeBase.ingestDocument(c.req.param('id'), { name, content, sourceType, sourceUrl, mimeType, metadata });
-      return c.json({ document: doc }, 201);
-    } catch (e: any) {
-      return c.json({ error: e.message }, 400);
-    }
-  });
-
-  router.delete('/knowledge-bases/:kbId/documents/:docId', (c) => {
-    const ok = knowledgeBase.deleteDocument(c.req.param('kbId'), c.req.param('docId'));
-    return ok ? c.json({ success: true }) : c.json({ error: 'Not found' }, 404);
-  });
-
-  router.post('/knowledge-bases/search', async (c) => {
-    const { agentId, query, kbIds, maxResults, minScore } = await c.req.json();
-    const results = await knowledgeBase.search(agentId, query, { kbIds, maxResults, minScore });
-    return c.json({ results, total: results.length });
-  });
-
-  router.post('/knowledge-bases/context', async (c) => {
-    const { agentId, query, maxTokens } = await c.req.json();
-    const context = await knowledgeBase.getContext(agentId, query, maxTokens);
-    return c.json({ context });
-  });
-
-  // Update knowledge base name/description
-  router.put('/knowledge-bases/:id', async (c) => {
-    const id = c.req.param('id');
-    const kb = knowledgeBase.getKnowledgeBase(id);
-    if (!kb) return c.json({ error: 'Knowledge base not found' }, 404);
-    const body = await c.req.json();
-    if (body.name !== undefined) (kb as any).name = body.name;
-    if (body.description !== undefined) (kb as any).description = body.description;
-    if (body.agentIds !== undefined) (kb as any).agentIds = body.agentIds;
-    if (body.clientOrgId !== undefined) (kb as any).clientOrgId = body.clientOrgId || null;
-    (kb as any).updatedAt = new Date().toISOString();
-    // Persist to DB if engine supports it
-    if ((knowledgeBase as any).db) {
-      try {
-        await (knowledgeBase as any).db.execute(
-          'UPDATE knowledge_bases SET name = $1, description = $2, agent_ids = $3, updated_at = $4, client_org_id = $5 WHERE id = $6',
-          [kb.name, kb.description, JSON.stringify((kb as any).agentIds || []), (kb as any).updatedAt, (kb as any).clientOrgId || null, id]
-        );
-      } catch { /* in-memory only fallback */ }
-    }
-    return c.json({ knowledgeBase: kb });
-  });
-
-  // Get chunks for a specific document
-  router.get('/knowledge-bases/:kbId/documents/:docId/chunks', (c) => {
-    const kbId = c.req.param('kbId');
-    const docId = c.req.param('docId');
-    const kb = knowledgeBase.getKnowledgeBase(kbId);
-    if (!kb) return c.json({ error: 'Knowledge base not found' }, 404);
-    // Find the document and return its chunks
-    const doc = kb.documents?.find((d: any) => d.id === docId);
-    if (!doc) return c.json({ error: 'Document not found' }, 404);
-    const docChunks = (doc.chunks || []).slice().sort((a: any, b: any) => (a.position || 0) - (b.position || 0));
-    return c.json({ chunks: docChunks, total: docChunks.length });
-  });
-
-  // Edit a document (rename, update metadata)
-  router.put('/knowledge-bases/:kbId/documents/:docId', async (c) => {
-    const docId = c.req.param('docId');
-    const kbId = c.req.param('kbId');
-    const body = await c.req.json();
-    try {
-      const db = (knowledgeBase as any).engineDb;
-      if (!db) return c.json({ error: 'No database' }, 500);
-      const sets: string[] = [];
-      const vals: any[] = [];
-      let i = 1;
-      if (body.name !== undefined) { sets.push(`name = $${i++}`); vals.push(body.name); }
-      if (body.sourceUrl !== undefined) { sets.push(`source_url = $${i++}`); vals.push(body.sourceUrl); }
-      if (body.status !== undefined) { sets.push(`status = $${i++}`); vals.push(body.status); }
-      sets.push(`updated_at = $${i++}`); vals.push(new Date().toISOString());
-      vals.push(docId);
-      await db.run(`UPDATE kb_documents SET ${sets.join(', ')} WHERE id = $${i}`, vals);
-      await knowledgeBase.reloadKnowledgeBase(kbId);
-      return c.json({ success: true });
-    } catch (e: any) { return c.json({ error: e.message }, 400); }
-  });
-
-  // Edit a chunk (update content, metadata)
-  router.put('/knowledge-bases/:kbId/chunks/:chunkId', async (c) => {
-    const chunkId = c.req.param('chunkId');
-    const kbId = c.req.param('kbId');
-    const body = await c.req.json();
-    try {
-      const db = (knowledgeBase as any).engineDb;
-      if (!db) return c.json({ error: 'No database' }, 500);
-      const sets: string[] = [];
-      const vals: any[] = [];
-      let i = 1;
-      if (body.content !== undefined) {
-        sets.push(`content = $${i++}`); vals.push(body.content);
-        sets.push(`token_count = $${i++}`); vals.push(Math.ceil(body.content.length / 4));
-      }
-      if (body.metadata !== undefined) { sets.push(`metadata = $${i++}`); vals.push(JSON.stringify(body.metadata)); }
-      vals.push(chunkId);
-      await db.run(`UPDATE kb_chunks SET ${sets.join(', ')} WHERE id = $${i}`, vals);
-      await knowledgeBase.reloadKnowledgeBase(kbId);
-      return c.json({ success: true });
-    } catch (e: any) { return c.json({ error: e.message }, 400); }
-  });
-
-  // Delete a single chunk
-  router.delete('/knowledge-bases/:kbId/chunks/:chunkId', async (c) => {
-    const kbId = c.req.param('kbId');
-    const chunkId = c.req.param('chunkId');
-    try {
-      const db = (knowledgeBase as any).engineDb;
-      if (!db) return c.json({ error: 'No database' }, 500);
-      await db.run('DELETE FROM kb_chunks WHERE id = $1', [chunkId]);
-      await knowledgeBase.reloadKnowledgeBase(kbId);
-      return c.json({ success: true });
-    } catch (e: any) { return c.json({ error: e.message }, 400); }
-  });
-
-  /**
-   * POST /knowledge-bases/auto-assign/:agentId — Auto-assign knowledge bases to an agent.
-   * 
-   * Logic:
-   * - If agent belongs to a client org → assign all KBs belonging to that org
-   * - If agent is internal (no client org) → assign all KBs NOT belonging to any client org
-   * - Does NOT remove existing assignments, only adds new ones
-   * - Returns list of newly assigned KB IDs
-   */
-  router.post('/knowledge-bases/auto-assign/:agentId', async (c) => {
-    const agentId = c.req.param('agentId');
-    const body = await c.req.json().catch(() => ({}));
-    const clientOrgId = body.clientOrgId || null;
-    
-    const allKbs = knowledgeBase.getAllKnowledgeBases();
-    const assigned: string[] = [];
-
-    for (const kb of allKbs) {
-      // Skip if agent already assigned
-      const agentIds: string[] = Array.isArray((kb as any).agentIds) ? (kb as any).agentIds : [];
-      if (agentIds.includes(agentId)) continue;
-
-      let shouldAssign = false;
-      if (clientOrgId) {
-        // Agent belongs to a client org → assign KBs of that org
-        shouldAssign = (kb as any).orgId === clientOrgId || (kb as any).clientOrgId === clientOrgId;
-      } else {
-        // Internal agent → assign KBs with no client org
-        shouldAssign = !(kb as any).clientOrgId;
-      }
-
-      if (shouldAssign) {
-        agentIds.push(agentId);
-        (kb as any).agentIds = agentIds;
-        (kb as any).updatedAt = new Date().toISOString();
-
-        // Persist to DB via the engine's upsert method
-        if ((knowledgeBase as any).engineDb) {
-          try {
-            await (knowledgeBase as any).engineDb.upsertKnowledgeBase(kb);
-          } catch (err: any) {
-            console.error('[knowledge] auto-assign persist failed:', err.message);
-          }
-        }
-        assigned.push(kb.id);
-      }
-    }
-
-    return c.json({ agentId, clientOrgId, assigned, count: assigned.length });
-  });
-
-  router.delete('/knowledge-bases/:id', (c) => {
-    const ok = knowledgeBase.deleteKnowledgeBase(c.req.param('id'));
-    return ok ? c.json({ success: true }) : c.json({ error: 'Not found' }, 404);
-  });
-
-  return router;
-}