@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/vimeo/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { assertPublicHttpUrl, queryParams, readBoundedResponseBytes } from "../../core/request.js";
+import { assertPublicHttpUrl, queryParams, storeResponseInTransit } from "../../core/request.js";
 import { createProviderTimeout, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
 export const vimeoApiBaseUrl = "https://api.vimeo.com";
 export const vimeoActionHandlers = {
@@ -199,12 +199,13 @@ async function vimeoDownloadVideoFile(input, context) {
     }
     const mimeType = response.headers.get("content-type") ?? optionalString(selected.type) ?? "application/octet-stream";
     const name = resolveDownloadFileName(input, selected, mimeType);
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const upload = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: "Vimeo video download",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const upload = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         videoId: input.videoId,
         sourceUrl: selected.link,

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

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

package/src/providers/viral_loops/actions.js

@@ -0,0 +1,90 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const identity = {
+    email: s.nonEmptyString("Participant email address."),
+    referralCode: s.nonEmptyString("Participant referral code."),
+};
+const selector = s.requireAnyProperty(s.object("Identify a participant by email or referral code.", identity, {
+    optional: ["email", "referralCode"],
+}), ["email", "referralCode"]);
+const participant = s.looseObject("Participant data; additional campaign-specific fields are preserved.", {
+    email: s.string("Participant email address."),
+    firstname: s.string("Participant first name."),
+    lastname: s.string("Participant last name."),
+    referralCode: s.string("Participant referral code."),
+    extraData: s.looseObject("Custom participant data.", {}),
+    rank: s.number("Participant rank."),
+    referralCountTotal: s.number("Total referral count."),
+    pointsTotal: s.integer("Total points for campaigns with points enabled."),
+    referredLeads: s.number("Number of referred leads."),
+    xReferrals: s.number("Additional referral count reported by the campaign."),
+    referrer: s.looseObject("Referrer details.", {}),
+    redeemedRewards: s.array("Redeemed rewards.", s.looseObject("Reward details.", {})),
+    pendingRewards: s.array("Pending rewards.", s.looseObject("Reward details.", {})),
+});
+function read(name, description, inputSchema, outputSchema) {
+    return defineProviderAction("viral_loops", {
+        name,
+        description,
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema,
+        outputSchema,
+    });
+}
+export const viralLoopsActions = [
+    read("get_campaign", "Get public information for the campaign associated with this connection.", s.object("No parameters are required.", {}, {
+        optional: [],
+    }), s.looseObject("Campaign information and configuration.", {
+        campaignName: s.string("Campaign name."),
+        companyName: s.string("Company name."),
+        type: s.string("Campaign type."),
+        template: s.string("Campaign template."),
+        landingPage: s.string("Campaign landing page."),
+        genericConfig: s.looseObject("Campaign configuration.", {}),
+    })),
+    read("get_campaign_stats", "Get the lead count and total referral count for the connected campaign.", s.object("No parameters are required.", {}, {
+        optional: [],
+    }), s.looseObject("Campaign statistics.", {
+        leadCount: s.integer("Number of campaign leads."),
+        referralCountTotal: s.integer("Total number of referrals."),
+    })),
+    read("get_participant", "Get full participant information using the connected campaign's secret API token.", selector, participant),
+    read("list_referrals", "Get one page of a participant's referrals, with optional conversion-status filtering.", s.requireAnyProperty(s.object("Participant and referral pagination parameters.", {
+        ...identity,
+        limit: s.integer("Maximum number of referrals to return.", { minimum: 1 }),
+        offset: s.integer("Number of referrals to skip.", { minimum: 0 }),
+        conversionStatus: s.number("Provider conversion-status filter."),
+    }, {
+        optional: ["email", "referralCode", "limit", "offset", "conversionStatus"],
+    }), ["email", "referralCode"]), s.looseObject("Referral page returned by Viral Loops; its fields depend on the campaign.", {})),
+    read("query_participants", "Query campaign participants by participant or referrer identifiers with limit and skip pagination.", s.object("Participant query parameters.", {
+        referrers: s.array("Referrer identifiers to filter by.", selector),
+        participants: s.array("Participant identifiers to filter by.", selector),
+        filter: s.object("Pagination controls.", {
+            limit: s.integer("Maximum number of results to return.", { minimum: 1 }),
+            skip: s.integer("Number of results to skip.", { minimum: 0 }),
+        }, {
+            optional: ["limit", "skip"],
+        }),
+    }, {
+        optional: ["referrers", "participants", "filter"],
+    }), s.looseObject("Participant query response.", {
+        results: s.array("Matching participant records.", s.unknown("Participant record returned by Viral Loops.")),
+    })),
+    read("get_referrer", "Get the referrer of a campaign participant.", selector, s.object("Referrer response wrapper.", {
+        result: s.unknown("Original Viral Loops referrer response, including an empty result when no referrer exists."),
+    }, {
+        optional: [],
+    })),
+    read("get_participant_rank", "Get a participant's waiting-list or leaderboard rank; flagged participants are excluded.", selector, s.looseObject("Participant rank information.", {
+        rank: s.integer("Participant rank."),
+        referralCountTotal: s.integer("Total referral count."),
+        pointsTotal: s.integer("Total points for campaigns with points enabled."),
+        suggestion: s.looseObject("Provider ranking suggestion.", {}),
+    })),
+    read("get_participant_order", "Get the order in which a participant joined the campaign.", selector, s.looseObject("Participant joining order.", {
+        order: s.integer("Joining order, starting at one."),
+        leadCount: s.integer("Number of campaign leads."),
+    })),
+];

package/src/providers/viral_loops/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/viral_loops/executors.js

@@ -0,0 +1,81 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, isAbortLikeError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { viralLoopsActions } from "./actions.js";
+const baseUrl = "https://app.viral-loops.com/api/v3";
+const endpoints = {
+    get_campaign: "/campaign/data",
+    get_campaign_stats: "/campaign/stats",
+    get_participant: "/campaign/participant/data",
+    list_referrals: "/campaign/participant/referrals",
+    query_participants: "/campaign/participant/query",
+    get_referrer: "/campaign/participant/referrer",
+    get_participant_rank: "/campaign/participant/rank",
+    get_participant_order: "/campaign/participant/order",
+};
+async function request(endpoint, method, input, apiKey, fetcher, parentSignal) {
+    const url = new URL(`${baseUrl}${endpoint}`);
+    if (method === "GET")
+        for (const [key, value] of Object.entries(input))
+            if (value != null)
+                url.searchParams.set(key, String(value));
+    return runProviderRequest({ signal: parentSignal, label: "Viral Loops" }, async (signal) => {
+        const headers = new Headers({ apiToken: apiKey, accept: "application/json" });
+        if (method === "POST")
+            headers.set("content-type", "application/json");
+        const response = await fetcher(url, {
+            method,
+            headers,
+            signal,
+            body: method === "POST" ? JSON.stringify(input) : undefined,
+        });
+        let payload;
+        try {
+            payload = await JSON.parse(await readProviderTextBody(response, "viral_loops response", undefined, signal));
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError || isAbortLikeError(error))
+                throw error;
+            if (response.ok)
+                throw new ProviderRequestError(502, "Viral Loops returned invalid JSON", undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const body = optionalRecord(payload);
+            const details = [
+                optionalRawString(body?.error),
+                optionalRawString(body?.message),
+                optionalRawString(body?.description),
+            ]
+                .filter(Boolean)
+                .join(": ");
+            throw new ProviderRequestError(response.status, (details || `Viral Loops HTTP ${response.status}`).replaceAll(apiKey, "[REDACTED]"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+export const executors = defineApiKeyProviderExecutors("viral_loops", mapProviderActionHandlers("viral_loops", viralLoopsActions, (_action, actionName) => async (input, context) => {
+    const result = await request(endpoints[actionName], actionName === "query_participants" ? "POST" : "GET", input, context.apiKey, context.fetcher, context.signal);
+    return actionName === "get_referrer" ? { result } : requiredResponseRecord(result, "Viral Loops response");
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const apiKey = requiredInputString(input.apiKey, "API Key");
+        await request("/campaign/stats", "GET", {}, apiKey, fetcher);
+        const campaign = requiredResponseRecord(await request("/campaign/data", "GET", {}, apiKey, fetcher), "Viral Loops campaign");
+        return {
+            profile: { displayName: optionalRawString(campaign.campaignName) ?? "Viral Loops Campaign" },
+            grantedScopes: [],
+            metadata: { validationEndpoint: "/campaign/stats" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "viral_loops",
+    baseUrl,
+    auth: { type: "api_key_header", name: "apiToken" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({ accept: "application/json" }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

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

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

package/src/providers/wbiztool/actions.js

@@ -0,0 +1,127 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const messageId = s.integer("The message ID returned by a send or schedule request.");
+const deliveryProperties = {
+    whatsapp_client: s.integer("The WhatsApp Client ID from https://wbiztool.com/whatsapp-settings/. Required for scheduling; sending can omit it when exactly one number is connected."),
+    phone: s.nonEmptyString("The recipient phone number, preferably including its country calling code. Supply phone or group_name, never both."),
+    group_name: s.nonEmptyString("The name of a WhatsApp group the sending number belongs to. Supply group_name or phone, never both."),
+    country_code: s.nonEmptyString("The country calling code without +. Omit when phone already contains the full international number; ignored for groups."),
+    msg_type: {
+        ...s.integer("The message type: 0 for text (default), 1 for an image, or 2 for a file or document."),
+        enum: [0, 1, 2],
+    },
+    msg: s.string("The message text, or optional caption for an image or file."),
+    img_url: s.url("The public HTTP or HTTPS image URL fetched by Wbiztool for msg_type 1. Scheduled URLs must remain available until sending."),
+    file_url: s.url("The public HTTP or HTTPS file URL fetched by Wbiztool for msg_type 2. Scheduled URLs must remain available until sending."),
+    file_name: s.nonEmptyString("The recipient-visible file name including its extension. Wbiztool lowercases and sanitizes it; unsupported extensions receive an added .pdf suffix."),
+    webhook: s.url("The URL notified by Wbiztool when the message is sent or fails. Cancelled and expired messages do not trigger this callback."),
+};
+function deliverySchema(scheduled) {
+    const properties = { ...deliveryProperties };
+    if (scheduled) {
+        properties.date = s.string("The scheduled date in dd/mm/yyyy format. A past time is sent immediately.", {
+            pattern: "^[0-9]{2}/[0-9]{2}/[0-9]{4}$",
+        });
+        properties.time = s.string("The scheduled local time in 24-hour HH:MM format, without seconds.", {
+            pattern: "^([01][0-9]|2[0-3]):[0-5][0-9]$",
+        });
+        properties.timezone = s.nonEmptyString("The IANA timezone, such as Asia/Kolkata, or an official uppercase abbreviation. Defaults to IST (Asia/Kolkata). Unknown zones are rejected by the connector.");
+    }
+    else {
+        properties.msg = s.string("The message text (up to 3,000 characters), or optional caption for an image or file.", {
+            maxLength: 3000,
+        });
+        properties.expire_after_seconds = s.integer("Expire an unsent message after this many seconds. Expiration is checked at least 30 seconds after the deadline.");
+    }
+    return {
+        ...s.object(scheduled ? "The message and its delivery schedule." : "The message to queue for sending.", properties, {
+            required: scheduled ? ["whatsapp_client", "date", "time"] : [],
+        }),
+        oneOf: [
+            { required: ["phone"], not: { required: ["group_name"] } },
+            { required: ["group_name"], not: { required: ["phone"] } },
+        ],
+        allOf: [
+            {
+                if: { properties: { msg_type: { const: 1 } }, required: ["msg_type"] },
+                then: { required: ["img_url"] },
+            },
+            {
+                if: { properties: { msg_type: { const: 2 } }, required: ["msg_type"] },
+                then: { required: ["file_url"] },
+            },
+            {
+                if: { properties: { msg_type: { const: 0 } } },
+                then: { required: ["msg"], properties: { msg: { minLength: 1 } } },
+            },
+        ],
+    };
+}
+const queuedOutput = s.object("The queued message. Acceptance does not confirm delivery.", {
+    status: s.integer("The request success flag, 1 when accepted."),
+    message: s.string("The upstream acceptance message."),
+    msg_id: messageId,
+}, {
+    optional: [],
+    additionalProperties: true,
+});
+function sendAction(name, scheduled) {
+    return defineProviderAction("wbiztool", {
+        name,
+        description: scheduled
+            ? "Schedule a WhatsApp text, image or file for one phone number or group."
+            : "Queue a WhatsApp text, image or file for one phone number or group.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: deliverySchema(scheduled),
+        outputSchema: queuedOutput,
+        asyncLifecycle: {
+            startActionId: `wbiztool.${name}`,
+            statusActionId: "wbiztool.get_message_status",
+            cancelActionId: "wbiztool.cancel_message",
+        },
+    });
+}
+export const wbiztoolActions = [
+    sendAction("send_message", false),
+    sendAction("schedule_message", true),
+    defineProviderAction("wbiztool", {
+        name: "get_message_status",
+        description: "Read a WhatsApp message state. Sent means sent from the account, not delivered or read.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("The message to query.", { msg_id: messageId }, {
+            optional: [],
+        }),
+        outputSchema: s.object("The current message state returned by Wbiztool.", {
+            status: s.integer("The message state: 0 Created, 1 Sent, 2 Failed, 3 Cancelled, or 4 Expired."),
+            status_text: s.string("The message state name: Created, Sent, Failed, Cancelled, or Expired."),
+            message: s.string("The upstream message state description."),
+            error: s.nullable(s.string("The reason sending failed, or empty when no error was reported.")),
+        }, {
+            optional: [],
+            additionalProperties: true,
+        }),
+        asyncLifecycle: {
+            startActionId: "wbiztool.send_message",
+            statusActionId: "wbiztool.get_message_status",
+            cancelActionId: "wbiztool.cancel_message",
+        },
+    }),
+    defineProviderAction("wbiztool", {
+        name: "cancel_message",
+        description: "Cancel a queued or scheduled WhatsApp message. A message already being sent may still go out.",
+        operationType: "destructive",
+        requiredScopes: [],
+        inputSchema: s.object("The queued message to cancel.", { msg_id: messageId }, {
+            optional: [],
+        }),
+        outputSchema: s.object("The cancellation response.", {
+            status: s.integer("The request success flag, 1 when cancelled."),
+            message: s.string("The upstream cancellation message."),
+        }, {
+            optional: [],
+            additionalProperties: true,
+        }),
+    }),
+];

package/src/providers/wbiztool/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/wbiztool/executors.js

@@ -0,0 +1,140 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerInputError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, isAbortLikeError, } from "../provider-runtime.js";
+import { wbiztoolActions } from "./actions.js";
+const baseUrl = "https://wbiztool.com/api/v1/";
+const headers = {
+    accept: "application/json",
+    "content-type": "application/json",
+    "user-agent": providerUserAgent,
+};
+function parseClientId(value) {
+    const id = value?.trim() ? Number(value) : NaN;
+    if (!Number.isSafeInteger(id)) {
+        throw new ProviderRequestError(400, "clientId must be a whole-number API Client ID", undefined, "invalid_input");
+    }
+    return id;
+}
+function validateSchedule(body) {
+    const [day, month, year] = String(body.date).split("/").map(Number);
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+        throw new ProviderRequestError(400, "date must be a valid calendar date in dd/mm/yyyy format", undefined, "invalid_input");
+    }
+    const timezone = optionalRawString(body.timezone);
+    if (!timezone)
+        return;
+    const abbreviations = {
+        IST: "Asia/Kolkata",
+        UTC: "UTC",
+        GMT: "GMT",
+        EST: "US/Eastern",
+        CST: "US/Central",
+        MST: "US/Mountain",
+        PST: "US/Pacific",
+        CET: "Europe/Paris",
+        CEST: "Europe/Paris",
+        EET: "Europe/Athens",
+        EEST: "Europe/Athens",
+        JST: "Asia/Tokyo",
+        AEST: "Australia/Sydney",
+        AEDT: "Australia/Sydney",
+    };
+    const normalized = abbreviations[timezone] ?? timezone;
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: normalized });
+    }
+    catch {
+        throw new ProviderRequestError(400, "timezone must be an IANA timezone or a documented uppercase abbreviation", undefined, "invalid_input");
+    }
+    body.timezone = normalized;
+}
+async function request(endpoint, body, apiKey, clientId, fetcher, validating = false, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "Wbiztool", timeoutMs: endpoint === "send_msg/" ? 120000 : undefined }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${endpoint}`, {
+            method: "POST",
+            headers,
+            signal,
+            body: JSON.stringify({ ...body, client_id: clientId, api_key: apiKey }),
+        });
+        let payload;
+        try {
+            payload = await JSON.parse(await readProviderTextBody(response, "wbiztool response", undefined, signal));
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError || isAbortLikeError(error))
+                throw error;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "Wbiztool returned a non-JSON response", undefined, "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "Wbiztool response");
+        const message = optionalRawString(result.message);
+        const isStatus = endpoint.startsWith("message/status/");
+        const validStatus = isStatus && result.status_text != null && message !== "Unknown message id";
+        if (!response.ok || (isStatus ? !validStatus : result.status !== 1)) {
+            const invalidKey = message === "Auth Error: invalid api key";
+            throw new ProviderRequestError(invalidKey ? (validating ? 400 : 401) : response.ok ? 502 : response.status, `Wbiztool: ${message ?? `request failed (HTTP ${response.status})`}`, undefined, invalidKey ? (validating ? "invalid_input" : "authorization_failed") : "provider_error");
+        }
+        return result;
+    });
+}
+export const executors = defineProviderExecutors({
+    service: "wbiztool",
+    handlers: mapProviderActionHandlers("wbiztool", wbiztoolActions, (_action, actionName) => async (input, context) => {
+        const body = input;
+        let endpoint;
+        switch (actionName) {
+            case "send_message":
+                endpoint = "send_msg/";
+                body.msg_type ??= 0;
+                break;
+            case "schedule_message":
+                endpoint = "schedule_msg/";
+                validateSchedule(body);
+                body.msg_type ??= 0;
+                break;
+            case "get_message_status":
+                endpoint = `message/status/${body.msg_id}/`;
+                delete body.msg_id;
+                break;
+            case "cancel_message":
+                endpoint = "cancel_msg/";
+                break;
+            default:
+                throw new ProviderRequestError(400, "Unknown Wbiztool action", undefined, "invalid_input");
+        }
+        return request(endpoint, body, context.apiKey, parseClientId(context.values?.clientId), context.fetcher, undefined, context.signal);
+    }),
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "wbiztool");
+        return { apiKey: credential.apiKey, values: credential.values, fetcher, signal: context.signal };
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const clientId = parseClientId(input.values.clientId);
+        const result = await request("me/", {}, requiredInputString(input.apiKey, "API Key"), clientId, fetcher, true);
+        return {
+            profile: { displayName: optionalRawString(result.name) ?? "Wbiztool API Key" },
+            grantedScopes: [],
+            metadata: { clientId },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "wbiztool",
+    baseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+    async customizeRequest({ context, method, body, setBody, headers: requestHeaders }) {
+        if (method.toUpperCase() !== "POST")
+            throw providerInputError("Wbiztool proxy supports JSON POST endpoints with body authentication");
+        const data = body == null ? {} : optionalRecord(body);
+        if (!data)
+            throw providerInputError("Wbiztool proxy requires a JSON object body");
+        const credential = await requireApiKeyCredential(context, "wbiztool");
+        setBody({ ...data, api_key: credential.apiKey, client_id: parseClientId(credential.values?.clientId) });
+        for (const [key, value] of Object.entries(headers))
+            requestHeaders.set(key, value);
+    },
+});

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) {