@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/hithink_finance/market-dumps.js

@@ -1,5 +1,5 @@
 import { optionalRecord, requiredString } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { ProviderRequestError, providerResponseError } from "../provider-runtime.js";
 const mimeType = "application/vnd.apache.parquet";
 const timeoutMs = 10 * 60 * 1_000;
@@ -35,34 +35,80 @@ async function exportMarketDump(get, path, name, context) {
         await response.body?.cancel().catch(() => undefined);
         throw new ProviderRequestError(502, `market dump download failed with HTTP ${response.status}`);
     }
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    if (!response.body)
+        throw new ProviderRequestError(502, "market dump does not have a valid Parquet envelope");
+    const stored = await storeResponseInTransit(new Response(response.body.pipeThrough(validateParquetEnvelopeStream()), { headers: response.headers }), context.transitFiles, {
+        name,
+        mimeType,
         fieldName: "market dump",
         createError: (message) => new ProviderRequestError(502, message),
+        signal,
     });
-    validateParquetEnvelope(bytes);
-    const stored = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         file: {
             fileId: stored.fileId,
             downloadUrl: stored.downloadUrl,
-            sizeBytes: bytes.byteLength,
+            sizeBytes: stored.sizeBytes,
             name,
             mimeType,
         },
         sourceExpiresAt,
     };
 }
