@openenthrium/oe-runtime-sdk 1.7.5

package/src/utils/agentChain.js

@@ -0,0 +1,141 @@
+const { getLLMConfig }        = require("../providers/llm");
+const { executeTool }         = require("./tools/registry");
+const engine                  = require("../engine");
+const { conditionMet }        = engine;
+
+async function runChainedAgent(agent, db, inputContext, depth, chatContext) {
+  const run = await db.agentRun.create({
+    data: { agentId: agent.id, status: "running", triggerType: "chained", input: inputContext?.slice(0, 2000) || null, triggeredFromWorkspaceId: chatContext?.workspaceId || null },
+  });
+
+  try {
+    const connectorIds = JSON.parse(agent.connectorIds || "[]");
+    const connectors   = connectorIds.length
+      ? await db.connector.findMany({ where: { id: { in: connectorIds }, status: "active" } })
+      : [];
+
+    const workspace = await db.workspace.findUnique({ where: { id: agent.workspaceId } });
+
+    let appendToPrompt = "\n\nIMPORTANT: This is an automated chained run. Execute immediately using available tools. Do not ask for clarification.";
+    if (workspace?.agentMemoryEnabled) {
+      const pastRuns = await db.agentRun.findMany({
+        where: { agentId: agent.id, status: "success" },
+        orderBy: { completedAt: "desc" },
+        take: workspace.agentMemoryRuns || 5,
+      });
+      if (pastRuns.length) {
+        const memoryBlock = pastRuns.reverse().map((r, i) =>
+          `Run ${i + 1} (${r.completedAt?.toISOString().slice(0, 10)}): ${(r.output || "").slice(0, 500)}`
+        ).join("\n\n");
+        appendToPrompt += `\n\n--- MEMORY FROM PREVIOUS RUNS ---\n${memoryBlock}\n--- END MEMORY ---`;
+      }
+    }
+
+    const llmConfig  = await getLLMConfig();
+    const agentSpec  = {
+      systemPrompt:   agent.systemPrompt,
+      workflow:       JSON.parse(agent.workflow || "[]"),
+      params:         JSON.parse(agent.params   || "[]"),
+      maxRounds:      workspace?.defaultAgentMaxRounds || 25,
+      input:          inputContext ? `Context from previous agent:\n\n${inputContext}\n\nNow execute your task.` : "Execute the agent task now.",
+      appendToPrompt,
+    };
+
+    const allToolCallNames = [];
+    const { output: fullOutput } = await engine.run(agentSpec, llmConfig, connectors, {
+      toolExecutor: (name, args, conns) => executeTool(name, args, conns, db),
+      onToolCall:   (name) => allToolCallNames.push(name),
+    });
+
+    await db.agentRun.update({
+      where: { id: run.id },
+      data: { status: "success", output: fullOutput, completedAt: new Date() },
+    });
+    console.log(`[chain] Agent "${agent.name}" (depth=${depth}) completed.`);
+
+    if (chatContext?.workspaceId) {
+      await db.chat.create({
+        data: {
+          workspaceId: chatContext.workspaceId,
+          threadId:    chatContext.threadId || null,
+          role:        "assistant",
+          content:     `**@${agent.slug}** *(chained)* — ${fullOutput}`,
+          toolCalls:   allToolCallNames.length ? JSON.stringify(allToolCallNames) : null,
+        },
+      });
+    }
+
+    // Continue chain
+    await maybeChain(agent, fullOutput, db, depth, chatContext);
+
+  } catch (err) {
+    await db.agentRun.update({
+      where: { id: run.id },
+      data: { status: "error", error: err.message, completedAt: new Date() },
+    });
+    if (chatContext?.workspaceId) {
+      await db.chat.create({
+        data: {
+          workspaceId: chatContext.workspaceId,
+          threadId:    chatContext.threadId || null,
+          role:        "assistant",
+          content:     `**@${agent.slug}** *(chained)* — ❌ Error: ${err.message}`,
+        },
+      });
+    }
+    console.error(`[chain] Agent "${agent.name}" failed:`, err.message);
+  }
+}
+
+async function maybeChain(agent, output, db, depth = 0, chatContext) {
+  const workspace = await db.workspace.findUnique({ where: { id: agent.workspaceId } });
+  const maxDepth  = workspace?.maxChainDepth || 5;
+  if (depth >= maxDepth) { console.warn(`[chain] Max depth (${maxDepth}) reached at agent "${agent.name}"`); return { pendingApprovals: 0 }; }
+
+  const chains = agent.chains
+    ? JSON.parse(agent.chains)
+    : agent.nextAgent
+      ? [{ condition: agent.nextAgentCondition || "always", nextAgent: agent.nextAgent }]
+      : [];
+
+  if (!chains.length) return { pendingApprovals: 0 };
+
+  let pendingApprovals = 0;
+
+  for (const chain of chains) {
+    if (!chain.nextAgent) continue;
+    if (!conditionMet(chain.condition || "always", output)) {
+      console.log(`[chain] Condition "${chain.condition}" not met → skipping "${chain.nextAgent}"`);
+      continue;
+    }
+    const nextAgent = await db.agent.findFirst({ where: { slug: chain.nextAgent } });
+    if (!nextAgent) { console.warn(`[chain] Next agent "${chain.nextAgent}" not found`); continue; }
+
+    if (chain.triggerType === "manual") {
+      const timeoutAt = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24h
+      await db.chainApproval.create({
+        data: {
+          workspaceId:   chatContext?.workspaceId || agent.workspaceId,
+          sourceAgentId: agent.id,
+          sourceRunId:   chatContext?.runId || 0,
+          threadId:      chatContext?.threadId || null,
+          nextAgentSlug: chain.nextAgent,
+          condition:     chain.condition || "always",
+          runOutput:     (output || "").slice(0, 2000),
+          status:        "pending",
+          timeoutAt,
+        }
+      });
+      pendingApprovals++;
+      console.log(`[chain] "${agent.name}" → "${chain.nextAgent}" queued for manual approval`);
+      continue;
+    }
+
+    console.log(`[chain] "${agent.name}" → "${nextAgent.name}" (condition: ${chain.condition}, depth: ${depth + 1})`);
+    await runChainedAgent(nextAgent, db, output, depth + 1, chatContext);
+  }
+
+  return { pendingApprovals };
+}
+
+module.exports = { maybeChain, runChainedAgent };

