@openenthrium/oe-runtime-sdk 1.7.5

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

@@ -0,0 +1,152 @@
+"use strict";
+const axios = require("axios");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_generate_video`,
+        description: `Generate a video from a text prompt or image using "${connector.name}". Returns a job ID or video URL (generation is async — use check_status to poll).`,
+        parameters: {
+          type: "object",
+          properties: {
+            prompt:    { type: "string", description: "Text description of the video to generate" },
+            image_url: { type: "string", description: "Optional: starting image URL for image-to-video generation" },
+            duration:  { type: "number", description: "Video duration in seconds (provider limits apply, typically 4–16s)" },
+            ratio:     { type: "string", description: "Aspect ratio: '16:9', '9:16', or '1:1'" },
+          },
+          required: ["prompt"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_check_status`,
+        description: `Check the status of a video generation job from "${connector.name}". Pass the job_id returned by generate_video.`,
+        parameters: {
+          type: "object",
+          properties: {
+            job_id: { type: "string", description: "Job ID returned by generate_video" },
+          },
+          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;
+
+  // ── Runway ────────────────────────────────────────────────────────────────
+  if (type === "runway") {
+    if (action === "generate_video") {
+      const body = {
+        promptText: args.prompt,
+        model:      "gen4_turbo",
+        ratio:      args.ratio || "1280:720",
+        duration:   args.duration || 5,
+      };
+      if (args.image_url) body.promptImage = args.image_url;
+      const resp = await axios.post(
+        "https://api.dev.runwayml.com/v1/image_to_video",
+        body,
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json", "X-Runway-Version": "2024-11-06" } }
+      );
+      const jobId = resp.data.id;
+      return `Video generation started. Job ID: ${jobId}. Use check_status with this ID to get the video URL (usually ready in 30–90 seconds).`;
+    }
+    if (action === "check_status") {
+      const resp = await axios.get(
+        `https://api.dev.runwayml.com/v1/tasks/${args.job_id}`,
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "X-Runway-Version": "2024-11-06" } }
+      );
+      const task   = resp.data;
+      const status = task.status;
+      if (status === "SUCCEEDED") return `Video ready: ${task.output?.[0] || "URL not available"}`;
+      if (status === "FAILED")    return `Video generation failed: ${task.failure || "Unknown error"}`;
+      return `Status: ${status}. Progress: ${task.progress || 0}%. Check again in a few seconds.`;
+    }
+  }
+
+  // ── Kling (Kuaishou) ──────────────────────────────────────────────────────
+  if (type === "kling") {
+    if (action === "generate_video") {
+      const endpoint = args.image_url
+        ? "https://api.klingai.com/v1/videos/image2video"
+        : "https://api.klingai.com/v1/videos/text2video";
+      const body = {
+        model_name:    "kling-v1",
+        prompt:        args.prompt,
+        duration:      String(args.duration || 5),
+        aspect_ratio:  args.ratio || "16:9",
+      };
+      if (args.image_url) body.image = args.image_url;
+      const resp = await axios.post(endpoint, body, {
+        headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" },
+      });
+      const jobId = resp.data.data?.task_id;
+      return `Video generation started. Task ID: ${jobId}. Use check_status to poll for completion.`;
+    }
+    if (action === "check_status") {
+      const resp = await axios.get(
+        `https://api.klingai.com/v1/videos/text2video/${args.job_id}`,
+        { headers: { Authorization: `Bearer ${creds.apiKey}` } }
+      );
+      const task   = resp.data.data;
+      const status = task?.task_status;
+      if (status === "succeed") return `Video ready: ${task.task_result?.videos?.[0]?.url || "URL not available"}`;
+      if (status === "failed")  return `Video generation failed: ${task.task_status_msg || "Unknown error"}`;
+      return `Status: ${status}. Check again in a few seconds.`;
+    }
+  }
+
+  // ── Pika ──────────────────────────────────────────────────────────────────
+  if (type === "pika") {
+    if (action === "generate_video") {
+      const resp = await axios.post(
+        "https://api.pika.art/v1/generate",
+        {
+          promptText:    args.prompt,
+          image:         args.image_url || null,
+          options: {
+            duration:     args.duration || 3,
+            aspectRatio:  args.ratio    || "16:9",
+            frameRate:    24,
+          },
+        },
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" } }
+      );
+      const jobId = resp.data.id || resp.data.jobId;
+      return `Video generation started. Job ID: ${jobId}. Use check_status to poll for completion.`;
+    }
+    if (action === "check_status") {
+      const resp = await axios.get(
+        `https://api.pika.art/v1/jobs/${args.job_id}`,
+        { headers: { Authorization: `Bearer ${creds.apiKey}` } }
+      );
+      const job    = resp.data;
+      const status = job.status;
+      if (status === "finished" || status === "completed") return `Video ready: ${job.videos?.[0]?.url || job.url || "URL not available"}`;
+      if (status === "failed")                             return `Video generation failed: ${job.error || "Unknown error"}`;
+      return `Status: ${status}. Check again in a few seconds.`;
+    }
+  }
+
+  return `Unsupported action "${action}" for video connector type: ${type}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,111 @@
+const axios = require("axios");
+
+let _id = 1;
+function rpc(url, method, params = []) {
+  return axios.post(url, { jsonrpc: "2.0", id: _id++, method, params }, { timeout: 30000 });
+}
+
+function getConnectorConfig(connector) {
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  return { ...auth, ...cfg };
+}
+
+function getToolDefinitions(connector) {
+  const cfg            = getConnectorConfig(connector);
+  const defaultAddress = cfg.walletAddress || null;
+  const addrHint       = defaultAddress
+    ? ` Defaults to the configured wallet address (${defaultAddress}) if omitted.`
+    : "";
+
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_call`,
+        description: `Call a JSON-RPC / Web3 method on "${connector.name}" (Ethereum, Solana, or any JSON-RPC node).`,
+        parameters: {
+          type: "object",
+          properties: {
+            method: { type: "string", description: "RPC method name, e.g. eth_blockNumber, eth_getBalance, solana getSlot" },
+            params: { type: "array",  description: "Array of parameters for the method", items: {} },
+          },
+          required: ["method"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_get_balance`,
+        description: `Get the native token balance of an address on "${connector.name}".${addrHint}`,
+        parameters: {
+          type: "object",
+          properties: {
+            address: { type: "string", description: `Wallet address.${addrHint}` },
+          },
+          required: [],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_get_block`,
+        description: `Get block information from "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            block: { type: "string", description: "Block number (hex) or 'latest'" },
+          },
+          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 cfg  = getConnectorConfig(connector);
+
+  const rpcUrl        = cfg.baseUrl || cfg.rpcUrl || "";
+  const defaultWallet = cfg.walletAddress || null;
+
+  if (!rpcUrl) return "Web3 RPC URL (baseUrl) not configured.";
+
+  try {
+    if (action === "call") {
+      const res = await rpc(rpcUrl, args.method, args.params || []);
+      if (res.data.error) return `RPC error: ${JSON.stringify(res.data.error)}`;
+      return JSON.stringify(res.data.result, null, 2);
+    }
+    if (action === "get_balance") {
+      const address = args.address || defaultWallet;
+      if (!address) return "No wallet address provided and none configured in the connector (walletAddress).";
+      const res = await rpc(rpcUrl, "eth_getBalance", [address, "latest"]);
+      if (res.data.error) return `RPC error: ${JSON.stringify(res.data.error)}`;
+      const hex = res.data.result;
+      const wei = BigInt(hex);
+      const eth = Number(wei) / 1e18;
+      return `Balance of ${address}: ${hex} wei (${eth.toFixed(6)} ETH)`;
+    }
+    if (action === "get_block") {
+      const res = await rpc(rpcUrl, "eth_getBlockByNumber", [args.block || "latest", false]);
+      if (res.data.error) return `RPC error: ${JSON.stringify(res.data.error)}`;
+      return JSON.stringify(res.data.result, null, 2).slice(0, 4000);
+    }
+    return `Unknown action: ${action}`;
+  } catch (err) {
+    return `Web3 error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,82 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client({ subdomain, email, apiToken }) {
+  return axios.create({
+    baseURL: `https://${subdomain}.zendesk.com/api/v2`,
+    auth: { username: `${email}/token`, password: apiToken },
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "search_tickets", desc: `Search Zendesk tickets via ${c.name}.`,
+    params: { query: { type: "string", description: "Search query (e.g. status:open priority:high)." } }, required: ["query"] },
+  { action: "get_ticket",     desc: `Get a Zendesk ticket by ID via ${c.name}.`,
+    params: { ticketId: { type: "number", description: "Ticket ID." } }, required: ["ticketId"] },
+  { action: "create_ticket",  desc: `Create a Zendesk ticket via ${c.name}.`,
+    params: { subject:        { type: "string", description: "Ticket subject." },
+              comment:        { type: "string", description: "Initial comment / description." },
+              requesterEmail: { type: "string", description: "Requester email address." },
+              priority:       { type: "string", description: "Priority: low, normal, high, urgent." } }, required: ["subject","comment"] },
+];
+
+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.subdomain || !creds.apiToken) return "Zendesk not configured. Please add credentials in Integrations.";
+  const api = client(creds);
+
+  try {
+    if (action === "search_tickets") {
+      const res = await api.get(`/search.json?query=type:ticket ${encodeURIComponent(args.query)}&per_page=15`);
+      const results = res.data.results || [];
+      if (!results.length) return "No tickets found.";
+      return results.map(t => `[#${t.id}] ${t.subject} — Status: ${t.status}, Priority: ${t.priority}`).join("\n");
+    }
+
+    if (action === "get_ticket") {
+      const res = await api.get(`/tickets/${args.ticketId}.json`);
+      const t = res.data.ticket;
+      return JSON.stringify({ id: t.id, subject: t.subject, status: t.status, priority: t.priority, created: t.created_at, description: t.description?.slice(0, 500) }, null, 2);
+    }
+
+    if (action === "create_ticket") {
+      const { subject, comment, requesterEmail, priority = "normal" } = args;
+      const body = { ticket: { subject, comment: { body: comment }, priority } };
+      if (requesterEmail) body.ticket.requester = { email: requesterEmail };
+      const res = await api.post("/tickets.json", body);
+      return `Created ticket #${res.data.ticket.id}: ${subject}`;
+    }
+
+    return `Unknown Zendesk action: ${action}`;
+  } catch (err) {
+    return `Zendesk error: ${err.response?.data?.description || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig).get("/tickets.json?per_page=1");
+    return Array.isArray(res.data.tickets);
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

package/src/utils/tools/adapters/zoho-mail.js

@@ -0,0 +1,246 @@
+const nodemailer = require("nodemailer");
+const { ImapFlow } = require("imapflow");
+
+function getTransport(auth) {
+  const port = parseInt(auth.smtpPort || "465");
+  return nodemailer.createTransport({
+    host:   auth.smtpHost || "smtppro.zoho.in",
+    port,
+    secure: port === 465,
+    auth: {
+      user: auth.email,
+      pass: auth.appPassword,
+    },
+  });
+}
+
+function getImapClient(auth) {
+  return new ImapFlow({
+    host:   auth.imapHost || "imappro.zoho.in",
+    port:   parseInt(auth.imapPort || "993"),
+    secure: true,
+    auth: {
+      user: auth.email,
+      pass: auth.appPassword,
+    },
+    logger: false,
+  });
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_send_email`,
+        description: `Send an outbound email via Zoho Mail (${connector.name}). Use for sales outreach, follow-ups, or notifications.`,
+        parameters: {
+          type: "object",
+          properties: {
+            to:      { type: "string", description: "Recipient email address (or comma-separated list)." },
+            subject: { type: "string", description: "Email subject line." },
+            body:    { type: "string", description: "Email body (plain text or HTML)." },
+            cc:      { type: "string", description: "CC email addresses (optional, comma-separated)." },
+            replyTo: { type: "string", description: "Reply-to email address (optional)." },
+          },
+          required: ["to", "subject", "body"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_search_emails`,
+        description: `Search emails in a Zoho Mail inbox folder. Use to find replies, bounces, or messages from specific senders.`,
+        parameters: {
+          type: "object",
+          properties: {
+            folder:      { type: "string",  description: "Mailbox folder to search. Default: INBOX." },
+            from:        { type: "string",  description: "Filter by sender email address (optional)." },
+            subject:     { type: "string",  description: "Filter by subject keyword (optional)." },
+            since_days:  { type: "number",  description: "Only return emails from the last N days. Default: 7." },
+            limit:       { type: "number",  description: "Max emails to return. Default: 50." },
+          },
+          required: []
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_read_email`,
+        description: `Read the full body of a specific email by its UID.`,
+        parameters: {
+          type: "object",
+          properties: {
+            uid:    { type: "string", description: "Email UID returned from search_emails." },
+            folder: { type: "string", description: "Mailbox folder. Default: INBOX." },
+          },
+          required: ["uid"]
+        }
+      }
+    }
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return [
+    {
+      name: `conn_${connector.id}_send_email`,
+      description: `Send an outbound email via Zoho Mail (${connector.name}). Use for sales outreach, follow-ups, or notifications.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          to:      { type: "string", description: "Recipient email address (or comma-separated list)." },
+          subject: { type: "string", description: "Email subject line." },
+          body:    { type: "string", description: "Email body (plain text or HTML)." },
+          cc:      { type: "string", description: "CC email addresses (optional, comma-separated)." },
+          replyTo: { type: "string", description: "Reply-to email address (optional)." },
+        },
+        required: ["to", "subject", "body"]
+      }
+    },
+    {
+      name: `conn_${connector.id}_search_emails`,
+      description: `Search emails in a Zoho Mail inbox folder. Use to find replies, bounces, or messages from specific senders.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          folder:      { type: "string", description: "Mailbox folder to search. Default: INBOX." },
+          from:        { type: "string", description: "Filter by sender email address (optional)." },
+          subject:     { type: "string", description: "Filter by subject keyword (optional)." },
+          since_days:  { type: "number", description: "Only return emails from the last N days. Default: 7." },
+          limit:       { type: "number", description: "Max emails to return. Default: 50." },
+        },
+        required: []
+      }
+    },
+    {
+      name: `conn_${connector.id}_read_email`,
+      description: `Read the full body of a specific email by its UID.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          uid:    { type: "string", description: "Email UID returned from search_emails." },
+          folder: { type: "string", description: "Mailbox folder. Default: INBOX." },
+        },
+        required: ["uid"]
+      }
+    }
+  ];
+}
+
+async function executeTool(action, args, connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+
+  if (!auth.email || !auth.appPassword) {
+    return "Zoho Mail not configured. Please add your email and app password in the connector settings.";
+  }
+
+  if (action === "send_email") {
+    const { to, subject, body, cc, replyTo } = args;
+    if (!to || !subject || !body) return "Missing required fields: to, subject, body.";
+
+    const isHtml = /<[a-z][\s\S]*>/i.test(body);
+    const mail = {
+      from:    auth.fromName ? `${auth.fromName} <${auth.email}>` : auth.email,
+      to,
+      subject,
+      ...(isHtml ? { html: body } : { text: body }),
+      ...(cc      ? { cc }      : {}),
+      ...(replyTo ? { replyTo } : {}),
+    };
+
+    try {
+      const transport = getTransport(auth);
+      await transport.sendMail(mail);
+      return `Email sent to ${to} with subject "${subject}".`;
+    } catch (err) {
+      return `Zoho Mail error: ${err.message}`;
+    }
+  }
+
+  if (action === "search_emails") {
+    const folder    = args.folder     || "INBOX";
+    const sinceDays = args.since_days || 7;
+    const limit     = args.limit      || 50;
+
+    const since = new Date();
+    since.setDate(since.getDate() - sinceDays);
+
+    const client = getImapClient(auth);
+    try {
+      await client.connect();
+      await client.mailboxOpen(folder);
+
+      const searchCriteria = { since };
+      if (args.from)    searchCriteria.from    = args.from;
+      if (args.subject) searchCriteria.subject = args.subject;
+
+      const messages = [];
+      for await (const msg of client.fetch(searchCriteria, {
+        uid: true, envelope: true, bodyStructure: true, size: true
+      })) {
+        messages.push({
+          uid:     String(msg.uid),
+          from:    msg.envelope.from?.[0]?.address || "",
+          fromName:msg.envelope.from?.[0]?.name    || "",
+          subject: msg.envelope.subject || "(no subject)",
+          date:    msg.envelope.date?.toISOString() || "",
+          size:    msg.size,
+        });
+        if (messages.length >= limit) break;
+      }
+
+      await client.logout();
+      if (messages.length === 0) return `No emails found in ${folder} matching the criteria.`;
+      return JSON.stringify(messages, null, 2);
+    } catch (err) {
+      try { await client.logout(); } catch {}
+      return `IMAP search error: ${err.message}`;
+    }
+  }
+
+  if (action === "read_email") {
+    const folder = args.folder || "INBOX";
+    const uid    = args.uid;
+    if (!uid) return "Missing required field: uid.";
+
+    const client = getImapClient(auth);
+    try {
+      await client.connect();
+      await client.mailboxOpen(folder);
+
+      let result = null;
+      for await (const msg of client.fetch({ uid: parseInt(uid) }, {
+        uid: true, envelope: true, bodyParts: ["TEXT", "1", "1.1", "2"]
+      })) {
+        const parts = msg.bodyParts;
+        let body = "";
+        for (const [, content] of parts) {
+          if (content) body += content.toString("utf8");
+        }
+        result = {
+          uid:     String(msg.uid),
+          from:    msg.envelope.from?.[0]?.address || "",
+          fromName:msg.envelope.from?.[0]?.name    || "",
+          subject: msg.envelope.subject || "(no subject)",
+          date:    msg.envelope.date?.toISOString() || "",
+          body:    body.slice(0, 3000),
+        };
+        break;
+      }
+
+      await client.logout();
+      if (!result) return `Email with UID ${uid} not found.`;
+      return JSON.stringify(result, null, 2);
+    } catch (err) {
+      try { await client.logout(); } catch {}
+      return `IMAP read error: ${err.message}`;
+    }
+  }
+
+  return `Unknown Zoho Mail action: ${action}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };