@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/tongdaxin/executors.js

@@ -1,6 +1,7 @@
 import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
 import { createHash } from "node:crypto";
-import { optionalRecord } from "../../core/cast.js";
+import { optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { readBoundedResponseBytes } from "../../core/request.js";
 import { withMcpClient } from "../mcp-client.js";
 import { defineApiKeyProviderExecutors, providerUserAgent, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
 import { tongdaxinActions, tongdaxinReadOnlyToolNames } from "./actions.js";
@@ -9,10 +10,15 @@ import { isTongdaxinNamedActionName, resolveTongdaxinNamedToolCall } from "./nam
 const service = "tongdaxin";
 const endpoint = new URL("https://txmcp.tdx.com.cn:3001/txmcp");
 const requestTimeoutMs = 60_000;
+const errorResponseMaxBytes = 64 * 1024;
+const insufficientPointsToolError = "MCP error -32603: Your usage quota has been reached";
+const insufficientPointsDescription = "TDX MCP quota is below 10. Please recharge before continuing.";
+const rechargeOrigin = "https://vip.tdx.com.cn";
+const rechargePath = "/site/app/pc-mall/main.html";
 const supportedToolNames = new Set(tongdaxinReadOnlyToolNames);
 const handlers = {
     async list_tools(_input, context) {
-        return { tools: await discoverSupportedTools(context, "execute") };
+        return { tools: await discoverSupportedTools(context) };
     },
     async call_tool(input, context) {
         const toolName = requiredInputString(input.toolName, "toolName");
@@ -20,7 +26,8 @@ const handlers = {
         if (!argumentsValue)
             throw new ProviderRequestError(400, "arguments must be a JSON object");
         assertToolArgumentsSize(argumentsValue);
-        const result = await withTongdaxinClient(context, "execute", false, (client) => client.callTool({ name: toolName, arguments: argumentsValue }, { timeout: requestTimeoutMs, signal: context.signal }));
+        const result = await withTongdaxinClient(context, false, (client) => client.callTool({ name: toolName, arguments: argumentsValue }, { timeout: requestTimeoutMs, signal: context.signal }));
+        assertSufficientTongdaxinCredit(result);
         if (!("toolResult" in result) && result.isError) {
             throw new ProviderRequestError(502, `Tongdaxin MCP tool ${toolName} returned an error`, result);
         }
@@ -37,7 +44,7 @@ for (const actionName of Object.keys(resolveNamedHandlers())) {
             throw new ProviderRequestError(400, `Unknown action: ${actionName}`);
         const toolCall = resolveTongdaxinNamedToolCall(actionName, input);
         assertToolArgumentsSize(toolCall.arguments);
-        const tools = await discoverSupportedTools(context, "execute");
+        const tools = await discoverSupportedTools(context);
         const tool = tools.find((candidate) => candidate.name === toolCall.toolName);
         if (!tool && toolCall.toolName !== "wenda_macro_query") {
             throw new ProviderRequestError(409, `Tongdaxin action ${actionName} is unavailable because this connection does not expose ${toolCall.toolName}`);
@@ -48,7 +55,8 @@ for (const actionName of Object.keys(resolveNamedHandlers())) {
                 tool.annotations.destructiveHint === true)) {
             throw new ProviderRequestError(403, `Tongdaxin MCP does not currently affirm ${tool.name} as a non-destructive read-only tool`);
         }
-        const result = await withTongdaxinClient(context, "execute", true, (client) => client.callTool({ name: toolCall.toolName, arguments: toolCall.arguments }, { timeout: requestTimeoutMs, signal: context.signal }));
+        const result = await withTongdaxinClient(context, true, (client) => client.callTool({ name: toolCall.toolName, arguments: toolCall.arguments }, { timeout: requestTimeoutMs, signal: context.signal }));
+        assertSufficientTongdaxinCredit(result);
         if (!("toolResult" in result) && result.isError) {
             throw new ProviderRequestError(502, `Tongdaxin MCP tool ${toolCall.toolName} returned an error`, result);
         }
@@ -62,7 +70,7 @@ export const executors = defineApiKeyProviderExecutors(service, handlers, {
 export const credentialValidators = {
     async apiKey(input, { fetcher, signal }) {
         const context = { apiKey: input.apiKey, fetcher, signal };
-        const tools = await discoverSupportedTools(context, "validate");
+        const tools = await discoverSupportedTools(context);
         if (tools.length === 0) {
             throw new ProviderRequestError(400, "Tongdaxin MCP did not expose any supported read-only tools");
         }
@@ -77,8 +85,8 @@ export const credentialValidators = {
         };
     },
 };
-async function discoverSupportedTools(context, phase) {
-    const result = await withTongdaxinClient(context, phase, true, (client) => client.listTools({}, { timeout: requestTimeoutMs, signal: context.signal }));
+async function discoverSupportedTools(context) {
+    const result = await withTongdaxinClient(context, true, (client) => client.listTools({}, { timeout: requestTimeoutMs, signal: context.signal }));
     return result.tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
@@ -86,30 +94,30 @@ async function discoverSupportedTools(context, phase) {
         inputSchema: tool.inputSchema,
     }));
 }
-async function withTongdaxinClient(context, phase, retryOnSessionNotFound, run) {
+async function withTongdaxinClient(context, retryOnSessionNotFound, run) {
     return withMcpClient({
         endpoint,
         transport: "streamable_http",
-        fetcher: context.fetcher,
+        fetcher: createTongdaxinFetcher(context.fetcher),
         headers: {
             authorization: `Bearer ${context.apiKey}`,
             "user-agent": providerUserAgent,
         },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         retryOnSessionNotFound,
-        mapError: (error) => mapTongdaxinError(error, phase),
+        mapError: mapTongdaxinError,
     }, run);
 }
-function mapTongdaxinError(error, phase) {
+function mapTongdaxinError(error) {
     if (error instanceof ProviderRequestError)
         return error;
     if (error instanceof UnauthorizedError) {
-        return new ProviderRequestError(phase === "validate" ? 400 : 401, "Tongdaxin API Key is invalid or expired");
+        return new ProviderRequestError(401, "Tongdaxin MCP denied this request");
     }
     if (error instanceof SdkHttpError) {
         if (error.status === 401) {
-            return new ProviderRequestError(phase === "validate" ? 400 : 401, "Tongdaxin API Key is invalid or expired");
+            return new ProviderRequestError(401, "Tongdaxin MCP denied this request");
         }
         const status = 400 <= error.status && error.status < 500 ? error.status : 502;
         return new ProviderRequestError(status, `Tongdaxin MCP request failed: ${error.message}`, error);
@@ -119,6 +127,62 @@ function mapTongdaxinError(error, phase) {
     }
     return new ProviderRequestError(502, error instanceof Error ? `Tongdaxin MCP request failed: ${error.message}` : "Tongdaxin MCP request failed", error);
 }
+function createTongdaxinFetcher(fetcher) {
+    return (async (...arguments_) => {
+        const response = await fetcher(...arguments_);
+        const details = await readInsufficientPoints(response);
+        if (details) {
+            void response.body?.cancel().catch(() => undefined);
+            throw insufficientCreditError(details);
+        }
+        return response;
+    });
+}
+async function readInsufficientPoints(response) {
+    if (response.status !== 401)
+        return undefined;
+    try {
+        const bytes = await readBoundedResponseBytes(response.clone(), {
+            maxBytes: errorResponseMaxBytes,
+            fieldName: "Tongdaxin MCP error response",
+            createError: (message) => new Error(message),
+        });
+        const payload = optionalRecord(JSON.parse(new TextDecoder().decode(bytes)));
+        const remainingCredit = optionalNumber(payload?.leftValue);
+        const rechargeUrl = optionalString(payload?.recharge_url);
+        if (payload?.error !== "unauthorized" ||
+            payload?.error_description !== insufficientPointsDescription ||
+            remainingCredit === undefined ||
+            !isOfficialRechargeUrl(rechargeUrl)) {
+            return undefined;
+        }
+        return { remainingCredit, rechargeUrl };
+    }
+    catch {
+        return undefined;
+    }
+}
+function isOfficialRechargeUrl(value) {
+    if (!value)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.origin === rechargeOrigin && url.pathname === rechargePath;
+    }
+    catch {
+        return false;
+    }
+}
+function assertSufficientTongdaxinCredit(result) {
+    if (!("content" in result) || result.isError !== true)
+        return;
+    const exhausted = result.content.some((content) => content.type === "text" && content.text === insufficientPointsToolError);
+    if (exhausted)
+        throw insufficientCreditError();
+}
+function insufficientCreditError(details) {
+    return new ProviderRequestError(402, "Tongdaxin AI points are insufficient. Recharge the account before retrying.", details ?? { rechargeUrl: `${rechargeOrigin}${rechargePath}#/page_product_ai_jfb` }, "insufficient_credit");
+}
 function resolveNamedHandlers() {
     return Object.fromEntries(tongdaxinActions
         .filter((action) => action.name !== "list_tools" && action.name !== "call_tool")

package/src/providers/uspto/executors.js

@@ -2,7 +2,7 @@ import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestErro
 async function get(path, accept, apiKey, fetcher, signal) {
     const response = await fetcher(new URL(path, "https://tsdrapi.uspto.gov"), {
         headers: { accept, "USPTO-API-KEY": apiKey, "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal,
     });
     const text = await response.text();

package/src/providers/waffo/executors.js

@@ -37,7 +37,7 @@ export const proxy = async (input, context) => {
             method: input.method,
             headers,
             body: input.method === "GET" || input.body == null ? undefined : signingBody,
-            redirect: "error",
+            redirect: "manual",
             signal: context.signal,
         });
         if (!response.ok) {

package/src/providers/waffo/runtime.js

@@ -281,7 +281,7 @@ export async function requestWaffoJson(input) {
             method: "POST",
             headers,
             body,
-            redirect: "error",
+            redirect: "manual",
             signal: timeout.signal,
         });
         const payload = await readProviderJsonBody(response, {

package/src/providers/wecom_mcp/runtime.js

@@ -173,7 +173,7 @@ async function withWeComMcpClient(context, run) {
         transport: "streamable_http",
         fetcher: createWeComRateLimitedFetch(context.fetcher, hashWeComRateLimitKey(context)),
         headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapWeComMcpError,
     }, run);

package/src/providers/weixin_store/access-token.d.ts

@@ -45,7 +45,8 @@ export declare function isWechatTokenError(errcode: number | null): boolean;
 /**
  * Map a failed WeChat API call to the shared provider error. Rate limits
  * (45009/45011) become 429, the missing-permission 48001 becomes 403, the
- * 4xxxx client errcodes become 400, and everything else becomes a 502.
+ * 4xxxx client errcodes and the documented invalid-input store errcodes become
+ * 400, and everything else becomes a 502.
  */
 export declare function normalizeWechatApiError(result: WechatApiResult): ProviderRequestError;
 export {};

package/src/providers/weixin_store/access-token.js

@@ -1,9 +1,19 @@
 import { createHash } from "node:crypto";
-import { optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { optionalIntegerOrNull, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, providerResponseError, providerUserAgent, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 const wechatStableTokenUrl = "https://api.weixin.qq.com/cgi-bin/stable_token";
 const defaultAccessTokenTtlSeconds = 7200;
 const accessTokenRefreshSkewMs = 120_000;
+/**
+ * WeChat Store errcodes outside the 4xxxx range that the category and
+ * qualification docs describe as bad parameters or materials, such as an
+ * invalid or non-leaf category id, a mismatched certificate group, or a file id
+ * that did not come from the qualification upload. The caller has to fix the
+ * input, so they map to 400 instead of an upstream failure.
+ */
+const wechatInvalidInputErrcodes = new Set([
+    9401020, 9700234, 10020017, 10020059, 10020060, 10020062, 10020063, 10020087, 10020094, 10020127, 10020504,
+]);
 const accessTokenCache = new Map();
 const accessTokenInFlight = new Map();
 const accessTokenRefreshInFlight = new Map();
@@ -115,7 +125,7 @@ export function parseWechatJson(rawText) {
 }
 /** Read the numeric errcode of a WeChat envelope; absent or non-numeric reads as null. */
 export function readWechatErrcode(record) {
-    return optionalInteger(record?.errcode) ?? null;
+    return optionalIntegerOrNull(record?.errcode);
 }
 /** Whether the errcode marks the access token as invalid, so the caller can refresh and retry once. */
 export function isWechatTokenError(errcode) {
@@ -124,7 +134,8 @@ export function isWechatTokenError(errcode) {
 /**
  * Map a failed WeChat API call to the shared provider error. Rate limits
  * (45009/45011) become 429, the missing-permission 48001 becomes 403, the
- * 4xxxx client errcodes become 400, and everything else becomes a 502.
+ * 4xxxx client errcodes and the documented invalid-input store errcodes become
+ * 400, and everything else becomes a 502.
  */
 export function normalizeWechatApiError(result) {
     const errcode = readWechatErrcode(result.record);
@@ -142,7 +153,7 @@ export function normalizeWechatApiError(result) {
     if (errcode === 48001) {
         return new ProviderRequestError(403, message, result.record);
     }
-    if (errcode !== null && errcode >= 40000 && errcode < 50000) {
+    if (errcode !== null && ((errcode >= 40000 && errcode < 50000) || wechatInvalidInputErrcodes.has(errcode))) {
         return new ProviderRequestError(400, message, result.record);
     }
     if (result.status >= 400 && result.status < 500) {

package/src/providers/weixin_store/executors.js

@@ -1,4 +1,4 @@
-import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalString } from "../../core/cast.js";
+import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, positiveInteger, } from "../../core/cast.js";
 import { createProviderFetch, defineProviderExecutors, providerInputError, providerUserAgent, readTransitFileInput, requireCustomCredential, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 import { getWechatAccessToken, isWechatTokenError, normalizeWechatApiError, parseWechatJson, readWechatErrcode, readWeixinStoreCredential, } from "./access-token.js";
 const service = "weixin_store";
@@ -35,6 +35,20 @@ const deliveryProductFieldMap = {
     productCnt: "product_cnt",
 };
 const weixinStoreActionHandlers = {
+    async upload_qualification_image(input, context) {
+        const file = await readTransitFileInput(input.file, context);
+        if (file.sizeBytes > 2 * 1024 * 1024) {
+            throw providerInputError("file must be at most 2 MB");
+        }
+        const formData = new FormData();
+        formData.set("media", file.file, file.name);
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/basics/qualification/upload",
+            body: formData,
+            timeoutMs: wechatImageUploadTimeoutMs,
+        });
+    },
     upload_image(input, context) {
         const imageUrl = optionalString(input.imageUrl);
         if ((imageUrl === undefined) === (input.file === undefined)) {
@@ -61,7 +75,53 @@ const weixinStoreActionHandlers = {
         return callWechatApi(context, {
             method: "POST",
             path: "/shop/ec/category/detail",
-            body: { cat_id: readPositiveInteger(input.catId, "catId") },
+            body: { cat_id: positiveInteger(input.catId, "catId", providerInputError) },
+        });
+    },
+    apply_category(input, context) {
+        const categoryInfo = optionalRecord(input.categoryInfo);
+        if (!categoryInfo) {
+            throw providerInputError("categoryInfo must be an object");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/category/add",
+            body: { category_info: mapCategoryApplication(categoryInfo) },
+        });
+    },
+    get_category_application(input, context) {
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/category/getbizcatflowdetail",
+            body: { audit_id: positiveInteger(input.auditId, "auditId", providerInputError) },
+        });
+    },
+    list_category_permissions(input, context) {
+        const status = optionalInteger(input.status);
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/category/get_category_relation_list",
+            body: compactObject({ is_filter_status: status !== undefined, status }),
+        });
+    },
+    precheck_product_category(input, context) {
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/product/categoryprecheck",
+            body: compactObject({
+                cat_id: input.catId === undefined ? undefined : positiveInteger(input.catId, "catId", providerInputError),
+            }),
+        });
+    },
+    get_category_product_rule(input, context) {
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/shop/ec/category/getcategoryproductrule",
+            body: compactObject({
+                cat_id: positiveInteger(input.catId, "catId", providerInputError),
+                release_mode: optionalInteger(input.releaseMode),
+                brand_id: input.brandId === undefined ? undefined : positiveInteger(input.brandId, "brandId", providerInputError),
+            }),
         });
     },
     list_valid_brands(input, context) {
@@ -260,7 +320,7 @@ const weixinStoreActionHandlers = {
             path: "/channels/ec/aftersale/rejectapply",
             body: compactObject({
                 after_sale_order_id: requiredInputString(input.afterSaleOrderId, "afterSaleOrderId"),
-                reject_reason_type: readPositiveInteger(input.rejectReasonType, "rejectReasonType"),
+                reject_reason_type: positiveInteger(input.rejectReasonType, "rejectReasonType", providerInputError),
                 reject_reason: optionalString(input.rejectReason),
             }),
         });
@@ -299,8 +359,8 @@ export const credentialValidators = {
 };
 /** Upload a local transit file as a store image, which WeChat sizes from the required pixel dimensions. */
 async function uploadImageFile(context, input) {
-    const width = readPositiveInteger(input.width, "width");
-    const height = readPositiveInteger(input.height, "height");
+    const width = positiveInteger(input.width, "width", providerInputError);
+    const height = positiveInteger(input.height, "height", providerInputError);
     const file = await readTransitFileInput(input.file, context);
     const formData = new FormData();
     formData.set("media", file.file, file.name);
@@ -362,6 +422,38 @@ async function executeWechatJsonRequest(context, request, accessToken) {
         return { status: response.status, record: parseWechatJson(rawText), rawText };
     });
 }
+/**
+ * Build the category_info of a category application: force the certificate-group
+ * protocol and send every id as the number WeChat documents, since callers often
+ * copy them from responses that carry numeric ids as strings.
+ */
+function mapCategoryApplication(categoryInfo) {
+    return {
+        ...categoryInfo,
+        cats_v2: objectArray(categoryInfo.cats_v2, "categoryInfo.cats_v2", providerInputError).map((cat) => ({
+            ...cat,
+            cat_id: positiveInteger(cat.cat_id, "categoryInfo.cats_v2[].cat_id", providerInputError),
+        })),
+        license_group_list: objectArray(categoryInfo.license_group_list, "categoryInfo.license_group_list", providerInputError).map((group) => {
+            const license = optionalRecord(group.license) ?? {};
+            return {
+                ...group,
+                license_group_id: positiveInteger(group.license_group_id, "categoryInfo.license_group_list[].license_group_id", providerInputError),
+                license: {
+                    ...license,
+                    license_id: positiveInteger(license.license_id, "categoryInfo.license_group_list[].license.license_id", providerInputError),
+                },
+            };
+        }),
+        brand_list: categoryInfo.brand_list === undefined
+            ? undefined
+            : objectArray(categoryInfo.brand_list, "categoryInfo.brand_list", providerInputError).map((brand) => ({
+                ...brand,
+                brand_id: positiveInteger(brand.brand_id, "categoryInfo.brand_list[].brand_id", providerInputError),
+            })),
+        is_new_apply_cat: true,
+    };
+}
 /** WeChat only reads deliver_acct_type when deliver_method is 3, and then it is required. */
 function checkProductPayload(input) {
     if (optionalInteger(input.deliverMethod) === 3 && input.deliverAcctType === undefined) {
@@ -447,13 +539,6 @@ function readOffsetLimit(input) {
 function readPageSize(input, max, defaultValue) {
     return readBoundedInteger(input.pageSize, "pageSize", 1, max) ?? defaultValue;
 }
-function readPositiveInteger(value, fieldName) {
-    const parsed = optionalInteger(value);
-    if (parsed === undefined || parsed < 1) {
-        throw providerInputError(`${fieldName} must be a positive integer`);
-    }
-    return parsed;
-}
 /** Read a WeChat id that the docs type inconsistently as string or number; numbers are sent in string form. */
 function readIdString(value, fieldName) {
     const stringId = optionalString(value);

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

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

package/src/providers/wisburg/executors.js

@@ -0,0 +1,13 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { validateWisburgCredential, wisburgActionHandlers, wisburgApiBaseUrl } from "./runtime.js";
+const service = "wisburg";
+export const executors = defineApiKeyProviderExecutors(service, wisburgActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: wisburgApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+});
+export const credentialValidators = { apiKey: validateWisburgCredential };

package/src/providers/wisburg/runtime.d.ts

@@ -0,0 +1,12 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderRuntimeHandler } from "../provider-runtime.ts";
+/** Output key a detail action nests its resource under. */
+export type WisburgDetailKey = "report" | "article" | "log";
+export declare const wisburgApiBaseUrl = "https://api-omen.wisburg.com";
+export declare const wisburgActionHandlers: ProviderActionHandlers<"wisburg", ProviderRuntimeHandler<ApiKeyProviderContext>>;
+export declare function validateWisburgCredential(input: {
+    apiKey: string;
+}, { fetcher, signal }: {
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;

package/src/providers/wisburg/runtime.js

@@ -0,0 +1,133 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { objectArray, optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, parseProviderJsonBodyText, providerResponseError, providerUserAgent, readProviderErrorTextBody, readProviderJsonBody, requiredInputNumber, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+export const wisburgApiBaseUrl = "https://api-omen.wisburg.com";
+export const wisburgActionHandlers = {
+    list_reports: (input, context) => listWisburgResource(input, context, "api/reports"),
+    get_report: (input, context) => getWisburgResource(input, context, "api/reports", "report"),
+    list_archives: (input, context) => listWisburgResource(input, context, "api/archives"),
+    get_archive: (input, context) => getWisburgResource(input, context, "api/archives", "report"),
+    list_company_reports: (input, context) => listWisburgResource(input, context, "api/company-reports"),
+    get_company_report: (input, context) => getWisburgResource(input, context, "api/company-reports", "report"),
+    list_earnings_calls: (input, context) => listWisburgResource(input, context, "api/earningscalls"),
+    get_earnings_call: (input, context) => getWisburgResource(input, context, "api/earningscalls", "report"),
+    list_articles: (input, context) => listWisburgResource(input, context, "api/articles"),
+    get_article: (input, context) => getWisburgResource(input, context, "api/articles", "article"),
+    list_market_daily: (input, context) => listWisburgResource(input, context, "api/market-daily"),
+    list_feed: (input, context) => listWisburgResource(input, context, "api/feed"),
+    list_images: (input, context) => listWisburgResource(input, context, "api/images"),
+    list_am_reports: (input, context) => listWisburgResource(input, context, "api/am-reports"),
+    get_am_report: (input, context) => getWisburgResource(input, context, "api/am-reports", "report"),
+    list_mikko_logs: (input, context) => listWisburgResource(input, context, "api/mikko-logs"),
+    get_mikko_log: (input, context) => getWisburgResource(input, context, "api/mikko-logs", "log"),
+};
+export async function validateWisburgCredential(input, { fetcher, signal }) {
+    try {
+        await wisburgRequest({ apiKey: input.apiKey, fetcher, signal }, { path: "api/feed", query: { first: "1" } });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError && error.status === 401) {
+            throw new ProviderRequestError(400, error.message, error.details);
+        }
+        // A 403 proves the key was accepted; the feed is simply outside this key's subscription.
+        if (!(error instanceof ProviderRequestError) || error.status !== 403)
+            throw error;
+    }
+    return {
+        profile: {
+            accountId: `wisburg:${sha256Hex(input.apiKey).slice(0, 32)}`,
+            displayName: "Wisburg API Key",
+        },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: wisburgApiBaseUrl,
+            validationEndpoint: "/api/feed",
+            credentialHelpUrl: "https://open-docs.wisburg.com/docs/getting-started/first-call",
+        },
+    };
+}
+async function listWisburgResource(input, context, path) {
+    const envelope = await wisburgRequest(context, {
+        path,
+        query: {
+            first: optionalInteger(input.first)?.toString(),
+            after: optionalString(input.after),
+            query: optionalString(input.query),
+            startTime: optionalString(input.startTime),
+            endTime: optionalString(input.endTime),
+        },
+    });
+    const data = requiredResponseRecord(envelope.data, "Wisburg list data");
+    const pageInfo = requiredResponseRecord(data.page_info, "Wisburg list page_info");
+    const endCursor = pageInfo.end_cursor;
+    if (endCursor != null && typeof endCursor !== "string") {
+        throw providerResponseError("Wisburg list page_info.end_cursor must be a string");
+    }
+    return {
+        requestId: optionalString(envelope.request_id) ?? "",
+        items: objectArray(data.items, "Wisburg list data.items", providerResponseError),
+        pageInfo: { endCursor: optionalString(endCursor) },
+    };
+}
+async function getWisburgResource(input, context, path, key) {
+    const id = requiredInputNumber(input.id, "id");
+    const envelope = await wisburgRequest(context, { path: `${path}/${id}` });
+    return {
+        requestId: optionalString(envelope.request_id) ?? "",
+        [key]: requiredResponseRecord(envelope.data, "Wisburg detail data"),
+    };
+}
+async function wisburgRequest(context, input) {
+    return runProviderRequest({ signal: context.signal, label: "Wisburg" }, async (signal) => {
+        const url = new URL(input.path, `${wisburgApiBaseUrl}/`);
+        setSearchParams(url, input.query ?? {});
+        const response = await context.fetcher(url, {
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${context.apiKey}`,
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        if (!response.ok) {
+            throw await readWisburgHttpError(response);
+        }
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Wisburg returned invalid JSON",
+        });
+        const envelope = requiredResponseRecord(payload, "Wisburg response");
+        const code = optionalNumber(envelope.code);
+        if (code !== undefined && code !== 200) {
+            throw mapWisburgError(code, envelope);
+        }
+        // The envelope marks failure as status 1 even when the code field disagrees; fall back to the 1002 internal-error code when none is present.
+        if (optionalNumber(envelope.status) === 1) {
+            throw mapWisburgError(code ?? 1002, envelope);
+        }
+        return envelope;
+    });
+}
+// Keep the HTTP status for non-JSON gateway error pages; the JSON envelope, when present, only supplies the code and message.
+async function readWisburgHttpError(response) {
+    const text = await readProviderErrorTextBody(response, "Wisburg error response");
+    const parsed = parseProviderJsonBodyText(text, {
+        emptyBody: {},
+        invalidJsonMessage: "Wisburg returned invalid JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const envelope = optionalRecord(parsed) ?? {};
+    return mapWisburgError(optionalNumber(envelope.code) ?? response.status, envelope);
+}
+function mapWisburgError(code, envelope) {
+    const message = optionalString(envelope.message) ?? `Wisburg request failed (${code})`;
+    // Besides the documented 401/403/404/429 codes, a bare gateway 4xx such as 414 stays a client error.
+    if (code >= 400 && code < 500) {
+        return new ProviderRequestError(code, message, envelope);
+    }
+    // 1001 marks invalid parameters and 1004 an out-of-range pagination cursor.
+    if (code === 1001 || code === 1004) {
+        return new ProviderRequestError(400, message, envelope);
+    }
+    return new ProviderRequestError(502, message, envelope);
+}

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

@@ -1,4 +1,7 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/woocommerce/executors.js

@@ -1,6 +1,7 @@
 import { isPrivateNetworkAccessAllowed } from "../../core/request.js";
 import { basicAuthorizationHeader, createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { resolveWooCommerceCredentialContext, validateWooCommerceCredential, woocommerceActionHandlers, } from "./runtime.js";
+import { wooCommerceStoreEvent } from "./trigger-on-store-event.js";
 const service = "woocommerce";
 const proxyFetch = createProviderFetch({ allowPrivateNetwork: isPrivateNetworkAccessAllowed });
 export const executors = defineProviderExecutors({
@@ -49,3 +50,4 @@ export const credentialValidators = {
         return validateWooCommerceCredential(input.values, guardedFetcher, signal);
     },
 };
+export const triggers = [wooCommerceStoreEvent];

package/src/providers/woocommerce/trigger-on-store-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const wooCommerceStoreEvent: IntegrationDefinition;

package/src/providers/woocommerce/trigger-on-store-event.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};