@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/futunn/actions.trading.js

@@ -0,0 +1,204 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const futunnTradingActions = [
+    defineProviderAction("futunn", {
+        name: "list_open_orders",
+        operationType: "read",
+        description: "List recent orders, including pending orders and orders filled or cancelled in the last 24 hours.",
+        requiredScopes: ["trade:read"],
+        inputSchema: s.object("Account order or fill query.", {
+            accountId: s.string("Trading account ID as a decimal string.", { pattern: "^[0-9]+$" }),
+            market: s.stringEnum("Trading market; HKCC denotes China Stock Connect.", [
+                "NONE",
+                "HK",
+                "US",
+                "SG",
+                "HKCC",
+                "CA",
+                "FUTURES",
+                "JP",
+                "KR",
+                "MY",
+                "AU",
+            ]),
+            pageFlag: s.string("Opaque page flag; omit or use an empty string for the first page."),
+            pageSize: s.integer("Page size; default 50, range 10-100.", { minimum: 10, maximum: 100 }),
+        }, { optional: ["pageFlag", "pageSize"] }),
+        outputSchema: s.requiredObject("One page of account records.", {
+            orders: s.array("Returned account records in provider order.", s.looseObject("Order with original quantities, prices and status fields.", {
+                order_id: s.string("Order ID."),
+                code: s.string("Security code including market prefix, for example HK.00700.", {
+                    minLength: 1,
+                }),
+                order_status: s.string("Order status."),
+                qty: s.string("Quantity as a decimal string."),
+                price: s.string("Price as a decimal string."),
+                create_time: s.integer("Creation timestamp in microseconds."),
+            })),
+            pageFlag: s.nullable(s.string("Next-page flag; null when omitted.")),
+            completed: s.nullable(s.boolean("True means this batch is complete; null means the provider omitted the flag.")),
+        }),
+    }),
+    defineProviderAction("futunn", {
+        name: "list_history_orders",
+        operationType: "read",
+        description: "List historical orders filtered by creation time in microseconds.",
+        requiredScopes: ["trade:read"],
+        inputSchema: s.object("Account order or fill query.", {
+            accountId: s.string("Trading account ID as a decimal string.", { pattern: "^[0-9]+$" }),
+            market: s.stringEnum("Trading market; HKCC denotes China Stock Connect.", [
+                "NONE",
+                "HK",
+                "US",
+                "SG",
+                "HKCC",
+                "CA",
+                "FUTURES",
+                "JP",
+                "KR",
+                "MY",
+                "AU",
+            ]),
+            pageFlag: s.string("Opaque page flag; omit or use an empty string for the first page."),
+            pageSize: s.integer("Page size; default 50, range 10-100.", { minimum: 10, maximum: 100 }),
+            code: s.string("Security code including market prefix, for example HK.00700.", {
+                minLength: 1,
+            }),
+            start: s.string("Unix timestamp in microseconds as a decimal string; 0 uses the provider 90-day default window.", { pattern: "^[0-9]+$" }),
+            end: s.string("Unix timestamp in microseconds as a decimal string; 0 uses the provider 90-day default window.", { pattern: "^[0-9]+$" }),
+        }, { optional: ["pageFlag", "pageSize", "code", "start", "end"] }),
+        outputSchema: s.requiredObject("One page of account records.", {
+            orders: s.array("Returned account records in provider order.", s.looseObject("Order with original quantities, prices and status fields.", {
+                order_id: s.string("Order ID."),
+                code: s.string("Security code including market prefix, for example HK.00700.", {
+                    minLength: 1,
+                }),
+                order_status: s.string("Order status."),
+                qty: s.string("Quantity as a decimal string."),
+                price: s.string("Price as a decimal string."),
+                create_time: s.integer("Creation timestamp in microseconds."),
+            })),
+            pageFlag: s.nullable(s.string("Next-page flag; null when omitted.")),
+            completed: s.nullable(s.boolean("True means this batch is complete; null means the provider omitted the flag.")),
+        }),
+    }),
+    defineProviderAction("futunn", {
+        name: "list_today_deals",
+        operationType: "read",
+        description: "List today's execution fills for a trading account.",
+        requiredScopes: ["trade:read"],
+        inputSchema: s.object("Account order or fill query.", {
+            accountId: s.string("Trading account ID as a decimal string.", { pattern: "^[0-9]+$" }),
+            market: s.stringEnum("Trading market; HKCC denotes China Stock Connect.", [
+                "NONE",
+                "HK",
+                "US",
+                "SG",
+                "HKCC",
+                "CA",
+                "FUTURES",
+                "JP",
+                "KR",
+                "MY",
+                "AU",
+            ]),
+            pageFlag: s.string("Opaque page flag; omit or use an empty string for the first page."),
+            pageSize: s.integer("Page size; default 50, range 10-100.", { minimum: 10, maximum: 100 }),
+        }, { optional: ["pageFlag", "pageSize"] }),
+        outputSchema: s.requiredObject("One page of account records.", {
+            deals: s.array("Returned account records in provider order.", s.looseObject("Execution fill record.", {
+                deal_id: s.string("Case-sensitive base58 fill ID; preserve exactly."),
+                order_id: s.string("Order ID."),
+                qty: s.string("Quantity as a decimal string."),
+                price: s.string("Price as a decimal string."),
+                create_time: s.integer("Creation timestamp in microseconds."),
+            })),
+            pageFlag: s.nullable(s.string("Next-page flag; null when omitted.")),
+            completed: s.nullable(s.boolean("True means this batch is complete; null means the provider omitted the flag.")),
+        }),
+    }),
+    defineProviderAction("futunn", {
+        name: "list_history_deals",
+        operationType: "read",
+        description: "List historical execution fills filtered by update time in microseconds.",
+        requiredScopes: ["trade:read"],
+        inputSchema: s.object("Account order or fill query.", {
+            accountId: s.string("Trading account ID as a decimal string.", { pattern: "^[0-9]+$" }),
+            market: s.stringEnum("Trading market; HKCC denotes China Stock Connect.", [
+                "NONE",
+                "HK",
+                "US",
+                "SG",
+                "HKCC",
+                "CA",
+                "FUTURES",
+                "JP",
+                "KR",
+                "MY",
+                "AU",
+            ]),
+            pageFlag: s.string("Opaque page flag; omit or use an empty string for the first page."),
+            pageSize: s.integer("Page size; default 50, range 10-50.", { minimum: 10, maximum: 50 }),
+            code: s.string("Security code including market prefix, for example HK.00700.", {
+                minLength: 1,
+            }),
+            start: s.string("Unix timestamp in microseconds as a decimal string; 0 uses the provider 90-day default window.", { pattern: "^[0-9]+$" }),
+            end: s.string("Unix timestamp in microseconds as a decimal string; 0 uses the provider 90-day default window.", { pattern: "^[0-9]+$" }),
+        }, { optional: ["pageFlag", "pageSize", "code", "start", "end"] }),
+        outputSchema: s.requiredObject("One page of account records.", {
+            deals: s.array("Returned account records in provider order.", s.looseObject("Execution fill record.", {
+                deal_id: s.string("Case-sensitive base58 fill ID; preserve exactly."),
+                order_id: s.string("Order ID."),
+                qty: s.string("Quantity as a decimal string."),
+                price: s.string("Price as a decimal string."),
+                create_time: s.integer("Creation timestamp in microseconds."),
+            })),
+            pageFlag: s.nullable(s.string("Next-page flag; null when omitted.")),
+            completed: s.nullable(s.boolean("True means this batch is complete; null means the provider omitted the flag.")),
+        }),
+    }),
+    defineProviderAction("futunn", {
+        name: "get_order_details",
+        operationType: "read",
+        description: "Get details of fewer than 50 orders from the same exchange.",
+        requiredScopes: ["trade:read"],
+        inputSchema: s.requiredObject("Order detail query.", {
+            accountId: s.string("Trading account ID as a decimal string.", { pattern: "^[0-9]+$" }),
+            exchange: s.stringEnum("Exchange shared by all requested orders.", [
+                "US",
+                "SEHK",
+                "SGX",
+                "SSE",
+                "SZSE",
+                "JP",
+                "CA",
+                "CME",
+                "CBOT",
+                "NYMEX",
+                "COMEX",
+                "CBOE",
+                "HKFE",
+                "KR",
+                "BMS",
+                "BMD",
+                "ASX",
+            ]),
+            orderIds: s.array("Order IDs from the same exchange.", s.string("Order ID.", { minLength: 1 }), {
+                minItems: 1,
+                maxItems: 49,
+            }),
+        }),
+        outputSchema: s.requiredObject("Order detail results.", {
+            orders: s.array("Order details.", s.looseObject("Order with original quantities, prices and status fields.", {
+                order_id: s.string("Order ID."),
+                code: s.string("Security code including market prefix, for example HK.00700.", {
+                    minLength: 1,
+                }),
+                order_status: s.string("Order status."),
+                qty: s.string("Quantity as a decimal string."),
+                price: s.string("Price as a decimal string."),
+                create_time: s.integer("Creation timestamp in microseconds."),
+            })),
+        }),
+    }),
+];

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

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

