@openenthrium/oe-runtime-sdk 1.7.5

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

@@ -0,0 +1,118 @@
+const { Client } = require("ldapts");
+
+function getConfig(connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+  return {
+    url:          auth.url          || cfg.url          || auth.baseUrl || cfg.baseUrl || "ldap://localhost:389",
+    bindDN:       auth.bindDN       || cfg.bindDN       || "",
+    bindPassword: auth.bindPassword || cfg.bindPassword || auth.password || cfg.password || "",
+    baseDN:       auth.baseDN       || cfg.baseDN       || "",
+  };
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_search`,
+        description: `Search the LDAP/Active Directory "${connector.name}" for users, groups, or objects.`,
+        parameters: {
+          type: "object",
+          properties: {
+            filter: { type: "string", description: "LDAP filter, e.g. (objectClass=person) or (mail=user@example.com)" },
+            base:   { type: "string", description: "Search base DN (uses configured baseDN if omitted)" },
+            attributes: { type: "array", items: { type: "string" }, description: "Attributes to return (default: all)" },
+          },
+          required: ["filter"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_get_user`,
+        description: `Look up a specific user in "${connector.name}" by username or email.`,
+        parameters: {
+          type: "object",
+          properties: {
+            username: { type: "string", description: "sAMAccountName, uid, or email" },
+          },
+          required: ["username"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_groups`,
+        description: `List all groups in the LDAP directory "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            base: { type: "string", description: "Base DN to search (optional)" },
+          },
+          required: [],
+        },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const config = getConfig(connector);
+  if (!config.url) return "LDAP URL not configured.";
+
+  const client = new Client({ url: config.url, tlsOptions: { rejectUnauthorized: false } });
+
+  try {
+    if (config.bindDN) await client.bind(config.bindDN, config.bindPassword);
+
+    if (action === "search") {
+      const { searchEntries } = await client.search(args.base || config.baseDN, {
+        filter: args.filter,
+        attributes: args.attributes || ["*"],
+        scope: "sub",
+        sizeLimit: 100,
+      });
+      return JSON.stringify(searchEntries, null, 2).slice(0, 8000);
+    }
+
+    if (action === "get_user") {
+      const filter = args.username.includes("@")
+        ? `(mail=${args.username})`
+        : `(|(sAMAccountName=${args.username})(uid=${args.username}))`;
+      const { searchEntries } = await client.search(config.baseDN, { filter, scope: "sub", sizeLimit: 5 });
+      return searchEntries.length
+        ? JSON.stringify(searchEntries[0], null, 2).slice(0, 4000)
+        : "User not found.";
+    }
+
+    if (action === "list_groups") {
+      const { searchEntries } = await client.search(args.base || config.baseDN, {
+        filter: "(objectClass=group)",
+        attributes: ["cn", "description", "member"],
+        scope: "sub",
+        sizeLimit: 200,
+      });
+      return searchEntries.map(g => g.cn).join("\n") || "No groups found.";
+    }
+
+    return `Unknown LDAP action: ${action}`;
+  } catch (err) {
+    return `LDAP error: ${err.message}`;
+  } finally {
+    await client.unbind().catch(() => {});
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/mcp-client.js

@@ -0,0 +1,138 @@
+const { Client }     = require("@modelcontextprotocol/sdk/client/index.js");
+const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
+const { SSEClientTransport }   = require("@modelcontextprotocol/sdk/client/sse.js");
+const axios = require("axios");
+
+function getConfig(connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+  return {
+    sseUrl:  auth.baseUrl  || cfg.baseUrl  || auth.sseUrl  || cfg.sseUrl  || "",
+    command: auth.command  || cfg.command  || "",
+    args:    auth.args     || cfg.args     || [],
+    bearerToken: auth.bearerToken || cfg.bearerToken || "",
+  };
+}
+
+async function withMcpClient(config, fn) {
+  const client = new Client({ name: "open-enthrium", version: "1.0.0" }, { capabilities: {} });
+
+  let transport;
+  if (config.sseUrl) {
+    const headers = config.bearerToken ? { Authorization: `Bearer ${config.bearerToken}` } : {};
+    transport = new SSEClientTransport(new URL(config.sseUrl), { requestInit: { headers } });
+  } else if (config.command) {
+    transport = new StdioClientTransport({ command: config.command, args: config.args });
+  } else {
+    throw new Error("MCP connector requires either sseUrl or command.");
+  }
+
+  await client.connect(transport);
+  try {
+    return await fn(client);
+  } finally {
+    await client.close().catch(() => {});
+  }
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_tools`,
+        description: `List all tools available on the MCP server "${connector.name}".`,
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_call_tool`,
+        description: `Call a specific tool on the MCP server "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            tool:      { type: "string", description: "Tool name to call" },
+            arguments: { type: "object", description: "Arguments to pass to the tool", additionalProperties: true },
+          },
+          required: ["tool"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_resources`,
+        description: `List resources exposed by the MCP server "${connector.name}".`,
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_read_resource`,
+        description: `Read a resource from the MCP server "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            uri: { type: "string", description: "Resource URI" },
+          },
+          required: ["uri"],
+        },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const config = getConfig(connector);
+
+  try {
+    if (action === "list_tools") {
+      return await withMcpClient(config, async client => {
+        const { tools } = await client.listTools();
+        return tools.map(t => `${t.name}: ${t.description || ""}`).join("\n") || "No tools found.";
+      });
+    }
+
+    if (action === "call_tool") {
+      if (!args.tool) return "Tool name required.";
+      return await withMcpClient(config, async client => {
+        const result = await client.callTool({ name: args.tool, arguments: args.arguments || {} });
+        const content = result.content || [];
+        return content.map(c => c.text || JSON.stringify(c)).join("\n").slice(0, 8000);
+      });
+    }
+
+    if (action === "list_resources") {
+      return await withMcpClient(config, async client => {
+        const { resources } = await client.listResources();
+        return resources.map(r => `${r.uri} — ${r.name || ""}`).join("\n") || "No resources found.";
+      });
+    }
+
+    if (action === "read_resource") {
+      if (!args.uri) return "Resource URI required.";
+      return await withMcpClient(config, async client => {
+        const result = await client.readResource({ uri: args.uri });
+        const content = result.contents || [];
+        return content.map(c => c.text || JSON.stringify(c)).join("\n").slice(0, 8000);
+      });
+    }
+
+    return `Unknown MCP action: ${action}`;
+  } catch (err) {
+    return `MCP error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,119 @@
+const { MongoClient } = require("mongodb");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_find`,
+        description: `Search documents in the "${connector.name}" MongoDB database. Use for filtering, retrieving, and looking up records.`,
+        parameters: {
+          type: "object",
+          properties: {
+            collection: { type: "string",  description: "Collection name to query." },
+            filter:     { type: "object",  description: "MongoDB filter (e.g. {\"status\": \"active\"}). Use {} for all." },
+            projection: { type: "object",  description: "Fields to include/exclude (optional)." },
+            limit:      { type: "number",  description: "Max results to return (default 20, max 100)." },
+          },
+          required: ["collection", "filter"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_aggregate`,
+        description: `Run a MongoDB aggregation pipeline on the "${connector.name}" database. Use for grouping, counting, summing, or analytics.`,
+        parameters: {
+          type: "object",
+          properties: {
+            collection: { type: "string", description: "Collection name." },
+            pipeline:   { type: "array",  description: "Aggregation pipeline stages (e.g. [{\"$group\": {\"_id\": \"$status\", \"count\": {\"$sum\": 1}}}])." },
+          },
+          required: ["collection", "pipeline"]
+        }
+      }
+    }
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return [
+    {
+      name: `conn_${connector.id}_find`,
+      description: `Search documents in the "${connector.name}" MongoDB database.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          collection: { type: "string",  description: "Collection name to query." },
+          filter:     { type: "object",  description: "MongoDB filter document." },
+          projection: { type: "object",  description: "Fields to include/exclude (optional)." },
+          limit:      { type: "number",  description: "Max results (default 20, max 100)." },
+        },
+        required: ["collection", "filter"]
+      }
+    },
+    {
+      name: `conn_${connector.id}_aggregate`,
+      description: `Run a MongoDB aggregation pipeline on the "${connector.name}" database.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          collection: { type: "string", description: "Collection name." },
+          pipeline:   { type: "array",  description: "Aggregation pipeline stages." },
+        },
+        required: ["collection", "pipeline"]
+      }
+    }
+  ];
+}
+
+function buildUri(cfg, auth) {
+  if (cfg.uri) return cfg.uri;
+  const creds = auth.username ? `${encodeURIComponent(auth.username)}:${encodeURIComponent(auth.password || "")}@` : "";
+  const host  = cfg.host || "localhost";
+  const port  = cfg.port || "27017";
+  const db    = cfg.database ? `/${cfg.database}` : "";
+  return `mongodb://${creds}${host}:${port}${db}`;
+}
+
+async function executeTool(action, args, connector) {
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const uri  = buildUri(cfg, auth);
+
+  const client = new MongoClient(uri, { serverSelectionTimeoutMS: 10000, connectTimeoutMS: 10000 });
+  try {
+    await client.connect();
+    const db = client.db(cfg.database || undefined);
+
+    if (action === "find") {
+      const { collection, filter = {}, projection, limit = 20 } = args;
+      if (!collection) return "Collection name required.";
+      const safeLimit = Math.min(parseInt(limit) || 20, 100);
+      const opts = projection ? { projection } : {};
+      const docs = await db.collection(collection).find(filter, opts).limit(safeLimit).toArray();
+      if (!docs.length) return "No documents found.";
+      return JSON.stringify(docs, null, 2);
+    }
+
+    if (action === "aggregate") {
+      const { collection, pipeline = [] } = args;
+      if (!collection) return "Collection name required.";
+      if (!Array.isArray(pipeline)) return "Pipeline must be an array.";
+      const hasLimit = pipeline.some(s => "$limit" in s);
+      const safePipeline = hasLimit ? pipeline : [...pipeline, { $limit: 100 }];
+      const docs = await db.collection(collection).aggregate(safePipeline).toArray();
+      if (!docs.length) return "Aggregation returned no results.";
+      return JSON.stringify(docs, null, 2);
+    }
+
+    return `Unknown MongoDB action: ${action}`;
+  } catch (err) {
+    return `MongoDB error: ${err.message}`;
+  } finally {
+    await client.close().catch(() => {});
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, buildUri };

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

@@ -0,0 +1,106 @@
+const mqtt = require("mqtt");
+
+function getConfig(connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+  return {
+    brokerUrl: auth.brokerUrl || cfg.brokerUrl || auth.baseUrl || cfg.baseUrl || "mqtt://localhost:1883",
+    username:  auth.username  || cfg.username  || undefined,
+    password:  auth.password  || cfg.password  || undefined,
+    clientId:  auth.clientId  || cfg.clientId  || `oe-${Date.now()}`,
+  };
+}
+
+function connect(config) {
+  return new Promise((resolve, reject) => {
+    const client = mqtt.connect(config.brokerUrl, {
+      clientId: config.clientId,
+      username: config.username,
+      password: config.password,
+      connectTimeout: 10000,
+    });
+    client.on("connect", () => resolve(client));
+    client.on("error", reject);
+  });
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_publish`,
+        description: `Publish a message to an MQTT topic on "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            topic:   { type: "string", description: "MQTT topic" },
+            message: { type: "string", description: "Message payload" },
+            qos:     { type: "number", description: "QoS level (0, 1, or 2). Default 0." },
+          },
+          required: ["topic", "message"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_subscribe`,
+        description: `Subscribe to an MQTT topic and read recent messages from "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            topic:   { type: "string", description: "MQTT topic or wildcard (e.g. sensors/#)" },
+            timeout: { type: "number", description: "Seconds to listen (default 5, max 30)" },
+          },
+          required: ["topic"],
+        },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const config = getConfig(connector);
+
+  try {
+    if (action === "publish") {
+      const client = await connect(config);
+      await new Promise((res, rej) =>
+        client.publish(args.topic, args.message, { qos: args.qos || 0 }, err => err ? rej(err) : res())
+      );
+      client.end();
+      return `Published to "${args.topic}".`;
+    }
+
+    if (action === "subscribe") {
+      const client  = await connect(config);
+      const timeout = Math.min(parseInt(args.timeout) || 5, 30) * 1000;
+      const messages = [];
+
+      await new Promise((resolve) => {
+        client.subscribe(args.topic, { qos: 1 });
+        client.on("message", (topic, payload) => {
+          messages.push(`[${topic}] ${payload.toString()}`);
+        });
+        setTimeout(resolve, timeout);
+      });
+      client.end();
+      return messages.length ? messages.join("\n") : "No messages received within timeout.";
+    }
+
+    return `Unknown MQTT action: ${action}`;
+  } catch (err) {
+    return `MQTT error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/music-gen.js

@@ -0,0 +1,118 @@
+"use strict";
+const axios = require("axios");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_generate_music`,
+        description: `Generate music or audio from a text prompt using "${connector.name}". Returns audio URLs (generation may be async).`,
+        parameters: {
+          type: "object",
+          properties: {
+            prompt:      { type: "string",  description: "Description of the music to generate (genre, mood, instruments, tempo, etc.)" },
+            duration:    { type: "number",  description: "Duration in seconds (default 30, max 240)" },
+            title:       { type: "string",  description: "Optional song title" },
+            instrumental:{ type: "boolean", description: "If true, generate instrumental music without vocals" },
+          },
+          required: ["prompt"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_check_status`,
+        description: `Check the status of a music generation job. Pass the job_id returned by generate_music.`,
+        parameters: {
+          type: "object",
+          properties: {
+            job_id: { type: "string", description: "Job ID returned by generate_music" },
+          },
+          required: ["job_id"],
+        },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name:         t.function.name,
+    description:  t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const auth  = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg   = connector.config     ? JSON.parse(connector.config)     : {};
+  const creds = { ...cfg, ...auth };
+  const type  = connector.type;
+
+  // ── Suno ──────────────────────────────────────────────────────────────────
+  if (type === "suno") {
+    if (action === "generate_music") {
+      const resp = await axios.post(
+        "https://studio-api.suno.ai/api/external/generate/",
+        {
+          prompt:        args.prompt,
+          tags:          args.prompt,
+          title:         args.title || "Generated Track",
+          make_instrumental: args.instrumental || false,
+          wait_audio:    false,
+        },
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" } }
+      );
+      const clips = resp.data || [];
+      if (Array.isArray(clips) && clips.length) {
+        const ids = clips.map(c => c.id).join(", ");
+        return `Music generation started. Clip IDs: ${ids}. Use check_status with any ID to get the audio URL.`;
+      }
+      return `Music generation started. Response: ${JSON.stringify(resp.data).slice(0, 200)}`;
+    }
+    if (action === "check_status") {
+      const resp = await axios.get(
+        `https://studio-api.suno.ai/api/external/clips/?ids=${args.job_id}`,
+        { headers: { Authorization: `Bearer ${creds.apiKey}` } }
+      );
+      const clip = (resp.data?.clips || resp.data)?.[0];
+      if (!clip) return "Clip not found.";
+      if (clip.status === "complete") return `Music ready:\n  Title: ${clip.title}\n  URL: ${clip.audio_url}\n  Duration: ${clip.duration}s`;
+      return `Status: ${clip.status}. Check again in a few seconds.`;
+    }
+  }
+
+  // ── Udio ──────────────────────────────────────────────────────────────────
+  if (type === "udio") {
+    if (action === "generate_music") {
+      const resp = await axios.post(
+        "https://www.udio.com/api/generate-proxy",
+        {
+          prompt:     args.prompt,
+          samplerOptions: { seed: -1 },
+        },
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" } }
+      );
+      const trackIds = (resp.data?.track_ids || []).join(", ");
+      return trackIds
+        ? `Music generation started. Track IDs: ${trackIds}. Use check_status to get the audio URL.`
+        : `Music generation started. Response: ${JSON.stringify(resp.data).slice(0, 200)}`;
+    }
+    if (action === "check_status") {
+      const resp = await axios.get(
+        `https://www.udio.com/api/songs?songIds=${args.job_id}`,
+        { headers: { Authorization: `Bearer ${creds.apiKey}` } }
+      );
+      const song = (resp.data?.songs || [])[0];
+      if (!song) return "Song not found.";
+      if (song.finished) return `Music ready:\n  Title: ${song.title || "Track"}\n  URL: ${song.song_path}`;
+      return `Status: generating. Check again in a few seconds.`;
+    }
+  }
+
+  return `Unsupported action "${action}" for music connector type: ${type}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,93 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client({ integrationToken }) {
+  return axios.create({
+    baseURL: "https://api.notion.com/v1",
+    headers: { Authorization: `Bearer ${integrationToken}`, "Notion-Version": "2022-06-28", "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "search",      desc: `Search Notion pages and databases via ${c.name}.`,
+    params: { query: { type: "string", description: "Search query." } }, required: ["query"] },
+  { action: "get_page",    desc: `Get content of a Notion page via ${c.name}.`,
+    params: { pageId: { type: "string", description: "Notion page ID." } }, required: ["pageId"] },
+  { action: "create_page", desc: `Create a new Notion page via ${c.name}.`,
+    params: { parentId: { type: "string", description: "Parent page ID to create the page under." },
+              title:    { type: "string", description: "Page title." },
+              content:  { type: "string", description: "Page content (plain text)." } }, required: ["parentId","title"] },
+];
+
+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) {
+  const creds = cfg(connector);
+  if (!creds.integrationToken) return "Notion not configured. Please add credentials in Integrations.";
+  const api = client(creds);
+
+  try {
+    if (action === "search") {
+      const res = await api.post("/search", { query: args.query, page_size: 10 });
+      const results = res.data.results || [];
+      if (!results.length) return "No results found.";
+      return results.map(r => {
+        const title = r.properties?.title?.title?.[0]?.plain_text || r.properties?.Name?.title?.[0]?.plain_text || "(untitled)";
+        return `[${r.id}] ${title} (${r.object})`;
+      }).join("\n");
+    }
+
+    if (action === "get_page") {
+      const [page, blocks] = await Promise.all([
+        api.get(`/pages/${args.pageId}`),
+        api.get(`/blocks/${args.pageId}/children?page_size=50`),
+      ]);
+      const title = Object.values(page.data.properties || {}).find(p => p.type === "title")?.title?.[0]?.plain_text || "(untitled)";
+      const content = (blocks.data.results || []).map(b => {
+        const type = b.type;
+        return b[type]?.rich_text?.map(t => t.plain_text).join("") || "";
+      }).filter(Boolean).join("\n");
+      return `Title: ${title}\n\n${content.slice(0, 3000)}`;
+    }
+
+    if (action === "create_page") {
+      const { parentId, title, content = "" } = args;
+      const res = await api.post("/pages", {
+        parent: { page_id: parentId },
+        properties: { title: { title: [{ type: "text", text: { content: title } }] } },
+        children: content ? [{ object: "block", type: "paragraph",
+          paragraph: { rich_text: [{ type: "text", text: { content: content.slice(0, 2000) } }] } }] : [],
+      });
+      return `Created Notion page: ${title} (ID: ${res.data.id})`;
+    }
+
+    return `Unknown Notion action: ${action}`;
+  } catch (err) {
+    return `Notion error: ${err.response?.data?.message || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig).post("/search", { page_size: 1 });
+    return Array.isArray(res.data.results);
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };