@oomol-lab/open-connector 1.6.3 → 1.6.5

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

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

package/src/providers/ixspy/executors.js

@@ -0,0 +1,220 @@
+import { compactObject, looseArray, optionalInteger, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "ixspy";
+const baseUrl = "https://open.ixspy.com";
+const configs = {
+    get_category_resource: { path: "/api/v1/aliexpress/category-resource", kind: "category_resource" },
+    list_category_children: { path: "/api/v1/aliexpress/category-children", kind: "category_children" },
+    search_categories: { path: "/api/v1/aliexpress/category-lookup", kind: "list" },
+    search_products: { path: "/api/v1/aliexpress/product-search", kind: "list" },
+    get_product_details: { path: "/api/v1/aliexpress/product-detail", kind: "list" },
+    search_stores: { path: "/api/v1/aliexpress/store-search", kind: "list" },
+    get_store_details: { path: "/api/v1/aliexpress/store-detail", kind: "list" },
+    get_product_sku_sales: { path: "/api/v1/aliexpress/product-orders-sku-stat", kind: "product_statistics" },
+    get_product_shipping_stats: { path: "/api/v1/aliexpress/product-orders-shipping-stat", kind: "product_statistics" },
+    get_product_region_sales: { path: "/api/v1/aliexpress/product-orders-region-stat", kind: "product_statistics" },
+    get_product_trends: { path: "/api/v1/aliexpress/product-trend-data", kind: "product_trends" },
+    get_store_category_distribution: { path: "/api/v1/aliexpress/store-category-stat", kind: "store_statistics" },
+    get_store_region_sales: { path: "/api/v1/aliexpress/store-orders-region-stat", kind: "store_statistics" },
+    get_store_trends: { path: "/api/v1/aliexpress/store-trend-data", kind: "store_trends" },
+    get_product_rank: { path: "/api/v1/aliexpress/product-rank", kind: "list" },
+    get_region_product_rank: { path: "/api/v1/aliexpress/product-rank-by-region", kind: "list" },
+    get_store_rank: { path: "/api/v1/aliexpress/store-rank", kind: "list" },
+    get_keyword_rank: { path: "/api/v1/aliexpress/keyword-rank", kind: "list" },
+    list_rank_dates: { path: "/api/v1/aliexpress/rank-date-list", kind: "rank_dates", method: "GET" },
+    research_categories: { path: "/api/v1/aliexpress/category-research", kind: "list" },
+    get_market_insights: { path: "/api/v1/aliexpress/market-insights", kind: "list" },
+};
+const keyOverrides = {
+    averagePriceMax: "avg_price_max",
+    averagePriceMin: "avg_price_min",
+    choiceTypes: "choice_type",
+    createdAfter: "created_time_min",
+    createdBefore: "created_time_max",
+    discoveredAfter: "discovered_time_start",
+    discoveredBefore: "discovered_time_end",
+    linkIds: "store_link_id",
+    merchantIds: "store_merchant_id",
+    productIds: "product_id_list",
+    sales7dMax: "sales_count_7d_max",
+    sales7dMin: "sales_count_7d_min",
+    updatedAfter: "updated_time_min",
+    updatedBefore: "updated_time_max",
+};
+const orderValues = {
+    clickRate: "click_rate",
+    conversionRate: "conversion_rate",
+    createdTime: "created_time",
+    discoveredTime: "discovered_time",
+    sales7d: "sales_count_7d",
+    searchGrowth: "searches_rise_index",
+    searchPopularity: "search_cookies_count",
+    totalFollowers: "total_followers",
+    totalReviews: "total_reviews",
+    totalSales: "total_sales",
+};
+const rankValues = {
+    holidayNew: "holiday_new",
+    holidayNormal: "holiday_normal",
+    holidayRank: "holiday_rank",
+    keywordRank: "keyword_rank",
+    newGrowth: "new_inc",
+    newHot: "new_hot",
+    normalGrowth: "normal_inc",
+    normalHot: "normal_hot",
+    normalRank: "normal_rank",
+};
+const handlers = Object.fromEntries(Object.entries(configs).map(([name, config]) => [
+    name,
+    async (input, context) => normalize(config.kind, await request(name, config, input, context, false)),
+]));
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, context) {
+        const payload = await request("list_category_children", configs.list_category_children, { parentId: 0 }, { ...context, apiKey: input.apiKey }, true);
+        const data = requiredResponseRecord(payload.data, "IXSPY category data");
+        return {
+            profile: { accountId: "ixspy-api-key", displayName: "IXSPY API Key" },
+            grantedScopes: [],
+            metadata: {
+                apiBaseUrl: baseUrl,
+                validationEndpoint: configs.list_category_children.path,
+                categoryCount: optionalInteger(data.count) ?? looseArray(data.children).length,
+            },
+        };
+    },
+};
+async function request(name, config, input, context, validating) {
+    const method = config.method ?? "POST";
+    const body = upstream(name, input);
+    return runProviderRequest({ signal: context.signal, label: "IXSPY" }, async (signal) => {
+        const url = new URL(config.path, baseUrl);
+        if (method === "GET")
+            for (const [key, value] of Object.entries(body)) {
+                if (Array.isArray(value))
+                    for (const item of value)
+                        url.searchParams.append(key, String(item));
+                else
+                    url.searchParams.set(key, String(value));
+            }
+        const response = await context.fetcher(url, {
+            method,
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${context.apiKey}`,
+                ...(method === "POST" ? { "content-type": "application/json" } : {}),
+                "user-agent": providerUserAgent,
+            },
+            body: method === "POST" ? JSON.stringify(body) : undefined,
+            signal,
+        });
+        const payload = requiredResponseRecord(await readProviderJsonBody(response, { emptyBody: {}, invalidJsonMessage: "IXSPY returned invalid JSON" }), "IXSPY response");
+        const error = optionalRecord(payload.error);
+        const code = optionalInteger(error?.code);
+        if (code !== undefined && code !== 0)
+            throw ixspyError(code, optionalString(error?.message), validating);
+        if (!response.ok)
+            throw new ProviderRequestError(response.status, optionalString(error?.message) ?? `IXSPY request failed with HTTP ${response.status}`, payload);
+        if (code !== 0)
+            throw providerResponseError("IXSPY response is missing a success code");
+        return payload;
+    });
+}
+function upstream(name, input) {
+    return compactObject(Object.fromEntries(Object.entries(input).map(([key, value]) => {
+        let field = keyOverrides[key] ?? snake(key);
+        if ((name === "get_product_rank" || name === "get_region_product_rank") &&
+            (key === "priceMin" || key === "priceMax"))
+            field = key === "priceMin" ? "product_price_min" : "product_price_max";
+        if (key === "hasVideo")
+            value = value === true ? 1 : value === false ? 2 : value;
+        if ((key === "isLeaf" || key === "styleZone") && typeof value === "boolean")
+            value = value ? 1 : 0;
+        if (key === "orderBy" && typeof value === "string")
+            value = orderValues[value] ?? value;
+        if (key === "rankType" && typeof value === "string")
+            value = rankValues[value] ?? value;
+        return [field, value];
+    })));
+}
+function snake(value) {
+    let result = "";
+    for (const character of value)
+        result += character === character.toLowerCase() ? character : `_${character.toLowerCase()}`;
+    return result;
+}
+function ixspyError(code, message, validating) {
+    const detail = message?.trim() || `IXSPY error ${code}`;
+    if (code === 10402 || code === 10404)
+        return validating ? providerInputError(detail) : new ProviderRequestError(409, detail);
+    if (code === 10429)
+        return new ProviderRequestError(429, detail);
+    if (code === 5024)
+        return new ProviderRequestError(402, detail);
+    if (code === 10422)
+        return providerInputError(detail);
+    return new ProviderRequestError(code === 5016 ? 404 : 502, detail);
+}
+function normalize(kind, payload) {
+    const data = requiredResponseRecord(payload.data, "IXSPY data");
+    const credits = optionalNumber(payload.credits) ?? null;
+    if (kind === "category_resource")
+        return { url: responseString(data.link, "category resource link"), credits };
+    if (kind === "category_children")
+        return {
+            parentId: identifier(data.parent_id, "parent category ID"),
+            count: optionalInteger(data.count) ?? looseArray(data.children).length,
+            categories: looseArray(data.children),
+            credits,
+        };
+    if (kind === "rank_dates")
+        return {
+            rankType: responseString(data.rank_type, "rank type"),
+            dateTypes: looseArray(data.date_type_list),
+            credits,
+        };
+    if (kind === "product_statistics" || kind === "store_statistics")
+        return {
+            entityId: identifier(data[kind === "product_statistics" ? "product_id" : "store_merchant_id"], "entity ID"),
+            statistics: looseArray(data.stat_data),
+            credits,
+        };
+    if (kind === "product_trends" || kind === "store_trends")
+        return {
+            entityId: identifier(data[kind === "product_trends" ? "product_id" : "store_merchant_id"], "entity ID"),
+            startDate: optionalString(data.start_date) ?? null,
+            endDate: optionalString(data.end_date) ?? null,
+            points: looseArray(data.trend_data),
+            credits,
+        };
+    return {
+        items: looseArray(data.list),
+        page: numberLike(data.page),
+        pages: numberLike(data.pages),
+        total: numberLike(data.total),
+        credits,
+    };
+}
+function identifier(value, label) {
+    if (typeof value === "string" || (typeof value === "number" && Number.isFinite(value)))
+        return value;
+    throw providerResponseError(`IXSPY ${label} is required`);
+}
+function responseString(value, label) {
+    const result = optionalString(value);
+    if (result != null)
+        return result;
+    throw providerResponseError(`IXSPY ${label} is required`);
+}
+function numberLike(value) {
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const result = Number(value);
+        if (Number.isFinite(result))
+            return result;
+    }
+    return null;
+}

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

@@ -10,6 +10,7 @@ export interface McpClientOptions {
     signal?: AbortSignal;
     protocolVersion?: McpProtocolVersion;
     terminateSession?: boolean;
+    retryOnSessionNotFound?: boolean;
     mapError?: (error: unknown) => unknown;
 }
 export declare function withMcpClient<T>(options: McpClientOptions, run: (client: Client) => Promise<T>): Promise<T>;

package/src/providers/mcp-client.js

@@ -1,4 +1,4 @@
-import { Client } from "@modelcontextprotocol/client";
+import { Client, SdkHttpError } from "@modelcontextprotocol/client";
 import { SSEClientTransport } from "@modelcontextprotocol/client";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/client/validators/cf-worker";
@@ -6,33 +6,47 @@ const mcpConnectTimeoutMs = 60_000;
 const modernMcpProtocolVersion = "2026-07-28";
 const mcpJsonSchemaValidator = new CfWorkerJsonSchemaValidator();
 export async function withMcpClient(options, run) {
-    const transportOptions = {
-        fetch: options.fetcher,
-        requestInit: {
-            headers: options.headers,
-            redirect: options.redirect,
-            signal: options.signal,
-        },
-    };
-    const transport = options.transport === "sse"
-        ? new SSEClientTransport(options.endpoint, transportOptions)
-        : new StreamableHTTPClientTransport(options.endpoint, transportOptions);
-    const client = new Client({ name: "open-connector", version: "1.0.0" }, {
-        jsonSchemaValidator: mcpJsonSchemaValidator,
-        versionNegotiation: { mode: resolveVersionNegotiationMode(options.protocolVersion) },
-    });
-    try {
-        await client.connect(transport, { timeout: mcpConnectTimeoutMs, signal: options.signal });
-        return await run(client);
-    }
-    catch (error) {
-        throw options.mapError ? options.mapError(error) : error;
-    }
-    finally {
-        if (options.terminateSession && transport instanceof StreamableHTTPClientTransport) {
-            await terminateMcpSession(transport);
+    let retriedSession = false;
+    while (true) {
+        const transportOptions = {
+            fetch: options.fetcher,
+            requestInit: {
+                headers: options.headers,
+                redirect: options.redirect,
+                signal: options.signal,
+            },
+        };
+        const transport = options.transport === "sse"
+            ? new SSEClientTransport(options.endpoint, transportOptions)
+            : new StreamableHTTPClientTransport(options.endpoint, transportOptions);
+        const client = new Client({ name: "open-connector", version: "1.0.0" }, {
+            jsonSchemaValidator: mcpJsonSchemaValidator,
+            versionNegotiation: { mode: resolveVersionNegotiationMode(options.protocolVersion) },
+        });
+        let connected = false;
+        try {
+            await client.connect(transport, { timeout: mcpConnectTimeoutMs, signal: options.signal });
+            connected = true;
+            return await run(client);
+        }
+        catch (error) {
+            if (connected &&
+                options.transport === "streamable_http" &&
+                options.retryOnSessionNotFound === true &&
+                !retriedSession &&
+                error instanceof SdkHttpError &&
+                error.status === 404) {
+                retriedSession = true;
+                continue;
+            }
+            throw options.mapError ? options.mapError(error) : error;
+        }
+        finally {
+            if (options.terminateSession && transport instanceof StreamableHTTPClientTransport) {
+                await terminateMcpSession(transport);
+            }
+            await client.close().catch(() => undefined);
         }
-        await client.close().catch(() => undefined);
     }
 }
 async function terminateMcpSession(transport) {

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

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

package/src/providers/osv/executors.js

@@ -0,0 +1,11 @@
+import { defineProviderExecutors } from "../provider-runtime.js";
+import { osvActionHandlers } from "./runtime.js";
+const service = "osv";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: osvActionHandlers,
+    skipDnsValidation: true,
+    createContext(context, fetcher) {
+        return { fetcher, signal: context.signal };
+    },
+});

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

@@ -0,0 +1,9 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const osvApiBaseUrl = "https://api.osv.dev";
+export interface OsvRuntimeContext {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type OsvActionHandler = (input: Record<string, unknown>, context: OsvRuntimeContext) => Promise<unknown>;
+export declare const osvActionHandlers: ProviderActionHandlers<"osv", OsvActionHandler>;
+export {};

package/src/providers/osv/runtime.js

@@ -0,0 +1,66 @@
+import { compactObject, optionalRawString, optionalRecord, optionalString } from "../../core/cast.js";
+import { providerResponseError, providerUserAgent, ProviderRequestError, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const osvApiBaseUrl = "https://api.osv.dev";
+export const osvActionHandlers = {
+    async query_vulnerabilities(input, context) {
+        const payload = requiredResponseRecord(await requestOsvJson("/v1/query", {
+            method: "POST",
+            body: JSON.stringify(compactObject({
+                package: {
+                    ecosystem: requiredInputString(input.ecosystem, "ecosystem"),
+                    name: requiredInputString(input.package, "package"),
+                },
+                version: optionalString(input.version),
+                page_token: optionalString(input.pageToken),
+            })),
+        }, context), "OSV query response");
+        const vulnerabilities = payload.vulns === undefined ? [] : payload.vulns;
+        if (!Array.isArray(vulnerabilities)) {
+            throw providerResponseError("OSV query vulnerabilities must be an array of objects");
+        }
+        if (!vulnerabilities.every((vulnerability) => optionalRecord(vulnerability))) {
+            throw providerResponseError("OSV query vulnerabilities must be an array of objects");
+        }
+        return {
+            vulnerabilities,
+            nextPageToken: optionalString(payload.next_page_token),
+        };
+    },
+    async get_vulnerability(input, context) {
+        const id = encodeURIComponent(requiredInputString(input.id, "id"));
+        return requiredResponseRecord(await requestOsvJson(`/v1/vulns/${id}`, { method: "GET" }, context), "OSV vulnerability response");
+    },
+};
+async function requestOsvJson(path, init, context) {
+    return runProviderRequest({ label: "OSV", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(`${osvApiBaseUrl}${path}`, {
+            ...init,
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "OSV returned invalid JSON",
+            invalidJsonFallback: response.ok ? undefined : (text) => text.trim(),
+        });
+        if (!response.ok) {
+            throw createOsvError(response.status, payload);
+        }
+        return payload;
+    });
+}
+function createOsvError(status, payload) {
+    const record = optionalRecord(payload);
+    const message = optionalRawString(payload) ??
+        optionalString(record?.message) ??
+        optionalString(record?.error) ??
+        `OSV request failed with status ${status}`;
+    if (status === 401 || status === 403) {
+        return new ProviderRequestError(502, message, payload);
+    }
+    return new ProviderRequestError(status || 502, message, payload);
+}

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

@@ -0,0 +1,108 @@
+import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+const service = "pdf_vector";
+const pdfVectorApiBaseUrl = "https://global.pdfvector.com/api";
+const credentialUrl = "https://global.pdfvector.com/rpc/authenticate/validateCredential";
+const handlers = {
+    parse_document(input, context) {
+        return executeDocumentAction("/document/parse", input, context);
+    },
+    ask_document(input, context) {
+        return executeDocumentAction("/document/ask", input, context);
+    },
+    extract_document(input, context) {
+        return executeDocumentAction("/document/extract", input, context);
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: pdfVectorApiBaseUrl,
+    auth: { type: "bearer" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+        headers.set("x-pdfvector-source", "oomol-connector");
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await requestJson({
+            url: credentialUrl,
+            body: {},
+            context: { apiKey: input.apiKey, fetcher, signal },
+            phase: "validate",
+        });
+        const version = optionalString(optionalRecord(optionalRecord(payload)?.json)?.version);
+        if (!version)
+            throw new ProviderRequestError(502, "PDF Vector credential validation response did not include a server version");
+        return {
+            profile: { accountId: "pdf-vector-api-key", displayName: "PDF Vector API Key" },
+            grantedScopes: [],
+            metadata: {
+                apiBaseUrl: pdfVectorApiBaseUrl,
+                validationEndpoint: "/rpc/authenticate/validateCredential",
+                serverVersion: version,
+            },
+        };
+    },
+};
+function executeDocumentAction(path, input, context) {
+    return requestJson({
+        url: `${pdfVectorApiBaseUrl}${path}`,
+        body: compactObject({
+            url: requiredInputString(input.documentUrl, "documentUrl"),
+            model: optionalString(input.model),
+            includePages: input.includePages,
+            question: optionalString(input.question),
+            prompt: optionalString(input.prompt),
+            schema: optionalRecord(input.schema),
+        }),
+        documentId: optionalString(input.documentId),
+        context,
+        phase: "execute",
+    });
+}
+async function requestJson(input) {
+    return runProviderRequest({ signal: input.context.signal, label: "PDF Vector" }, async (signal) => {
+        const response = await input.context.fetcher(input.url, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${input.context.apiKey}`,
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+                "x-pdfvector-source": "oomol-connector",
+                ...(input.documentId ? { "x-pdfvector-document-id": input.documentId } : {}),
+            },
+            body: JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "PDF Vector returned invalid JSON",
+        });
+        if (!response.ok)
+            throw createError(response.status, payload, input.phase);
+        return payload;
+    });
+}
+function createError(status, payload, phase) {
+    const record = optionalRecord(payload);
+    const json = optionalRecord(record?.json);
+    const error = optionalRecord(record?.error);
+    const message = optionalString(json?.message) ??
+        optionalString(error?.message) ??
+        optionalString(record?.message) ??
+        `PDF Vector request failed with status ${status}`;
+    const code = optionalString(json?.code) ?? optionalString(error?.code) ?? optionalString(record?.code);
+    if (phase === "validate" && status === 401 && code === "UNAUTHORIZED")
+        return providerInputError(message);
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (phase === "execute" && [400, 404, 422].includes(status))
+        return providerInputError(message);
+    return new ProviderRequestError(status || 502, message, payload);
+}

package/src/providers/provider-runtime.d.ts

@@ -284,6 +284,8 @@ export interface ProviderProxyDefinition {
     auth: ProviderProxyAuth;
     allowedEndpoint?: (endpoint: string) => boolean;
     customizeRequest?: (input: ProviderProxyRequestCustomizationInput) => Promise<void> | void;
+    /** Parse a failed HTTP response using the same provider error rules as actions. */
+    readError?: (response: Response) => Promise<ProviderRequestError>;
     /** Provider-specific credential/signature headers that redirects must not forward cross-origin. */
     sensitiveHeaders?: readonly string[];
     /** Exact code-controlled origins that `customizeRequest` may select in addition to the resolved base origin. */
@@ -299,6 +301,7 @@ export interface ProviderProxyDefinition {
     /** Deliberate provider-specific response byte cap; defaults to the shared 20 MiB limit. */
     maxResponseBytes?: number;
 }
+export declare const defaultProviderJsonMaxResponseBytes: number;
 export declare function createProviderProxyUrl(baseUrl: string, endpointInput: unknown, queryInput?: unknown, allowedOrigins?: readonly string[]): URL;
 export declare function normalizeProviderProxyEndpoint(endpointInput: unknown, allowedOrigins?: readonly string[]): string;
 export declare function normalizeProviderProxyQuery(queryInput: unknown): Record<string, string>;

package/src/providers/provider-runtime.js

@@ -125,7 +125,7 @@ const blockedProxyRequestHeaders = new Set([
     "transfer-encoding",
 ]);
 const defaultProviderProxyMaxResponseBytes = 20 * 1024 * 1024;
-const defaultProviderJsonMaxResponseBytes = 20 * 1024 * 1024;
+export const defaultProviderJsonMaxResponseBytes = 20 * 1024 * 1024;
 const defaultProviderErrorMaxResponseBytes = 64 * 1024;
 const defaultProviderRequestTimeoutMs = 30_000;
 export function createProviderProxyUrl(baseUrl, endpointInput, queryInput, allowedOrigins) {
@@ -356,6 +356,9 @@ export function defineProviderProxy(input) {
                 }
                 const response = await egressFetch(url, init);
                 if (!response.ok) {
+                    if (input.readError) {
+                        throw await input.readError(response);
+                    }
                     throw new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, `provider request failed with HTTP ${response.status}`));
                 }
                 return {

package/src/providers/pulsetic/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;