-function validateParquetEnvelope(bytes) {
+/**
+ * Validate the Parquet envelope while the body streams to transit storage: the
+ * file starts and ends with `PAR1`, and the four bytes before the footer hold a
+ * metadata length within the file. Only the first four and the last eight bytes
+ * are ever buffered, so a market dump of any size costs a constant amount of
+ * memory. A violation errors the stream, and the store discards the partial
+ * file.
+ */
+function validateParquetEnvelopeStream() {
+    const magicLength = 4;
+    let header = new Uint8Array(0);
+    let tail = new Uint8Array(0);
+    let total = 0;
+    return new TransformStream({
+        transform(chunk, controller) {
+            if (header.byteLength < magicLength) {
+                const length = Math.min(magicLength, header.byteLength + chunk.byteLength);
+                const merged = new Uint8Array(length);
+                merged.set(header);
+                merged.set(chunk.subarray(0, length - header.byteLength), header.byteLength);
+                header = merged;
+            }
+            total += chunk.byteLength;
+            if (chunk.byteLength >= 8) {
+                tail = new Uint8Array(chunk.subarray(chunk.byteLength - 8));
+            }
+            else {
+                const merged = new Uint8Array(tail.byteLength + chunk.byteLength);
+                merged.set(tail);
+                merged.set(chunk, tail.byteLength);
+                tail = new Uint8Array(merged.subarray(Math.max(0, merged.byteLength - 8)));
+            }
+            controller.enqueue(chunk);
+        },
+        flush(controller) {
+            try {
+                assertParquetEnvelope(header, tail, total);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
+function assertParquetEnvelope(header, tail, total) {
     const magic = [0x50, 0x41, 0x52, 0x31];
-    const hasHeader = magic.every((byte, index) => bytes[index] === byte);
-    const hasFooter = magic.every((byte, index) => bytes[bytes.byteLength - 4 + index] === byte);
-    if (bytes.byteLength < 13 || !hasHeader || !hasFooter) {
+    const hasHeader = magic.every((byte, index) => header[index] === byte);
+    const hasFooter = magic.every((byte, index) => tail[tail.byteLength - 4 + index] === byte);
+    if (total < 13 || !hasHeader || !hasFooter) {
         throw new ProviderRequestError(502, "market dump does not have a valid Parquet envelope");
     }
-    const footer = bytes.subarray(bytes.byteLength - 8, bytes.byteLength - 4);
+    const footer = tail.subarray(tail.byteLength - 8, tail.byteLength - 4);
     const metadataLength = (footer[0] | (footer[1] << 8) | (footer[2] << 16) | (footer[3] << 24)) >>> 0;
-    if (metadataLength === 0 || metadataLength > bytes.byteLength - 12) {
+    if (metadataLength === 0 || metadataLength > total - 12) {
         throw new ProviderRequestError(502, "market dump does not have valid Parquet metadata bounds");
     }
 }

package/src/providers/hithink_finance/runtime.js

@@ -393,7 +393,7 @@ function getPool(get, path, input, context) {
 function getFinancialStatements(path, input, context) {
     return get(path, {
         thscode: requiredInputString(input.thscode, "thscode"),
-        period: optionalString(input.period),
+        period: optionalString(input.period) ?? "annual",
         limit: optionalNumber(input.limit),
         start: optionalNumber(input.startTimeMs),
         end: optionalNumber(input.endTimeMs),

package/src/providers/http-json-runtime.js

@@ -1,6 +1,6 @@
 import { optionalRecord, optionalString } from "../core/cast.js";
 import { queryParams } from "../core/request.js";
-import { providerUserAgent, ProviderRequestError } from "./provider-runtime.js";
+import { isAbortLikeError, isAbortSignalError, providerUserAgent, ProviderRequestError } from "./provider-runtime.js";
 export async function requestJson(input) {
     let response;
     let payload;
@@ -17,6 +17,9 @@ export async function requestJson(input) {
         if (error instanceof ProviderRequestError) {
             throw error;
         }
+        if (isAbortLikeError(error) || isAbortSignalError(input.signal, error)) {
+            throw new ProviderRequestError(504, `${input.providerName} request timed out`);
+        }
         throw new ProviderRequestError(502, error instanceof Error
             ? `${input.providerName} request failed: ${error.message}`
             : `${input.providerName} request failed`);

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

@@ -0,0 +1,58 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { optionalRecord } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, requiredInputString, } from "../provider-runtime.js";
+const origin = "https://mcp.huodingdong.com";
+const endpoint = `${origin}/mcp`;
+function connection(context) {
+    return {
+        endpoint,
+        service: "Huodingdong",
+        fetcher: context.fetcher,
+        signal: context.signal,
+        headers: { "X-Mcp-Key": requiredInputString(context.apiKey, "X-Mcp-Key") },
+        redirect: "manual",
+        terminateSession: true,
+        maxResponseBytes: 16 * 1024 * 1024,
+    };
+}
+export const executors = defineApiKeyProviderExecutors("huodingdong_mcp", {
+    async list_tools(_input, context) {
+        return {
+            tools: await listMcpTools(connection(context), { includeAnnotations: true, includeOutputSchema: true }),
+        };
+    },
+    async call_tool(input, context) {
+        const toolName = requiredInputString(input.toolName, "toolName");
+        const args = optionalRecord(input.arguments) ?? {};
+        // The official connector package requires region even when the live schema omits it.
+        if (toolName === "hdd_product_pricing_simulation")
+            requiredInputString(args.region, "region");
+        return { result: await callMcpTool({ ...connection(context), toolName, arguments: args }) };
+    },
+}, { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const key = requiredInputString(input.apiKey, "X-Mcp-Key");
+        const tools = await listMcpTools(connection({ apiKey: key, fetcher, signal }));
+        const hash = sha256Hex(key);
+        return {
+            profile: { accountId: `huodingdong-mcp:${hash}`, displayName: `Huodingdong ERP MCP · ${hash.slice(-6)}` },
+            grantedScopes: [],
+            metadata: { mcpEndpoint: endpoint, discoveredToolCount: tools.length },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "huodingdong_mcp",
+    baseUrl: origin,
+    auth: { type: "api_key_header", name: "X-Mcp-Key" },
+    skipDnsValidation: true,
+    sensitiveHeaders: ["X-Mcp-Key"],
+    customizeRequest({ url, headers }) {
+        if (url.href !== endpoint)
+            throw providerInputError("Huodingdong MCP proxy only supports the official /mcp endpoint without a query string");
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json, text/event-stream");
+    },
+});

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

@@ -0,0 +1,16 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { indexedActionHandlers, indexedApiBaseUrl, readIndexedError, validateIndexedCredential } from "./runtime.js";
+const service = "indexed";
+export const executors = defineApiKeyProviderExecutors(service, indexedActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: indexedApiBaseUrl,
+    auth: { type: "api_key_header", name: "X-API-Key" },
+    readError: readIndexedError,
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey: validateIndexedCredential,
+};

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

@@ -0,0 +1,26 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const indexedApiBaseUrl = "https://indexed.vc/api/v1";
+type IndexedPhase = "validate" | "execute";
+type IndexedActionHandler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const indexedActionHandlers: ProviderActionHandlers<"indexed", IndexedActionHandler>;
+/**
+ * Validate a key with GET /usage, which the API documents as free of credit charges.
+ */
+export declare function validateIndexedCredential(input: {
+    apiKey: string;
+}, options: {
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;
+/**
+ * Read an Indexed error response and map it onto the runtime's status conventions.
+ * 402 is a billing state (credits exhausted), reported as insufficient_credit.
+ * 403 TIER_UPGRADE_REQUIRED is a plan limit rather than a credential failure, so
+ * it is reported as invalid input instead of prompting a reconnect. During key
+ * validation a 401 or 403 is a field error on the submitted key. Every other
+ * status keeps its upstream value, so a 404 stays a not-found result.
+ */
+export declare function readIndexedError(response: Response, phase?: IndexedPhase): Promise<ProviderRequestError>;
+export {};

package/src/providers/indexed/runtime.js

@@ -0,0 +1,128 @@
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { encodePathSegment, queryParams } from "../../core/request.js";
+import { parseProviderJsonBodyText, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const indexedApiBaseUrl = "https://indexed.vc/api/v1";
+export const indexedActionHandlers = {
+    lookup_company_by_domain(input, context) {
+        return requestIndexed({
+            context,
+            path: "/companies",
+            query: { domain: requiredInputString(input.domain, "domain") },
+        });
+    },
+    lookup_companies_by_domains(input, context) {
+        return requestIndexed({ context, path: "/companies/lookup", body: { domains: input.domains } });
+    },
+    search_companies(input, context) {
+        return requestIndexed({
+            context,
+            path: "/companies",
+            query: {
+                q: optionalString(input.q),
+                industries: joinList(input.industries),
+                countries: joinList(input.countries),
+                employees: joinList(input.employees),
+                operatingStatus: joinList(input.operatingStatus),
+                minFunding: optionalInteger(input.minFunding),
+                maxFunding: optionalInteger(input.maxFunding),
+                minCompleteness: optionalInteger(input.minCompleteness),
+                updated_since: optionalString(input.updatedSince),
+                reveal_status: optionalString(input.revealStatus),
+                sort: optionalString(input.sort),
+                order: optionalString(input.order),
+                page: optionalInteger(input.page),
+                limit: optionalInteger(input.limit),
+                cursor: optionalString(input.cursor),
+            },
+        });
+    },
+    get_company(input, context) {
+        return requestIndexed({
+            context,
+            path: `/companies/${encodePathSegment(requiredInputString(input.slug, "slug"))}`,
+            query: { depth: optionalString(input.depth) },
+        });
+    },
+};
+/**
+ * Validate a key with GET /usage, which the API documents as free of credit charges.
+ */
+export async function validateIndexedCredential(input, options) {
+    const payload = await requestIndexed({
+        context: { apiKey: input.apiKey, fetcher: options.fetcher, signal: options.signal },
+        path: "/usage",
+        phase: "validate",
+    });
+    const usage = optionalRecord(payload.data);
+    const tier = optionalString(usage?.tier);
+    return {
+        profile: {
+            displayName: tier ? `Indexed API Key (${tier} plan)` : "Indexed API Key",
+        },
+        grantedScopes: [],
+        metadata: compactObject({
+            apiBaseUrl: indexedApiBaseUrl,
+            validationEndpoint: "/usage",
+            tier,
+            creditsRemaining: optionalInteger(usage?.credits_remaining),
+        }),
+    };
+}
+function joinList(value) {
+    return Array.isArray(value) && value.length > 0 ? value.join(",") : undefined;
+}
+async function requestIndexed(input) {
+    const { context } = input;
+    const url = new URL(`${indexedApiBaseUrl}${input.path}`);
+    for (const [key, value] of Object.entries(queryParams(input.query ?? {}))) {
+        url.searchParams.set(key, value);
+    }
+    return runProviderRequest({ signal: context.signal, label: "Indexed" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: input.body ? "POST" : "GET",
+            headers: compactObject({
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": context.apiKey,
+                "content-type": input.body ? "application/json" : undefined,
+            }),
+            body: input.body ? JSON.stringify(input.body) : undefined,
+            signal,
+        });
+        if (!response.ok) {
+            throw await readIndexedError(response, input.phase ?? "execute");
+        }
+        const payload = parseProviderJsonBodyText(await readProviderTextBody(response, "Indexed response"), {
+            emptyBody: {},
+            invalidJsonMessage: "Indexed returned malformed JSON",
+        });
+        return requiredResponseRecord(payload, "Indexed response");
+    });
+}
+/**
+ * Read an Indexed error response and map it onto the runtime's status conventions.
+ * 402 is a billing state (credits exhausted), reported as insufficient_credit.
+ * 403 TIER_UPGRADE_REQUIRED is a plan limit rather than a credential failure, so
+ * it is reported as invalid input instead of prompting a reconnect. During key
+ * validation a 401 or 403 is a field error on the submitted key. Every other
+ * status keeps its upstream value, so a 404 stays a not-found result.
+ */
+export async function readIndexedError(response, phase = "execute") {
+    const status = response.status;
+    const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "Indexed error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "Indexed returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const body = optionalRecord(payload);
+    const message = optionalString(body?.error) ?? `Indexed request failed with HTTP ${status}`;
+    const details = withRetryAfterSeconds(response, payload);
+    if (status === 402) {
+        return new ProviderRequestError(402, message, details, "insufficient_credit");
+    }
+    if ((status === 401 || status === 403) &&
+        (phase === "validate" || optionalString(body?.code) === "TIER_UPGRADE_REQUIRED")) {
+        return new ProviderRequestError(400, message, details);
+    }
+    return new ProviderRequestError(status, message, details, status === 429 ? "rate_limited" : "provider_error");
+}

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

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

package/src/providers/issue_badge/actions.js

@@ -0,0 +1,95 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const issuedBadge = s.looseObject("An issued badge with recipient details and verification URLs.", {
+    issue_id: s.string("Encrypted issue ID."),
+    recipient_name: s.string("Recipient's full name."),
+    recipient_email: s.string("Recipient's email address."),
+    recipient_phone: s.string("Recipient's phone number."),
+    badge_id: s.string("Encrypted badge ID."),
+    badge_name: s.string("Badge name."),
+    organization_name: s.string("Issuing organization name."),
+    issue_date: s.string("Badge issue date."),
+    expire_date: s.nullable(s.string("Badge expiration date, if set.")),
+    serial_number: s.nullable(s.string("Badge serial number, if set.")),
+    memo: s.nullable(s.string("Additional notes, if set.")),
+    public_url: s.string("Public verification URL."),
+    pdf_url: s.string("PDF download URL."),
+    metadata: s.nullable(s.looseObject("Custom field values and additional metadata.", {})),
+    created_at: s.string("Record creation timestamp."),
+    updated_at: s.string("Record last update timestamp."),
+});
+export const issueBadgeActions = [
+    defineProviderAction("issue_badge", {
+        name: "list_badges",
+        description: "List up to 100 badge templates in your IssueBadge organization. The API does not expose pagination for this list.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Input for listing badge templates.", {}),
+        outputSchema: s.looseObject("Badge template list response.", {
+            success: s.boolean("Whether the request succeeded."),
+            message: s.string("Response message."),
+            data: s.array("Available badge templates.", s.looseObject("A badge template.", {
+                id: s.string("Encrypted badge ID."),
+                name: s.string("Badge name."),
+            })),
+        }),
+    }),
+    defineProviderAction("issue_badge", {
+        name: "issue_badge",
+        description: "Issue an existing IssueBadge template to a recipient and create a public verification URL. Providing an email address triggers a notification email. Reuse an idempotency key to retrieve the existing issuance without issuing it again.",
+        operationType: "write",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Input for issuing a badge.", {
+            badge_id: s.nonEmptyString("Encrypted badge ID from list_badges."),
+            name: s.nonEmptyString("Recipient's full name.", { maxLength: 200 }),
+            email: s.optional(s.email("Recipient's email address for notification.")),
+            phone: s.optional(s.string("Recipient's phone number.")),
+            idempotency_key: s.optional(s.nonEmptyString("Unique key to prevent duplicate issuance. Generated by IssueBadge when omitted.", {
+                maxLength: 100,
+            })),
+            metadata: s.optional(s.looseObject("Custom field values and additional metadata.", {})),
+        }),
+        outputSchema: s.looseObject("Badge issuance response, including an existing issue on an idempotency replay.", {
+            success: s.boolean("Whether the request succeeded."),
+            IssueId: s.string("Encrypted issue ID for tracking."),
+            publicUrl: s.string("Public verification URL."),
+        }),
+    }),
+    defineProviderAction("issue_badge", {
+        name: "list_issued_badges",
+        description: "List issued IssueBadge records with pagination and optional badge, recipient name, and recipient email filters.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Input for listing issued badges.", {
+            badge_id: s.optional(s.nonEmptyString("Filter by encrypted badge ID.")),
+            recipient_name: s.optional(s.string("Search by recipient name using a partial match.")),
+            recipient_email: s.optional(s.string("Search by recipient email using a partial match.")),
+            page: s.optional(s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 })),
+            per_page: s.optional(s.integer("Items per page, up to 100. Defaults to 10.", { minimum: 1, maximum: 100 })),
+        }),
+        outputSchema: s.looseObject("Paginated issued badge response.", {
+            success: s.boolean("Whether the request succeeded."),
+            data: s.array("Issued badges matching the filters.", issuedBadge),
+            pagination: s.looseObject("Pagination metadata.", {
+                current_page: s.integer("Current page number."),
+                per_page: s.integer("Items per page."),
+                total: s.integer("Total number of matching records."),
+                total_pages: s.integer("Total number of pages."),
+                has_more: s.boolean("Whether another page is available."),
+            }),
+        }),
+    }),
+    defineProviderAction("issue_badge", {
+        name: "get_issued_badge",
+        description: "Retrieve an issued IssueBadge record by encrypted issue ID, including recipient details, metadata, verification URL, and PDF URL.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Input for retrieving an issued badge.", {
+            id: s.nonEmptyString("Encrypted issue ID."),
+        }),
+        outputSchema: s.looseObject("Issued badge details response.", {
+            success: s.boolean("Whether the request succeeded."),
+            data: issuedBadge,
+        }),
+    }),
+];

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

@@ -0,0 +1,98 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, providerUserAgent, readProviderTextBody, } from "../provider-runtime.js";
+import { issueBadgeActions } from "./actions.js";
+const apiBaseUrl = "https://app.issuebadge.com/api/v1";
+async function request(path, apiKey, fetcher, options = {}, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "IssueBadge" }, async (signal) => {
+        const url = new URL(`${apiBaseUrl}${path}`);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+        const headers = new Headers({ accept: "application/json", "user-agent": providerUserAgent });
+        if (!options.validate)
+            headers.set("authorization", `Bearer ${apiKey}`);
+        if (options.body)
+            headers.set("content-type", "application/json");
+        const response = await fetcher(url, {
+            method: options.method ?? "GET",
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+            signal,
+        });
+        const text = await readProviderTextBody(response, "issue_badge response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = null;
+        }
+        const record = optionalRecord(payload);
+        const message = [optionalRawString(record?.message), optionalRawString(record?.error)].filter(Boolean).join(": ") ||
+            (!response.ok && payload === null ? text.trim().slice(0, 1000) : "") ||
+            `IssueBadge request failed (HTTP ${response.status})`;
+        if (!response.ok) {
+            throw new ProviderRequestError(response.status, message, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (options.validate && optionalRecord(record?.data)?.valid === false) {
+            throw new ProviderRequestError(400, message, undefined, "invalid_input");
+        }
+        if (record?.success === false) {
+            throw new ProviderRequestError(502, message, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "IssueBadge");
+    });
+}
+const handlers = mapProviderActionHandlers("issue_badge", issueBadgeActions, (action) => async (values, context) => {
+    const apiKey = context.apiKey;
+    const fetcher = context.fetcher;
+    switch (action.name) {
+        case "list_badges":
+            return request("/badge/getall", apiKey, fetcher, undefined, context.signal);
+        case "issue_badge":
+            return request("/issue/create", apiKey, fetcher, { method: "POST", body: values }, context.signal);
+        case "list_issued_badges":
+            return request("/issue/get", apiKey, fetcher, { query: values }, context.signal);
+        case "get_issued_badge": {
+            const id = requiredInputString(values.id, "id");
+            if (id === "." || id === "..") {
+                throw new ProviderRequestError(400, "id cannot be a dot path segment", undefined, "invalid_input");
+            }
+            return request(`/issue/get/${encodeURIComponent(id)}`, apiKey, fetcher, undefined, context.signal);
+        }
+    }
+});
+export const executors = defineApiKeyProviderExecutors("issue_badge", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const payload = await request("/validate-key", requiredInputString(input.apiKey, "API Key"), fetcher, {
+            method: "POST",
+            body: { api_key: requiredInputString(input.apiKey, "API Key") },
+            validate: true,
+        });
+        const data = optionalRecord(payload.data);
+        if (data?.valid !== true) {
+            throw new ProviderRequestError(502, "IssueBadge validation response omitted a valid result", undefined, "provider_error");
+        }
+        return {
+            profile: { displayName: "IssueBadge API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "issue_badge",
+    baseUrl: apiBaseUrl,
+    auth: { type: "bearer" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+        if (!headers.has("user-agent"))
+            headers.set("user-agent", providerUserAgent);
+    },
+});

package/src/providers/iyunbiao/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
+import { assertPublicHttpUrl, storeResponseInTransit } from "../../core/request.js";
 import { providerInputError, ProviderRequestError, readTransitFileInput, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 function readIyunbiaoCredentials(values) {
     const url = assertPublicHttpUrl(requiredInputString(values.instanceUrl, "instanceUrl"), {
@@ -193,12 +193,13 @@ export async function executeIyunbiaoAction(name, input, values, options) {
                 const mimeType = response.headers.get("content-type") || "application/octet-stream";
                 if (!options.transitFiles)
                     throw providerInputError("Transit file storage is not enabled");
-                const bytes = await readBoundedResponseBytes(response, {
-                    maxBytes: options.transitFiles.maxBytes,
+                const file = await storeResponseInTransit(response, options.transitFiles, {
+                    name: fileName,
+                    mimeType,
                     fieldName: "Yunbiao attachment download",
                     createError: (message) => new ProviderRequestError(413, message),
+                    signal,
                 });
-                const file = await options.transitFiles.create(new File([Uint8Array.from(bytes)], fileName, { type: mimeType }));
                 return { file, fileName, mimeType };
             });
     }

package/src/providers/justoneapi/actions-commerce.d.ts

@@ -0,0 +1,2 @@
+import type { JustoneapiEndpoint } from "./endpoint-definition.ts";
+export declare const commerceEndpoints: readonly JustoneapiEndpoint[];