@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/tikhub/bounded-response.js

@@ -1,44 +1,18 @@
+import { readBoundedResponseBytes } from "../../core/request.js";
 import { TikHubRequestError } from "./errors.js";
 export class BoundedResponseTooLargeError extends TikHubRequestError {
 }
 export async function readBoundedResponseText(response, input) {
-    const declaredLength = response.headers.get("content-length");
-    if (declaredLength !== null) {
-        const parsedLength = Number(declaredLength);
-        if (Number.isFinite(parsedLength) && parsedLength > input.maxBytes) {
-            await cancelResponseBody(response);
-            throw responseTooLarge(input);
-        }
-    }
-    if (!response.body) {
-        return "";
-    }
-    const reader = response.body.getReader();
-    const chunks = [];
-    let totalBytes = 0;
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
-            break;
-        }
-        totalBytes += result.value.byteLength;
-        if (totalBytes > input.maxBytes) {
-            await reader.cancel();
-            throw responseTooLarge(input);
-        }
-        chunks.push(result.value);
-    }
-    const bytes = new Uint8Array(totalBytes);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
+    const bytes = await readBoundedResponseBytes(response, {
+        maxBytes: input.maxBytes,
+        fieldName: input.label,
+        createError: () => responseTooLarge(input),
+    });
     return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
 }
-export async function cancelResponseBody(response) {
+export function cancelResponseBody(response) {
     try {
-        await response.body?.cancel();
+        void response.body?.cancel().catch(() => undefined);
     }
     catch {
         return;

package/src/providers/tikhub/endpoint-catalog.js

@@ -105,7 +105,7 @@ async function fetchOpenApi(fetcher) {
         const response = await fetcher(tikhubOpenApiUrl, {
             method: "GET",
             headers: { accept: "application/json" },
-            redirect: "error",
+            redirect: "manual",
             signal: timeout.signal,
         });
         if (!response.ok) {

package/src/providers/tikhub/runtime.js

@@ -166,7 +166,7 @@ async function invokeTikHubEndpoint(input, fetcher, apiKey) {
                 "user-agent": providerUserAgent,
             },
             ...(serializedBody === undefined ? {} : { body: serializedBody }),
-            redirect: "error",
+            redirect: "manual",
             signal: timeout.signal,
         });
         let responseBody;
@@ -454,7 +454,7 @@ async function requestTikHubUserJson(input) {
                 authorization: `Bearer ${input.apiKey}`,
                 "user-agent": providerUserAgent,
             },
-            redirect: "error",
+            redirect: "manual",
             signal: timeout.signal,
         });
         const payload = await readTikHubResponseBody(response, tikhubDynamicResponseMaxBytes);

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/tushare/runtime.js

@@ -234,12 +234,18 @@ export const tushareActionHandlers = {
     },
 };
 export async function validateTushareCredential(apiKey, fetcher, signal) {
-    const payload = await tushareRequest({
-        apiName: "trade_cal",
-        params: { exchange: "", start_date: "20180901", end_date: "20180902" },
-        fields: "exchange,cal_date,is_open",
-    }, { apiKey, fetcher, signal });
-    normalizeTableData(payload.data);
+    try {
+        const payload = await tushareRequest({
+            apiName: "daily",
+            params: { ts_code: "000001.SZ", trade_date: "20180903" },
+            fields: "ts_code,trade_date",
+        }, { apiKey, fetcher, signal });
+        normalizeTableData(payload.data);
+    }
+    catch (error) {
+        if (!(error instanceof ProviderRequestError) || error.status !== 403)
+            throw error;
+    }
     return {
         profile: {
             accountId: "tushare-token",
@@ -248,7 +254,7 @@ export async function validateTushareCredential(apiKey, fetcher, signal) {
         grantedScopes: [],
         metadata: {
             apiBaseUrl: tushareApiBaseUrl,
-            validationApiName: "trade_cal",
+            validationApiName: "daily",
             credentialHelpUrl: "https://tushare.pro/document/1?doc_id=39",
         },
     };
@@ -333,8 +339,10 @@ async function readJsonPayload(response) {
 }
 function createTushareHttpError(status, payload) {
     const message = extractErrorMessage(payload) ?? `Tushare request failed with ${status || 500}`;
-    if (status === 401 || status === 403)
+    if (status === 401)
         return new ProviderRequestError(400, message, payload);
+    if (status === 403)
+        return new ProviderRequestError(403, message, payload);
     if (status === 429)
         return new ProviderRequestError(429, message, payload);
     return new ProviderRequestError(status || 502, message, payload);
@@ -343,12 +351,17 @@ function createTushareApiError(code, payload) {
     const message = `Tushare request failed: ${extractErrorMessage(payload) ?? `code ${code}`}`;
     if (code === 40101)
         return new ProviderRequestError(400, message, payload);
-    if (code === 2002)
+    if (isTusharePermissionError(code, message))
         return new ProviderRequestError(403, message, payload);
     if (code === 2003 || code === 2004 || message.includes("频率超限"))
         return new ProviderRequestError(429, message, payload);
     return new ProviderRequestError(502, message, payload);
 }
+function isTusharePermissionError(code, message) {
+    return (code === 2002 ||
+        message.includes("没有权限访问该接口") ||
+        (message.includes("没有接口(") && message.includes("访问权限")));
+}
 function normalizeTableData(value) {
     const data = requiredResponseRecord(value, "data");
     return {

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/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/xydc_mcp/executors.js

@@ -38,7 +38,7 @@ export const proxy = defineProviderProxy({
     },
     timeoutMs: generationTimeoutMs,
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     customizeRequest({ headers }) {
         headers.set("accept", "application/json, text/event-stream");
         headers.set("content-type", "application/json");
@@ -61,7 +61,7 @@ async function withClient(context, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers: { authorization: `Bearer ${context.apiKey}`, "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError,
     }, run);

package/src/providers/youtube/executors.js

@@ -1,4 +1,4 @@
-import { googleJsonRequest } from "../google-runtime.js";
+import { googleJsonRequest } from "../googledrive/runtime-request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerProxyEndpointPrefixes, } from "../provider-runtime.js";
 import { youtubeActionHandlers } from "./runtime.js";
 const service = "youtube";

package/src/providers/youtube/runtime.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { compactObject, optionalBoolean, optionalInteger, optionalString, rawStringOrNull } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 const youtubeApiBaseUrl = "https://www.googleapis.com/youtube/v3";
 const youtubeUploadApiBaseUrl = "https://www.googleapis.com/upload/youtube/v3";

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

@@ -0,0 +1,9 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { ProviderActionHandlers, ProviderRuntimeHandler } from "../provider-runtime.ts";
+import type { ZerotierActionContext } from "./runtime.ts";
+type ZerotierHandler = ProviderRuntimeHandler<ZerotierActionContext>;
+export declare const zerotierActionHandlers: ProviderActionHandlers<"zerotier", ZerotierHandler>;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;
+export {};