@openenthrium/oe-runtime-sdk 1.7.5

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

@@ -0,0 +1,107 @@
+"use strict";
+const axios = require("axios");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_extract_text`,
+        description: `Extract text from an image or document using "${connector.name}" OCR.`,
+        parameters: {
+          type: "object",
+          properties: {
+            image_url:   { type: "string", description: "Publicly accessible URL of the image or document to process" },
+            language:    { type: "string", description: "Language hint (e.g. 'en', 'fr', 'de'). Optional." },
+          },
+          required: ["image_url"],
+        },
+      },
+    },
+  ];
+}
+
+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 !== "extract_text") return `Unknown action: ${action}`;
+
+  const imageUrl = args.image_url;
+  if (!imageUrl) return "Error: image_url is required.";
+
+  // ── Azure Computer Vision ─────────────────────────────────────────────────
+  if (type === "azure-vision") {
+    const endpoint = (creds.endpoint || "").replace(/\/$/, "");
+    const resp = await axios.post(
+      `${endpoint}/computervision/imageanalysis:analyze?api-version=2023-02-01-preview&features=read`,
+      { url: imageUrl },
+      { headers: { "Ocp-Apim-Subscription-Key": creds.apiKey, "Content-Type": "application/json" } }
+    );
+    const blocks = resp.data.readResult?.blocks || [];
+    return blocks.flatMap(b => b.lines.map(l => l.text)).join("\n") || "No text found.";
+  }
+
+  // ── Google Cloud Vision ───────────────────────────────────────────────────
+  if (type === "google-vision") {
+    const resp = await axios.post(
+      `https://vision.googleapis.com/v1/images:annotate?key=${creds.apiKey}`,
+      {
+        requests: [{
+          image:    { source: { imageUri: imageUrl } },
+          features: [{ type: "DOCUMENT_TEXT_DETECTION" }],
+        }],
+      }
+    );
+    return resp.data.responses?.[0]?.fullTextAnnotation?.text || "No text found.";
+  }
+
+  // ── AWS Textract ──────────────────────────────────────────────────────────
+  if (type === "aws-textract") {
+    const { AwsClient } = await (async () => {
+      try { return require("aws4"); } catch { return null; }
+    })();
+    // Simplified: use Textract via direct HTTPS with AWS4 signing
+    // For URL-based images, download first then send as bytes — use URL form here
+    const region = creds.region || "us-east-1";
+    const resp   = await axios.post(
+      `https://textract.${region}.amazonaws.com/`,
+      { Document: { S3Object: null, Bytes: null }, FeatureTypes: [] },
+      {
+        headers: {
+          "X-Amz-Target":    "Textract.DetectDocumentText",
+          "Content-Type":    "application/x-amz-json-1.1",
+          "X-Api-Source-Url": imageUrl,
+        },
+      }
+    ).catch(() => null);
+    if (!resp) return "Textract: provide an S3 URL or configure AWS credentials with proper signing.";
+    const blocks = (resp.data.Blocks || []).filter(b => b.BlockType === "LINE");
+    return blocks.map(b => b.Text).join("\n") || "No text found.";
+  }
+
+  // ── Tesseract (self-hosted OCR service) ───────────────────────────────────
+  if (type === "tesseract-ocr") {
+    const baseUrl = (creds.baseUrl || "http://localhost:8884").replace(/\/$/, "");
+    const resp = await axios.post(
+      `${baseUrl}/ocr`,
+      { url: imageUrl, language: args.language || "eng" },
+      { headers: { "Content-Type": "application/json" } }
+    );
+    return resp.data.text || resp.data.result || "No text found.";
+  }
+
+  return `Unsupported OCR connector type: ${type}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,72 @@
+const axios = require("axios");
+
+function cfg(connector) { return connector.config    ? JSON.parse(connector.config)    : {}; }
+function auth(connector) { return connector.authConfig ? JSON.parse(connector.authConfig) : {}; }
+
+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 tenantId = c.tenantId || "common";
+  const { data } = await axios.post(`https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`,
+    new URLSearchParams({ grant_type: "refresh_token", refresh_token: a.refreshToken, client_id: c.clientId, client_secret: c.clientSecret, scope: "Files.Read.All offline_access User.Read" }),
+    { headers: { "Content-Type": "application/x-www-form-urlencoded" } });
+  const newAuth = { ...a, accessToken: data.access_token, expiresAt: Date.now() + data.expires_in * 1000, refreshToken: data.refresh_token || a.refreshToken };
+  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://graph.microsoft.com/v1.0", headers: { Authorization: `Bearer ${token}` } });
+}
+
+const TOOLS = c => [
+  { action: "list_files", desc: `List files/folders in OneDrive via ${c.name}.`,
+    params: { itemId: { type: "string", description: 'Item ID or path. Use "root" for root folder.' } }, required: [] },
+  { action: "read_file",  desc: `Read the text content of a OneDrive file via ${c.name}.`,
+    params: { itemId: { type: "string", description: "OneDrive file item ID." } }, required: ["itemId"] },
+  { action: "search",     desc: `Search files in OneDrive 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.itemId || "root";
+      const res = await api.get(`/me/drive/items/${id}/children?$top=100`);
+      const items = res.data.value || [];
+      return items.map(i => `${i.folder ? "📁" : "📄"} ${i.name} (id: ${i.id})`).join("\n") || "Empty folder.";
+    }
+    if (action === "read_file") {
+      const res = await api.get(`/me/drive/items/${args.itemId}/content`, { responseType: "text" });
+      return String(res.data).slice(0, 8000);
+    }
+    if (action === "search") {
+      const res = await api.get(`/me/drive/root/search(q='${encodeURIComponent(args.query)}')?$top=20`);
+      const items = res.data.value || [];
+      return items.map(i => `${i.name} (id: ${i.id})`).join("\n") || "No results.";
+    }
+    return `Unknown OneDrive action: ${action}`;
+  } catch (err) { return `OneDrive error: ${err.response?.data?.error?.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("/me/drive");
+    return !!res.data.id;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection, getToken, client: (t) => client(t) };

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

@@ -0,0 +1,104 @@
+const Redis = require("ioredis");
+
+function cfg(connector) {
+  return connector.config   ? JSON.parse(connector.config)   : {};
+}
+function auth(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client(connector) {
+  const c = cfg(connector);
+  const a = auth(connector);
+  return new Redis({
+    host:     c.host     || "localhost",
+    port:     parseInt(c.port || "6379"),
+    password: a.password || undefined,
+    db:       parseInt(c.db || "0"),
+    tls:      c.tls ? {} : undefined,
+    lazyConnect: true,
+    connectTimeout: 8000,
+    commandTimeout: 10000,
+  });
+}
+
+const TOOLS = c => [
+  { action: "get",    desc: `Get the value of a key from ${c.name}.`,
+    params: { key: { type: "string", description: "The Redis key." } }, required: ["key"] },
+  { action: "set",    desc: `Set a key-value pair in ${c.name}.`,
+    params: { key: { type: "string" }, value: { type: "string" }, ttl: { type: "number", description: "TTL in seconds (optional)." } }, required: ["key","value"] },
+  { action: "del",    desc: `Delete one or more keys from ${c.name}.`,
+    params: { keys: { type: "array", items: { type: "string" }, description: "Keys to delete." } }, required: ["keys"] },
+  { action: "keys",   desc: `List keys matching a pattern in ${c.name}.`,
+    params: { pattern: { type: "string", description: 'Pattern e.g. "user:*"' } }, required: ["pattern"] },
+  { action: "hgetall",desc: `Get all fields of a hash key from ${c.name}.`,
+    params: { key: { type: "string" } }, required: ["key"] },
+  { action: "lrange", desc: `Get a range of elements from a list in ${c.name}.`,
+    params: { key: { type: "string" }, start: { type: "number", description: "Start index (0)." }, stop: { type: "number", description: "Stop index (-1 for all)." } }, required: ["key"] },
+];
+
+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 r = client(connector);
+  try {
+    await r.connect();
+
+    if (action === "get") {
+      const val = await r.get(args.key);
+      return val === null ? `Key "${args.key}" not found.` : val;
+    }
+    if (action === "set") {
+      if (args.ttl) await r.set(args.key, args.value, "EX", args.ttl);
+      else          await r.set(args.key, args.value);
+      return `OK — set "${args.key}"`;
+    }
+    if (action === "del") {
+      const n = await r.del(...args.keys);
+      return `Deleted ${n} key(s).`;
+    }
+    if (action === "keys") {
+      const keys = await r.keys(args.pattern || "*");
+      return keys.length ? keys.slice(0, 200).join("\n") : "No keys matched.";
+    }
+    if (action === "hgetall") {
+      const hash = await r.hgetall(args.key);
+      return hash && Object.keys(hash).length ? JSON.stringify(hash, null, 2) : `Hash "${args.key}" not found or empty.`;
+    }
+    if (action === "lrange") {
+      const items = await r.lrange(args.key, args.start ?? 0, args.stop ?? -1);
+      return items.length ? JSON.stringify(items, null, 2) : `List "${args.key}" not found or empty.`;
+    }
+    return `Unknown Redis action: ${action}`;
+  } catch (err) {
+    return `Redis error: ${err.message}`;
+  } finally {
+    r.disconnect();
+  }
+}
+
+async function testConnection(authConfig, config) {
+  const connector = { config: JSON.stringify(config || {}), authConfig: JSON.stringify(authConfig || {}) };
+  const r = client(connector);
+  try {
+    await r.connect();
+    await r.ping();
+    return true;
+  } catch { return false; }
+  finally { r.disconnect(); }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

package/src/utils/tools/adapters/rest-api.js

@@ -0,0 +1,119 @@
+"use strict";
+const axios = require("axios");
+const fs    = require("fs");
+const path  = require("path");
+const os    = require("os");
+
+function buildHeaders(creds) {
+  const headers = { "Content-Type": "application/json", Accept: "application/json" };
+  if (creds.bearerToken) headers["Authorization"] = `Bearer ${creds.bearerToken}`;
+  if (creds.apiKey)      headers[creds.headerName || "X-API-Key"] = creds.apiKey;
+  if (creds.username && creds.password)
+    headers["Authorization"] = "Basic " + Buffer.from(`${creds.username}:${creds.password}`).toString("base64");
+  if (creds.headers && typeof creds.headers === "object") Object.assign(headers, creds.headers);
+  return headers;
+}
+
+function buildParams(creds, extra) {
+  const params = { ...(extra || {}) };
+  if (creds.queryParamName && creds.apiKey) params[creds.queryParamName] = creds.apiKey;
+  return params;
+}
+
+function getToolDefinitions(connector) {
+  const desc   = (method) => `Perform an HTTP ${method} request against the "${connector.name}" API.`;
+  const pathP  = { path:   { type: "string",  description: "URL path (e.g. /users or /generate)" } };
+  const qP     = { params: { type: "object",  description: "Query parameters as key-value pairs", additionalProperties: { type: "string" } } };
+  const bodyP  = { body:   { type: "object",  description: "JSON request body", additionalProperties: true } };
+
+  return [
+    { type: "function", function: { name: `conn_${connector.id}_get`,    description: desc("GET"),    parameters: { type: "object", properties: { ...pathP, ...qP },          required: ["path"] } } },
+    { type: "function", function: { name: `conn_${connector.id}_post`,   description: desc("POST"),   parameters: { type: "object", properties: { ...pathP, ...bodyP },        required: ["path", "body"] } } },
+    { type: "function", function: { name: `conn_${connector.id}_put`,    description: desc("PUT"),    parameters: { type: "object", properties: { ...pathP, ...bodyP },        required: ["path", "body"] } } },
+    { type: "function", function: { name: `conn_${connector.id}_patch`,  description: desc("PATCH"),  parameters: { type: "object", properties: { ...pathP, ...bodyP },        required: ["path", "body"] } } },
+    { type: "function", function: { name: `conn_${connector.id}_delete`, description: desc("DELETE"), parameters: { type: "object", properties: { ...pathP, ...qP },          required: ["path"] } } },
+  ];
+}
+
+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 creds = { ...cfg, ...auth };
+
+  const baseUrl = (creds.baseUrl || "").replace(/\/$/, "");
+  if (!baseUrl) return "Connector base URL not configured. Add baseUrl to oe-config.json.";
+
+  const headers = buildHeaders(creds);
+  const params  = buildParams(creds, args.params);
+  const url     = baseUrl + (args.path || "");
+  const opts    = { headers, params, timeout: 300000, responseType: "arraybuffer" };
+
+  try {
+    // Serialize body as URL-encoded form data when Content-Type demands it
+    const isFormEncoded = (headers["Content-Type"] || "").includes("application/x-www-form-urlencoded");
+    const serializeBody = (b) => isFormEncoded ? new URLSearchParams(b || {}).toString() : (b || {});
+
+    let res;
+    if (action === "get")    res = await axios.get(url, opts);
+    if (action === "post")   res = await axios.post(url,  serializeBody(args.body), opts);
+    if (action === "put")    res = await axios.put(url,   serializeBody(args.body), opts);
+    if (action === "patch")  res = await axios.patch(url, serializeBody(args.body), opts);
+    if (action === "delete") res = await axios.delete(url, opts);
+    if (!res) return "Unknown HTTP action.";
+
+    const contentType = (res.headers["content-type"] || "").toLowerCase();
+
+    // Binary response — save audio/video to a temp file and return the path
+    if (
+      contentType.includes("audio/") ||
+      contentType.includes("video/") ||
+      contentType.includes("application/octet-stream")
+    ) {
+      const ext = contentType.includes("audio/mpeg") ? ".mp3"
+                : contentType.includes("audio/wav")  ? ".wav"
+                : contentType.includes("audio/ogg")  ? ".ogg"
+                : contentType.includes("video/mp4")  ? ".mp4"
+                : ".bin";
+      const tmpFile = path.join(os.tmpdir(), `oe-output-${Date.now()}${ext}`);
+      fs.writeFileSync(tmpFile, Buffer.from(res.data));
+      return `Audio/video saved to: ${tmpFile}`;
+    }
+
+    // JSON or text
+    const text = Buffer.from(res.data).toString("utf8");
+    try {
+      const parsed = JSON.parse(text);
+
+      // OpenAI-style image response with b64_json — save each image to a temp file
+      if (Array.isArray(parsed?.data) && parsed.data[0]?.b64_json) {
+        const saved = parsed.data.map((item, i) => {
+          const tmpFile = path.join(os.tmpdir(), `oe-image-${Date.now()}-${i}.png`);
+          fs.writeFileSync(tmpFile, Buffer.from(item.b64_json, "base64"));
+          return { ...item, b64_json: undefined, local_path: tmpFile };
+        });
+        return JSON.stringify({ ...parsed, data: saved }, null, 2).slice(0, 8000);
+      }
+
+      return JSON.stringify(parsed, null, 2).slice(0, 8000);
+    } catch { return text.slice(0, 8000); }
+
+  } catch (err) {
+    if (err.response) {
+      const body = Buffer.isBuffer(err.response.data)
+        ? Buffer.from(err.response.data).toString("utf8").slice(0, 500)
+        : String(err.response.data || "").slice(0, 500);
+      return `API error ${err.response.status}: ${body}`;
+    }
+    return `Request error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,142 @@
+const { S3Client, ListBucketsCommand, ListObjectsV2Command, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } = require("@aws-sdk/client-s3");
+
+function getClient(connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+
+  const accessKeyId     = auth.accessKeyId     || cfg.accessKeyId     || "";
+  const secretAccessKey = auth.secretAccessKey || cfg.secretAccessKey || "";
+  const region          = auth.region          || cfg.region          || "us-east-1";
+  const endpoint        = auth.endpoint        || cfg.endpoint        || auth.baseUrl || cfg.baseUrl || undefined;
+
+  return {
+    client: new S3Client({
+      region,
+      credentials: accessKeyId ? { accessKeyId, secretAccessKey } : undefined,
+      endpoint,
+      forcePathStyle: !!endpoint,
+    }),
+    defaultBucket: auth.bucket || cfg.bucket || "",
+  };
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_buckets`,
+        description: `List all S3 buckets accessible from "${connector.name}".`,
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_objects`,
+        description: `List objects in a bucket on "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            bucket: { type: "string", description: "Bucket name (uses configured default if omitted)" },
+            prefix: { type: "string", description: "Optional key prefix to filter" },
+          },
+          required: [],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_get_object`,
+        description: `Read/download an object from "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            bucket: { type: "string" },
+            key:    { type: "string", description: "Object key" },
+          },
+          required: ["key"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_put_object`,
+        description: `Upload/write an object to "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            bucket:  { type: "string" },
+            key:     { type: "string" },
+            content: { type: "string", description: "Text content to upload" },
+          },
+          required: ["key", "content"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_delete_object`,
+        description: `Delete an object from "${connector.name}".`,
+        parameters: {
+          type: "object",
+          properties: {
+            bucket: { type: "string" },
+            key:    { type: "string" },
+          },
+          required: ["key"],
+        },
+      },
+    },
+  ];
+}
+
+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 { client, defaultBucket } = getClient(connector);
+  const bucket = args.bucket || defaultBucket;
+
+  try {
+    if (action === "list_buckets") {
+      const res = await client.send(new ListBucketsCommand({}));
+      return (res.Buckets || []).map(b => `${b.Name} (created: ${b.CreationDate})`).join("\n") || "No buckets found.";
+    }
+    if (action === "list_objects") {
+      if (!bucket) return "Bucket name required.";
+      const res = await client.send(new ListObjectsV2Command({ Bucket: bucket, Prefix: args.prefix || undefined, MaxKeys: 100 }));
+      return (res.Contents || []).map(o => `${o.Key} (${o.Size} bytes)`).join("\n") || "Empty bucket.";
+    }
+    if (action === "get_object") {
+      if (!bucket) return "Bucket name required.";
+      const res = await client.send(new GetObjectCommand({ Bucket: bucket, Key: args.key }));
+      const chunks = [];
+      for await (const chunk of res.Body) chunks.push(chunk);
+      return Buffer.concat(chunks).toString("utf8").slice(0, 8000);
+    }
+    if (action === "put_object") {
+      if (!bucket) return "Bucket name required.";
+      await client.send(new PutObjectCommand({ Bucket: bucket, Key: args.key, Body: args.content || "" }));
+      return `Uploaded: s3://${bucket}/${args.key}`;
+    }
+    if (action === "delete_object") {
+      if (!bucket) return "Bucket name required.";
+      await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: args.key }));
+      return `Deleted: s3://${bucket}/${args.key}`;
+    }
+    return `Unknown S3 action: ${action}`;
+  } catch (err) {
+    return `S3 error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

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

@@ -0,0 +1,80 @@
+"use strict";
+const axios = require("axios");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_search`,
+        description: `Search the web using "${connector.name}" and return the top results with titles, URLs, and snippets.`,
+        parameters: {
+          type: "object",
+          properties: {
+            query:       { type: "string",  description: "Search query" },
+            num_results: { type: "number",  description: "Number of results to return (default 5, max 10)" },
+          },
+          required: ["query"],
+        },
+      },
+    },
+  ];
+}
+
+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;
+  const query = args.query || "";
+  const num   = Math.min(args.num_results || 5, 10);
+
+  if (action !== "search") return `Unknown action: ${action}`;
+
+  // ── Perplexity ────────────────────────────────────────────────────────────
+  if (type === "perplexity-search") {
+    const resp = await axios.post(
+      "https://api.perplexity.ai/chat/completions",
+      {
+        model:    "sonar",
+        messages: [{ role: "user", content: query }],
+        max_tokens: 1024,
+      },
+      { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" } }
+    );
+    const answer = resp.data.choices?.[0]?.message?.content || "";
+    const citations = (resp.data.citations || []).slice(0, num).map((url, i) => `[${i + 1}] ${url}`).join("\n");
+    return `${answer}\n\nSources:\n${citations}`.trim();
+  }
+
+  // ── Google Custom Search ──────────────────────────────────────────────────
+  if (type === "google-search") {
+    const resp = await axios.get("https://www.googleapis.com/customsearch/v1", {
+      params: { key: creds.apiKey, cx: creds.searchEngineId, q: query, num },
+    });
+    const items = resp.data.items || [];
+    return items.map((r, i) => `${i + 1}. ${r.title}\n   ${r.link}\n   ${r.snippet || ""}`).join("\n\n") || "No results found.";
+  }
+
+  // ── Bing Web Search ───────────────────────────────────────────────────────
+  if (type === "bing-search") {
+    const resp = await axios.get("https://api.bing.microsoft.com/v7.0/search", {
+      params:  { q: query, count: num },
+      headers: { "Ocp-Apim-Subscription-Key": creds.apiKey },
+    });
+    const results = resp.data.webPages?.value || [];
+    return results.map((r, i) => `${i + 1}. ${r.name}\n   ${r.url}\n   ${r.snippet || ""}`).join("\n\n") || "No results found.";
+  }
+
+  return `Unsupported search connector type: ${type}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };