@jskit-ai/connectors-catalog 0.1.63 → 0.1.65

package/src/server/google-slides.js

@@ -1,31 +1,25 @@
-import { createSchema } from "json-rest-schema";
-import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { googleSlidesDefinition } from "../shared/google.js";
-import { googleRead, googleProvider, googleFileVerification, documentId } from "./google.js";
+import { googleOperation, googleBatchRequests, googleRead, googleProvider, googleFileVerification, documentId } from "./google.js";
 const origin = "https://slides.googleapis.com";
 const readScopes = ["presentations.readonly", "presentations", "drive.readonly", "drive.file", "drive"];
-const writable = ["presentations", "drive.file", "drive"].map(scope => `https://www.googleapis.com/auth/${scope}`);
+const writable = ["presentations", "drive.file", "drive"];
 const validPresentation = value => typeof value?.presentationId === "string" && typeof value.title === "string";
 const get = googleRead(readScopes, { presentationId: documentId }, ({ presentationId }) => ({
   url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}`
 }), validPresentation);
 const pageId = { ...documentId, validator: value => /^[a-zA-Z0-9_][a-zA-Z0-9_:-]*$/.test(value) || "Enter a slide object ID, not its URL." };
-const create = createSchema({ title: { type: "string", required: true, minLength: 1, maxLength: 1024 } });
-const batch = createSchema({ presentationId: documentId, requests: { type: "array", required: true }, requiredRevisionId: { type: "string", minLength: 1, maxLength: 1024 } });
 const base = googleProvider(googleSlidesDefinition, origin, "connection.verify", {
   "connection.verify": googleFileVerification(get, "presentationId"),
   "presentations.get": get,
-  "presentations.create": { scopes: writable, validateResult: validPresentation, request(input) {
-    return { method: "POST", url: `${origin}/v1/presentations`, body: validateSchemaPayload({ schema: create, mode: "replace" }, input, { statusCode: 422 }) };
-  } },
-  "presentations.batchUpdate": { scopes: writable,
-    validateResult: value => typeof value?.presentationId === "string" && (value.replies === undefined || Array.isArray(value.replies)),
-    request(input) {
-      const { presentationId, requests, requiredRevisionId } = validateSchemaPayload({ schema: batch, mode: "replace" }, input, { statusCode: 422 });
-      if (!requests.length || requests.length > 100 || Buffer.byteLength(JSON.stringify(requests)) > 1048576 || requests.some(request => !request || typeof request !== "object" || Array.isArray(request) || Object.keys(request).length !== 1 || !/^[a-zA-Z][a-zA-Z0-9]+$/.test(Object.keys(request)[0]) || !Object.values(request)[0] || typeof Object.values(request)[0] !== "object" || Array.isArray(Object.values(request)[0]))) throw Object.assign(new Error("Supply 1–100 native Slides request objects, one operation per object, within 1 MiB."), { statusCode: 422 });
+  "presentations.create": googleOperation(writable, { title: { type: "string", required: true, minLength: 1, maxLength: 1024 } },
+    body => ({ method: "POST", url: `${origin}/v1/presentations`, body }), validPresentation),
+  "presentations.batchUpdate": googleOperation(writable,
+    { presentationId: documentId, requests: { type: "array", required: true }, requiredRevisionId: { type: "string", minLength: 1, maxLength: 1024 } },
+    ({ presentationId, requests, requiredRevisionId }) => {
+      googleBatchRequests(requests, "Slides");
       return { method: "POST", url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, body: { requests, ...(requiredRevisionId ? { writeControl: { requiredRevisionId } } : {}) } };
-    }
-  },
+    },
+    value => typeof value?.presentationId === "string" && (value.replies === undefined || Array.isArray(value.replies))),
   "pages.get": googleRead(readScopes, { presentationId: documentId, pageObjectId: pageId }, ({ presentationId, pageObjectId }) => ({ url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}/pages/${encodeURIComponent(pageObjectId)}` }), value => typeof value?.objectId === "string"),
   "pages.getThumbnail": googleRead(readScopes, { presentationId: documentId, pageObjectId: pageId, size: { type: "string", enum: ["SMALL", "MEDIUM", "LARGE"] } }, ({ presentationId, pageObjectId, size }) => ({ url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}/pages/${encodeURIComponent(pageObjectId)}/thumbnail`, query: { "thumbnailProperties.mimeType": "PNG", "thumbnailProperties.thumbnailSize": size } }), value => {
     if (typeof value?.contentUrl !== "string" || !Number.isFinite(value.width) || !Number.isFinite(value.height) || value.width <= 0 || value.height <= 0) return false;

package/src/server/google.js

@@ -1,5 +1,7 @@
 import { createSchema } from "json-rest-schema";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { validatedOperation } from "./jsonOperation.js";
 
 const oauth = Object.freeze({
   issuer: "https://accounts.google.com",
@@ -10,15 +12,21 @@ const googleScope = (name) => name.startsWith("https:") ? name : `https://www.go
 const documentId = { type: "string", required: true, minLength: 1, maxLength: 1024, validator: (value) => /^[a-zA-Z0-9_-]+$/u.test(value) || "Enter the document ID from its URL." };
 const pageToken = { type: "string", minLength: 1, maxLength: 4096 };
 
+// Request builders report rejected input as the caller's mistake, not a provider outage.
+const inputInvalid = (message, statusCode = 422) => new ConnectorError("connector_input_invalid", message, { statusCode });
+const nativeRequest = request => request && typeof request === "object" && !Array.isArray(request) && Object.keys(request).length === 1 &&
+  /^[a-zA-Z][a-zA-Z0-9]+$/.test(Object.keys(request)[0]) && Boolean(Object.values(request)[0]) &&
+  typeof Object.values(request)[0] === "object" && !Array.isArray(Object.values(request)[0]);
+// Docs, Slides and Sheets batchUpdate share one limit: 1-100 single-operation request objects within 1 MiB.
+function googleBatchRequests(requests, product) {
+  if (!requests.length || requests.length > 100 || Buffer.byteLength(JSON.stringify(requests)) > 1048576 || !requests.every(nativeRequest)) {
+    throw inputInvalid(`Supply 1–100 native ${product} request objects, one operation per object, within 1 MiB.`);
+  }
+  return requests;
+}
+
 function googleOperation(scopes, fields, request, validateResult) {
-  const schema = createSchema(fields);
-  return {
-    scopes: scopes.map(scope => `https://www.googleapis.com/auth/${scope}`),
-    validateResult,
-    request(input) {
-      return request(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
-    }
-  };
+  return validatedOperation(fields, request, validateResult, scopes.map(googleScope));
 }
 
 function googleRead(scopes, fields, destination, validateResult) {
@@ -58,4 +66,4 @@ function googleFileVerification(get, field) {
     validateResult: value => get.validateResult(value) || Array.isArray(value?.files)
   };
 }
-export { googleOperation, googleRead, googleProvider, googleFileVerification, documentId, pageToken };
+export { googleScope, googleOperation, googleBatchRequests, inputInvalid, googleRead, googleProvider, googleFileVerification, documentId, pageToken };

package/src/server/jsonOperation.js

@@ -3,32 +3,31 @@ import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 
 // Providers with custom paths or bodies share input validation, while retaining
 // ownership of their request construction and response checks.
-function validatedOperation(fields, build, validateResult) {
+function validatedOperation(fields, build, validateResult, scopes = []) {
   const schema = createSchema(fields);
   return {
-    scopes: [],
-    request(input) {
-      return build(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+    scopes,
+    request(input, settings = {}, providerData) {
+      return build(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }), settings, providerData);
     },
     validateResult
   };
 }
 
+// Copies validated values into a URL's query string.
+function withQuery(url, values) {
+  const destination = new URL(url);
+  for (const [name, value] of Object.entries(values)) destination.searchParams.set(name, String(value));
+  return destination.href;
+}
+
 // Provider endpoints with either query parameters or a JSON request body.
 function jsonOperation(url, fields, validateResult, method = "GET") {
-  const schema = createSchema(fields);
-  return {
-    scopes: [],
-    request(input, settings = {}) {
-      const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      const endpoint = typeof url === "function" ? url(settings) : url;
-      if (method === "POST") return { method, url: endpoint, body: values };
-      const destination = new URL(endpoint);
-      for (const [name, value] of Object.entries(values)) destination.searchParams.set(name, String(value));
-      return { method, url: destination.href };
-    },
-    validateResult
-  };
+  return validatedOperation(fields, (values, settings) => {
+    const endpoint = typeof url === "function" ? url(settings) : url;
+    if (method === "POST") return { method, url: endpoint, body: values };
+    return { method, url: withQuery(endpoint, values) };
+  }, validateResult);
 }
 
-export { jsonOperation, validatedOperation };
+export { jsonOperation, validatedOperation, withQuery };

package/src/server/lexware.js

@@ -1,7 +1,6 @@
 import { createSchema } from "json-rest-schema";
-import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { lexwareDefinition } from "../shared/tokens.js";
-import { jsonOperation } from "./jsonOperation.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
 
 const id = { type: "string", required: true, validator: value => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) || "Use a Lexware resource UUID." };
 const text = { type: "string", minLength: 1, maxLength: 1000 };
@@ -10,10 +9,6 @@ const paging = { page: { type: "integer", min: 0, max: 100000, defaultTo: 0 }, s
 const pageResult = result => Array.isArray(result?.content) && typeof result.first === "boolean" && typeof result.last === "boolean" &&
   ["totalPages", "totalElements", "numberOfElements", "number"].every(field => Number.isInteger(result[field]) && result[field] >= 0) && Number.isInteger(result.size) && result.size > 0;
 const resourceResult = result => typeof result?.id === "string";
-function operation(fields, build, validateResult = resourceResult) {
-  const schema = createSchema(fields);
-  return { scopes: [], request(input) { return build(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 })); }, validateResult };
-}
 const line = createSchema({
   name: { ...text, required: true }, description: { ...text, maxLength: 5000 },
   quantity: { type: "number", required: true, min: 0.000001, max: 1000000 },
@@ -31,7 +26,7 @@ const lexwareProvider = Object.freeze({
       ...paging, customer: { type: "boolean" }, vendor: { type: "boolean" }
     }, pageResult),
     ...Object.fromEntries(["contacts", "articles", "invoices", "vouchers"].map(resource => [
-      `${resource}.get`, operation({ id }, ({ id }) => ({ method: "GET", url: `https://api.lexware.io/v1/${resource}/${id}` }))
+      `${resource}.get`, validatedOperation({ id }, ({ id }) => ({ method: "GET", url: `https://api.lexware.io/v1/${resource}/${id}` }), resourceResult)
     ])),
     "articles.list": jsonOperation("https://api.lexware.io/v1/articles", {
       ...paging, articleNumber: text, gtin: text, type: { type: "string", enum: ["PRODUCT", "SERVICE"] }
@@ -42,7 +37,7 @@ const lexwareProvider = Object.freeze({
       voucherStatus: { type: "string", required: true, enum: ["any", "draft", "open", "overdue", "paid", "paidoff", "voided", "transferred", "sepadebit", "unchecked"] },
       contactId: { ...id, required: false }, archived: { type: "boolean" }
     }, pageResult),
-    "invoices.createDraft": operation({
+    "invoices.createDraft": validatedOperation({
       contactId: id, voucherDate: date, shippingDate: date,
       shippingType: { type: "string", required: true, enum: ["service", "delivery"] },
       lineItems: { type: "array", required: true, validator: value => value.length > 0 && value.length <= 100 || "Use 1–100 invoice lines.",
@@ -53,7 +48,7 @@ const lexwareProvider = Object.freeze({
       body: { ...other, voucherDate, address: { contactId },
         lineItems: lineItems.map(({ netAmount, taxRatePercentage, ...item }) => ({ ...item, type: "custom", unitPrice: { currency: "EUR", netAmount, taxRatePercentage } })),
         totalPrice: { currency: "EUR" }, taxConditions: { taxType: "net" }, shippingConditions: { shippingDate, shippingType } }
-    }))
+    }), resourceResult)
   }
 });
 export { lexwareProvider };

package/src/server/resend.js

@@ -1,6 +1,7 @@
 import { createSchema } from "json-rest-schema";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
-import { resendDefinition } from "../shared/definitions.js";
+import { resendDefinition } from "../shared/resend.js";
+import { validatedOperation, withQuery } from "./jsonOperation.js";
 
 const pagination = createSchema({
   limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
@@ -32,17 +33,12 @@ const membershipResult = (result) => result?.object === "contact_segment" && typ
 const listResult = (result) => result?.object === "list" && Array.isArray(result.data);
 // Fixed provider routes; the application authorizes each named operation before HTTP.
 function marketingOperation(fields, method, destination, validateResult = hasId, draft = false) {
-  const schema = createSchema(fields);
-  return { scopes: [], request(input) {
-    const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+  return validatedOperation(fields, values => {
     const { id, segmentId, ...body } = values;
-    const url = new URL(`https://api.resend.com/${destination(values)}`);
-    if (method === "GET") {
-      for (const [key, value] of Object.entries(body)) url.searchParams.set(key, String(value));
-      return { method, url: url.href };
-    }
-    return { method, url: url.href, ...(method === "DELETE" ? {} : { body: draft ? { ...body, send: false } : body }) };
-  }, validateResult };
+    const url = `https://api.resend.com/${destination(values)}`;
+    if (method === "GET") return { method, url: withQuery(url, body) };
+    return { method, url: new URL(url).href, ...(method === "DELETE" ? {} : { body: draft ? { ...body, send: false } : body }) };
+  }, validateResult);
 }
 
 const resendProvider = Object.freeze({
@@ -82,9 +78,7 @@ const resendProvider = Object.freeze({
       scopes: [],
       request(input) {
         const query = validateSchemaPayload({ schema: pagination, mode: "replace" }, input, { statusCode: 422 });
-        const url = new URL("https://api.resend.com/domains");
-        for (const [name, value] of Object.entries(query)) url.searchParams.set(name, String(value));
-        return { method: "GET", url: url.href };
+        return { method: "GET", url: withQuery("https://api.resend.com/domains", query) };
       },
       validateResult: (result) => result?.object === "list" && Array.isArray(result.data) && typeof result.has_more === "boolean"
     }

package/src/server/semrush.js

@@ -60,6 +60,8 @@ function semrushKeywordReport(target, kind) {
   };
 }
 
+const trackingObject = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value) && value.error === undefined);
+
 function semrushTrackingReport(type, positions = false) {
   const operation = jsonOperation("https://api.semrush.com/", {
     campaignId: { type: "string", required: true, pattern: /^\d+(?:_\d+)?$/u, maxLength: 80 },
@@ -72,7 +74,14 @@ function semrushTrackingReport(type, positions = false) {
       display_filter: { type: "string", minLength: 1, maxLength: 4000 }
     } : {})
   });
-  return { scopes: [], request(input, settings) {
+  return { scopes: [], validateResult(value, request) {
+    const url = new URL(request.url);
+    return trackingObject(value) && value.data !== null && typeof value.data === "object" && /^(0|[1-9]\d*)$/u.test(String(value.total)) &&
+      (type === "tracking_campaign_dates" ? Object.values(value.data).every((entry) => /^\d{8}$/u.test(String(entry?.Dt))) :
+        String(value.limit) === url.searchParams.get("display_limit") && String(value.offset) === url.searchParams.get("display_offset") &&
+        Object.values(value.data).length <= Number(url.searchParams.get("display_limit")) &&
+        Object.values(value.data).every((entry) => typeof entry?.Ph === "string" && typeof entry.Pi === "string" && entry.Dt !== null && typeof entry.Dt === "object"));
+  }, request(input, settings) {
     if (!settings.v3ApiKeyRef) throw new ConnectorError("connector_binding_missing", "Configure the Semrush V3 key for position tracking.");
     const result = operation.request(input);
     const url = new URL(result.url);
@@ -118,6 +127,32 @@ function validProject(project) {
     Array.isArray(project.tools) && project.tools.every((tool) => typeof tool?.name === "string" && tool.name.length > 0);
 }
 
+// Every V4 answer carries a successful envelope; each operation then checks it answered its own request.
+function v4Result(check, status = 200) {
+  return (value, request) => value?.meta?.success === true && value.meta.status_code === status &&
+    typeof value.meta.request_id === "string" && value.meta.request_id.length > 0 && value.error === undefined &&
+    Boolean(check(value, new URL(request.url), request));
+}
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+// Backlink reports keep the requested scope and, when Semrush supplies them, the requested page bounds.
+function backlinkResult(report) {
+  return v4Result((value, url) => {
+    const { meta, data } = value;
+    if (meta.scope !== undefined && meta.scope !== url.searchParams.get("scope")) return false;
+    if (report === "overview") return ["backlinks_count", "domains_count", "urls_count", "score"].every((field) => count(data?.[field]));
+    // Some report envelopes omit pagination metadata; validate it when supplied.
+    return Array.isArray(data) && data.length <= Number(url.searchParams.get("limit")) && data.every((row) => {
+      if (!row || typeof row !== "object" || Array.isArray(row)) return false;
+      if (report === "links") return typeof row.source_url === "string" && typeof row.target_url === "string" &&
+        typeof row.anchor === "string" && typeof row.is_nofollow === "boolean";
+      if (report === "ref-domains") return typeof row.domain === "string" && count(row.backlinks_count) && count(row.domain_score);
+      return typeof row.anchor === "string" && count(row.backlinks_count) && count(row.domains_count);
+    }) && ["limit", "offset"].every((field) => meta[field] === undefined || String(meta[field]) === url.searchParams.get(field)) &&
+      (meta.total === undefined || count(meta.total));
+  });
+}
+const requestedProject = (url) => Number(url.pathname.split("/").at(-1));
+
 const semrushProvider = Object.freeze({
   ...semrushDefinition, apiOrigins: ["https://api.semrush.com"],
   apiKey: { headers: (key) => {
@@ -128,7 +163,11 @@ const semrushProvider = Object.freeze({
   } },
   checkOperation: "projects.list",
   operations: {
-    "tracking.campaigns": { scopes: [], request(input, settings) {
+    "tracking.campaigns": { scopes: [], validateResult: (value, request) => trackingObject(value) &&
+      String(value.project_id) === new URL(request.url).pathname.split("/")[4] && Array.isArray(value.campaigns) &&
+      value.campaigns.every((campaign) => typeof campaign?.id === "string" && /^\d+(?:_\d+)?$/u.test(campaign.id) &&
+        typeof campaign.url === "string" && typeof campaign.device === "string" && typeof campaign.isGathering === "boolean"),
+    request(input, settings) {
       const { projectId } = validateSchemaPayload({ schema: projectSchema, mode: "replace" }, input, { statusCode: 422 });
       if (!settings.v3ApiKeyRef) throw new ConnectorError("connector_binding_missing", "Configure the Semrush V3 key for campaign discovery.");
       return { method: "GET", url: `https://api.semrush.com/management/v1/projects/${projectId}/tracking/campaigns` };
@@ -159,10 +198,10 @@ const semrushProvider = Object.freeze({
         return { ...result, url: url.href };
       }
     },
-    "backlinks.overview": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/overview", backlinkTarget),
-    "backlinks.list": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/links", backlinkPage),
-    "backlinks.referringDomains": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/ref-domains", backlinkPage),
-    "backlinks.anchors": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/anchors", backlinkPage),
+    "backlinks.overview": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/overview", backlinkTarget, backlinkResult("overview")),
+    "backlinks.list": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/links", backlinkPage, backlinkResult("links")),
+    "backlinks.referringDomains": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/ref-domains", backlinkPage, backlinkResult("ref-domains")),
+    "backlinks.anchors": jsonOperation("https://api.semrush.com/apis/v4/backlinks/v1/anchors", backlinkPage, backlinkResult("anchors")),
     "keywords.metrics": {
       scopes: [],
       request(input) {
@@ -179,39 +218,57 @@ const semrushProvider = Object.freeze({
         }
         url.searchParams.set("format", "json");
         return { ...result, url: url.href };
-      }
+      },
+      validateResult: v4Result(({ meta, data }, url) => meta.keyword === url.searchParams.get("keyword") && meta.country === url.searchParams.get("country") &&
+        typeof meta.month === "string" && /^\d{4}-(0[1-9]|1[0-2])$/u.test(meta.month) &&
+        (!url.searchParams.has("month") || meta.month === url.searchParams.get("month")) &&
+        data !== null && typeof data === "object" && !Array.isArray(data) &&
+        ["cpc", "number_of_results", "search_volume"].every((key) => typeof data[key] === "string" && /^\d+$/u.test(data[key])) &&
+        ["competitive_density", "keyword_difficulty"].every((key) => Number.isFinite(data[key])) &&
+        ["intents", "serp_features"].every((key) => Array.isArray(data[key]) && data[key].every((value) => typeof value === "string")) &&
+        Array.isArray(data.trends) && data.trends.every(Number.isFinite))
     },
     "projects.create": jsonOperation(projectsUrl, {
       domain: { type: "string", required: true, minLength: 1, maxLength: 253, pattern: /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/iu },
       project_name: projectName
-    }, undefined, "POST"),
+    }, v4Result(({ data }, url, request) => validProject(data) && data.project_name === request.body.project_name &&
+      data.domain.toLowerCase() === request.body.domain.toLowerCase(), 201), "POST"),
     "projects.update": {
       scopes: [],
       request(input) {
         const { projectId, project_name } = validateSchemaPayload({ schema: renameSchema, mode: "replace" }, input, { statusCode: 422 });
         return { method: "PATCH", url: `${projectsUrl}/${projectId}`, body: { project_name } };
-      }
+      },
+      validateResult: v4Result(({ data }, url, request) => validProject(data) && data.project_id === requestedProject(url) &&
+        data.project_name === request.body.project_name)
     },
     "projects.list": jsonOperation(projectsUrl, {
       scope: { type: "string", enum: ["OWN", "ALL", "SHARED", "CORPORATE"], defaultTo: "OWN" },
       limit: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
       offset: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER, defaultTo: 0 }
-    }),
+    }, v4Result(({ meta, data }, url) => {
+      const limit = Number(url.searchParams.get("limit"));
+      return meta.scope === url.searchParams.get("scope") && meta.limit === limit && meta.offset === Number(url.searchParams.get("offset")) &&
+        count(meta.total_count) && Array.isArray(data) && data.length <= limit && data.length <= meta.total_count && data.every(validProject);
+    })),
     "projects.delete": {
       scopes: [],
       request(input) {
         const { projectId } = validateSchemaPayload({ schema: projectSchema, mode: "replace" }, input, { statusCode: 422 });
         return { method: "DELETE", url: `${projectsUrl}/${projectId}` };
-      }
+      },
+      validateResult: v4Result(({ data }, url) => Number.isSafeInteger(data?.project_id) && data.project_id === requestedProject(url))
     },
     "projects.get": {
       scopes: [],
       request(input) {
         const { projectId } = validateSchemaPayload({ schema: projectSchema, mode: "replace" }, input, { statusCode: 422 });
         return { method: "GET", url: `${projectsUrl}/${projectId}` };
-      }
+      },
+      validateResult: v4Result(({ data }, url) => validProject(data) && data.project_id === requestedProject(url))
     }
   },
+  // V3 reports need their own key and CSV/JSON decoding; V4 maps Semrush's error envelope. Operations validate results.
   async exchange(address, options, { request, fetchImpl, settings, resolveReference }) {
     const path = new URL(address).pathname;
     if (path === "/" || path.startsWith("/management/v1/projects/") || path.startsWith("/reports/v1/projects/")) {
@@ -238,28 +295,9 @@ const semrushProvider = Object.freeze({
       }
       if (text.length > 2_000_000) throw new ConnectorError("connector_response_invalid", "Semrush returned an oversized V3 report.", { statusCode: 502 });
       if (path !== "/") {
-        let result;
-        try { result = JSON.parse(text); } catch {
+        try { return JSON.parse(text); } catch {
           throw new ConnectorError("connector_response_invalid", "Semrush returned invalid tracking JSON.", { statusCode: 502 });
         }
-        let valid = result && typeof result === "object" && !Array.isArray(result) && result.error === undefined;
-        if (path.endsWith("/campaigns")) {
-          valid &&= String(result.project_id) === path.split("/")[4] && Array.isArray(result.campaigns) &&
-            result.campaigns.every((campaign) => typeof campaign?.id === "string" && /^\d+(?:_\d+)?$/u.test(campaign.id) &&
-              typeof campaign.url === "string" && typeof campaign.device === "string" && typeof campaign.isGathering === "boolean");
-        } else {
-          valid &&= result.data !== null && typeof result.data === "object" &&
-            /^(0|[1-9]\d*)$/u.test(String(result.total));
-          if (url.searchParams.get("type") === "tracking_campaign_dates") {
-            valid &&= Object.values(result.data).every((entry) => /^\d{8}$/u.test(String(entry?.Dt)));
-          } else {
-            valid &&= String(result.limit) === url.searchParams.get("display_limit") && String(result.offset) === url.searchParams.get("display_offset") &&
-              Object.values(result.data).length <= Number(url.searchParams.get("display_limit")) &&
-              Object.values(result.data).every((entry) => typeof entry?.Ph === "string" && typeof entry.Pi === "string" && entry.Dt !== null && typeof entry.Dt === "object");
-          }
-        }
-        if (!valid) throw new ConnectorError("connector_response_invalid", "Semrush returned unexpected tracking data.", { statusCode: 502 });
-        return result;
       }
       const columns = url.searchParams.get("type") === "domain_rank" ? domainColumns : keywordColumns;
       const rowLimit = columns === domainColumns ? 1 : Number(url.searchParams.get("display_limit")) - Number(url.searchParams.get("display_offset"));
@@ -296,63 +334,6 @@ const semrushProvider = Object.freeze({
       }
       throw new ConnectorError("connector_provider_failed", "Semrush could not complete this request.", { statusCode: 502 });
     }
-    const url = new URL(address);
-    const meta = result?.meta;
-    const creating = options.method === "POST" && url.pathname === "/apis/v4/projects/v1/projects";
-    let valid = meta?.success === true && meta.status_code === (creating ? 201 : 200) &&
-      typeof meta.request_id === "string" && meta.request_id.length > 0 && result.error === undefined;
-    if (url.pathname === "/apis/v4/keywords/v1/metrics") {
-      const data = result?.data;
-      valid &&= meta.keyword === url.searchParams.get("keyword") && meta.country === url.searchParams.get("country") &&
-        typeof meta.month === "string" && /^\d{4}-(0[1-9]|1[0-2])$/u.test(meta.month) &&
-        (!url.searchParams.has("month") || meta.month === url.searchParams.get("month")) &&
-        data !== null && typeof data === "object" && !Array.isArray(data) &&
-        ["cpc", "number_of_results", "search_volume"].every((key) => typeof data[key] === "string" && /^\d+$/u.test(data[key])) &&
-        ["competitive_density", "keyword_difficulty"].every((key) => Number.isFinite(data[key])) &&
-        ["intents", "serp_features"].every((key) => Array.isArray(data[key]) && data[key].every((value) => typeof value === "string")) &&
-        Array.isArray(data.trends) && data.trends.every(Number.isFinite);
-    } else if (url.pathname.startsWith("/apis/v4/backlinks/v1/")) {
-      const report = url.pathname.split("/").at(-1);
-      const count = (value) => Number.isSafeInteger(value) && value >= 0;
-      if (report === "overview") {
-        valid &&= ["backlinks_count", "domains_count", "urls_count", "score"].every((field) => count(result.data?.[field]));
-      } else {
-        valid &&= Array.isArray(result.data) && result.data.length <= Number(url.searchParams.get("limit")) &&
-          result.data.every((row) => {
-            if (!row || typeof row !== "object" || Array.isArray(row)) return false;
-            if (report === "links") return typeof row.source_url === "string" && typeof row.target_url === "string" &&
-              typeof row.anchor === "string" && typeof row.is_nofollow === "boolean";
-            if (report === "ref-domains") return typeof row.domain === "string" && count(row.backlinks_count) && count(row.domain_score);
-            return typeof row.anchor === "string" && count(row.backlinks_count) && count(row.domains_count);
-          });
-        // Some report envelopes omit pagination metadata; validate it when supplied.
-        for (const field of ["limit", "offset"]) {
-          if (meta?.[field] !== undefined) valid &&= String(meta[field]) === url.searchParams.get(field);
-        }
-        if (meta?.total !== undefined) valid &&= count(meta.total);
-      }
-      if (meta?.scope !== undefined) valid &&= meta.scope === url.searchParams.get("scope");
-    } else if (creating) {
-      const submitted = options.body;
-      valid &&= validProject(result.data) && result.data.project_name === submitted.project_name &&
-        result.data.domain.toLowerCase() === submitted.domain.toLowerCase();
-    } else if (url.pathname === "/apis/v4/projects/v1/projects") {
-      const limit = Number(url.searchParams.get("limit"));
-      valid &&= meta.scope === url.searchParams.get("scope") && meta.limit === limit &&
-        meta.offset === Number(url.searchParams.get("offset")) &&
-        Number.isSafeInteger(meta.total_count) && meta.total_count >= 0 &&
-        Array.isArray(result.data) && result.data.length <= limit && result.data.length <= meta.total_count &&
-        result.data.every(validProject);
-    } else if (options.method === "DELETE") {
-      valid &&= Number.isSafeInteger(result.data?.project_id) &&
-        result.data.project_id === Number(url.pathname.split("/").at(-1));
-    } else {
-      valid &&= validProject(result.data) && result.data.project_id === Number(url.pathname.split("/").at(-1));
-      if (options.method === "PATCH") valid &&= result.data.project_name === options.body.project_name;
-    }
-    if (!valid) {
-      throw new ConnectorError("connector_response_invalid", "Semrush returned unexpected report or project data.", { statusCode: 502 });
-    }
     return result;
   }
 });