@openenthrium/oe-runtime-sdk 1.7.5

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

@@ -0,0 +1,157 @@
+const { google } = require("googleapis");
+
+async function getGoogleCredentials(db, workspaceId) {
+  let clientId     = process.env.GOOGLE_CLIENT_ID;
+  let clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  if (db && workspaceId) {
+    const rows = await db.setting.findMany({
+      where: { key: { in: [
+        `oauth.google.clientId.ws.${workspaceId}`,
+        `oauth.google.clientSecret.ws.${workspaceId}`,
+      ]}}
+    });
+    for (const r of rows) {
+      if (r.key === `oauth.google.clientId.ws.${workspaceId}`     && r.value) clientId     = r.value;
+      if (r.key === `oauth.google.clientSecret.ws.${workspaceId}` && r.value) clientSecret = r.value;
+    }
+  }
+  return { clientId, clientSecret };
+}
+
+async function makeOAuth2Client(db, workspaceId, callbackPath = "/api/oauth/gmail/callback", overrides = {}) {
+  const { clientId: dbId, clientSecret: dbSecret } = await getGoogleCredentials(db, workspaceId);
+  const clientId     = overrides.clientId     || dbId;
+  const clientSecret = overrides.clientSecret || dbSecret;
+  const callbackBase = process.env.OAUTH_CALLBACK_BASE || "http://localhost:3001";
+  return new google.auth.OAuth2(clientId, clientSecret, `${callbackBase}${callbackPath}`);
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_send_email`,
+        description: `Send an email via the connected Gmail account (${connector.name}). Use when the user asks to email, notify, or send a message.`,
+        parameters: {
+          type: "object",
+          properties: {
+            to:      { type: "string", description: "Recipient email address." },
+            subject: { type: "string", description: "Email subject line." },
+            body:    { type: "string", description: "Plain text email body." },
+          },
+          required: ["to", "subject", "body"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_search_emails`,
+        description: `Search emails in the connected Gmail account (${connector.name}). Use when the user asks to find, look up, or check emails.`,
+        parameters: {
+          type: "object",
+          properties: {
+            query:      { type: "string", description: "Gmail search query (e.g. 'from:someone@gmail.com subject:invoice')" },
+            maxResults: { type: "number", description: "Max emails to return (default 5, max 20)." },
+          },
+          required: ["query"]
+        }
+      }
+    }
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return [
+    {
+      name: `conn_${connector.id}_send_email`,
+      description: `Send an email via the connected Gmail account (${connector.name}).`,
+      input_schema: {
+        type: "object",
+        properties: {
+          to:      { type: "string", description: "Recipient email address." },
+          subject: { type: "string", description: "Email subject line." },
+          body:    { type: "string", description: "Plain text email body." },
+        },
+        required: ["to", "subject", "body"]
+      }
+    },
+    {
+      name: `conn_${connector.id}_search_emails`,
+      description: `Search emails in the connected Gmail account (${connector.name}).`,
+      input_schema: {
+        type: "object",
+        properties: {
+          query:      { type: "string", description: "Gmail search query." },
+          maxResults: { type: "number", description: "Max emails to return (default 5, max 20)." },
+        },
+        required: ["query"]
+      }
+    }
+  ];
+}
+
+async function buildGmailClient(authConfig, db, workspaceId) {
+  const oauth2 = await makeOAuth2Client(db, workspaceId, "/api/oauth/gmail/callback", {
+    clientId:     authConfig.clientId,
+    clientSecret: authConfig.clientSecret,
+  });
+  oauth2.setCredentials({
+    access_token:  authConfig.accessToken,
+    refresh_token: authConfig.refreshToken,
+    expiry_date:   authConfig.expiresAt,
+  });
+  return google.gmail({ version: "v1", auth: oauth2 });
+}
+
+async function executeTool(action, args, connector, db) {
+  const authConfig = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  if (!authConfig.refreshToken) return "Gmail not connected. Please connect via the Integrations tab.";
+
+  try {
+    const gmail = await buildGmailClient(authConfig, db, connector.workspaceId);
+
+    if (action === "send_email") {
+      const { to, subject, body } = args;
+      if (!to || !subject || !body) return "Missing required fields: to, subject, body.";
+
+      const raw = Buffer.from(
+        `To: ${to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body}`
+      ).toString("base64url");
+
+      await gmail.users.messages.send({ userId: "me", requestBody: { raw } });
+      return `Email sent to ${to} with subject "${subject}".`;
+    }
+
+    if (action === "search_emails") {
+      const { query, maxResults = 5 } = args;
+      const safeMax = Math.min(parseInt(maxResults) || 5, 20);
+
+      const list = await gmail.users.messages.list({ userId: "me", q: query, maxResults: safeMax });
+      const messages = list.data.messages || [];
+      if (!messages.length) return `No emails found for query: "${query}"`;
+
+      const details = await Promise.all(
+        messages.map(m =>
+          gmail.users.messages.get({ userId: "me", id: m.id, format: "metadata",
+            metadataHeaders: ["From", "Subject", "Date"] })
+        )
+      );
+
+      const results = details.map(r => {
+        const headers = r.data.payload?.headers || [];
+        const get = name => headers.find(h => h.name === name)?.value || "";
+        return { from: get("From"), subject: get("Subject"), date: get("Date"), snippet: r.data.snippet };
+      });
+
+      return JSON.stringify(results, null, 2);
+    }
+
+    return `Unknown Gmail action: ${action}`;
+  } catch (err) {
+    return `Gmail error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, makeOAuth2Client, getGoogleCredentials };

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

@@ -0,0 +1,73 @@
+const axios = require("axios");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_query`,
+        description: `Run a GraphQL query against "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            query:     { type: "string", description: "GraphQL query string" },
+            variables: { type: "object", description: "Optional variables", additionalProperties: true },
+          },
+          required: ["query"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_mutate`,
+        description: `Run a GraphQL mutation against "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            mutation:  { type: "string", description: "GraphQL mutation string" },
+            variables: { type: "object", description: "Optional variables", additionalProperties: true },
+          },
+          required: ["mutation"],
+        },
+      },
+    },
+  ];
+}
+
+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 cfg  = connector.config    ? JSON.parse(connector.config)    : {};
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+
+  const endpoint = (cfg.baseUrl || auth.baseUrl || "").replace(/\/$/, "");
+  if (!endpoint) return "GraphQL endpoint (baseUrl) not configured.";
+
+  const headers = { "Content-Type": "application/json" };
+  if (auth.bearerToken) headers["Authorization"] = `Bearer ${auth.bearerToken}`;
+  if (auth.apiKey)      headers[auth.headerName || "X-API-Key"] = auth.apiKey;
+  if (auth.headers) {
+    try { Object.assign(headers, typeof auth.headers === "string" ? JSON.parse(auth.headers) : auth.headers); } catch {}
+  }
+
+  const body = action === "query"
+    ? { query: args.query, variables: args.variables || {} }
+    : { query: args.mutation, variables: args.variables || {} };
+
+  try {
+    const res = await axios.post(endpoint, body, { headers, timeout: 30000 });
+    if (res.data.errors) return `GraphQL errors: ${JSON.stringify(res.data.errors, null, 2)}`;
+    return JSON.stringify(res.data.data, null, 2).slice(0, 8000);
+  } catch (err) {
+    return `GraphQL error: ${err.response?.status} ${err.response?.statusText || err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,101 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client({ privateAppToken }) {
+  return axios.create({
+    baseURL: "https://api.hubapi.com",
+    headers: { Authorization: `Bearer ${privateAppToken}`, "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "search_contacts", desc: `Search HubSpot contacts via ${c.name}.`,
+    params: { query: { type: "string", description: "Search query (name, email, company)." } }, required: ["query"] },
+  { action: "get_contact",     desc: `Get a HubSpot contact by ID via ${c.name}.`,
+    params: { contactId: { type: "string", description: "HubSpot contact ID." } }, required: ["contactId"] },
+  { action: "create_contact",  desc: `Create a HubSpot contact via ${c.name}.`,
+    params: { email:     { type: "string", description: "Contact email." },
+              firstName: { type: "string", description: "First name." },
+              lastName:  { type: "string", description: "Last name." },
+              company:   { type: "string", description: "Company name." } }, required: ["email"] },
+  { action: "search_deals",    desc: `Search HubSpot deals via ${c.name}.`,
+    params: { query: { type: "string", description: "Deal name or keyword." } }, 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) {
+  const creds = cfg(connector);
+  if (!creds.privateAppToken) return "HubSpot not configured. Please add credentials in Integrations.";
+  const api = client(creds);
+
+  try {
+    if (action === "search_contacts") {
+      const res = await api.post("/crm/v3/objects/contacts/search", {
+        query: args.query, limit: 10,
+        properties: ["firstname","lastname","email","company","phone"],
+      });
+      const results = res.data.results || [];
+      if (!results.length) return "No contacts found.";
+      return results.map(r => {
+        const p = r.properties;
+        return `[${r.id}] ${p.firstname || ""} ${p.lastname || ""} <${p.email}> — ${p.company || ""}`;
+      }).join("\n");
+    }
+
+    if (action === "get_contact") {
+      const res = await api.get(`/crm/v3/objects/contacts/${args.contactId}?properties=firstname,lastname,email,company,phone,createdate`);
+      return JSON.stringify(res.data.properties, null, 2);
+    }
+
+    if (action === "create_contact") {
+      const { email, firstName = "", lastName = "", company = "" } = args;
+      const res = await api.post("/crm/v3/objects/contacts", {
+        properties: { email, firstname: firstName, lastname: lastName, company },
+      });
+      return `Created contact: ${firstName} ${lastName} <${email}> (ID: ${res.data.id})`;
+    }
+
+    if (action === "search_deals") {
+      const res = await api.post("/crm/v3/objects/deals/search", {
+        query: args.query, limit: 10,
+        properties: ["dealname","amount","dealstage","closedate"],
+      });
+      const results = res.data.results || [];
+      if (!results.length) return "No deals found.";
+      return results.map(r => {
+        const p = r.properties;
+        return `[${r.id}] ${p.dealname} — Stage: ${p.dealstage}, Amount: ${p.amount || "N/A"}`;
+      }).join("\n");
+    }
+
+    return `Unknown HubSpot action: ${action}`;
+  } catch (err) {
+    return `HubSpot error: ${err.response?.data?.message || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig).get("/crm/v3/objects/contacts?limit=1");
+    return Array.isArray(res.data.results);
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

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

@@ -0,0 +1,120 @@
+"use strict";
+const axios = require("axios");
+const fs    = require("fs");
+const os    = require("os");
+const path  = require("path");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_generate_image`,
+        description: `Generate an image from a text prompt using "${connector.name}". Returns the image URL.`,
+        parameters: {
+          type: "object",
+          properties: {
+            prompt:       { type: "string", description: "Detailed description of the image to generate. Include all style, mood, and visual direction here (e.g. minimalist, bold, photorealistic)." },
+            size:         { type: "string", description: "Image size: '1024x1024', '1792x1024', or '1024x1792'" },
+            dalle_style:  { type: "string", description: "OpenAI DALL-E rendering style only: 'vivid' (hyper-real) or 'natural' (realistic). Do NOT use brand style words here — put those in the prompt." },
+            n:            { type: "number", description: "Number of images to generate (default 1, max 4)" },
+          },
+          required: ["prompt"],
+        },
+      },
+    },
+  ];
+}
+
+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;
+
+  if (action !== "generate_image") return `Unknown action: ${action}`;
+
+  const prompt = args.prompt || "";
+  const n      = Math.min(args.n || 1, 4);
+  const size   = args.size  || "1024x1024";
+
+  // ── OpenAI DALL-E / GPT-Image ─────────────────────────────────────────────
+  if (type === "openai-image") {
+    const model      = creds.model || "gpt-image-1";
+    const dalleStyle = ["vivid", "natural"].includes(args.dalle_style) ? args.dalle_style : "vivid";
+    const body = { model, prompt, n: model === "dall-e-3" ? 1 : n, size };
+    let resp;
+    try {
+      resp = await axios.post(
+        "https://api.openai.com/v1/images/generations",
+        body,
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" } }
+      );
+    } catch (err) {
+      const detail = err.response?.data?.error?.message || err.response?.data || err.message;
+      return `OpenAI image error (${err.response?.status}): ${typeof detail === "object" ? JSON.stringify(detail) : detail}`;
+    }
+    const results = [];
+    for (const d of (resp.data.data || [])) {
+      if (d.url) {
+        results.push(`Image URL: ${d.url}`);
+      } else if (d.b64_json) {
+        const outFile = path.join(os.tmpdir(), `oe-image-${Date.now()}.png`);
+        fs.writeFileSync(outFile, Buffer.from(d.b64_json, "base64"));
+        results.push(`Image saved to: ${outFile}`);
+      }
+    }
+    return results.length ? results.join("\n") : "Image generated but no URL or data returned.";
+  }
+
+  // ── FLUX (via Together AI) ────────────────────────────────────────────────
+  if (type === "flux") {
+    const model = creds.model || "black-forest-labs/FLUX.1-schnell-Free";
+    const resp  = await axios.post(
+      "https://api.together.xyz/v1/images/generations",
+      { model, prompt, n, width: 1024, height: 1024, steps: 4 },
+      { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" } }
+    );
+    const urls = (resp.data.data || []).map(d => d.url || d.b64_json);
+    return urls.length === 1 ? `Image generated: ${urls[0]}` : urls.map((u, i) => `Image ${i + 1}: ${u}`).join("\n");
+  }
+
+  // ── Stable Diffusion (Stability AI) ──────────────────────────────────────
+  if (type === "stable-diffusion") {
+    const [w, h] = (size || "1024x1024").split("x").map(Number);
+    const resp   = await axios.post(
+      "https://api.stability.ai/v2beta/stable-image/generate/core",
+      { prompt, output_format: "webp", aspect_ratio: w >= h ? "16:9" : "9:16" },
+      {
+        headers:      { Authorization: `Bearer ${creds.apiKey}`, Accept: "application/json" },
+        responseType: "json",
+      }
+    );
+    const image = resp.data.image;
+    if (!image) return "Stable Diffusion returned no image.";
+    return `Image generated (base64 webp, ${image.length} chars). You can embed it as: data:image/webp;base64,${image.slice(0, 40)}...`;
+  }
+
+  // ── Ideogram ──────────────────────────────────────────────────────────────
+  if (type === "ideogram") {
+    const resp = await axios.post(
+      "https://api.ideogram.ai/generate",
+      { image_request: { prompt, resolution: "RESOLUTION_1024_1024", style_type: args.style || "REALISTIC", num_images: n } },
+      { headers: { "Api-Key": creds.apiKey, "Content-Type": "application/json" } }
+    );
+    const urls = (resp.data.data || []).map(d => d.url);
+    return urls.length === 1 ? `Image generated: ${urls[0]}` : urls.map((u, i) => `Image ${i + 1}: ${u}`).join("\n");
+  }
+
+  return `Unsupported image generation connector type: ${type}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,86 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client({ domain, email, apiToken }) {
+  return axios.create({
+    baseURL: `https://${domain}/rest/api/3`,
+    auth: { username: email, password: apiToken },
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "search_issues", desc: `Search Jira issues via ${c.name} using JQL.`,
+    params: { jql:        { type: "string", description: "JQL query (e.g. project=MYPROJ AND status=Open)" },
+              maxResults: { type: "number", description: "Max results (default 10)." } }, required: ["jql"] },
+  { action: "get_issue",    desc: `Get details of a Jira issue via ${c.name}.`,
+    params: { issueKey: { type: "string", description: "Issue key (e.g. PROJ-123)" } }, required: ["issueKey"] },
+  { action: "create_issue", desc: `Create a Jira issue via ${c.name}.`,
+    params: { project:     { type: "string", description: "Project key (e.g. PROJ)" },
+              summary:     { type: "string", description: "Issue summary/title." },
+              description: { type: "string", description: "Issue description." },
+              issueType:   { type: "string", description: "Issue type (e.g. Bug, Task, Story). Default: Task." } },
+    required: ["project","summary"] },
+];
+
+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.domain || !creds.apiToken) return "Jira not configured. Please add credentials in Integrations.";
+  const api = client(creds);
+
+  try {
+    if (action === "search_issues") {
+      const { jql, maxResults = 10 } = args;
+      const res = await api.get(`/search?jql=${encodeURIComponent(jql)}&maxResults=${Math.min(maxResults, 25)}&fields=summary,status,assignee,priority`);
+      const issues = res.data.issues || [];
+      if (!issues.length) return "No issues found.";
+      return issues.map(i => `${i.key}: ${i.fields.summary} [${i.fields.status?.name}]`).join("\n");
+    }
+
+    if (action === "get_issue") {
+      const res = await api.get(`/issue/${args.issueKey}`);
+      const f = res.data.fields;
+      return JSON.stringify({ key: res.data.key, summary: f.summary, status: f.status?.name, assignee: f.assignee?.displayName, priority: f.priority?.name, description: f.description }, null, 2);
+    }
+
+    if (action === "create_issue") {
+      const { project, summary, description = "", issueType = "Task" } = args;
+      const res = await api.post("/issue", {
+        fields: { project: { key: project }, summary, issuetype: { name: issueType },
+          description: { type: "doc", version: 1, content: [{ type: "paragraph", content: [{ type: "text", text: description }] }] } },
+      });
+      return `Created issue ${res.data.key}: ${summary}`;
+    }
+
+    return `Unknown Jira action: ${action}`;
+  } catch (err) {
+    return `Jira error: ${err.response?.data?.errorMessages?.join(", ") || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig).get("/myself");
+    return !!res.data.accountId;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

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

@@ -0,0 +1,126 @@
+const { Kafka } = require("kafkajs");
+
+function getClient(connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+
+  const brokers  = (auth.brokers || cfg.brokers || auth.baseUrl || cfg.baseUrl || "localhost:9092")
+    .split(",").map(b => b.trim().replace(/^https?:\/\//, ""));
+  const clientId = auth.clientId || cfg.clientId || "open-enthrium";
+
+  const kafkaCfg = { clientId, brokers };
+
+  const username = auth.username || cfg.username;
+  const password = auth.password || cfg.password;
+  if (username && password) {
+    kafkaCfg.ssl  = true;
+    kafkaCfg.sasl = { mechanism: "plain", username, password };
+  }
+
+  return { kafka: new Kafka(kafkaCfg), defaultTopic: auth.topic || cfg.topic || "" };
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_produce`,
+        description: `Publish a message to a Kafka topic on "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            topic:   { type: "string", description: "Topic name" },
+            message: { type: "string", description: "Message value (string or JSON string)" },
+            key:     { type: "string", description: "Optional message key" },
+          },
+          required: ["message"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_consume`,
+        description: `Read recent messages from a Kafka topic on "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            topic: { type: "string", description: "Topic name" },
+            limit: { type: "number", description: "Max messages to read (default 10)" },
+          },
+          required: [],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_topics`,
+        description: `List all topics on the Kafka cluster "${connector.name}".`,
+        parameters: { type: "object", properties: {}, 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 { kafka, defaultTopic } = getClient(connector);
+
+  try {
+    if (action === "produce") {
+      const topic = args.topic || defaultTopic;
+      if (!topic) return "Topic name required.";
+      const producer = kafka.producer();
+      await producer.connect();
+      await producer.send({ topic, messages: [{ key: args.key || null, value: args.message }] });
+      await producer.disconnect();
+      return `Message published to topic "${topic}".`;
+    }
+
+    if (action === "consume") {
+      const topic = args.topic || defaultTopic;
+      if (!topic) return "Topic name required.";
+      const limit  = Math.min(parseInt(args.limit) || 10, 50);
+      const groupId = `oe-consumer-${Date.now()}`;
+      const consumer = kafka.consumer({ groupId });
+      await consumer.connect();
+      await consumer.subscribe({ topic, fromBeginning: false });
+
+      const messages = [];
+      await new Promise((resolve) => {
+        consumer.run({
+          eachMessage: async ({ message }) => {
+            messages.push(`[${message.offset}] ${message.value?.toString()}`);
+            if (messages.length >= limit) resolve();
+          },
+        });
+        setTimeout(resolve, 5000);
+      });
+      await consumer.disconnect();
+      return messages.length ? messages.join("\n") : "No messages received.";
+    }
+
+    if (action === "list_topics") {
+      const admin = kafka.admin();
+      await admin.connect();
+      const topics = await admin.listTopics();
+      await admin.disconnect();
+      return topics.join("\n") || "No topics found.";
+    }
+
+    return `Unknown Kafka action: ${action}`;
+  } catch (err) {
+    return `Kafka error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };