@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/linkfox/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, providerInputError, providerResponseError, } from "../provider-runtime.js";
 import { chuhaijiangOperations } from "./chuhaijiang-actions.js";
 import { normalizeChuhaijiang, searchChuhaijiangImage } from "./chuhaijiang-runtime.js";
 import { mercadoOperations } from "./mercado-actions.js";
@@ -317,7 +317,7 @@ export async function executeLinkfoxAction(actionName, input, apiKey, fetcher, p
     }
     const handler = customHandlers[actionName];
     if (!handler) {
-        throw providerError("invalid_input", `unknown linkfox action: ${actionName}`, 400);
+        throw providerInputError(`unknown linkfox action: ${actionName}`);
     }
     return handler(input, { apiKey, fetcher, signal: parentSignal });
 }
@@ -326,70 +326,70 @@ function validateSifInput(actionName, input) {
         const periodType = optionalString(input.timePieceType) ?? "latelyDay";
         const periodValue = optionalString(input.timePieceValue);
         if ((periodType === "month" || periodType === "week") && !periodValue) {
-            throw new ProviderRequestError(400, "timePieceValue is required for month or week periods");
+            throw providerInputError("timePieceValue is required for month or week periods");
         }
     }
     const startDate = optionalString(input.startDate);
     const endDate = optionalString(input.endDate);
     if ((startDate && !endDate) || (!startDate && endDate)) {
-        throw new ProviderRequestError(400, "startDate and endDate must be provided together");
+        throw providerInputError("startDate and endDate must be provided together");
     }
     if ((startDate || endDate) && input.last7d !== false) {
-        throw new ProviderRequestError(400, "last7d must be false when a date range is provided");
+        throw providerInputError("last7d must be false when a date range is provided");
     }
     if (startDate && endDate && startDate > endDate) {
-        throw new ProviderRequestError(400, "startDate must not be later than endDate");
+        throw providerInputError("startDate must not be later than endDate");
     }
     if (actionName === "get_sif_asin_traffic_summary") {
         const asins = optionalString(input.asins);
         if (asins && asins.split(",").length > 10) {
-            throw new ProviderRequestError(400, "asins must contain at most 10 comma-separated ASINs");
+            throw providerInputError("asins must contain at most 10 comma-separated ASINs");
         }
     }
 }
 function validateLinkfoxActionInput(actionName, input) {
     if (actionName === "search_amazon_by_image" && input.deliveryZip && input.countryOrAreaCode) {
-        throw new ProviderRequestError(400, "deliveryZip and countryOrAreaCode cannot be used together");
+        throw providerInputError("deliveryZip and countryOrAreaCode cannot be used together");
     }
     if (actionName === "search_amazon_opportunities") {
         const meaningful = Object.keys(input).some((key) => key !== "amazonDomain" && key !== "limit" && input[key] !== undefined);
         if (!meaningful)
-            throw new ProviderRequestError(400, "Provide keyword, nicheName, or at least one opportunity metric filter");
+            throw providerInputError("Provide keyword, nicheName, or at least one opportunity metric filter");
     }
     if (actionName === "search_1688_products" && !input.keyWord && !input.goodsUrl && !input.productIds) {
-        throw new ProviderRequestError(400, "Provide keyWord, goodsUrl, or productIds");
+        throw providerInputError("Provide keyWord, goodsUrl, or productIds");
     }
     if (actionName === "search_1688_by_image" && !input.imageUrl && !input.imageId) {
-        throw new ProviderRequestError(400, "Provide imageUrl or imageId");
+        throw providerInputError("Provide imageUrl or imageId");
     }
     if (actionName === "get_echotik_products")
         validateIdentifierLists(input, "productIds", "productUrls");
     if (actionName === "get_echotik_videos")
         validateIdentifierLists(input, "videoIds", "videoUrls");
     if (actionName === "search_amazon_store_orders" && Boolean(input.createdAfter) === Boolean(input.lastUpdatedAfter)) {
-        throw new ProviderRequestError(400, "Provide exactly one of createdAfter or lastUpdatedAfter");
+        throw providerInputError("Provide exactly one of createdAfter or lastUpdatedAfter");
     }
     if (actionName === "get_amazon_store_report" &&
         !input.reportId &&
         (!input.reportType || !Array.isArray(input.marketplaceIds) || input.marketplaceIds.length === 0)) {
-        throw new ProviderRequestError(400, "Provide reportId, or provide reportType and marketplaceIds to create a report");
+        throw providerInputError("Provide reportId, or provide reportType and marketplaceIds to create a report");
     }
     if (actionName === "get_amazon_ads_report" && !input.reportId) {
         for (const field of ["reportTypeId", "adProduct", "groupBy", "columns", "startDate", "endDate"]) {
             const value = input[field];
             if (value === undefined || (Array.isArray(value) && value.length === 0)) {
-                throw new ProviderRequestError(400, `${field} is required when reportId is not provided`);
+                throw providerInputError(`${field} is required when reportId is not provided`);
             }
         }
     }
     if (actionName === "search_ozon_products" && !input.keyword && !input.productIds) {
-        throw new ProviderRequestError(400, "Provide keyword or productIds");
+        throw providerInputError("Provide keyword or productIds");
     }
     if (Array.isArray(input.filters)) {
         for (const filter of input.filters) {
             const record = optionalRecord(filter);
             if (record?.op === "BETWEEN" && record.value2 === undefined) {
-                throw new ProviderRequestError(400, "value2 is required when op is BETWEEN");
+                throw providerInputError("value2 is required when op is BETWEEN");
             }
         }
     }
@@ -404,22 +404,22 @@ function validateLinkfoxActionInput(actionName, input) {
     ].includes(actionName) &&
         typeof input.pageSize === "number" &&
         input.pageSize % 10 !== 0) {
-        throw new ProviderRequestError(400, "pageSize must be a multiple of 10");
+        throw providerInputError("pageSize must be a multiple of 10");
     }
 }
 function validateIdentifierLists(input, idsField, urlsField) {
     const ids = Array.isArray(input[idsField]) ? input[idsField] : [];
     const urls = Array.isArray(input[urlsField]) ? input[urlsField] : [];
     if (ids.length === 0 && urls.length === 0)
-        throw new ProviderRequestError(400, `${idsField} or ${urlsField} is required`);
+        throw providerInputError(`${idsField} or ${urlsField} is required`);
     if (new Set([...ids, ...urls]).size > 1000) {
-        throw new ProviderRequestError(400, `The combined ${idsField} and ${urlsField} count cannot exceed 1000`);
+        throw providerInputError(`The combined ${idsField} and ${urlsField} count cannot exceed 1000`);
     }
 }
 function validateTikTokProductInput(value) {
     const productInput = optionalString(value);
     if (!productInput)
-        throw new ProviderRequestError(400, "productInput is required");
+        throw providerInputError("productInput is required");
     if (isNineteenDigitId(productInput))
         return;
     try {
@@ -437,7 +437,7 @@ function validateTikTokProductInput(value) {
     catch {
         // Return the input error below for both invalid cases.
     }
-    throw new ProviderRequestError(400, "productInput must be a 19-digit product ID or supported TikTok product URL");
+    throw providerInputError("productInput must be a 19-digit product ID or supported TikTok product URL");
 }
 function isNineteenDigitId(value) {
     return value.length === 19 && [...value].every((character) => "0" <= character && character <= "9");
@@ -479,31 +479,31 @@ async function readJsonPayload(response) {
         if (!response.ok) {
             return text;
         }
-        throw providerError("provider_error", "LinkFox returned invalid JSON", 502);
+        throw providerResponseError("LinkFox returned invalid JSON");
     }
 }
 function createLinkfoxError(httpStatus, businessCode, payload, phase) {
     const code = businessCode ?? httpStatus;
     const message = readErrorMessage(payload) ?? `LinkFox request failed with code ${code}`;
     if (businessCode === 401) {
-        return providerError(phase === "validate" ? "invalid_input" : "credential_expired", message, phase === "validate" ? 400 : 401);
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
     }
     if (httpStatus === 401 || httpStatus === 403 || businessCode === 403) {
-        return providerError("provider_error", message, httpStatus >= 400 ? httpStatus : 403);
+        return new ProviderRequestError(httpStatus >= 400 ? httpStatus : 403, message);
     }
     if (code === 402 || httpStatus === 402) {
-        return providerError("invalid_input", message || "LinkFox credits are insufficient", 402);
+        return new ProviderRequestError(402, message || "LinkFox credits are insufficient");
     }
     if (code === 429 || httpStatus === 429 || code === 1003) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (code === 501 && message.toLowerCase().includes("kalodata api http 5")) {
-        return providerError("provider_error", message, 502);
+        return providerResponseError(message);
     }
     if ((httpStatus >= 400 && httpStatus < 500) || [400, 403, 404, 422, 501, 1002, 1004, 1005].includes(code)) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
-    return providerError("provider_error", message, httpStatus >= 500 ? httpStatus : 502);
+    return new ProviderRequestError(httpStatus >= 500 ? httpStatus : 502, message);
 }
 function readBusinessCode(payload) {
     const record = optionalRecord(payload);
@@ -655,7 +655,7 @@ function normalizeOpportunityReport(payload) {
     const record = requireRecord(payload, "LinkFox returned an invalid opportunity report response");
     const report = readString(record.stdout);
     if (!report) {
-        throw providerError("provider_error", "LinkFox opportunity report did not include stdout", 502);
+        throw providerResponseError("LinkFox opportunity report did not include stdout");
     }
     return {
         report,
@@ -667,7 +667,7 @@ function normalizeAuthorizationUrl(payload) {
     const record = requireRecord(payload, "LinkFox returned an invalid authorization response");
     const authorizeUrl = readString(record.authorizeUrl);
     if (!authorizeUrl) {
-        throw providerError("provider_error", "LinkFox response did not include authorizeUrl", 502);
+        throw providerResponseError("LinkFox response did not include authorizeUrl");
     }
     return { authorizeUrl };
 }
@@ -832,7 +832,7 @@ async function executeStoreReport(input, context) {
         }, context);
         reportId = readString(readDeveloperProxyBody(created).reportId);
         if (!reportId) {
-            throw providerError("provider_error", "Amazon report creation did not return reportId", 502);
+            throw providerResponseError("Amazon report creation did not return reportId");
         }
     }
     const maxAttempts = readInteger(input.maxAttempts) ?? 20;
@@ -855,7 +855,7 @@ async function executeStoreReport(input, context) {
         if (status === "DONE") {
             const documentId = readString(statusBody.reportDocumentId);
             if (!documentId) {
-                throw providerError("provider_error", "Completed Amazon report did not include reportDocumentId", 502);
+                throw providerResponseError("Completed Amazon report did not include reportDocumentId");
             }
             const documentPayload = await callDeveloperProxy("/spApi/developerProxy", {
                 region: input.region,
@@ -866,7 +866,7 @@ async function executeStoreReport(input, context) {
             const document = readDeveloperProxyBody(documentPayload);
             const downloadUrl = readString(document.url);
             if (!downloadUrl) {
-                throw providerError("provider_error", "Amazon report document did not include url", 502);
+                throw providerResponseError("Amazon report document did not include url");
             }
             return {
                 reportId,
@@ -877,10 +877,10 @@ async function executeStoreReport(input, context) {
             };
         }
         if (["FATAL", "CANCELLED"].includes(status)) {
-            throw providerError("provider_error", `Amazon report generation ended with ${status}`, 502);
+            throw providerResponseError(`Amazon report generation ended with ${status}`);
         }
         if (!["IN_QUEUE", "IN_PROGRESS"].includes(status)) {
-            throw providerError("provider_error", `Amazon report returned unknown status ${status}`, 502);
+            throw providerResponseError(`Amazon report returned unknown status ${status}`);
         }
         if (attempt < maxAttempts && Date.now() + pollIntervalSeconds * 1000 < pollDeadline) {
             await waitSeconds(pollIntervalSeconds);
@@ -966,7 +966,7 @@ async function executeAdsReport(input, context) {
             reportId = readString(readDeveloperProxyBody(created).reportId);
         }
         if (!reportId) {
-            throw providerError("provider_error", "Amazon Ads report creation did not return reportId", 502);
+            throw providerResponseError("Amazon Ads report creation did not return reportId");
         }
     }
     const maxAttempts = readInteger(input.maxAttempts) ?? 20;
@@ -989,7 +989,7 @@ async function executeAdsReport(input, context) {
         if (["COMPLETED", "SUCCESS"].includes(status)) {
             const downloadUrl = readString(statusBody.url);
             if (!downloadUrl) {
-                throw providerError("provider_error", "Completed Amazon Ads report did not include url", 502);
+                throw providerResponseError("Completed Amazon Ads report did not include url");
             }
             return {
                 reportId,
@@ -1001,10 +1001,10 @@ async function executeAdsReport(input, context) {
         }
         if (["FAILURE", "FAILED", "CANCELLED"].includes(status)) {
             const reason = readString(statusBody.failureReason);
-            throw providerError("provider_error", reason ? `Amazon Ads report failed: ${reason}` : `Amazon Ads report ended with ${status}`, 502);
+            throw providerResponseError(reason ? `Amazon Ads report failed: ${reason}` : `Amazon Ads report ended with ${status}`);
         }
         if (!["PENDING", "PROCESSING", "IN_QUEUE", "IN_PROGRESS"].includes(status)) {
-            throw providerError("provider_error", `Amazon Ads report returned unknown status ${status}`, 502);
+            throw providerResponseError(`Amazon Ads report returned unknown status ${status}`);
         }
         if (attempt < maxAttempts && Date.now() + pollIntervalSeconds * 1000 < pollDeadline) {
             await waitSeconds(pollIntervalSeconds);
@@ -1028,7 +1028,7 @@ async function callDeveloperProxy(path, body, context) {
 function readDeveloperProxyBody(payload) {
     const httpStatus = readInteger(payload.httpStatus);
     if (httpStatus === null) {
-        throw providerError("provider_error", "LinkFox developer proxy omitted httpStatus", 502);
+        throw providerResponseError("LinkFox developer proxy omitted httpStatus");
     }
     const body = parseNestedJson(payload.body);
     if (httpStatus >= 200 && httpStatus < 300) {
@@ -1036,18 +1036,18 @@ function readDeveloperProxyBody(payload) {
     }
     const message = readErrorMessage(body) ?? `Amazon upstream request failed with status ${httpStatus}`;
     if (httpStatus === 401) {
-        throw providerError("credential_expired", message, 401);
+        throw new ProviderRequestError(401, message);
     }
     if (httpStatus === 403) {
-        throw providerError("scope_missing", message, 403);
+        throw new ProviderRequestError(403, message);
     }
     if (httpStatus === 429) {
-        throw providerError("rate_limited", message, 429);
+        throw new ProviderRequestError(429, message);
     }
     if (httpStatus >= 400 && httpStatus < 500) {
-        throw providerError("invalid_input", message, 400);
+        throw providerInputError(message);
     }
-    throw providerError("provider_error", message, httpStatus);
+    throw new ProviderRequestError(httpStatus, message);
 }
 function parseNestedJson(value) {
     if (typeof value !== "string") {
@@ -1060,7 +1060,7 @@ function parseNestedJson(value) {
         return JSON.parse(value);
     }
     catch {
-        throw providerError("provider_error", "LinkFox developer proxy returned invalid JSON", 502);
+        throw providerResponseError("LinkFox developer proxy returned invalid JSON");
     }
 }
 function readDuplicateReportId(value) {
@@ -1097,7 +1097,7 @@ function appendQuery(query, name, value) {
 function requireRecord(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw providerError("provider_error", message, 502);
+        throw providerResponseError(message);
     }
     return record;
 }
@@ -1129,6 +1129,3 @@ function waitSeconds(seconds) {
         setTimeout(resolve, seconds * 1000);
     });
 }
-function providerError(_code, message, status) {
-    return new ProviderRequestError(status, message);
-}

package/src/providers/listinggood/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const listinggoodActions: ActionDefinition[];

package/src/providers/listinggood/actions.js

@@ -0,0 +1,95 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "listinggood";
+const lang = s.stringEnum("Report language. Defaults to en.", ["en", "zh"]);
+const result = s.requiredObject("The ListingGood response.", {
+    result: s.looseObject("The upstream JSON result, including provider-defined fields."),
+});
+const productFields = {
+    category: s.string("Product category name."),
+    category_code: s.string("ListingGood category code, when known."),
+    brand: s.string("Product brand."),
+    gender: s.string("Intended audience or gender."),
+    price: s.string("Product price, optionally including the currency."),
+    material_main: s.string("Main product material."),
+    material_lining: s.string("Lining material."),
+    sizes: s.string("Available sizes."),
+    colors: s.string("Available colors."),
+    season: s.string("Intended seasons."),
+    occasion: s.string("Intended occasions."),
+    keywords: s.string("Target search keywords."),
+    note: s.string("Additional factual product details."),
+    diff: s.string("Product differentiators."),
+    selling_points: s.array("Factual product selling points.", s.string("One selling point.")),
+    lang,
+};
+export const listinggoodActions = [
+    defineProviderAction(service, {
+        name: "ai_readiness_check",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Check listing copy for AI readability and compliance signals without submitting lead contact details.",
+        inputSchema: s.object("Listing copy to check.", {
+            text: s.nonEmptyString("Listing title, bullets and description as plain text."),
+            marketplace: s.nonEmptyString("Marketplace code, such as US or DE. Defaults to US."),
+            lang,
+        }, { optional: ["marketplace", "lang"] }),
+        outputSchema: result,
+    }),
+    defineProviderAction(service, {
+        name: "compliance_check",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Run a quick pre-publication check for risky listing terms and category issues.",
+        inputSchema: s.object("Listing copy for a quick check.", {
+            text: s.nonEmptyString("Listing copy to check."),
+            category: s.string("Optional category hint, such as electronics or apparel."),
+            lang,
+        }, { optional: ["category", "lang"] }),
+        outputSchema: result,
+    }),
+    defineProviderAction(service, {
+        name: "fill_from_sentence",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Expand a short product description into structured fields for listing generation.",
+        inputSchema: s.object("Product description to structure.", {
+            sentence: s.string("Product description containing 4 to 1000 characters.", {
+                minLength: 4,
+                maxLength: 1000,
+            }),
+            lang,
+        }, { optional: ["lang"] }),
+        outputSchema: result,
+    }),
+    defineProviderAction(service, {
+        name: "generate_listing",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Submit a text-based listing generation task for explicitly selected marketplaces. Uses account credits and saves generated copy in ListingGood; does not publish to Amazon.",
+        asyncLifecycle: { startActionId: "listinggood.generate_listing", statusActionId: "listinggood.get_task" },
+        inputSchema: s.object("Text-based listing generation parameters.", {
+            cn_name: s.nonEmptyString("Product name; the upstream field is named cn_name."),
+            sku: s.nonEmptyString("Product SKU."),
+            marketplaces: s.array("Marketplace codes to generate for. Select explicitly to avoid generating for every marketplace.", s.nonEmptyString("Marketplace code, such as US, UK or DE."), { minItems: 1, uniqueItems: true }),
+            ...productFields,
+        }, { optional: Object.keys(productFields) }),
+        outputSchema: s.looseRequiredObject("Accepted generation task and upstream metadata.", {
+            task_id: s.nonEmptyString("Task identifier for get_task."),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_task",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a ListingGood task and its generated result, preserving upstream status and metadata.",
+        asyncLifecycle: { startActionId: "listinggood.generate_listing", statusActionId: "listinggood.get_task" },
+        inputSchema: s.requiredObject("Task lookup parameters.", {
+            task_id: s.nonEmptyString("Task identifier returned by generate_listing."),
+        }),
+        outputSchema: s.requiredObject("Task state and full upstream response.", {
+            status: s.stringEnum("Normalized task state.", ["pending", "succeeded", "failed"]),
+            task: s.looseObject("Upstream task with status, progress, message, result or error."),
+        }),
+    }),
+];

package/src/providers/listinggood/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/listinggood/executors.js

@@ -0,0 +1,99 @@
+import { optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, providerUserAgent, ProviderRequestError, runProviderRequest, isAbortLikeError, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { listinggoodActions } from "./actions.js";
+const baseUrl = "https://listinggood.com/api";
+const paths = {
+    ai_readiness_check: "/free-check",
+    compliance_check: "/compliance-check",
+    fill_from_sentence: "/fill-from-sentence",
+    generate_listing: "/generate",
+};
+const defaultHeaders = { accept: "application/json", "user-agent": providerUserAgent };
+async function request({ path, apiKey, body, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "ListingGood" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${path}`, {
+            method: body ? "POST" : "GET",
+            headers: {
+                ...defaultHeaders,
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`,
+            },
+            body: body ? JSON.stringify(body) : undefined,
+            signal,
+        });
+        let payload;
+        try {
+            payload = requiredResponseRecord(await response.json(), "ListingGood response");
+        }
+        catch (error) {
+            if (isAbortLikeError(error))
+                throw error;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "ListingGood returned an invalid JSON response", undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const detail = optionalRawString(payload.error_en) ?? optionalRawString(payload.error);
+            throw new ProviderRequestError(response.status, `ListingGood request failed${detail ? `: ${detail}` : ""}`, undefined, "provider_error");
+        }
+        return payload;
+    });
+}
+const handlers = mapProviderActionHandlers("listinggood", listinggoodActions, (action) => async (dataInput, context) => {
+    const values = dataInput;
+    const isTask = action.name === "get_task";
+    const path = isTask ? `/task/${encodeURIComponent(String(values.task_id))}` : paths[action.name];
+    const payload = isTask ? undefined : { ...values, lang: values.lang ?? "en" };
+    if (action.name === "ai_readiness_check" && payload)
+        payload.marketplace ??= "US";
+    const body = await request({
+        path: path,
+        apiKey: context.apiKey,
+        body: payload,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+    if (action.name === "generate_listing") {
+        if (!optionalRawString(body.task_id)?.trim())
+            throw new ProviderRequestError(502, "ListingGood did not return a task_id", undefined, "provider_error");
+        return body;
+    }
+    if (isTask) {
+        const state = optionalRawString(body.status);
+        if (!state?.trim())
+            throw new ProviderRequestError(502, "ListingGood task is missing status", undefined, "provider_error");
+        return {
+            status: state === "done" ? "succeeded" : state === "error" ? "failed" : "pending",
+            task: body,
+        };
+    }
+    return { result: body };
+});
+export const executors = defineApiKeyProviderExecutors("listinggood", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        return {
+            profile: { displayName: "ListingGood API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationMode: "local_non_empty_key" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "listinggood",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/mcp-tools.d.ts

@@ -8,6 +8,7 @@ export interface McpToolSummary {
     annotations?: ToolAnnotations;
     inputSchema: Record<string, unknown>;
     outputSchema?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
 }
 export interface McpToolOptions {
     endpoint: string;
@@ -24,7 +25,9 @@ export interface McpToolOptions {
     toolListMaxTools?: number;
     toolListTimeoutMs?: number;
 }
+export declare function withMcpToolClient<T>(input: McpToolOptions, run: (client: Client) => Promise<T>): Promise<T>;
 interface ListMcpToolsOptions {
+    includeMetadata?: boolean;
     includeOutputSchema?: boolean;
     includeAnnotations?: boolean;
 }

package/src/providers/mcp-tools.js

@@ -5,7 +5,7 @@ const defaultMcpToolListMaxBytes = 16 * 1024 * 1024;
 const defaultMcpToolListMaxPages = 100;
 const defaultMcpToolListMaxTools = 10_000;
 const defaultMcpToolListTimeoutMs = 60_000;
-async function withToolClient(input, run) {
+export async function withMcpToolClient(input, run) {
     const fetcher = input.fetcher ?? providerFetch;
     const limitedFetcher = createLimitedMcpFetch(fetcher, input.service, input.maxResponseBytes);
     return withMcpClient({
@@ -25,9 +25,10 @@ function createLimitedMcpFetch(fetcher, service, maxResponseBytes) {
     return async (url, init) => limitMcpResponse(await fetcher(url, init), service, maxResponseBytes);
 }
 export async function listMcpTools(input, options = {}) {
-    return withToolClient(input, async (client) => {
+    return withMcpToolClient(input, async (client) => {
         const tools = await listAllStreamableHttpMcpTools(client, input);
         return tools.map((tool) => ({
+            metadata: options.includeMetadata ? tool._meta : undefined,
             name: tool.name,
             description: tool.description,
             annotations: options.includeAnnotations ? tool.annotations : undefined,
@@ -37,7 +38,7 @@ export async function listMcpTools(input, options = {}) {
     });
 }
 export async function callMcpTool(input) {
-    return withToolClient(input, async (client) => {
+    return withMcpToolClient(input, async (client) => {
         if (input.authorizeTool) {
             const tools = await listAllStreamableHttpMcpTools(client, input);
             const matchingTools = tools.filter((tool) => tool.name === input.toolName);
@@ -52,7 +53,7 @@ export async function callMcpTool(input) {
             result = await client.callTool({
                 name: input.toolName,
                 arguments: input.arguments,
-            }, { signal: requestTimeout.signal });
+            }, { signal: requestTimeout.signal, timeout: input.requestTimeoutMs });
         }
         finally {
             requestTimeout.cleanup();