package/src/utils/buildVisualization.js

@@ -0,0 +1,102 @@
+function parseVizConfig(instructions) {
+  const s = instructions || "";
+  const type =
+    /pie\s+chart/i.test(s) ? "pie" :
+    /bar\s+chart/i.test(s) ? "bar" :
+    /line\s+chart/i.test(s) ? "line" : "auto";
+
+  const limitMatch = s.match(/top\s+(\d+)/i);
+  const limit = limitMatch ? parseInt(limitMatch[1]) : null;
+
+  const style = /donut/i.test(s) ? "donut" : "solid";
+
+  const legend =
+    /legend.*right|right.*legend/i.test(s) ? "right" :
+    /legend.*bottom|bottom.*legend/i.test(s) ? "bottom" :
+    /no\s+legend|legend.*none/i.test(s) ? "none" : "right";
+
+  const groupOthers = /group.*others?|others?.*group/i.test(s);
+
+  return { type, limit, style, legend, groupOthers };
+}
+
+function buildVisualization(rawResults, instructions) {
+  if (!rawResults?.length) return null;
+
+  const cfg = parseVizConfig(instructions);
+
+  for (let i = rawResults.length - 1; i >= 0; i--) {
+    const viz = _tryBuild(rawResults[i], cfg);
+    if (viz) return viz;
+  }
+  return null;
+}
+
+function _tryBuild(raw, cfg) {
+  if (!raw || typeof raw !== "string") return null;
+
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch { return null; }
+
+  // Plain number
+  if (typeof parsed === "number") {
+    return { type: "stat", data: [{ label: "Result", value: parsed }], style: cfg.style, legend: cfg.legend };
+  }
+
+  // Single object: { count: 47 }
+  if (parsed && !Array.isArray(parsed) && typeof parsed === "object") {
+    const keys = Object.keys(parsed);
+    const numKeys = keys.filter(k => typeof parsed[k] === "number" || (!isNaN(Number(parsed[k])) && parsed[k] !== ""));
+    if (numKeys.length === 1) return { type: "stat", data: [{ label: numKeys[0], value: Number(parsed[numKeys[0]]) }], style: cfg.style, legend: cfg.legend };
+    if (numKeys.length > 1) return _applyConfig({ type: "bar", data: numKeys.map(k => ({ label: k, value: Number(parsed[k]) })) }, cfg);
+    return null;
+  }
+
+  if (!Array.isArray(parsed) || !parsed.length) return null;
+  const first = parsed[0];
+  if (typeof first !== "object" || first === null) return null;
+
+  const keys = Object.keys(first);
+  const numKey = keys.find(k => parsed.every(r => r[k] !== undefined && !isNaN(Number(r[k])) && r[k] !== ""));
+  const labelKey = keys.find(k => k !== numKey && typeof first[k] === "string");
+
+  // Single row
+  if (parsed.length === 1) {
+    const numKeys = keys.filter(k => !isNaN(Number(first[k])) && first[k] !== "");
+    if (numKeys.length === 1) return { type: "stat", data: [{ label: numKeys[0], value: Number(first[numKeys[0]]) }], style: cfg.style, legend: cfg.legend };
+    if (numKeys.length > 1) return _applyConfig({ type: "bar", data: numKeys.map(k => ({ label: k, value: Number(first[k]) })) }, cfg);
+    return null;
+  }
+
+  // Multiple rows
+  if (numKey && labelKey) {
+    const detectedType = cfg.type !== "auto" ? cfg.type : (/date|time|month|year|week|day|hour/i.test(labelKey) ? "line" : "bar");
+    const data = parsed.map(r => ({ label: String(r[labelKey]), value: Number(r[numKey]) }));
+    return _applyConfig({ type: detectedType, data }, cfg);
+  }
+
+  if (numKey) {
+    const data = parsed.map((r, i) => ({ label: String(i + 1), value: Number(r[numKey]) }));
+    return _applyConfig({ type: cfg.type !== "auto" ? cfg.type : "bar", data }, cfg);
+  }
+
+  return null;
+}
+
+function _applyConfig(viz, cfg) {
+  let data = viz.data;
+
+  if (cfg.limit && data.length > cfg.limit) {
+    const sorted = [...data].sort((a, b) => b.value - a.value);
+    const top = sorted.slice(0, cfg.limit);
+    if (cfg.groupOthers) {
+      const othersValue = sorted.slice(cfg.limit).reduce((s, d) => s + d.value, 0);
+      top.push({ label: "Others", value: othersValue });
+    }
+    data = top;
+  }
+
+  return { type: viz.type, data, style: cfg.style, legend: cfg.legend };
+}
+
+module.exports = { buildVisualization };