package/src/providers/futunn/executors.js

@@ -0,0 +1,24 @@
+import { defineOAuthProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { futunnActions } from "./actions.js";
+import { executeFutunnAction } from "./runtime.js";
+import { futunnApiBaseUrl } from "./transport.js";
+const service = "futunn";
+function createHandler(actionName) {
+    return (input, context) => executeFutunnAction({
+        actionName,
+        input,
+        accessToken: context.accessToken,
+        signal: context.signal,
+    }, context.fetcher);
+}
+const handlers = Object.fromEntries(futunnActions.map((action) => [action.name, createHandler(action.name)]));
+export const executors = defineOAuthProviderExecutors(service, handlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: futunnApiBaseUrl,
+    auth: { type: "oauth_bearer" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/futunn/runtime-research.d.ts

@@ -0,0 +1,3 @@
+import type { FutunnActionInput } from "./transport.ts";
+export declare function isFutunnResearchAction(name: string): boolean;
+export declare function executeFutunnResearchAction(input: FutunnActionInput, fetcher: typeof fetch): Promise<unknown>;

package/src/providers/futunn/runtime-research.js

@@ -0,0 +1,133 @@
+import { optionalNumber, optionalRecord } from "../../core/cast.js";
+import { ProviderRequestError, requiredInputString, requiredResponseRecord } from "../provider-runtime.js";
+import { futunnResearchActions } from "./actions.research.js";
+import { readFutunnData, readFutunnList, requestFutunn } from "./transport.js";
+const researchNames = new Set(futunnResearchActions.map((action) => action.name));
+export function isFutunnResearchAction(name) {
+    return researchNames.has(name);
+}
+export async function executeFutunnResearchAction(input, fetcher) {
+    const v = input.input;
+    const request = (path, query, body, allowNoData = false) => requestFutunn(input, fetcher, path, query, body, allowNoData);
+    const securityPath = (suffix) => `/api/v1.0/quote/${encodeURIComponent(requiredInputString(v.symbol, "symbol"))}/${suffix}`;
+    switch (input.actionName) {
+        case "search_news":
+        case "search_community": {
+            const news = input.actionName === "search_news";
+            const envelope = await request(`/api/v1.0/quote/${news ? "find-news" : "find-community"}`, {
+                symbol: v.keyword,
+                size: v.size,
+                [news ? "news_type" : "community_type"]: v.type,
+                sort_type: v.sortType,
+                lang: v.language,
+            });
+            return { items: readFutunnList(readFutunnData(envelope), "search results") };
+        }
+        case "get_security_info": {
+            const data = requiredResponseRecord(readFutunnData(await request("/api/v1.0/quote/stock-basicinfo", {}, { code_list: v.symbols })), "Futunn security info");
+            return { securities: readFutunnList(data.basic_list, "basic_list") };
+        }
+        case "get_market_state": {
+            const data = requiredResponseRecord(readFutunnData(await request("/api/v1.0/quote/market-state", {}, {
+                code_list: v.symbols,
+                is_contain_ba: v.includePreAfterMarket,
+                is_contain_overnight: v.includeOvernight,
+                is_need_crypto_multi_broker: v.includeCryptoBrokers,
+            })), "Futunn market state");
+            return { states: readFutunnList(data.market_state_list, "market_state_list") };
+        }
+        case "screen_stocks": {
+            const envelope = await request("/api/v1.0/quote/stock-screen", {}, {
+                screen_queries: v.screenQueries,
+                retrieve_queries: v.retrieveQueries,
+                sort: v.sort,
+                sorts: v.sorts,
+                next_key: v.nextKey,
+                limit: v.limit,
+                watchlist_stock_ids: v.watchlistStockIds,
+                holding_stock_ids: v.holdingStockIds,
+                user_stock_list_mode: v.userStockListMode,
+            });
+            const data = requiredResponseRecord(readFutunnData(envelope), "Futunn screening data");
+            return {
+                items: readFutunnList(data.items, "screening items"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+            };
+        }
+        case "get_financial_statements": {
+            const envelope = await request(securityPath("financials/statements"), {
+                statement_type: v.statementType,
+                financial_type: v.financialType,
+                currency_code: v.currencyCode,
+                next_key: v.nextKey,
+                limit: v.limit,
+            }, undefined, true);
+            const noData = envelope.ret_code === -10;
+            const data = noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn financial statements");
+            return {
+                reports: data === null ? [] : readFutunnList(data.report_list, "report_list"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+                noData,
+            };
+        }
+        case "get_revenue_breakdown": {
+            const envelope = await request(securityPath("financials/revenue-breakdown"), { date: v.date, financial_type: v.financialType, currency_code: v.currencyCode }, undefined, true);
+            const noData = envelope.ret_code === -10;
+            return {
+                revenue: noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn revenue breakdown"),
+                noData,
+            };
+        }
+        case "get_operational_efficiency": {
+            const envelope = await request(securityPath("company/operational-efficiency"), {
+                limit: v.limit,
+                financial_type: v.financialType,
+                currency_code: v.currencyCode,
+                next_key: v.nextKey,
+            }, undefined, true);
+            const noData = envelope.ret_code === -10;
+            return {
+                efficiency: noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn operational efficiency"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+                noData,
+            };
+        }
+        case "get_valuation":
+            return {
+                valuation: requiredResponseRecord(readFutunnData(await request(securityPath("valuation/detail"), {
+                    valuation_type: v.valuationType,
+                    interval_type: v.intervalType,
+                })), "Futunn valuation"),
+            };
+        case "get_capital_flow": {
+            const data = requiredResponseRecord(readFutunnData(await request(securityPath("capital-flow"), { section: v.section })), "Futunn capital flow");
+            return {
+                flows: readFutunnList(data.flow_list, "flow_list"),
+                lastValidTime: optionalNumber(data.last_valid_time) ?? null,
+            };
+        }
+        case "get_capital_flow_history": {
+            const envelope = await request(securityPath("capital-flow/history"), {
+                period_type: v.periodType,
+                start: v.start,
+                end: v.end,
+                count: v.count,
+            });
+            const data = requiredResponseRecord(readFutunnData(envelope), "Futunn capital flow history");
+            return {
+                flows: readFutunnList(data.flow_list, "flow_list"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+            };
+        }
+        case "get_capital_distribution": {
+            const envelope = await request(securityPath("capital-distribution"), {}, undefined, true);
+            const noData = envelope.ret_code === -10;
+            return {
+                distribution: noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn capital distribution"),
+                noData,
+            };
+        }
+        default:
+            throw new ProviderRequestError(400, `Unknown Futunn research action: ${input.actionName}`);
+    }
+}

package/src/providers/futunn/runtime-trading.d.ts

@@ -0,0 +1,3 @@
+import type { FutunnActionInput } from "./transport.ts";
+export declare function isFutunnTradingAction(name: string): boolean;
+export declare function executeFutunnTradingAction(input: FutunnActionInput, fetcher: typeof fetch): Promise<unknown>;

package/src/providers/futunn/runtime-trading.js

@@ -0,0 +1,39 @@
+import { optionalBoolean, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, requiredInputString, requiredResponseRecord } from "../provider-runtime.js";
+import { futunnTradingActions } from "./actions.trading.js";
+import { readFutunnData, readFutunnList, requestFutunn } from "./transport.js";
+const tradingNames = new Set(futunnTradingActions.map((action) => action.name));
+export function isFutunnTradingAction(name) {
+    return tradingNames.has(name);
+}
+const listEndpoints = {
+    list_open_orders: { path: "orders", field: "orders", history: false },
+    list_history_orders: { path: "orders_history", field: "orders", history: true },
+    list_today_deals: { path: "order_fills", field: "order_fills", history: false },
+    list_history_deals: { path: "fills_history", field: "order_fills", history: true },
+};
+export async function executeFutunnTradingAction(input, fetcher) {
+    const v = input.input;
+    const path = `/api/v1.0/accounts/${encodeURIComponent(requiredInputString(v.accountId, "accountId"))}`;
+    if (input.actionName === "get_order_details") {
+        const envelope = await requestFutunn(input, fetcher, `${path}/orders/detail`, {}, { exchange: v.exchange, order_ids: v.orderIds });
+        return { orders: readFutunnList(readFutunnData(envelope), "order details") };
+    }
+    const endpoint = listEndpoints[input.actionName];
+    if (!endpoint)
+        throw new ProviderRequestError(400, `Unknown Futunn trading action: ${input.actionName}`);
+    const envelope = await requestFutunn(input, fetcher, `${path}/${endpoint.path}`, {
+        trd_market: v.market,
+        page_flag: v.pageFlag ?? "",
+        page_size: v.pageSize,
+        code: endpoint.history ? v.code : undefined,
+        start: endpoint.history ? v.start : undefined,
+        end: endpoint.history ? v.end : undefined,
+    });
+    const data = requiredResponseRecord(readFutunnData(envelope), "Futunn account records");
+    return {
+        [endpoint.field === "orders" ? "orders" : "deals"]: readFutunnList(data[endpoint.field], endpoint.field),
+        pageFlag: optionalString(data.page_flag) ?? null,
+        completed: optionalBoolean(data.completed) ?? null,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { FutunnActionInput } from "./transport.ts";
+export declare function executeFutunnAction(input: FutunnActionInput, fetcher: typeof fetch): Promise<unknown>;

package/src/providers/futunn/runtime.js

@@ -0,0 +1,50 @@
+import { optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord } from "../provider-runtime.js";
+import { executeFutunnResearchAction, isFutunnResearchAction } from "./runtime-research.js";
+import { executeFutunnTradingAction, isFutunnTradingAction } from "./runtime-trading.js";
+import { readFutunnData, readFutunnList, requestFutunn } from "./transport.js";
+export async function executeFutunnAction(input, fetcher) {
+    const values = input.input;
+    const request = (path, query, body) => requestFutunn(input, fetcher, path, query, body).then(readFutunnData);
+    if (isFutunnResearchAction(input.actionName))
+        return executeFutunnResearchAction(input, fetcher);
+    if (isFutunnTradingAction(input.actionName))
+        return executeFutunnTradingAction(input, fetcher);
+    switch (input.actionName) {
+        case "get_market_snapshot": {
+            const data = requiredResponseRecord(await request("/api/v1.0/quote/snapshot", {}, { code_list: values.symbols }), "Futunn snapshot data");
+            return { snapshots: readFutunnList(data.snapshot_list, "snapshot_list") };
+        }
+        case "get_history_kline": {
+            const data = requiredResponseRecord(await request(`/api/v1.0/quote/${encodeURIComponent(requiredInputString(values.symbol, "symbol"))}/history-kline`, {
+                start: values.start,
+                end: values.end,
+                ktype: values.ktype,
+                autype: values.autype,
+                num: values.num,
+                extended_time: values.extendedTime,
+            }), "Futunn history data");
+            return {
+                bars: readFutunnList(data.kline_list, "kline_list"),
+                nextTime: optionalNumber(data.next_time) ?? null,
+                volumePrecision: optionalNumber(data.volume_precision) ?? null,
+            };
+        }
+        case "list_trading_days": {
+            const data = requiredResponseRecord(await request("/api/v1.0/quote/trading-days", values), "Futunn calendar data");
+            return { tradingDays: readFutunnList(data.trading_days, "trading_days") };
+        }
+        case "list_accounts": {
+            const data = requiredResponseRecord(await request("/api/v1.0/accounts/authorized_trd_accs"), "Futunn account data");
+            return { accounts: readFutunnList(data.accounts, "accounts") };
+        }
+        case "get_account_funds":
+            return {
+                funds: requiredResponseRecord(await request(`/api/v1.0/accounts/${encodeURIComponent(requiredInputString(values.accountId, "accountId"))}/funds`, { currency: values.currency }), "Futunn funds"),
+            };
+        case "list_positions":
+            return {
+                positions: readFutunnList(await request(`/api/v1.0/accounts/${encodeURIComponent(requiredInputString(values.accountId, "accountId"))}/positions`, { code: values.code, pl_ratio_min: values.plRatioMin, pl_ratio_max: values.plRatioMax }), "positions"),
+            };
+    }
+}

package/src/providers/futunn/transport.d.ts

@@ -0,0 +1,11 @@
+export interface FutunnActionInput {
+    actionName: string;
+    input: Record<string, unknown>;
+    accessToken: string;
+    signal?: AbortSignal;
+}
+export declare const futunnApiBaseUrl = "https://webapi.futunn.com";
+export declare function readFutunnResponse(response: Response, allowNoData?: boolean): Promise<Record<string, unknown>>;
+export declare function requestFutunn(input: FutunnActionInput, fetcher: typeof fetch, path: string, query?: Record<string, unknown>, body?: unknown, allowNoData?: boolean): Promise<Record<string, unknown>>;
+export declare function readFutunnList(value: unknown, label: string): unknown[];
+export declare function readFutunnData(envelope: Record<string, unknown>): unknown;

package/src/providers/futunn/transport.js

@@ -0,0 +1,76 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const futunnApiBaseUrl = "https://webapi.futunn.com";
+export async function readFutunnResponse(response, allowNoData = false) {
+    let payload;
+    try {
+        payload = JSON.parse(await response.text(), (key, value, context) => {
+            // Preserve the source decimal text of uint64 trading account IDs during JSON parsing.
+            if (key !== "account_id" || typeof value !== "number")
+                return value;
+            if (!Number.isInteger(value))
+                throw new Error("Invalid Futunn account ID");
+            if (Number.isSafeInteger(value))
+                return String(value);
+            if (!context?.source)
+                throw new Error("Futunn account ID source is unavailable");
+            return BigInt(context.source).toString();
+        });
+    }
+    catch {
+        throw new ProviderRequestError(response.ok ? 502 : response.status, "Futunn returned invalid JSON");
+    }
+    const envelope = requiredResponseRecord(payload, "Futunn response");
+    if (response.ok && allowNoData && envelope.ret_code === -10)
+        return envelope;
+    const error = optionalRecord(envelope.error);
+    if (!response.ok ||
+        envelope.s === "error" ||
+        (envelope.ret_code !== undefined && envelope.ret_code !== 0) ||
+        envelope.error) {
+        const message = optionalString(envelope.errmsg) ??
+            optionalString(envelope.ret_msg) ??
+            optionalString(envelope.error_description) ??
+            optionalString(error?.message) ??
+            optionalString(envelope.error) ??
+            "request failed";
+        const code = envelope.errcode ?? envelope.ret_code ?? error?.code;
+        throw new ProviderRequestError(response.ok ? 502 : response.status, `Futunn${code === undefined ? "" : ` (${String(code)})`}: ${message}`);
+    }
+    return envelope;
+}
+export async function requestFutunn(input, fetcher, path, query = {}, body, allowNoData = false) {
+    const url = new URL(path, futunnApiBaseUrl);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined)
+            url.searchParams.set(key, String(value));
+    }
+    return runProviderRequest({ label: "Futunn", signal: input.signal }, async (signal) => {
+        const response = await fetcher(url, {
+            method: body === undefined ? "GET" : "POST",
+            headers: {
+                authorization: `Bearer ${input.accessToken}`,
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+            redirect: "manual",
+        });
+        const envelope = await readFutunnResponse(response, allowNoData);
+        if (envelope.s === "ok" || envelope.ret_code === 0 || (allowNoData && envelope.ret_code === -10))
+            return envelope;
+        throw new ProviderRequestError(502, "Futunn response is missing its success envelope");
+    });
+}
+export function readFutunnList(value, label) {
+    if (!Array.isArray(value))
+        throw new ProviderRequestError(502, `Futunn ${label} must be an array`);
+    return value;
+}
+export function readFutunnData(envelope) {
+    if (envelope.ret_code === -10)
+        return null;
+    return envelope.s === "ok" ? envelope.d : envelope.data;
+}

package/src/providers/gildata/executors.js

@@ -202,7 +202,7 @@ function buildGildataMcpInput(serverType, apiKey, fetcher, parentSignal, request
             }
             return response;
         },
-        redirect: "error",
+        redirect: "manual",
         terminateSession: true,
         signal: parentSignal,
         requestTimeoutMs,

package/src/providers/gmail/attachment-stream.d.ts

@@ -0,0 +1,2 @@
+/** Decode MessagePartBody.data while retaining only a small JSON envelope and one base64 block. */
+export declare function decodeGmailAttachment(body: ReadableStream<Uint8Array>, maxBytes: number): ReadableStream<Uint8Array>;