@openenthrium/oe-runtime-sdk 1.7.5

package/src/engine/index.js

@@ -0,0 +1,183 @@
+const { createLLMClient }                                         = require("./llm");
+const { buildSystemPrompt, applyParams }                          = require("./promptBuilder");
+const { getToolDefinitions, getAnthropicToolDefinitions, executeTool } = require("../utils/tools/registry");
+
+function conditionMet(condition, output) {
+  switch (condition) {
+    case "always":      return true;
+    case "on_success":  return true;
+    case "on_critical": return /CRITICAL|🚨/i.test(output || "");
+    case "on_warning":  return /WARNING|CRITICAL|⚠️|🚨/i.test(output || "");
+    default:            return true;
+  }
+}
+
+function friendlyToolName(rawName, connectors) {
+  const connId = rawName.match(/^conn_(\d+)_/)?.[1];
+  if (connId) {
+    const conn = (connectors || []).find(c => c.id === parseInt(connId));
+    return conn ? conn.name : rawName.replace(/^conn_\d+_/, "");
+  }
+  return rawName.replace(/_/g, " ");
+}
+
+/**
+ * Run an agent. Pure function — no Prisma, no Express, no SSE.
+ * All side-effects go through hooks.
+ *
+ * agentSpec: {
+ *   systemPrompt:   string,
+ *   workflow:       [{ name, content }],   ← parsed array
+ *   params:         [{ name, default }],
+ *   paramValues:    object,
+ *   maxRounds:      number,
+ *   input:          string,
+ *   appendToPrompt: string,
+ * }
+ *
+ * llmConfig: { provider, apiKey, model, baseURL?, azureEndpoint?, azureDeployment? }
+ *
+ * connectors: [{ id, name, type, config, authConfig, ... }]
+ *
+ * hooks: {
+ *   onToolCall(friendlyName):         called each time a tool fires
+ *   onDone(output, toolCallNames):    called on clean completion
+ *   onError(err):                     called on failure
+ *   checkCancel():                    async fn, return true to abort mid-run
+ *   toolExecutor(name, args, conns):  optional override — use to inject db in web layer
+ * }
+ *
+ * Returns: { output, toolCalls }
+ */
+async function run(agentSpec, llmConfig, connectors, hooks = {}) {
+  const { onToolCall, onDone, onError, checkCancel } = hooks;
+
+  // Allow caller to inject db-aware tool executor (web layer);
+  // fall back to registry directly with null db (CLI / standalone).
+  const execTool = hooks.toolExecutor
+    || ((name, args, conns) => executeTool(name, args, conns, null));
+
+  // Build system prompt
+  const basePrompt   = buildSystemPrompt(agentSpec);
+  let   systemPrompt = applyParams(basePrompt, agentSpec.params || [], agentSpec.paramValues);
+  if (agentSpec.appendToPrompt) systemPrompt += "\n\n" + agentSpec.appendToPrompt;
+
+  const userMessage  = agentSpec.input?.trim() || "Execute the agent task now using the available tools.";
+  const MAX_ROUNDS   = agentSpec.maxRounds || 25;
+  const hasWorkflow  = (agentSpec.workflow || []).length > 0;
+
+  const { provider, client, model } = await createLLMClient(llmConfig);
+
+  let fullOutput       = "";
+  const allToolCalls   = [];
+
+  try {
+    if (provider === "anthropic") {
+      const tools = getAnthropicToolDefinitions(connectors);
+      const msgs  = [{ role: "user", content: userMessage }];
+      let madeToolCall = false;
+
+      for (let round = 0; round < MAX_ROUNDS; round++) {
+        const resp = await client.messages.create({
+          model: model || "claude-sonnet-4-6",
+          max_tokens: 4096,
+          system: systemPrompt,
+          messages: msgs,
+          tools: tools.length ? tools : undefined,
+          temperature: 0.3,
+        });
+
+        if (resp.stop_reason !== "tool_use" || !tools.length) {
+          if (hasWorkflow && tools.length && !madeToolCall && round === 0) {
+            msgs.push({ role: "assistant", content: resp.content });
+            msgs.push({ role: "user", content: "Do not plan or summarise. Call your first tool RIGHT NOW." });
+            continue;
+          }
+          fullOutput = resp.content?.find(b => b.type === "text")?.text || "";
+          break;
+        }
+
+        madeToolCall = true;
+        const toolUseBlocks = resp.content.filter(b => b.type === "tool_use");
+
+        for (const tb of toolUseBlocks) {
+          const name = friendlyToolName(tb.name, connectors);
+          allToolCalls.push(name);
+          onToolCall?.(name);
+        }
+
+        msgs.push({ role: "assistant", content: resp.content });
+        const toolResults = [];
+        for (const tb of toolUseBlocks) {
+          const result = await execTool(tb.name, tb.input, connectors);
+          hooks.onToolResult?.(friendlyToolName(tb.name, connectors), String(result));
+          toolResults.push({ type: "tool_result", tool_use_id: tb.id, content: String(result) });
+        }
+        msgs.push({ role: "user", content: toolResults });
+
+        if (checkCancel && await checkCancel()) { fullOutput = "[Run cancelled by user]"; break; }
+
+        if (round === MAX_ROUNDS - 1) {
+          const fr = await client.messages.create({
+            model: model || "claude-sonnet-4-6", max_tokens: 4096,
+            system: systemPrompt, messages: msgs, temperature: 0.3,
+          });
+          fullOutput = fr.content?.find(b => b.type === "text")?.text || "";
+        }
+      }
+
+    } else {
+      const tools    = getToolDefinitions(connectors);
+      const messages = [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }];
+      let madeToolCall = false;
+
+      for (let round = 0; round < MAX_ROUNDS; round++) {
+        const reqBody = { model, messages, temperature: 0.3, max_tokens: 4096 };
+        if (tools.length) { reqBody.tools = tools; reqBody.tool_choice = "auto"; }
+
+        const resp   = await client.chat.completions.create(reqBody);
+        const choice = resp.choices[0];
+
+        if (choice.finish_reason !== "tool_calls" || !tools.length) {
+          if (hasWorkflow && tools.length && !madeToolCall && round === 0) {
+            messages.push(choice.message);
+            messages.push({ role: "user", content: "Do not plan or summarise. Call your first tool RIGHT NOW." });
+            continue;
+          }
+          fullOutput = choice.message.content || "";
+          break;
+        }
+
+        madeToolCall = true;
+        messages.push(choice.message);
+
+        for (const tc of choice.message.tool_calls || []) {
+          let args = {};
+          try { args = JSON.parse(tc.function.arguments); } catch { /**/ }
+          const name = friendlyToolName(tc.function.name, connectors);
+          allToolCalls.push(name);
+          onToolCall?.(name);
+          const result = await execTool(tc.function.name, args, connectors);
+          hooks.onToolResult?.(name, String(result));
+          messages.push({ role: "tool", tool_call_id: tc.id, content: String(result) });
+        }
+
+        if (checkCancel && await checkCancel()) { fullOutput = "[Run cancelled by user]"; break; }
+
+        if (round === MAX_ROUNDS - 1) {
+          const fr = await client.chat.completions.create({ model, messages, temperature: 0.3, max_tokens: 4096 });
+          fullOutput = fr.choices[0].message.content || "";
+        }
+      }
+    }
+
+    onDone?.(fullOutput, allToolCalls);
+    return { output: fullOutput, toolCalls: allToolCalls };
+
+  } catch (err) {
+    onError?.(err);
+    throw err;
+  }
+}
+
+module.exports = { run, conditionMet };