package/src/utils/dlpScanner.js

@@ -0,0 +1,57 @@
+// Built-in pattern library — each entry has a regex factory (fresh instance per call)
+const BUILTIN_PATTERNS = {
+  passwords:    () => /(?:password|passwd|pwd|secret|token|pass)\s*[:=]\s*\S+/gi,
+  ip_addresses: () => /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
+  api_keys:     () => /\b(?:sk-[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{20,}|AKIA[0-9A-Z]{16}|xox[bpoa]-[0-9A-Za-z\-]+|Bearer\s+[A-Za-z0-9\-._~+/]{20,})/g,
+  credit_cards: () => /\b\d{4}[\s\-]?\d{4}[\s\-]?\d{4}[\s\-]?\d{4}\b/g,
+};
+
+/**
+ * Scan a message against active DLP policies.
+ * Returns: { blocked, violations, redactedText }
+ *   - blocked: true if any policy with action="block" matched
+ *   - violations: [{ policyId, policyName, action, snippet }]
+ *   - redactedText: message with redacted content (or original if nothing to redact)
+ */
+function scanMessage(text, policies = []) {
+  const violations = [];
+  let redactedText = text;
+  let blocked = false;
+
+  for (const policy of policies) {
+    if (!policy.enabled) continue;
+
+    let regex;
+    try {
+      // Use built-in pattern if available, otherwise compile custom pattern
+      const builtin = BUILTIN_PATTERNS[policy.category];
+      regex = builtin ? builtin() : new RegExp(policy.pattern, "gi");
+    } catch (_) {
+      continue; // skip malformed patterns
+    }
+
+    const matches = text.match(regex);
+    if (!matches || matches.length === 0) continue;
+
+    const snippet = text;
+
+    violations.push({
+      policyId:   policy.id,
+      policyName: policy.name,
+      action:     policy.action,
+      snippet,
+    });
+
+    if (policy.action === "block") {
+      blocked = true;
+    }
+
+    if (policy.action === "redact") {
+      redactedText = redactedText.replace(regex, "[REDACTED]");
+    }
+  }
+
+  return { blocked, violations, redactedText };
+}
+
+module.exports = { scanMessage };

package/src/utils/ingestionQueue.js

@@ -0,0 +1,240 @@
+const axios = require("axios");
+const FormData = require("form-data");
+const fs = require("fs");
+const path = require("path");
+const { v4: uuidv4 } = require("uuid");
+const { upsertChunksBatched } = require("./vectorStore");
+
+const OCR_MIME_MAP = {
+  ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
+  ".gif": "image/gif",  ".webp": "image/webp",  ".tiff": "image/tiff", ".bmp": "image/bmp"
+};
+const OCR_PROMPT =
+  "Extract ALL text from this image exactly as it appears. " +
+  "Preserve headings, bullet points, numbered lists, tables, and paragraph structure. " +
+  "Return only the extracted text — no commentary, no explanation, nothing else.";
+
+const PROCESSOR_URL = `http://localhost:${process.env.PROCESSOR_PORT || 5002}`;
+const EMBED_BATCH_SIZE = 10;
+
+async function getChunkSettings(db) {
+  const rows = await db.setting.findMany({ where: { key: { in: ["chunk_size", "chunk_overlap"] } } });
+  const map  = Object.fromEntries(rows.map(r => [r.key, parseInt(r.value)]));
+  return { chunkSize: map.chunk_size || 1000, chunkOverlap: map.chunk_overlap || 150 };
+}
+
+class IngestionQueue {
+  constructor() {
+    this._queue   = [];
+    this._running = false;
+  }
+
+  /**
+   * Add a document job to the queue.
+   * @param {object}  db                Prisma client
+   * @param {object}  workspace         { id, slug, name }
+   * @param {object}  doc               { uid, name, ... }
+   * @param {string}  source            file path or URL string
+   * @param {string}  sourceType        "file" | "url"
+   * @param {boolean} keepFile          don't delete temp file after processing
+   * @param {number}  uploadedByUserId  user who triggered the ingestion
+   */
+  enqueue(db, workspace, doc, source, sourceType = "file", keepFile = false, uploadedByUserId = null) {
+    this._queue.push({ db, workspace, doc, source, sourceType, keepFile, uploadedByUserId });
+    if (!this._running) this._run();
+  }
+
+  async _run() {
+    this._running = true;
+    while (this._queue.length > 0) {
+      const job = this._queue.shift();
+      await this._processJob(job).catch(e => console.error("[Queue] job error:", e.message));
+    }
+    this._running = false;
+  }
+
+  async _processJob({ db, workspace, doc, source, sourceType, keepFile, uploadedByUserId }) {
+    // Mark ingesting
+    try {
+      await db.document.update({
+        where: { uid: doc.uid },
+        data: { status: "ingesting", chunksProcessed: 0, totalChunks: 0, cancelRequested: false, errorMessage: null }
+      });
+    } catch {
+      return; // doc may have been deleted while queued
+    }
+
+    try {
+      // ── 1. Extract text + chunk via processor ─────────────────────────
+      const { chunkSize, chunkOverlap } = await getChunkSettings(db);
+      let chunks;
+
+      if (sourceType === "website-crawl") {
+        // ── BFS crawl: discover pages, create + enqueue each as a URL doc ──
+        const { startUrl, maxPages, maxDepth } = JSON.parse(source);
+        const origin = new URL(startUrl).origin;
+        const visited  = new Set();
+        const bfsQueue = [{ url: startUrl, depth: 0 }];
+        const toIngest = [];
+
+        while (bfsQueue.length > 0 && toIngest.length < maxPages) {
+          const { url: raw, depth } = bfsQueue.shift();
+          let normalized;
+          try { const u = new URL(raw); u.hash = ""; normalized = u.toString(); } catch { continue; }
+          if (visited.has(normalized)) continue;
+          visited.add(normalized);
+
+          try {
+            const resp = await fetch(normalized, {
+              headers: { "User-Agent": "OpenEnthrium-Crawler/1.0" },
+              redirect: "follow",
+              signal: AbortSignal.timeout(8000)
+            });
+            if (!resp.ok) continue;
+            const ct = resp.headers.get("content-type") || "";
+            if (!ct.includes("text/html")) continue;
+            const html = await resp.text();
+            toIngest.push(normalized);
+
+            if (depth < maxDepth) {
+              const linkRe = /href=["']([^"'#]+)["']/gi;
+              let m;
+              while ((m = linkRe.exec(html)) !== null) {
+                try {
+                  const linked = new URL(m[1], normalized);
+                  linked.hash = "";
+                  if (linked.origin === origin && !visited.has(linked.toString()))
+                    bfsQueue.push({ url: linked.toString(), depth: depth + 1 });
+                } catch { /* skip */ }
+              }
+            }
+          } catch { /* skip unreachable */ }
+        }
+
+        if (!toIngest.length) throw new Error("No pages could be fetched from that URL");
+
+        for (const url of toIngest) {
+          const urlDoc = await db.document.create({
+            data: { uid: uuidv4(), name: url, type: "url", workspaceId: workspace.id, status: "queued", uploadedByUserId }
+          });
+          ingestionQueue.enqueue(db, workspace, urlDoc, url, "url", false, uploadedByUserId);
+        }
+
+        // Mark the crawler tracker doc as ready (it has no chunks of its own)
+        await db.document.update({
+          where: { uid: doc.uid },
+          data: { status: "ready", chunkCount: toIngest.length, chunksProcessed: toIngest.length, totalChunks: toIngest.length, uploadedByUserId }
+        });
+        return;
+
+      } else if (sourceType === "ocr") {
+        // ── OCR: LLM Vision → text → processor ───────────────────────
+        if (!fs.existsSync(source)) throw new Error("Image file not found: " + source);
+
+        const mimeType = OCR_MIME_MAP[path.extname(source).toLowerCase()] || "image/jpeg";
+        const base64   = fs.readFileSync(source).toString("base64");
+
+        const { getLLMClient, getSetting } = require("../providers/llm");
+        const { provider, client } = await getLLMClient();
+        const model = (await getSetting("llm_model")) || (provider === "anthropic" ? "claude-3-5-sonnet-20241022" : "gpt-4o");
+
+        let extractedText = "";
+        if (provider === "anthropic") {
+          const response = await client.messages.create({
+            model, max_tokens: 4096,
+            messages: [{ role: "user", content: [
+              { type: "image", source: { type: "base64", media_type: mimeType, data: base64 } },
+              { type: "text",  text: OCR_PROMPT }
+            ]}]
+          });
+          extractedText = response.content?.[0]?.text || "";
+        } else {
+          const response = await client.chat.completions.create({
+            model, max_tokens: 4096,
+            messages: [{ role: "user", content: [
+              { type: "image_url", image_url: { url: `data:${mimeType};base64,${base64}`, detail: "high" } },
+              { type: "text",      text: OCR_PROMPT }
+            ]}]
+          });
+          extractedText = response.choices?.[0]?.message?.content || "";
+        }
+
+        if (!extractedText.trim()) throw new Error("No text could be extracted from this image");
+
+        // Write extracted text to a temp .txt file, process normally
+        const UPLOAD_DIR = path.join(__dirname, "../../storage/uploads/");
+        fs.mkdirSync(UPLOAD_DIR, { recursive: true });
+        const txtPath = path.join(UPLOAD_DIR, uuidv4() + ".txt");
+        fs.writeFileSync(txtPath, extractedText, "utf-8");
+
+        try {
+          const form = new FormData();
+          form.append("file", fs.createReadStream(txtPath), doc.name.replace(/ \(OCR\)$/, "") + ".txt");
+          form.append("chunkSize",    String(chunkSize));
+          form.append("chunkOverlap", String(chunkOverlap));
+          const { data } = await axios.post(`${PROCESSOR_URL}/process/file`, form, {
+            headers: form.getHeaders(), maxContentLength: Infinity, maxBodyLength: Infinity
+          });
+          chunks = data.chunks;
+        } finally {
+          fs.unlink(txtPath, () => {});
+        }
+
+      } else if (sourceType === "url") {
+        const { data } = await axios.post(`${PROCESSOR_URL}/process/url`, { url: source, chunkSize, chunkOverlap });
+        chunks = data.chunks;
+      } else {
+        if (!fs.existsSync(source)) throw new Error("Source file not found: " + source);
+        const form = new FormData();
+        form.append("file", fs.createReadStream(source), doc.name);
+        form.append("chunkSize",    String(chunkSize));
+        form.append("chunkOverlap", String(chunkOverlap));
+        const { data } = await axios.post(`${PROCESSOR_URL}/process/file`, form, {
+          headers: form.getHeaders(),
+          maxContentLength: Infinity,
+          maxBodyLength:    Infinity
+        });
+        chunks = data.chunks;
+      }
+
+      // Store total so the UI can show X / Y
+      await db.document.update({ where: { uid: doc.uid }, data: { totalChunks: chunks.length } });
+
+      // Calculate content size (for URL/OCR docs that had no file size at upload)
+      const contentSize = chunks.reduce((sum, c) => sum + Buffer.byteLength(c.text || "", "utf8"), 0);
+
+      // ── 2. Embed + upsert in batches, checking cancel between each ────
+      const { chunksProcessed: processed, embeddingTokens, embeddingModel } = await upsertChunksBatched(workspace.slug, doc.uid, chunks, {
+        batchSize:    EMBED_BATCH_SIZE,
+        onProgress:   async (count) => {
+          await db.document.update({ where: { uid: doc.uid }, data: { chunksProcessed: count } });
+        },
+        shouldCancel: async () => {
+          const row = await db.document.findUnique({ where: { uid: doc.uid }, select: { cancelRequested: true } });
+          return row?.cancelRequested === true;
+        }
+      });
+
+      // ── 3. Finalise status ─────────────────────────────────────────────
+      const wasCancelled = processed < chunks.length;
+      const sizeUpdate = (sourceType === "url" || sourceType === "ocr") ? { size: contentSize } : {};
+      await db.document.update({
+        where: { uid: doc.uid },
+        data: wasCancelled
+          ? { status: processed > 0 ? "partial" : "failed", chunkCount: processed, cancelRequested: false, embeddingTokens, embeddingModel, uploadedByUserId, ...sizeUpdate }
+          : { status: "ready", chunkCount: processed, chunksProcessed: processed, cancelRequested: false, embeddingTokens, embeddingModel, uploadedByUserId, ...sizeUpdate }
+      });
+    } catch (err) {
+      console.error(`[Queue] Ingestion failed for ${doc.uid}:`, err.message);
+      await db.document.update({
+        where: { uid: doc.uid },
+        data: { status: "failed", errorMessage: err.message }
+      }).catch(() => {});
+    } finally {
+      if (!keepFile && sourceType !== "url" && sourceType !== "website-crawl") fs.unlink(source, () => {});
+    }
+  }
+}
+
+const ingestionQueue = new IngestionQueue();
+module.exports = ingestionQueue;

package/src/utils/prepareConnectors.js

@@ -0,0 +1,66 @@
+"use strict";
+const fs  = require("fs");
+const os  = require("os");
+
+/**
+ * Merge YAML connector declarations (name+type only, no secrets)
+ * with config-file credentials, producing the connector objects
+ * the engine expects: { id, name, type, status, authConfig, config }.
+ *
+ * configConnectors supports both array format (canonical) and legacy
+ * object format { "Name": { type, ...creds } }.
+ */
+function prepareConnectors(yamlConnectors, configConnectors) {
+  // Normalise config to array
+  let cfgArray;
+  if (Array.isArray(configConnectors)) {
+    cfgArray = configConnectors;
+  } else if (configConnectors && typeof configConnectors === "object") {
+    cfgArray = Object.entries(configConnectors).map(([name, cfg]) => ({
+      connection_name: name,
+      connection_type: cfg.type,
+      ...cfg,
+    }));
+  } else {
+    cfgArray = [];
+  }
+
+  return (yamlConnectors || []).map((yc, i) => {
+    // Accept both new (connection_*) and legacy (name/type) field names
+    const ycName = yc.connection_name || yc.name;
+    const ycType = yc.connection_type || yc.type;
+
+    // Match by name first, then fall back to type
+    const cc = cfgArray.find(c => (c.connection_name || c.name) === ycName)
+            || cfgArray.find(c => (c.connection_type || c.type) === ycType);
+
+    if (!cc) {
+      return { id: i + 1, name: ycName, type: ycType, status: "active", authConfig: "{}", config: "{}" };
+    }
+
+    const { connection_name, connection_type, name, type, ...creds } = cc;
+    const resolvedName = connection_name || name || ycName;
+    const resolvedType = connection_type || type || ycType;
+
+    // Expand privateKeyPath → inline PEM (normalize CRLF for ssh2)
+    if (creds.privateKeyPath) {
+      const keyPath = creds.privateKeyPath.replace(/^~/, os.homedir());
+      creds.privateKey = fs.readFileSync(keyPath, "utf8").replace(/\r\n/g, "\n");
+      delete creds.privateKeyPath;
+    }
+    if (creds.privateKey) {
+      creds.privateKey = creds.privateKey.replace(/\\n/g, "\n").replace(/\r\n/g, "\n");
+    }
+
+    return {
+      id:         i + 1,
+      name:       resolvedName,
+      type:       resolvedType,
+      status:     "active",
+      authConfig: JSON.stringify(creds),
+      config:     JSON.stringify(creds),
+    };
+  });
+}
+
+module.exports = { prepareConnectors };

package/src/utils/rag/_settings.js

@@ -0,0 +1,6 @@
+const { PrismaClient } = require("@prisma/client");
+const db = new PrismaClient();
+module.exports = async function getSetting(key) {
+  const s = await db.setting.findUnique({ where: { key } });
+  return s?.value || null;
+};