@oomol-lab/open-connector 1.6.5 → 1.7.0

package/src/providers/slack/actions.js

@@ -50,6 +50,16 @@ const messageContentProperties = {
     unfurlMedia: s.boolean({ description: "Whether Slack should unfurl media in the message." }),
     metadata: s.unknownObject("Slack message metadata to attach to the message."),
 };
+// Shared by `conversations.history` and `conversations.replies`: opt in to
+// the untouched vendor record. Off by default so the row read in bulk stays
+// lean. Opting in also asks Slack for message metadata, which it leaves out
+// unless the request sets `include_all_metadata`.
+const includeRawProperties = {
+    includeRaw: s.boolean({
+        description: "When true, each returned message also carries the untouched Slack record under raw, including its blocks, attachments, files and message metadata. Defaults to false.",
+    }),
+};
+const rawMessageSchema = s.unknownObject("The untouched Slack record, exactly as the Slack API returned it. Present only when includeRaw is true.");
 const slackReactionSchema = s.looseObject({
     name: s.string({ description: "The emoji name of the reaction." }),
     count: s.integer({ description: "How many users added this reaction." }),
@@ -60,9 +70,10 @@ const slackReactionSchema = s.looseObject({
 // Only fields the executor actually normalizes are declared. The object is
 // loose, but that permits extras it does NOT make them appear: the executor
 // builds each row explicitly, so an undeclared Slack field is simply not
-// emitted. Deliberately absent: `blocks`, `attachments` and `files`. Those
-// are unbounded nested payloads on a row shape that ETL reads in bulk, and
-// each wants its own normalized contract rather than a raw passthrough.
+// emitted. Deliberately absent: `blocks`, `attachments`, `files` and
+// `metadata`. Those are unbounded nested payloads on a row shape that ETL
+// reads in bulk, so they stay out of the default row; a caller that needs
+// them passes includeRaw and reads them from `raw`, the untouched record.
 const slackMessageSchema = s.looseObject({
     ts: s.string({ description: "The message timestamp identifier." }),
     type: s.string({ description: "The Slack message type, normally 'message'." }),
@@ -77,15 +88,20 @@ const slackMessageSchema = s.looseObject({
     clientMsgId: s.string({ description: "The client-generated message identifier when Slack returns one." }),
     text: s.string({ description: "The text content of the message." }),
     editedTs: s.string({ description: "The timestamp of the most recent edit, when the message was edited." }),
+    editedUserId: s.string({ description: "The user ID of the most recent editor, when the message was edited." }),
     threadTs: s.string({
         description: "The timestamp of the thread parent. Equal to ts on a thread parent, and absent on a message that is not in a thread.",
     }),
     parentUserId: s.string({ description: "The author of the thread parent, on a threaded reply." }),
     replyCount: s.integer({ description: "The number of replies to this thread parent." }),
     replyUsersCount: s.integer({ description: "The number of distinct users who replied to this thread parent." }),
+    replyUserIds: s.array(s.string({ description: "A Slack user ID." }), {
+        description: "Up to five user IDs of people who replied to this thread parent. Slack caps this list; use replyUsersCount for the total.",
+    }),
     latestReply: s.string({ description: "The timestamp of the most recent reply to this thread parent." }),
     isLocked: s.boolean({ description: "Whether the thread is locked." }),
     reactions: s.array(slackReactionSchema, { description: "Reaction summaries attached to the message." }),
+    raw: rawMessageSchema,
 }, { description: "A Slack message record." });
 const searchMessageMatchSchema = s.looseObject({
     matchId: s.string({ description: "Slack's search result item identifier." }),
@@ -98,6 +114,7 @@ const searchMessageMatchSchema = s.looseObject({
     permalink: s.string({ description: "A Slack permalink for the matching message." }),
     teamId: s.string({ description: "The Slack team ID returned for the match." }),
     type: s.string({ description: "The Slack result type." }),
+    raw: rawMessageSchema,
 }, { description: "A normalized Slack message search match." });
 const conversationSchema = s.object({
     channelId: s.string({ description: "The unique identifier of the conversation." }),
@@ -113,6 +130,21 @@ const conversationSchema = s.object({
     purpose: s.nullable(s.string({ description: "The conversation purpose." })),
     userId: s.string({ description: "The linked user identifier for IM conversations." }),
     locale: s.string({ description: "The locale returned by Slack when requested." }),
+    created: s.integer({ description: "Creation time as a Unix timestamp in seconds when Slack provides it." }),
+    updated: s.integer({
+        description: "Last settings update time, passed through as Slack returns it. Slack documents epoch milliseconds for channels (unlike created) and a Unix timestamp for legacy IM and MPIM objects.",
+    }),
+    creatorId: s.string({ description: "The user who created the conversation when Slack provides it." }),
+    isShared: s.boolean({ description: "Whether the conversation is shared with another workspace." }),
+    isExtShared: s.boolean({ description: "Whether the conversation is shared with an external organization." }),
+    isOrgShared: s.boolean({
+        description: "Whether the conversation is shared between workspaces of the same Enterprise organization.",
+    }),
+    contextTeamId: s.string({
+        description: "The ID of the workspace the conversation is within when Slack provides it.",
+    }),
+    lastRead: s.string({ description: "The last-read message timestamp when Slack provides it." }),
+    unreadCount: s.integer({ description: "The unread message count when Slack provides it." }),
 }, {
     required: ["channelId", "name", "type", "isArchived", "isPrivate", "isMember", "topic", "purpose"],
     description: "A normalized Slack conversation record.",
@@ -127,6 +159,18 @@ const userSchema = s.object({
     isAdmin: s.nullable(s.boolean({ description: "Whether the user is an admin." })),
     isOwner: s.nullable(s.boolean({ description: "Whether the user is an owner." })),
     locale: s.string({ description: "The locale returned by Slack when requested." }),
+    email: s.string({
+        description: "The profile email. Slack returns it only when the token holds the users:read.email scope.",
+    }),
+    tz: s.string({ description: "The user's time zone identifier when Slack provides it." }),
+    tzOffset: s.integer({ description: "The user's UTC offset in seconds when Slack provides it." }),
+    updated: s.integer({ description: "When the user object was last updated, as a Unix timestamp in seconds." }),
+    teamId: s.string({ description: "The user's team ID when Slack provides it." }),
+    isRestricted: s.boolean({
+        description: "Whether the user is a guest. Single-channel guests also set isUltraRestricted.",
+    }),
+    isUltraRestricted: s.boolean({ description: "Whether the user is a single-channel guest." }),
+    isAppUser: s.boolean({ description: "Whether the user is an authorized user of the calling app." }),
 }, {
     required: ["userId", "username", "realName", "displayName", "isBot", "isDeleted", "isAdmin", "isOwner"],
     description: "A normalized Slack user record.",
@@ -188,6 +232,7 @@ export const slackActions = [
                 description: "The Slack pagination cursor from a previous page. Omit for the first page.",
             }),
             ...historyWindowProperties,
+            ...includeRawProperties,
         }, { required: ["channelId"], description: "Input parameters for reading Slack conversation history." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the conversation." }),
@@ -242,6 +287,9 @@ export const slackActions = [
             sort: searchSortSchema,
             sortDir: sortDirectionSchema,
             teamId: s.string({ description: "The encoded team ID to search when using an org-level token." }),
+            includeRaw: s.boolean({
+                description: "When true, each returned match also carries the untouched Slack search match under raw, including any blocks, attachments and files. Defaults to false.",
+            }),
         }, { required: ["query"], description: "Input parameters for searching Slack messages." }),
         outputSchema: s.object({
             query: s.string({ description: "The search query Slack executed." }),
@@ -323,6 +371,7 @@ export const slackActions = [
                 description: "The Slack pagination cursor from a previous page. Omit for the first page.",
             }),
             ...historyWindowProperties,
+            ...includeRawProperties,
         }, { required: ["channelId", "threadTs"], description: "Input parameters for reading a Slack thread." }),
         outputSchema: s.object({
             messages: s.array(slackMessageSchema, { description: "The list of messages in the thread." }),

package/src/providers/slack/runtime.js

@@ -1,6 +1,6 @@
-import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
+import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, optionalStringArray, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { slackConversationTypes } from "./constants.js";
 export const slackApiBaseUrl = "https://slack.com/api";
 const slackFileUrlMaxBytes = 100 * 1024 * 1024;
@@ -196,7 +196,8 @@ async function slackGetChannelMessages(input, context) {
         url.searchParams.set("cursor", String(input.cursor));
     }
     applySlackHistoryWindow(url, input);
-    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history");
+    const includeRaw = applySlackIncludeRaw(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.history", includeRaw);
 }
 async function slackConversationsMembers(input, context) {
     const url = slackApiUrl("conversations.members");
@@ -214,6 +215,7 @@ async function slackConversationsMembers(input, context) {
     };
 }
 async function slackSearchMessages(input, context) {
+    const includeRaw = input.includeRaw === true;
     const query = requiredString(input.query, "query", (message) => new ProviderRequestError(400, message));
     if (input.page != null && input.cursor != null) {
         throw new ProviderRequestError(400, "page and cursor cannot be used together");
@@ -244,7 +246,7 @@ async function slackSearchMessages(input, context) {
     const payload = await slackGetJson(url, context);
     return {
         query: optionalString(payload.query) ?? query,
-        matches: (payload.messages?.matches ?? []).map((match) => normalizeSearchMessageMatch(match)),
+        matches: (payload.messages?.matches ?? []).map((match) => normalizeSearchMessageMatch(match, includeRaw)),
         total: typeof payload.messages?.total === "number" ? payload.messages.total : 0,
         pagination: payload.messages?.pagination ?? {},
         paging: payload.messages?.paging ?? {},
@@ -318,7 +320,8 @@ async function slackGetThread(input, context) {
         url.searchParams.set("cursor", String(input.cursor));
     }
     applySlackHistoryWindow(url, input);
-    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies");
+    const includeRaw = applySlackIncludeRaw(url, input);
+    return readSlackMessagePage(await slackGetJson(url, context), "conversations.replies", includeRaw);
 }
 async function slackListConversations(input, context) {
     const url = slackApiUrl("conversations.list");
@@ -651,7 +654,7 @@ async function slackFormRequestJson(context, method, body) {
 async function readSlackResponseJson(response) {
     const payload = (optionalRecord(await response.json().catch(() => undefined)) ?? {});
     if (!response.ok) {
-        throw slackHttpError(response.status, payload, response.headers.get("retry-after"));
+        throw slackHttpError(response, payload);
     }
     assertSlackPayload(payload);
     // Preserve HTTP/Slack failures (including Retry-After) above, but require
@@ -844,6 +847,15 @@ function normalizeConversation(conversation) {
         purpose: typeof purpose?.value === "string" ? purpose.value : null,
         userId: optionalString(conversation.user),
         locale: optionalString(conversation.locale),
+        created: optionalInteger(conversation.created),
+        updated: optionalInteger(conversation.updated),
+        creatorId: optionalString(conversation.creator),
+        isShared: optionalBoolean(conversation.is_shared),
+        isExtShared: optionalBoolean(conversation.is_ext_shared),
+        isOrgShared: optionalBoolean(conversation.is_org_shared),
+        contextTeamId: optionalString(conversation.context_team_id),
+        lastRead: optionalString(conversation.last_read),
+        unreadCount: optionalInteger(conversation.unread_count),
     });
 }
 /**
@@ -863,13 +875,27 @@ function applySlackHistoryWindow(url, input) {
         url.searchParams.set("inclusive", String(input.inclusive));
     }
 }
+/**
+ * Apply the shared `includeRaw` opt-in of `conversations.history` /
+ * `conversations.replies` and report whether it is on. Only a literal `true`
+ * opts in. Slack leaves message metadata out of both methods unless the
+ * request sets `include_all_metadata`, and `raw` promises the whole record, so
+ * opting in asks for it too.
+ */
+function applySlackIncludeRaw(url, input) {
+    const includeRaw = input.includeRaw === true;
+    if (includeRaw) {
+        url.searchParams.set("include_all_metadata", "true");
+    }
+    return includeRaw;
+}
 /**
  * Read one `conversations.history` / `conversations.replies` page. A page whose
  * list is missing or whose rows are not objects is rejected rather than
  * flattened into an empty result, so a broken upstream response cannot pass
  * for the documented end of a walk.
  */
-function readSlackMessagePage(payload, method) {
+function readSlackMessagePage(payload, method, includeRaw = false) {
     if (payload.has_more !== undefined && typeof payload.has_more !== "boolean") {
         throw slackResponseError(`${method} has_more`);
     }
@@ -879,7 +905,7 @@ function readSlackMessagePage(payload, method) {
             if (!record) {
                 throw slackResponseError(`${method} message`);
             }
-            return normalizeSlackMessage(record);
+            return normalizeSlackMessage(record, includeRaw);
         }),
         hasMore: payload.has_more ?? false,
         nextCursor: readSlackNextCursor(payload, method),
@@ -927,8 +953,13 @@ function requireSlackId(value, label) {
  * missing value stays distinguishable from an empty one. `userId` is the one
  * exception kept for compatibility: it stays `""` on a message with no
  * author, where `botId` / `username` carry the identity instead.
+ *
+ * `files`, `attachments`, `blocks` and `metadata` stay out of the row: they
+ * are unbounded nested payloads on a row read in bulk. With `includeRaw` the
+ * whole untouched record rides along under `raw` for a consumer that needs
+ * them, or any other field this normalizer does not model.
  */
-function normalizeSlackMessage(message) {
+function normalizeSlackMessage(message, includeRaw = false) {
     const edited = optionalRecord(message.edited) ?? {};
     const reactions = Array.isArray(message.reactions) ? message.reactions : undefined;
     return compactObject({
@@ -943,13 +974,16 @@ function normalizeSlackMessage(message) {
         clientMsgId: optionalString(message.client_msg_id),
         text: typeof message.text === "string" ? message.text : "",
         editedTs: optionalString(edited.ts),
+        editedUserId: optionalString(edited.user),
         threadTs: optionalString(message.thread_ts),
         parentUserId: optionalString(message.parent_user_id),
         replyCount: optionalInteger(message.reply_count),
         replyUsersCount: optionalInteger(message.reply_users_count),
+        replyUserIds: optionalStringArray(message.reply_users),
         latestReply: optionalString(message.latest_reply),
         isLocked: optionalBoolean(message.is_locked),
         reactions: reactions?.map((reaction) => normalizeSlackReaction(optionalRecord(reaction) ?? {})),
+        raw: includeRaw ? message : undefined,
     });
 }
 function normalizeSlackReaction(reaction) {
@@ -959,7 +993,7 @@ function normalizeSlackReaction(reaction) {
         userIds: Array.isArray(reaction.users) ? reaction.users.map((user) => String(user)) : undefined,
     });
 }
-function normalizeSearchMessageMatch(match) {
+function normalizeSearchMessageMatch(match, includeRaw = false) {
     const channel = optionalRecord(match.channel) ?? {};
     return compactObject({
         matchId: optionalString(match.iid),
@@ -972,6 +1006,7 @@ function normalizeSearchMessageMatch(match) {
         permalink: optionalString(match.permalink),
         teamId: optionalString(match.team),
         type: optionalString(match.type),
+        raw: includeRaw ? match : undefined,
     });
 }
 function normalizeUser(user) {
@@ -986,6 +1021,14 @@ function normalizeUser(user) {
         isAdmin: typeof user.is_admin === "boolean" ? user.is_admin : null,
         isOwner: typeof user.is_owner === "boolean" ? user.is_owner : null,
         locale: optionalString(user.locale),
+        email: optionalString(profile.email),
+        tz: optionalString(user.tz),
+        tzOffset: optionalInteger(user.tz_offset),
+        updated: optionalInteger(user.updated),
+        teamId: optionalString(user.team_id),
+        isRestricted: optionalBoolean(user.is_restricted),
+        isUltraRestricted: optionalBoolean(user.is_ultra_restricted),
+        isAppUser: optionalBoolean(user.is_app_user),
     });
 }
 function normalizeFile(file) {
@@ -1037,17 +1080,11 @@ function formatSlackPayloadError(payload) {
     }
     return `${error}: ${details.join("; ")}`;
 }
-function slackHttpError(status, payload, retryAfter) {
-    const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${status}`;
-    if (status === 429 && retryAfter !== null && /^\d+$/.test(retryAfter)) {
-        const retryAfterSeconds = Number(retryAfter);
-        if (Number.isSafeInteger(retryAfterSeconds)) {
-            // The action envelope carries provider details; retain pacing so callers
-            // can resume the same page without guessing when this workspace may retry.
-            return new ProviderRequestError(status, message, { ...payload, retryAfterSeconds });
-        }
-    }
-    return new ProviderRequestError(status, message, payload);
+function slackHttpError(response, payload) {
+    const message = payload.error ? formatSlackPayloadError(payload) : `slack request failed with ${response.status}`;
+    // The action envelope carries provider details; retain pacing so callers
+    // can resume the same page without guessing when this workspace may retry.
+    return new ProviderRequestError(response.status, message, withRetryAfterSeconds(response, payload));
 }
 function slackResponseError(message) {
     return new ProviderRequestError(502, `slack response is invalid: ${message}`);

package/src/providers/slickdeals/runtime.js

@@ -155,7 +155,7 @@ async function requestSlickdealsJson(input) {
                 authorization: `Bearer ${input.token}`,
                 "user-agent": providerUserAgent,
             },
-            redirect: "error",
+            redirect: "manual",
             signal,
         });
         const payload = await readPayload(response);

package/src/providers/sorftime_mcp/executors.js

@@ -45,7 +45,7 @@ export const proxy = defineProviderProxy({
     baseUrl: sorftimeMcpEndpoint,
     auth: { type: "api_key_authorization", prefix: "Bearer " },
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     timeoutMs: requestTimeoutMs,
     allowedEndpoint(endpoint) {
         const url = new URL(endpoint, sorftimeMcpEndpoint);
@@ -79,7 +79,7 @@ function withSorftimeClient(context, run) {
             authorization: `Bearer ${context.apiKey}`,
             "user-agent": providerUserAgent,
         },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapSorftimeError,
     }, run);

package/src/providers/tikhub/bounded-response.d.ts

@@ -5,4 +5,4 @@ export declare function readBoundedResponseText(response: Response, input: {
     maxBytes: number;
     label: string;
 }): Promise<string>;
-export declare function cancelResponseBody(response: Response): Promise<void>;
+export declare function cancelResponseBody(response: Response): void;

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/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);