package/src/engine/llm.js

@@ -0,0 +1,71 @@
+const OPENAI_COMPATIBLE = {
+  groq:             { baseURL: "https://api.groq.com/openai/v1" },
+  togetherai:       { baseURL: "https://api.together.xyz/v1" },
+  mistral:          { baseURL: "https://api.mistral.ai/v1" },
+  openrouter:       { baseURL: "https://openrouter.ai/api/v1" },
+  perplexity:       { baseURL: "https://api.perplexity.ai" },
+  deepseek:         { baseURL: "https://api.deepseek.com/v1" },
+  xai:              { baseURL: "https://api.x.ai/v1" },
+  fireworks:        { baseURL: "https://api.fireworks.ai/inference/v1" },
+  gemini:           { baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/" },
+  nvidiaNim:        { baseURL: "https://integrate.api.nvidia.com/v1" },
+  sambanova:        { baseURL: "https://api.sambanova.ai/v1" },
+  litellm:          { baseURL: null, apiKey: "no-key", localDefault: "http://localhost:4000" },
+  ollama:           { baseURL: null, apiKey: "ollama", localDefault: "http://localhost:11434/v1" },
+  lmstudio:         { baseURL: null, apiKey: "lmstudio", localDefault: "http://localhost:1234/v1" },
+  "generic-openai": { baseURL: null, localDefault: "" },
+};
+
+/**
+ * Create an LLM client from a plain config object — no Prisma, no DB.
+ *
+ * config: { provider, apiKey, model, baseURL?, azureEndpoint?, azureDeployment? }
+ * Returns: { provider, client, model }
+ */
+async function createLLMClient(config) {
+  const openaiPkg = require("openai");
+  const OpenAI    = openaiPkg.OpenAI || openaiPkg.default || openaiPkg;
+  const provider  = config.provider || "openai";
+  const model    = config.model    || "gpt-4o";
+
+  if (provider === "azure") {
+    const endpoint   = config.azureEndpoint   || process.env.AZURE_OPENAI_ENDPOINT;
+    const deployment = config.azureDeployment || process.env.AZURE_OPENAI_DEPLOYMENT;
+    const key        = config.apiKey          || process.env.AZURE_OPENAI_API_KEY;
+    return {
+      provider: "azure", model,
+      client: new OpenAI({
+        apiKey: key,
+        baseURL: `${endpoint}/openai/deployments/${deployment}`,
+        defaultQuery: { "api-version": "2024-08-01-preview" },
+        defaultHeaders: { "api-key": key },
+      }),
+    };
+  }
+
+  if (provider === "anthropic") {
+    const Anthropic = require("@anthropic-ai/sdk");
+    return {
+      provider: "anthropic", model,
+      client: new Anthropic({ apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY }),
+    };
+  }
+
+  if (provider === "openai") {
+    return {
+      provider: "openai", model,
+      client: new OpenAI({ apiKey: config.apiKey || process.env.OPENAI_API_KEY }),
+    };
+  }
+
+  const compat = OPENAI_COMPATIBLE[provider];
+  if (compat) {
+    const baseURL = config.baseURL || compat.baseURL || compat.localDefault;
+    const key     = config.apiKey  || compat.apiKey  || "no-key";
+    return { provider, model, client: new OpenAI({ apiKey: key, baseURL }) };
+  }
+
+  throw new Error(`Unknown LLM provider: ${provider}`);
+}
+
+module.exports = { createLLMClient, OPENAI_COMPATIBLE };

package/src/engine/promptBuilder.js

@@ -0,0 +1,38 @@
+/**
+ * Build the full system prompt from an agentSpec or a DB agent object.
+ *
+ * Accepts workflow as either:
+ *   - a parsed array  [{ name, content }]  (agentSpec from CLI / engine)
+ *   - a JSON string   "[{...}]"            (DB agent from Platform routes)
+ */
+function buildSystemPrompt(agentSpec) {
+  const raw   = agentSpec.workflow ?? agentSpec.steps ?? [];
+  const steps = typeof raw === "string" ? JSON.parse(raw || "[]") : raw;
+
+  const todayDate  = new Date().toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" });
+  const dateHeader = `SYSTEM: Today's date is ${todayDate}. Use this exact date whenever instructions say "today's date" or "TODAY".`;
+
+  if (!steps.length) return dateHeader + "\n\n" + (agentSpec.systemPrompt || "");
+
+  const parts = [dateHeader];
+  if (agentSpec.systemPrompt?.trim()) parts.push(agentSpec.systemPrompt.trim());
+
+  steps.forEach((step, i) => {
+    const header = `step_${i + 1}: — ${step.name || `Step ${i + 1}`}`;
+    const body   = step.content?.trim() || "";
+    parts.push(body ? `${header}\n\n${body}` : header);
+  });
+
+  return parts.join("\n\n");
+}
+
+function applyParams(template, paramDefs, paramValues) {
+  let result = template || "";
+  for (const p of (paramDefs || [])) {
+    const val = String(paramValues?.[p.name] ?? p.default ?? "");
+    result = result.split(`{{${p.name}}}`).join(val);
+  }
+  return result;
+}
+
+module.exports = { buildSystemPrompt, applyParams };

package/src/index.js

@@ -0,0 +1,156 @@
+require("dotenv").config();
+const express = require("express");
+const cors = require("cors");
+const fs = require("fs");
+const path = require("path");
+const { PrismaClient } = require("@prisma/client");
+
+const { version } = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../package.json"), "utf8"));
+
+const authRoutes      = require("./routes/auth");
+const workspaceRoutes = require("./routes/workspaces");
+const documentRoutes  = require("./routes/documents");
+const chatRoutes      = require("./routes/chat");
+const threadRoutes    = require("./routes/threads");
+const adminRoutes     = require("./routes/admin");
+const settingsRoutes  = require("./routes/settings");
+const modelsRoutes    = require("./routes/models");
+const audioRoutes      = require("./routes/audio");
+const dashboardRoutes  = require("./routes/dashboard");
+const embedRoutes      = require("./routes/embed");
+const apiKeyRoutes     = require("./routes/apiKeys");
+const oauthRoutes      = require("./routes/oauth");
+const agentRoutes      = require("./routes/agents");
+const projectRoutes    = require("./routes/projects");
+const templateRoutes   = require("./routes/templates");
+const ingestionQueue   = require("./utils/ingestionQueue");
+
+const app    = express();
+const prisma = new PrismaClient();
+const PORT   = process.env.SERVER_PORT || 3001;
+
+app.use(cors({ origin: "*" }));
+app.use(express.json({ limit: "50mb" }));
+app.use(express.urlencoded({ extended: true }));
+
+app.use((req, _res, next) => { req.db = prisma; next(); });
+
+const commercialRoutesPath = path.resolve(__dirname, "../../commercial/routes");
+const isCommercial = fs.existsSync(commercialRoutesPath);
+if (isCommercial) {
+  try {
+    require(commercialRoutesPath).register(app);
+    console.log("[Commercial] Routes loaded");
+  } catch (e) {
+    console.log("[Commercial] Failed to load routes:", e.message);
+  }
+}
+
+app.get("/api/instance", async (req, res) => {
+  const isEnterprise = isCommercial;
+
+  const licenseType = isEnterprise ? "enterprise"                : "community";
+  const edition     = isEnterprise ? "Open Enthrium Commercial" : "Open Enthrium Community";
+  const price       = isEnterprise ? "custom"                    : "free";
+
+  try {
+    const [brandingName, brandingUrl, brandingLogo] = await Promise.all([
+      req.db.setting.findUnique({ where: { key: "branding_name" } }),
+      req.db.setting.findUnique({ where: { key: "branding_url"  } }),
+      req.db.setting.findUnique({ where: { key: "branding_logo" } }),
+    ]);
+    res.set("Cache-Control", "no-store");
+    res.json({
+      licenseType,
+      edition,
+      price,
+      brandingName: brandingName?.value || null,
+      brandingUrl:  brandingUrl?.value  || null,
+      brandingLogo: brandingLogo?.value || null,
+    });
+  } catch {
+    res.set("Cache-Control", "no-store");
+    res.json({ licenseType, edition, price, brandingName: null, brandingUrl: null, brandingLogo: null });
+  }
+});
+
+app.use("/api/auth",       authRoutes);
+app.use("/api/workspaces", workspaceRoutes);
+app.use("/api/documents",  documentRoutes);
+app.use("/api/chat",       chatRoutes);
+app.use("/api/threads",    threadRoutes);
+app.use("/api/admin",      adminRoutes);
+app.use("/api/settings",   settingsRoutes);
+app.use("/api/models",     modelsRoutes);
+app.use("/api/audio",      audioRoutes);
+app.use("/api/dashboard",  dashboardRoutes);
+app.use("/api/embed",          embedRoutes);
+app.use("/api/admin/api-keys",  apiKeyRoutes);
+app.use("/api/oauth",          oauthRoutes);
+app.use("/api/admin",          agentRoutes);
+app.use("/api/admin/workspaces/:workspaceId/projects", projectRoutes);
+app.use("/api/admin/templates", templateRoutes);
+
+app.get("/api/health", (_req, res) => res.json({ status: "ok", version }));
+
+// Feature flags — readable by any authenticated user
+app.get("/api/features", async (req, res) => {
+  try {
+    const rows = await prisma.setting.findMany({
+      where: { key: { in: ["feature.kbSharing"] } },
+    });
+    const s = Object.fromEntries(rows.map(r => [r.key, r.value]));
+    res.json({
+      kbSharing: s["feature.kbSharing"] === "true",
+    });
+  } catch { res.json({ kbSharing: false }); }
+});
+
+async function recoverPendingJobs() {
+  try {
+    const stuck = await prisma.document.findMany({
+      where:   { status: { in: ["queued", "ingesting"] } },
+      include: { workspace: true }
+    });
+    if (!stuck.length) return;
+
+    console.log(`[Queue] Recovering ${stuck.length} interrupted document(s)…`);
+
+    for (const doc of stuck) {
+      if (doc.type === "website-crawl") continue; // crawler tracker docs have no chunks of their own
+
+      const reset = { status: "queued", chunksProcessed: 0, cancelRequested: false, errorMessage: null };
+
+      if (doc.type === "url") {
+        await prisma.document.update({ where: { uid: doc.uid }, data: reset });
+        ingestionQueue.enqueue(prisma, doc.workspace, doc, doc.name, "url");
+      } else if (doc.sourcePath && fs.existsSync(doc.sourcePath)) {
+        await prisma.document.update({ where: { uid: doc.uid }, data: reset });
+        const sourceType = doc.type === "ocr" ? "ocr" : "file";
+        const keepFile   = !doc.sourcePath.includes("uploads");
+        ingestionQueue.enqueue(prisma, doc.workspace, doc, doc.sourcePath, sourceType, keepFile);
+      } else {
+        await prisma.document.update({
+          where: { uid: doc.uid },
+          data:  { status: "failed", errorMessage: "Source file unavailable after server restart. Please re-upload." }
+        });
+      }
+    }
+  } catch (err) {
+    console.error("[Queue] Recovery error:", err.message);
+  }
+}
+
+// Serve built frontend in production
+if (process.env.NODE_ENV === "production") {
+  const path = require("path");
+  const publicDir = path.join(__dirname, "../../public");
+  app.use(express.static(publicDir));
+  app.get("*", (_req, res) => res.sendFile(path.join(publicDir, "index.html")));
+}
+
+app.listen(PORT, async () => {
+  console.log(`Open Enthrium server running on port ${PORT}`);
+  await recoverPendingJobs();
+  try { await require("./telemetry/bootstrap")(prisma); } catch {}
+});

package/src/middleware/auth.js

@@ -0,0 +1,63 @@
+const jwt    = require("jsonwebtoken");
+const crypto = require("crypto");
+const fs     = require("fs");
+const path   = require("path");
+
+const _commercialExists = fs.existsSync(path.resolve(__dirname, "../../../commercial/routes"));
+
+function authenticate(req, res, next) {
+  const header = req.headers.authorization;
+  if (!header) return res.status(401).json({ error: "No token provided" });
+
+  const token = header.startsWith("Bearer ") ? header.slice(7) : header;
+  try {
+    req.user = jwt.verify(token, process.env.JWT_SECRET);
+    next();
+  } catch {
+    res.status(401).json({ error: "Invalid or expired token" });
+  }
+}
+
+function requireAdmin(req, res, next) {
+  if (req.user?.role !== "admin") return res.status(403).json({ error: "Admin only" });
+  next();
+}
+
+function requireManagerOrAdmin(req, res, next) {
+  if (req.user?.role !== "admin" && req.user?.role !== "manager") {
+    return res.status(403).json({ error: "Manager or admin access required" });
+  }
+  next();
+}
+
+async function authenticateApiKey(req, res, next) {
+  const header = req.headers.authorization;
+  if (!header?.startsWith("Bearer ")) {
+    return res.status(401).json({ error: "API key required. Use: Authorization: Bearer emb_..." });
+  }
+  const rawKey = header.slice(7);
+  if (!rawKey.startsWith("emb_")) {
+    return res.status(401).json({ error: "Invalid API key format" });
+  }
+  const keyHash = crypto.createHash("sha256").update(rawKey).digest("hex");
+  const apiKey  = await req.db.apiKey.findFirst({ where: { keyHash, revoked: false } });
+  if (!apiKey) return res.status(401).json({ error: "Invalid or revoked API key" });
+
+  await req.db.apiKey.update({ where: { id: apiKey.id }, data: { lastUsedAt: new Date() } });
+  req.apiKey = apiKey;
+  next();
+}
+
+function requireManagerOrAdminOrUser(req, res, next) {
+  if (!req.user) return res.status(401).json({ error: "Not authenticated" });
+  next();
+}
+
+function requireCommercial(req, res, next) {
+  if (!_commercialExists) {
+    return res.status(403).json({ error: "This feature requires a commercial license." });
+  }
+  next();
+}
+
+module.exports = { authenticate, requireAdmin, requireManagerOrAdmin, requireManagerOrAdminOrUser, authenticateApiKey, requireCommercial };

package/src/providers/embedding/index.js

@@ -0,0 +1,69 @@
+const { PrismaClient } = require("@prisma/client");
+const db = new PrismaClient();
+
+async function getSetting(key) {
+  const s = await db.setting.findUnique({ where: { key } });
+  return s?.value || null;
+}
+
+/**
+ * Embed texts and return { embeddings, tokensUsed, model }.
+ * tokensUsed is the actual count from the API response (0 for local providers).
+ */
+async function embed(texts) {
+  const { default: OpenAI } = await import("openai");
+
+  const provider = (await getSetting("embedding_provider")) || process.env.EMBEDDING_PROVIDER || "openai";
+  const model    = (await getSetting("embedding_model"))    || process.env.EMBEDDING_MODEL    || "text-embedding-3-small";
+
+  let res;
+
+  if (provider === "azure") {
+    const endpoint   = (await getSetting("embedding_azure_endpoint"))   || (await getSetting("llm_azure_endpoint"))   || process.env.AZURE_OPENAI_ENDPOINT;
+    const deployment = (await getSetting("embedding_azure_deployment")) || process.env.AZURE_OPENAI_EMBEDDING_DEPLOYMENT;
+    const apiKey     = (await getSetting("embedding_api_key")) || (await getSetting("llm_api_key")) || process.env.AZURE_OPENAI_API_KEY;
+    const client = new OpenAI({
+      apiKey,
+      baseURL: `${endpoint}/openai/deployments/${deployment}`,
+      defaultQuery: { "api-version": "2024-08-01-preview" },
+      defaultHeaders: { "api-key": apiKey }
+    });
+    res = await client.embeddings.create({ model, input: texts });
+
+  } else if (provider === "ollama") {
+    const rawUrl = (await getSetting("embedding_base_url")) || (await getSetting("llm_base_url")) || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+    const baseURL = rawUrl.replace(/\/v1\/?$/, "") + "/v1";
+    const client = new OpenAI({ baseURL, apiKey: "ollama" });
+    res = await client.embeddings.create({ model: model || "nomic-embed-text", input: texts });
+
+  } else if (provider === "lmstudio" || provider === "generic-openai") {
+    const rawUrl = (await getSetting("embedding_base_url")) || process.env.EMBEDDING_BASE_URL || "http://localhost:1234/v1";
+    const apiKey = (await getSetting("embedding_api_key")) || "lmstudio";
+    const client = new OpenAI({ baseURL: rawUrl, apiKey });
+    res = await client.embeddings.create({ model, input: texts });
+
+  } else if (provider === "gemini") {
+    const apiKey = (await getSetting("embedding_api_key")) || process.env.GEMINI_API_KEY;
+    const client = new OpenAI({ apiKey, baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/" });
+    res = await client.embeddings.create({ model: model || "text-embedding-004", input: texts });
+
+  } else if (provider === "cohere") {
+    const apiKey = (await getSetting("embedding_api_key")) || process.env.COHERE_API_KEY;
+    const client = new OpenAI({ apiKey, baseURL: "https://api.cohere.com/compatibility/v1" });
+    res = await client.embeddings.create({ model: model || "embed-english-v3.0", input: texts });
+
+  } else {
+    // Default: OpenAI
+    const apiKey = (await getSetting("embedding_api_key")) || (await getSetting("llm_api_key")) || process.env.OPENAI_API_KEY;
+    const client = new OpenAI({ apiKey });
+    res = await client.embeddings.create({ model, input: texts });
+  }
+
+  return {
+    embeddings: res.data.map(d => d.embedding),
+    tokensUsed: res.usage?.total_tokens || 0,
+    model:      model
+  };
+}
+
+module.exports = { embed };