@openenthrium/oe-runtime-sdk 1.7.5

package/src/utils/rag/weaviate.js

@@ -0,0 +1,137 @@
+const { embed } = require("../../providers/embedding");
+const getSetting = require("./_settings");
+const { v5: uuidv5 } = require("uuid");
+
+const UUID_NS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+
+async function getConfig(cfg = {}) {
+  const url    = cfg.url    || (await getSetting("vector_db_url"))     || "http://localhost:8080";
+  const apiKey = cfg.apiKey || (await getSetting("vector_db_api_key")) || null;
+  return { url, apiKey };
+}
+
+function className(workspaceSlug) {
+  return "Ws" + workspaceSlug.split(/[-_]/).map(p => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+
+async function req(baseUrl, apiKey, method, path, body) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const res = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers,
+    body: body != null ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(15000),
+  });
+  if (!res.ok && res.status !== 422) {
+    const text = await res.text();
+    throw new Error(`Weaviate ${method} ${path}: ${res.status} ${text}`);
+  }
+  const text = await res.text();
+  return text ? JSON.parse(text) : {};
+}
+
+async function ensureClass(baseUrl, apiKey, cls, vectorDim) {
+  try {
+    await req(baseUrl, apiKey, "GET", `/v1/schema/${cls}`);
+  } catch {
+    await req(baseUrl, apiKey, "POST", "/v1/schema", {
+      class: cls,
+      vectorizer: "none",
+      properties: [
+        { name: "documentUid", dataType: ["text"], tokenization: "field" },
+        { name: "text",        dataType: ["text"] },
+        { name: "metadata",    dataType: ["text"] },
+      ],
+    });
+  }
+}
+
+async function upsertChunksBatched(workspaceSlug, documentUid, chunks, options = {}, config = {}) {
+  const { batchSize = 50, onProgress, shouldCancel } = options;
+  const { url, apiKey } = await getConfig(config);
+  const cls = className(workspaceSlug);
+
+  let chunksProcessed = 0, embeddingTokens = 0, embeddingModel = null;
+  let classReady = false;
+
+  for (let i = 0; i < chunks.length; i += batchSize) {
+    if (shouldCancel && await shouldCancel()) return { chunksProcessed, embeddingTokens, embeddingModel };
+
+    const batch = chunks.slice(i, i + batchSize);
+    const { embeddings, tokensUsed, model } = await embed(batch.map(c => c.text));
+    embeddingTokens += tokensUsed;
+    if (!embeddingModel) embeddingModel = model;
+
+    if (!classReady) {
+      await ensureClass(url, apiKey, cls, embeddings[0].length);
+      classReady = true;
+    }
+
+    const objects = batch.map((c, j) => ({
+      class:  cls,
+      id:     uuidv5(`${documentUid}_${i + j}`, UUID_NS),
+      vector: embeddings[j],
+      properties: {
+        documentUid,
+        text:     c.text,
+        metadata: JSON.stringify(c.metadata || {}),
+      },
+    }));
+
+    await req(url, apiKey, "POST", "/v1/batch/objects", { objects });
+
+    chunksProcessed += batch.length;
+    if (onProgress) await onProgress(chunksProcessed);
+  }
+  return { chunksProcessed, embeddingTokens, embeddingModel };
+}
+
+async function similaritySearch(workspaceSlug, query, topK = 5, config = {}) {
+  try {
+    const { url, apiKey } = await getConfig(config);
+    const cls = className(workspaceSlug);
+    const { embeddings } = await embed([query]);
+    const gql = {
+      query: `{
+        Get {
+          ${cls}(
+            nearVector: { vector: [${embeddings[0].join(",")}] }
+            limit: ${topK}
+          ) {
+            text metadata documentUid
+            _additional { certainty }
+          }
+        }
+      }`,
+    };
+    const data = await req(url, apiKey, "POST", "/v1/graphql", gql);
+    const hits = data?.data?.Get?.[cls] || [];
+    return hits.map(h => ({
+      text:     h.text || "",
+      metadata: (() => { try { return JSON.parse(h.metadata || "{}"); } catch { return {}; } })(),
+      score:    h._additional?.certainty || 0,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+async function deleteDocumentChunks(workspaceSlug, documentUid, config = {}) {
+  try {
+    const { url, apiKey } = await getConfig(config);
+    const cls = className(workspaceSlug);
+    await req(url, apiKey, "DELETE", "/v1/batch/objects", {
+      match: {
+        class: cls,
+        where: {
+          operator:  "Equal",
+          path:      ["documentUid"],
+          valueText: documentUid,
+        },
+      },
+    });
+  } catch {}
+}
+
+module.exports = { upsertChunksBatched, similaritySearch, deleteDocumentChunks };

package/src/utils/rag/zilliz.js

@@ -0,0 +1,115 @@
+const { embed } = require("../../providers/embedding");
+const getSetting = require("./_settings");
+
+let _client = null, _clientKey = null;
+
+async function getClient(cfg = {}) {
+  const address = cfg.url    || (await getSetting("vector_db_url"))     || "";
+  const token   = cfg.apiKey || (await getSetting("vector_db_api_key")) || "";
+  const key = `${address}:${token}`;
+  if (!_client || _clientKey !== key) {
+    const { MilvusClient } = require("@zilliz/milvus2-sdk-node");
+    _client    = new MilvusClient({ address, token, ssl: true });
+    _clientKey = key;
+  }
+  return _client;
+}
+
+function colName(workspaceSlug) {
+  return `ws_${workspaceSlug.replace(/[-]/g, "_")}`;
+}
+
+async function ensureCollection(client, name, dim) {
+  const exists = await client.hasCollection({ collection_name: name });
+  if (!exists.value) {
+    await client.createCollection({
+      collection_name: name,
+      fields: [
+        { name: "id",           data_type: "VarChar", max_length: 128, is_primary_key: true },
+        { name: "documentUid", data_type: "VarChar", max_length: 128 },
+        { name: "text",         data_type: "VarChar", max_length: 65535 },
+        { name: "metadata",     data_type: "VarChar", max_length: 65535 },
+        { name: "embedding",    data_type: "FloatVector", dim },
+      ],
+    });
+    await client.createIndex({
+      collection_name: name,
+      field_name:      "embedding",
+      index_type:      "AUTOINDEX",
+      metric_type:     "COSINE",
+    });
+    await client.loadCollection({ collection_name: name });
+  }
+}
+
+async function upsertChunksBatched(workspaceSlug, documentUid, chunks, options = {}, config = {}) {
+  const { batchSize = 50, onProgress, shouldCancel } = options;
+  const client = await getClient(config);
+  const col    = colName(workspaceSlug);
+
+  let chunksProcessed = 0, embeddingTokens = 0, embeddingModel = null;
+  let collectionReady = false;
+
+  for (let i = 0; i < chunks.length; i += batchSize) {
+    if (shouldCancel && await shouldCancel()) return { chunksProcessed, embeddingTokens, embeddingModel };
+
+    const batch = chunks.slice(i, i + batchSize);
+    const { embeddings, tokensUsed, model } = await embed(batch.map(c => c.text));
+    embeddingTokens += tokensUsed;
+    if (!embeddingModel) embeddingModel = model;
+
+    if (!collectionReady) {
+      await ensureCollection(client, col, embeddings[0].length);
+      collectionReady = true;
+    }
+
+    await client.insert({
+      collection_name: col,
+      data: batch.map((c, j) => ({
+        id:          `${documentUid}_${i + j}`.slice(0, 128),
+        documentUid: documentUid.slice(0, 128),
+        text:        (c.text || "").slice(0, 65535),
+        metadata:    JSON.stringify(c.metadata || {}).slice(0, 65535),
+        embedding:   embeddings[j],
+      })),
+    });
+
+    chunksProcessed += batch.length;
+    if (onProgress) await onProgress(chunksProcessed);
+  }
+  return { chunksProcessed, embeddingTokens, embeddingModel };
+}
+
+async function similaritySearch(workspaceSlug, query, topK = 5, config = {}) {
+  try {
+    const client = await getClient(config);
+    const { embeddings } = await embed([query]);
+    const results = await client.search({
+      collection_name: colName(workspaceSlug),
+      vectors:         [embeddings[0]],
+      vector_type:     "FloatVector",
+      limit:           topK,
+      output_fields:   ["text", "metadata", "documentUid"],
+      metric_type:     "COSINE",
+    });
+    return (results.results || []).map(r => ({
+      text:     r.text || "",
+      metadata: (() => { try { return JSON.parse(r.metadata || "{}"); } catch { return {}; } })(),
+      score:    r.score,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+async function deleteDocumentChunks(workspaceSlug, documentUid, config = {}) {
+  try {
+    const client = await getClient(config);
+    await client.deleteEntities({
+      collection_name: colName(workspaceSlug),
+      expr: `documentUid == "${documentUid}"`,
+    });
+  } catch {}
+}
+
+module.exports = { upsertChunksBatched, similaritySearch, deleteDocumentChunks };

package/src/utils/scheduler.js

@@ -0,0 +1,168 @@
+const cron = require("node-cron");
+const { getToolDefinitions, getAnthropicToolDefinitions, executeTool } = require("./tools/registry");
+const { getLLMClient, getSetting } = require("../providers/llm");
+
+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;
+}
+
+const jobs = new Map(); // agentId -> cron.ScheduledTask
+
+async function runAgent(agent, db) {
+  const run = await db.agentRun.create({
+    data: { agentId: agent.id, status: "running", triggerType: "scheduled", input: 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 } });
+    const paramDefs    = JSON.parse(agent.params || "[]");
+    const { buildSystemPrompt } = require("./workflowEngine");
+    const systemPrompt = applyParams(
+      buildSystemPrompt(agent) || "You are a helpful AI agent. Complete the task given to you using the available tools.",
+      paramDefs, null
+    ) + "\n\nIMPORTANT: This is an automated scheduled run. Execute the task immediately using the available tools. Do not ask for clarification.";
+
+    const userTask = "Run the scheduled agent task.";
+
+    const { provider, client } = await getLLMClient();
+    const model = (await getSetting("llm_model")) || process.env.OPENAI_MODEL || process.env.OLLAMA_MODEL || "gpt-4o";
+
+    const MAX_ROUNDS = workspace?.defaultAgentMaxRounds || 25;
+    let fullOutput = "";
+
+    if (provider === "anthropic") {
+      const tools = getAnthropicToolDefinitions(connectors);
+      const msgs  = [{ role: "user", content: userTask }];
+
+      for (let round = 0; round < MAX_ROUNDS; round++) {
+        const resp = await client.messages.create({
+          model: model || "claude-3-5-sonnet-20241022",
+          max_tokens: 4096,
+          system: systemPrompt,
+          messages: msgs,
+          tools: tools.length ? tools : undefined,
+          temperature: 0.3,
+        });
+
+        if (resp.stop_reason !== "tool_use" || !tools.length) {
+          fullOutput = resp.content?.find(b => b.type === "text")?.text || "";
+          break;
+        }
+
+        const toolUseBlocks = resp.content.filter(b => b.type === "tool_use");
+        msgs.push({ role: "assistant", content: resp.content });
+        const toolResults = [];
+        for (const tb of toolUseBlocks) {
+          const result = await executeTool(tb.name, tb.input, connectors, db);
+          toolResults.push({ type: "tool_result", tool_use_id: tb.id, content: String(result) });
+        }
+        msgs.push({ role: "user", content: toolResults });
+
+        if (round === MAX_ROUNDS - 1) {
+          const finalResp = await client.messages.create({
+            model: model || "claude-3-5-sonnet-20241022",
+            max_tokens: 4096, system: systemPrompt, messages: msgs, temperature: 0.3,
+          });
+          fullOutput = finalResp.content?.find(b => b.type === "text")?.text || "";
+        }
+      }
+    } else {
+      const tools    = getToolDefinitions(connectors);
+      const messages = [{ role: "system", content: systemPrompt }, { role: "user", content: userTask }];
+
+      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) {
+          fullOutput = choice.message.content || "";
+          break;
+        }
+
+        messages.push(choice.message);
+        for (const tc of choice.message.tool_calls || []) {
+          let args = {};
+          try { args = JSON.parse(tc.function.arguments); } catch { /* */ }
+          const result = await executeTool(tc.function.name, args, connectors, db);
+          messages.push({ role: "tool", tool_call_id: tc.id, content: String(result) });
+        }
+
+        if (round === MAX_ROUNDS - 1) {
+          const finalResp = await client.chat.completions.create({ model, messages, temperature: 0.3, max_tokens: 4096 });
+          fullOutput = finalResp.choices[0].message.content || "";
+        }
+      }
+    }
+
+    await db.agentRun.update({
+      where: { id: run.id },
+      data:  { status: "success", output: fullOutput, completedAt: new Date() },
+    });
+    console.log(`[scheduler] Agent "${agent.name}" (id=${agent.id}) completed.`);
+
+    // Chain to next agent if configured
+    const { maybeChain } = require("./agentChain");
+    await maybeChain(agent, fullOutput, db);
+  } catch (err) {
+    await db.agentRun.update({
+      where: { id: run.id },
+      data:  { status: "error", error: err.message, completedAt: new Date() },
+    });
+    console.error(`[scheduler] Agent "${agent.name}" failed:`, err.message);
+  }
+}
+
+function scheduleAgent(agent, db) {
+  if (jobs.has(agent.id)) {
+    jobs.get(agent.id).stop();
+    jobs.delete(agent.id);
+  }
+  if (!agent.enabled || agent.triggerType !== "scheduled" || !agent.cronExpression) return;
+  if (!cron.validate(agent.cronExpression)) {
+    console.warn(`[scheduler] Invalid cron "${agent.cronExpression}" for agent ${agent.id}`);
+    return;
+  }
+  const task = cron.schedule(agent.cronExpression, () => runAgent(agent, db));
+  jobs.set(agent.id, task);
+  console.log(`[scheduler] Scheduled agent "${agent.name}" (id=${agent.id}) with cron "${agent.cronExpression}"`);
+}
+
+function unscheduleAgent(agentId) {
+  if (jobs.has(agentId)) {
+    jobs.get(agentId).stop();
+    jobs.delete(agentId);
+    console.log(`[scheduler] Removed job for agent id=${agentId}`);
+  }
+}
+
+async function init(db) {
+  // Mark any runs that were mid-flight when the server last died
+  const orphaned = await db.agentRun.updateMany({
+    where: { status: "running" },
+    data:  { status: "error", error: "Server restarted mid-run", completedAt: new Date() },
+  });
+  if (orphaned.count > 0) console.log(`[scheduler] Marked ${orphaned.count} orphaned run(s) as error.`);
+
+  const agents = await db.agent.findMany({
+    where: { triggerType: "scheduled", enabled: true },
+  });
+  for (const agent of agents) {
+    scheduleAgent(agent, db);
+  }
+  console.log(`[scheduler] Initialized ${agents.length} scheduled agent(s).`);
+}
+
+module.exports = { init, scheduleAgent, unscheduleAgent, runAgent };

package/src/utils/tier.js

@@ -0,0 +1,106 @@
+const TIERS = {
+  starter: {
+    maxConnectors: 10,
+    maxAgentRunsPerMonth: 500,
+    ingestionSpaceGb: 100,
+    bullmq: false, sso: false, customBranding: false, ha: false,
+  },
+  professional: {
+    maxConnectors: 50,
+    maxAgentRunsPerMonth: 5000,
+    ingestionSpaceGb: 1024,
+    bullmq: true, sso: false, customBranding: true, ha: false,
+  },
+  enterprise: {
+    maxConnectors: Infinity,
+    maxAgentRunsPerMonth: Infinity,
+    ingestionSpaceGb: Infinity,
+    bullmq: true, sso: true, customBranding: true, ha: true,
+  },
+};
+
+// Sync fallback (no DB) — used when db is not available
+function getTier() {
+  const name = (process.env.OE_TIER || "starter").toLowerCase();
+  const base = TIERS[name] || TIERS.starter;
+  return { name, ...base };
+}
+
+// Async — checks DB settings first, then env, then defaults
+async function getTierFromDB(db) {
+  if (!db) return getTier();
+
+  try {
+    const rows = await db.setting.findMany({
+      where: { key: { in: ["tier.maxConnectors", "tier.maxAgentRunsPerMonth", "tier.ingestionSpaceGb", "tier.maxWorkspaces", "tier.maxUsers"] } },
+    });
+    const s = {};
+    for (const r of rows) s[r.key] = r.value;
+
+    return {
+      name: "custom",
+      maxConnectors:        s["tier.maxConnectors"]        ? Number(s["tier.maxConnectors"])        : Infinity,
+      maxAgentRunsPerMonth: s["tier.maxAgentRunsPerMonth"] ? Number(s["tier.maxAgentRunsPerMonth"]) : Infinity,
+      ingestionSpaceGb:     s["tier.ingestionSpaceGb"]     ? Number(s["tier.ingestionSpaceGb"])     : Infinity,
+      maxWorkspaces:        s["tier.maxWorkspaces"]        ? Number(s["tier.maxWorkspaces"])        : Infinity,
+      maxUsers:             s["tier.maxUsers"]             ? Number(s["tier.maxUsers"])             : Infinity,
+      bullmq: true, sso: true, customBranding: true, ha: true,
+    };
+  } catch {
+    return getTier();
+  }
+}
+
+async function canAddConnector(currentCount, db) {
+  const tier = await getTierFromDB(db);
+  return currentCount < tier.maxConnectors;
+}
+
+// Returns YYYY-MM string for the current month
+function currentMonthKey() {
+  const now = new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+}
+
+async function getAgentRunsThisMonth(db) {
+  if (!db) return 0;
+  try {
+    const [monthRow, countRow] = await Promise.all([
+      db.setting.findUnique({ where: { key: "usage.agentRuns.month" } }),
+      db.setting.findUnique({ where: { key: "usage.agentRuns.count" } }),
+    ]);
+    if (monthRow?.value !== currentMonthKey()) return 0;
+    return parseInt(countRow?.value || "0");
+  } catch { return 0; }
+}
+
+async function incrementAgentRun(db) {
+  if (!db) return;
+  const month = currentMonthKey();
+  try {
+    const monthRow = await db.setting.findUnique({ where: { key: "usage.agentRuns.month" } });
+    if (monthRow?.value !== month) {
+      // New month — reset
+      await Promise.all([
+        db.setting.upsert({ where: { key: "usage.agentRuns.month" }, create: { key: "usage.agentRuns.month", value: month }, update: { value: month } }),
+        db.setting.upsert({ where: { key: "usage.agentRuns.count" }, create: { key: "usage.agentRuns.count", value: "1" }, update: { value: "1" } }),
+      ]);
+    } else {
+      const current = parseInt((await db.setting.findUnique({ where: { key: "usage.agentRuns.count" } }))?.value || "0");
+      await db.setting.upsert({
+        where:  { key: "usage.agentRuns.count" },
+        create: { key: "usage.agentRuns.count", value: String(current + 1) },
+        update: { value: String(current + 1) },
+      });
+    }
+  } catch { /* non-fatal */ }
+}
+
+async function canRunAgent(db) {
+  const tier = await getTierFromDB(db);
+  if (!isFinite(tier.maxAgentRunsPerMonth)) return true;
+  const used = await getAgentRunsThisMonth(db);
+  return used < tier.maxAgentRunsPerMonth;
+}
+
+module.exports = { getTier, getTierFromDB, canAddConnector, getAgentRunsThisMonth, incrementAgentRun, canRunAgent };

package/src/utils/tools/adapters/_template.js

@@ -0,0 +1,74 @@
+"use strict";
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  Open Enthrium — Connector Adapter Template
+//  Copy this file, rename it to <your-connector>.js, and implement the three
+//  exported functions below.
+//
+//  Steps to contribute a new connector:
+//  1. Copy this file  →  adapters/your-connector.js
+//  2. Add an entry    →  server/src/data/connectionTypes.json
+//     { "id": "your-connector", "label": "Your Connector", "color": "bg-blue-600", "initial": "YC", "cat": "Your Category" }
+//  3. Restart the server — auto-discovery picks up your file immediately.
+//
+//  That's it. No registry edits, no seed script changes required.
+// ══════════════════════════════════════════════════════════════════════════════
+
+// ── Tool definitions (OpenAI format) ─────────────────────────────────────────
+// Return an array of tools this connector exposes to the agent.
+// Each tool becomes a callable function in the agentic loop.
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_your_action`,
+        description: `What this action does on "${connector.name}"`,
+        parameters: {
+          type: "object",
+          properties: {
+            your_param: { type: "string", description: "Describe what this param does" },
+          },
+          required: ["your_param"],
+        },
+      },
+    },
+    // Add more tools here…
+  ];
+}
+
+// ── Tool definitions (Anthropic format) ──────────────────────────────────────
+// Converts OpenAI-style definitions to Anthropic's input_schema format.
+// In most cases you don't need to change this — just keep it as-is.
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name:         t.function.name,
+    description:  t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+// ── Execute ───────────────────────────────────────────────────────────────────
+// Called by the engine when the agent invokes one of your tools.
+//
+// Parameters:
+//   action    — the part after conn_<id>_  (e.g. "your_action")
+//   args      — object of parsed arguments from the agent
+//   connector — connector row from DB: connector.id, connector.name, connector.auth (JSON string)
+//   db        — Prisma client (available if you need to persist anything)
+//
+// Return a string — the engine sends it back to the LLM as the tool result.
+async function executeTool(action, args, connector, db) {
+  const auth = JSON.parse(connector.auth || "{}");
+  // auth contains whatever fields the user configured (apiKey, baseUrl, etc.)
+
+  if (action === "your_action") {
+    // TODO: implement your logic here
+    // const result = await yourApiCall(auth.apiKey, args.your_param);
+    return JSON.stringify({ result: "replace with real implementation" });
+  }
+
+  return `Unknown action: ${action}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/box.js

@@ -0,0 +1,71 @@
+const axios = require("axios");
+
+function auth(connector) { return connector.authConfig ? JSON.parse(connector.authConfig) : {}; }
+function cfg(connector)  { return connector.config    ? JSON.parse(connector.config)    : {}; }
+
+async function getToken(connector, db) {
+  const a = auth(connector);
+  const c = cfg(connector);
+  if (!a.refreshToken) return a.accessToken;
+  if (a.expiresAt && Date.now() < a.expiresAt - 60000) return a.accessToken;
+  const { data } = await axios.post("https://api.box.com/oauth2/token",
+    new URLSearchParams({ grant_type: "refresh_token", refresh_token: a.refreshToken, client_id: c.clientId, client_secret: c.clientSecret }),
+    { headers: { "Content-Type": "application/x-www-form-urlencoded" } });
+  const newAuth = { ...a, accessToken: data.access_token, refreshToken: data.refresh_token || a.refreshToken, expiresAt: Date.now() + data.expires_in * 1000 };
+  if (db) await db.connector.update({ where: { id: connector.id }, data: { authConfig: JSON.stringify(newAuth) } });
+  return data.access_token;
+}
+
+function client(token) {
+  return axios.create({ baseURL: "https://api.box.com/2.0", headers: { Authorization: `Bearer ${token}` } });
+}
+
+const TOOLS = c => [
+  { action: "list_files", desc: `List files/folders in Box via ${c.name}.`,
+    params: { folderId: { type: "string", description: 'Folder ID. Use "0" for root.' } }, required: [] },
+  { action: "read_file",  desc: `Read the text content of a Box file via ${c.name}.`,
+    params: { fileId: { type: "string", description: "Box file ID." } }, required: ["fileId"] },
+  { action: "search",     desc: `Search files in Box via ${c.name}.`,
+    params: { query: { type: "string", description: "Search query." } }, required: ["query"] },
+];
+
+function getToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({ type: "function", function: { name: `conn_${connector.id}_${t.action}`, description: t.desc, parameters: { type: "object", properties: t.params, required: t.required } } }));
+}
+function getAnthropicToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({ name: `conn_${connector.id}_${t.action}`, description: t.desc, input_schema: { type: "object", properties: t.params, required: t.required } }));
+}
+
+async function executeTool(action, args, connector, db) {
+  const token = await getToken(connector, db);
+  const api = client(token);
+  try {
+    if (action === "list_files") {
+      const id = args.folderId || "0";
+      const res = await api.get(`/folders/${id}/items?limit=100`);
+      const entries = res.data.entries || [];
+      return entries.map(e => `${e.type === "folder" ? "📁" : "📄"} ${e.name} (id: ${e.id})`).join("\n") || "Empty folder.";
+    }
+    if (action === "read_file") {
+      const res = await api.get(`/files/${args.fileId}/content`, { responseType: "text" });
+      return String(res.data).slice(0, 8000);
+    }
+    if (action === "search") {
+      const res = await api.get(`/search?query=${encodeURIComponent(args.query)}&limit=20`);
+      const entries = res.data.entries || [];
+      return entries.map(e => `${e.name} (id: ${e.id}, type: ${e.type})`).join("\n") || "No results.";
+    }
+    return `Unknown Box action: ${action}`;
+  } catch (err) { return `Box error: ${err.response?.data?.message || err.message}`; }
+}
+
+async function testConnection(authConfig, config, db, connectorId) {
+  try {
+    const connector = { authConfig: JSON.stringify(authConfig), config: JSON.stringify(config || {}), id: connectorId };
+    const token = await getToken(connector, db);
+    const res = await client(token).get("/users/me");
+    return !!res.data.id;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection, getToken };