@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/tongdaxin/executors.js

@@ -3,7 +3,9 @@ import { createHash } from "node:crypto";
 import { optionalRecord } from "../../core/cast.js";
 import { withMcpClient } from "../mcp-client.js";
 import { defineApiKeyProviderExecutors, providerUserAgent, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
-import { tongdaxinReadOnlyToolNames } from "./actions.js";
+import { tongdaxinActions, tongdaxinReadOnlyToolNames } from "./actions.js";
+import { normalizeTongdaxinNamedActionOutput } from "./named-action-output.js";
+import { isTongdaxinNamedActionName, resolveTongdaxinNamedToolCall } from "./named-action-routing.js";
 const service = "tongdaxin";
 const endpoint = new URL("https://txmcp.tdx.com.cn:3001/txmcp");
 const requestTimeoutMs = 60_000;
@@ -17,10 +19,7 @@ const handlers = {
         const argumentsValue = input.arguments === undefined ? {} : optionalRecord(input.arguments);
         if (!argumentsValue)
             throw new ProviderRequestError(400, "arguments must be a JSON object");
-        const tools = await discoverSupportedTools(context, "execute");
-        if (!tools.some((tool) => tool.name === toolName)) {
-            throw new ProviderRequestError(403, "The selected Tongdaxin tool is not available as read-only");
-        }
+        assertToolArgumentsSize(argumentsValue);
         const result = await withTongdaxinClient(context, "execute", (client) => client.callTool({ name: toolName, arguments: argumentsValue }, { timeout: requestTimeoutMs, signal: context.signal }));
         if (!("toolResult" in result) && result.isError) {
             throw new ProviderRequestError(502, `Tongdaxin MCP tool ${toolName} returned an error`, result);
@@ -32,6 +31,31 @@ const handlers = {
         return { result: text?.type === "text" ? text.text : result.content };
     },
 };
+for (const actionName of Object.keys(resolveNamedHandlers())) {
+    handlers[actionName] = async (input, context) => {
+        if (!isTongdaxinNamedActionName(actionName))
+            throw new ProviderRequestError(400, `Unknown action: ${actionName}`);
+        const toolCall = resolveTongdaxinNamedToolCall(actionName, input);
+        assertToolArgumentsSize(toolCall.arguments);
+        const tools = await discoverSupportedTools(context, "execute");
+        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}`);
+        }
+        if (tool &&
+            (!supportedToolNames.has(tool.name) ||
+                tool.annotations?.readOnlyHint !== true ||
+                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", (client) => client.callTool({ name: toolCall.toolName, arguments: toolCall.arguments }, { timeout: requestTimeoutMs, signal: context.signal }));
+        if (!("toolResult" in result) && result.isError) {
+            throw new ProviderRequestError(502, `Tongdaxin MCP tool ${toolCall.toolName} returned an error`, result);
+        }
+        const normalized = "toolResult" in result ? result : (result.structuredContent ?? extractTextContent(result.content));
+        return normalizeTongdaxinNamedActionOutput(actionName, normalized);
+    };
+}
 export const executors = defineApiKeyProviderExecutors(service, handlers, {
     skipDnsValidation: true,
 });
@@ -55,11 +79,7 @@ export const credentialValidators = {
 };
 async function discoverSupportedTools(context, phase) {
     const result = await withTongdaxinClient(context, phase, (client) => client.listTools({}, { timeout: requestTimeoutMs, signal: context.signal }));
-    return result.tools
-        .filter((tool) => supportedToolNames.has(tool.name) &&
-        tool.annotations?.readOnlyHint === true &&
-        tool.annotations.destructiveHint !== true)
-        .map((tool) => ({
+    return result.tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
         annotations: tool.annotations,
@@ -98,3 +118,24 @@ function mapTongdaxinError(error, phase) {
     }
     return new ProviderRequestError(502, error instanceof Error ? `Tongdaxin MCP request failed: ${error.message}` : "Tongdaxin MCP request failed", error);
 }
+function resolveNamedHandlers() {
+    return Object.fromEntries(tongdaxinActions
+        .filter((action) => action.name !== "list_tools" && action.name !== "call_tool")
+        .map((action) => [action.name, true]));
+}
+function assertToolArgumentsSize(argumentsValue) {
+    if (new TextEncoder().encode(JSON.stringify(argumentsValue)).byteLength > 64 * 1024) {
+        throw new ProviderRequestError(400, "arguments must not exceed 65536 JSON bytes");
+    }
+}
+function extractTextContent(content) {
+    const text = content.find((item) => item.type === "text")?.text;
+    if (text === undefined)
+        return content;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/src/providers/tongdaxin/named-action-output.d.ts

@@ -0,0 +1 @@
+export declare function normalizeTongdaxinNamedActionOutput(actionName: string, result: unknown): unknown;

package/src/providers/tongdaxin/named-action-output.js

@@ -0,0 +1,149 @@
+import { optionalBoolean, optionalRecord, optionalString, optionalStringOrNull, recordOrEmpty, } from "../../core/cast.js";
+import { providerResponseError, requiredResponseRecord } from "../provider-runtime.js";
+export function normalizeTongdaxinNamedActionOutput(actionName, result) {
+    const resultObject = requiredResponseRecord(result, "Tongdaxin named action result");
+    throwNamedActionFailure(resultObject);
+    switch (actionName) {
+        case "lookup_security":
+            return {
+                matches: normalizeLookupMatches(resultObject.data),
+                result,
+            };
+        case "get_quotes":
+            return normalizeQuotes(resultObject, result);
+        case "get_kline":
+            return normalizeKline(resultObject, result);
+        case "query_indicators":
+            return {
+                data: requireResponseArray(resultObject.data, "Tongdaxin indicator data"),
+                result,
+            };
+        case "screen_stocks":
+        case "screen_hk_stocks":
+        case "screen_funds":
+        case "screen_indices":
+        case "screen_fund_managers":
+            return normalizeScreening(resultObject, result);
+        case "search_news":
+        case "search_announcements":
+        case "search_reports":
+        case "query_macro_data":
+            return normalizeSearch(resultObject, result);
+        case "get_financial_statements":
+        case "get_company_profile":
+        case "get_shareholder_research":
+        case "get_institutional_holdings":
+        case "get_capital_and_trading_data":
+        case "get_dividends_and_financing":
+        case "get_share_capital":
+        case "get_valuation_and_ranking":
+        case "get_board_and_industry_data":
+        case "get_hot_topics":
+        case "get_hk_financials":
+            return normalizeF10(resultObject, result);
+        default:
+            return assertNever(actionName);
+    }
+}
+function normalizeLookupMatches(value) {
+    return requireResponseObjectArray(value, "Tongdaxin lookup data").map((match) => {
+        const marketCode = match.setcode;
+        if (typeof marketCode !== "string" && typeof marketCode !== "number") {
+            throw providerResponseError("Tongdaxin lookup setcode is required");
+        }
+        return {
+            ...match,
+            code: requireResponseString(match.code, "Tongdaxin lookup code"),
+            marketCode: String(marketCode),
+        };
+    });
+}
+function normalizeQuotes(resultObject, result) {
+    return {
+        baseInformation: requiredResponseRecord(resultObject.BaseInfo, "Tongdaxin quote BaseInfo"),
+        quote: requiredResponseRecord(resultObject.HQInfo, "Tongdaxin quote HQInfo"),
+        extendedInformation: requiredResponseRecord(resultObject.ExtInfo, "Tongdaxin quote ExtInfo"),
+        orderBook: resultObject.BspInfo == null ? [] : requireResponseObjectArray(resultObject.BspInfo, "Tongdaxin quote BspInfo"),
+        professionalInformation: resultObject.ProInfo == null ? {} : requiredResponseRecord(resultObject.ProInfo, "Tongdaxin quote ProInfo"),
+        financialInformation: resultObject.CwInfo == null ? {} : requiredResponseRecord(resultObject.CwInfo, "Tongdaxin quote CwInfo"),
+        statistics: resultObject.StatInfo == null ? {} : requiredResponseRecord(resultObject.StatInfo, "Tongdaxin quote StatInfo"),
+        result,
+    };
+}
+function normalizeKline(resultObject, result) {
+    const period = resultObject.Period;
+    if (typeof period !== "string" && typeof period !== "number") {
+        throw providerResponseError("Tongdaxin K-line Period is required");
+    }
+    return {
+        code: requireResponseString(resultObject.Code, "Tongdaxin K-line Code"),
+        period,
+        rows: requireResponseObjectArray(resultObject.Rows, "Tongdaxin K-line Rows"),
+        statistics: requiredResponseRecord(resultObject.Stats, "Tongdaxin K-line Stats"),
+        result,
+    };
+}
+function normalizeScreening(resultObject, result) {
+    return {
+        summary: asStringOrNull(resultObject.summary),
+        metadata: requiredResponseRecord(resultObject.meta, "Tongdaxin screening meta"),
+        headers: requireResponseStringArray(resultObject.headers, "Tongdaxin screening headers"),
+        data: requireResponseObjectArray(resultObject.data, "Tongdaxin screening data"),
+        result,
+    };
+}
+function normalizeSearch(resultObject, result) {
+    if (!Object.hasOwn(resultObject, "data")) {
+        throw providerResponseError("Tongdaxin search data is required");
+    }
+    return {
+        ok: optionalBoolean(resultObject.ok) ?? null,
+        query: asStringOrNull(resultObject.query),
+        data: resultObject.data ?? null,
+        result,
+    };
+}
+function normalizeF10(resultObject, result) {
+    const response = requiredResponseRecord(resultObject.response, "Tongdaxin F10 response");
+    const transformed = requiredResponseRecord(response.transformed, "Tongdaxin F10 transformed data");
+    return {
+        ok: optionalBoolean(resultObject.ok) ?? optionalBoolean(response.ok) ?? null,
+        summary: asStringOrNull(transformed.summary ?? resultObject.summary),
+        tables: requireResponseObjectArray(transformed.tables, "Tongdaxin F10 tables"),
+        result,
+    };
+}
+function assertNever(value) {
+    throw providerResponseError(`unhandled Tongdaxin action output: ${value}`);
+}
+function throwNamedActionFailure(result) {
+    const response = asObjectOrEmpty(result.response);
+    if (optionalBoolean(result.ok) !== false && optionalBoolean(response.ok) !== false) {
+        return;
+    }
+    throw providerResponseError("Tongdaxin returned an unsuccessful tool result");
+}
+function requireResponseArray(value, label) {
+    if (!Array.isArray(value))
+        throw providerResponseError(`${label} must be an array`);
+    return value;
+}
+function requireResponseObjectArray(value, label) {
+    return requireResponseArray(value, label).map((item) => {
+        const record = optionalRecord(item);
+        if (!record)
+            throw providerResponseError(`${label} must contain objects`);
+        return record;
+    });
+}
+function requireResponseString(value, label) {
+    const string = optionalString(value);
+    if (string === undefined)
+        throw providerResponseError(`${label} must be a string`);
+    return string;
+}
+function requireResponseStringArray(value, label) {
+    return requireResponseArray(value, label).map((item) => requireResponseString(item, label));
+}
+const asObjectOrEmpty = recordOrEmpty;
+const asStringOrNull = optionalStringOrNull;

package/src/providers/tongdaxin/named-action-routing.d.ts

@@ -0,0 +1,9 @@
+import type { TongdaxinReadOnlyToolName } from "./actions.ts";
+export interface TongdaxinNamedToolCall {
+    toolName: TongdaxinReadOnlyToolName;
+    arguments: Record<string, unknown>;
+}
+type NamedActionInput = Record<string, unknown>;
+export declare function isTongdaxinNamedActionName(value: string): boolean;
+export declare function resolveTongdaxinNamedToolCall(actionName: string, input: NamedActionInput): TongdaxinNamedToolCall;
+export {};

package/src/providers/tongdaxin/named-action-routing.js

@@ -0,0 +1,417 @@
+import { compactObject } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+const lookupRanges = {
+    A_SHARE: "AG",
+    HK_STOCK: "HK-GP",
+    HK_FUND: "HK-JJ",
+    FUND: "JJ",
+    US_STOCK: "MG-GP",
+    INDEX: "ZS",
+    FUTURES: "QH",
+    OPTION: "QQ",
+};
+const indicatorRanges = {
+    A_SHARE: "AG",
+    INDEX: "ZS",
+    FUND: "JJ",
+};
+const screenRanges = {
+    screen_stocks: "AG",
+    screen_hk_stocks: "HK-GP",
+    screen_funds: "JJ",
+    screen_indices: "ZS",
+    screen_fund_managers: "ZG-JJJL",
+};
+const klinePeriods = {
+    "5_SECONDS": "12",
+    "1_MINUTE": "7",
+    "5_MINUTES": "0",
+    "15_MINUTES": "1",
+    "30_MINUTES": "2",
+    "1_HOUR": "3",
+    DAILY: "4",
+    WEEKLY: "5",
+    MONTHLY: "6",
+    QUARTERLY: "10",
+    YEARLY: "11",
+};
+const adjustments = {
+    NONE: "0",
+    FORWARD: "1",
+    BACKWARD: "2",
+};
+const companyProfileSections = {
+    OVERVIEW: {
+        entry: "TdxSharePCCW.tdxf10_gg_zxts",
+        fixedTag: "gsgy",
+    },
+    BASIC_INFORMATION: {
+        entry: "TdxSharePCCW.tdxf10_gg_gsgk",
+        fixedTag: "0",
+    },
+    ISSUANCE_AND_TRADING: {
+        entry: "TdxSharePCCW.tdxf10_gg_gsgk",
+        fixedTag: "8",
+    },
+    EXECUTIVES: {
+        entry: "TdxSharePCCW.tdxf10_gg_gsgk",
+        fixedTag: "20",
+    },
+    AFFILIATES: {
+        entry: "TdxSharePCCW.tdxf10_gg_gsgk",
+        fixedTag: "3",
+    },
+    EMPLOYEE_STRUCTURE: {
+        entry: "TdxSharePCCW.tdxf10_gg_gsgk",
+        fixedTag: "4",
+    },
+    EMPLOYEE_EFFICIENCY: {
+        entry: "TdxSharePCCW.tdxf10_gg_gsgk",
+        fixedTag: "5",
+    },
+};
+const shareholderSections = {
+    CONTROLLING_SHAREHOLDER: "kggd",
+    SHAREHOLDER_COUNT: "gdrs",
+    SHAREHOLDER_COUNT_RANK: "thygdrs",
+    TOP_FLOAT_SHAREHOLDERS: "ltgd",
+    TOP_SHAREHOLDERS: "sdgdbgq",
+};
+const dividendSections = {
+    OVERVIEW: "pxmz",
+    DIVIDEND_CHART: "fh_zzt",
+    RIGHTS_ISSUE_PLAN: "pf",
+    PLACEMENT_DETAIL: "zfpg",
+    REFINANCING_PLAN: "zf",
+    PAYOUT_HISTORY: "fhlszs_glzfl",
+    YIELD_HISTORY: "fhlszs_gxl",
+    PAYOUT_RANK: "fhpm_glzfl",
+    YIELD_RANK: "fhpm_gxl",
+    CASH_FINANCING_RATIO_RANK: "fhpm_pxrzb",
+};
+const shareCapitalSections = {
+    STRUCTURE: "gbjg",
+    CHANGES: "gbbd",
+    RESTRICTED_UNLOCKS: "xslt",
+    STOCK_BUYBACK: "gphg",
+};
+const hotTopicSections = {
+    BOARD_FAMILY: "zttzbkz",
+    THEME_LIBRARY: "zttzztk",
+    EVENT_DRIVEN: "sjcd",
+    INFORMATION_OVERVIEW: "xxmmg",
+};
+const hkFinancialSections = {
+    INCOME_STATEMENT: "1",
+    BALANCE_SHEET: "2",
+    CASH_FLOW_STATEMENT: "3",
+};
+const tongdaxinNamedActionRoutes = {
+    lookup_security: (input) => toolCall("tdx_lookup_stock", {
+        query: input.query,
+        range: lookupRanges[input.market],
+    }),
+    get_quotes: (input) => toolCall("tdx_quotes", {
+        code: input.code,
+        setcode: input.marketCode,
+        bspNum: input.orderBookDepth,
+        hasProInfo: booleanFlag(input.includeProfessionalData),
+        hasCwInfo: booleanFlag(input.includeFinancialData),
+        hasStatInfo: booleanFlag(input.includeStatistics),
+        statParam: input.statisticParameter,
+    }),
+    get_kline: (input) => toolCall("tdx_kline", {
+        code: input.code,
+        setcode: input.marketCode,
+        period: klinePeriods[input.period],
+        wantNum: input.count,
+        startxh: input.offset,
+        tqFlag: adjustments[input.adjustment],
+        hasIpoPrice: booleanFlag(input.includeIpoPrice),
+    }),
+    query_indicators: (input) => toolCall("tdx_indicator_select", {
+        message: input.query,
+        rang: indicatorRanges[input.market],
+    }),
+    screen_stocks: (input) => screenToolCall("screen_stocks", input),
+    screen_hk_stocks: (input) => screenToolCall("screen_hk_stocks", input),
+    screen_funds: (input) => screenToolCall("screen_funds", input),
+    screen_indices: (input) => screenToolCall("screen_indices", input),
+    screen_fund_managers: (input) => screenToolCall("screen_fund_managers", input),
+    search_news: (input) => wendaToolCall("wenda_news_query", input),
+    search_announcements: (input) => wendaToolCall("wenda_notice_query", input),
+    search_reports: (input) => wendaToolCall("wenda_report_query", input),
+    query_macro_data: (input) => toolCall("wenda_macro_query", { query: input.query }),
+    get_financial_statements: (input) => toolCall("tdx_api_data", financialStatementArguments(input)),
+    get_company_profile: (input) => {
+        const route = companyProfileSections[input.section];
+        return toolCall("tdx_api_data", { ...route, code: input.code });
+    },
+    get_shareholder_research: (input) => toolCall("tdx_api_data", {
+        entry: "TdxSharePCCW.tdxf10_gg_gdyj",
+        code: input.code,
+        fixedTag: shareholderSections[input.section],
+        pageNo: input.page,
+        pageSize: input.pageSize,
+    }),
+    get_institutional_holdings: (input) => toolCall("tdx_api_data", institutionalHoldingArguments(input)),
+    get_capital_and_trading_data: (input) => toolCall("tdx_api_data", capitalAndTradingArguments(input)),
+    get_dividends_and_financing: (input) => toolCall("tdx_api_data", {
+        entry: "TdxSharePCCW.tdxf10_gg_fhrz",
+        code: input.code,
+        fixedTag: dividendSections[input.section],
+    }),
+    get_share_capital: (input) => toolCall("tdx_api_data", {
+        entry: "TdxSharePCCW.tdxf10_gg_gbjg",
+        code: input.code,
+        fixedTag: shareCapitalSections[input.section],
+    }),
+    get_valuation_and_ranking: (input) => toolCall("tdx_api_data", valuationAndRankingArguments(input)),
+    get_board_and_industry_data: (input) => toolCall("tdx_api_data", boardAndIndustryArguments(input)),
+    get_hot_topics: (input) => toolCall("tdx_api_data", {
+        entry: "TdxSharePCCW.tdxf10_gg_rdtc",
+        code: input.code,
+        fixedTag: hotTopicSections[input.section],
+    }),
+    get_hk_financials: (input) => toolCall("tdx_api_data", {
+        entry: "TdxSharePCCW.skef10_hk_cwfx",
+        code: input.code,
+        fixedTag: hkFinancialSections[input.statement],
+    }),
+};
+export function isTongdaxinNamedActionName(value) {
+    return value in tongdaxinNamedActionRoutes;
+}
+export function resolveTongdaxinNamedToolCall(actionName, input) {
+    return tongdaxinNamedActionRoutes[actionName](input);
+}
+function screenToolCall(actionName, input) {
+    return toolCall("tdx_screener", {
+        message: input.criteria,
+        rang: screenRanges[actionName],
+        pageNo: input.page,
+        pageSize: input.pageSize,
+    });
+}
+function toolCall(toolName, arguments_) {
+    return { toolName, arguments: compactObject(arguments_) };
+}
+function booleanFlag(value) {
+    return typeof value === "boolean" ? (value ? "1" : "0") : undefined;
+}
+function wendaToolCall(toolName, input) {
+    return toolCall(toolName, {
+        query: input.query,
+        name: input.name,
+        symbol: input.symbol,
+        bdate: input.startDate,
+        edate: input.endDate,
+        keywords: input.keywords,
+        desc: input.context,
+    });
+}
+function financialStatementArguments(input) {
+    const reportTag = input.reportView === "SINGLE_QUARTER" ? "00102" : "00101";
+    switch (input.statement) {
+        case "INCOME_STATEMENT":
+            return {
+                entry: "TdxShareCW.ph_agf10_cw_lyb",
+                code: input.code,
+                fixedTag: reportTag,
+            };
+        case "BALANCE_SHEET":
+            return { entry: "TdxShareCW.ph_agf10_cw_zcfzb", code: input.code };
+        case "CASH_FLOW_STATEMENT":
+            return {
+                entry: "TdxShareCW.ph_agf10_cw_xjllb",
+                code: input.code,
+                fixedTag: reportTag,
+            };
+        default:
+            throw unsupportedSection("financial statement", input.statement);
+    }
+}
+function institutionalHoldingArguments(input) {
+    const common = { code: input.code, pageNo: input.page, pageSize: input.pageSize };
+    switch (input.section) {
+        case "AVAILABLE_DATES":
+            return {
+                entry: "TdxSharePCCW.tdxf10_gg_comreq",
+                ...common,
+                fixedTag: "jgcg",
+            };
+        case "SUMMARY":
+            return {
+                entry: "TdxSharePCCW.tdxf10_gg_gdyj",
+                ...common,
+                fixedTag: "jgcg",
+            };
+        case "OVERVIEW":
+            return {
+                entry: "TdxSharePCCW.tdxf10_gg_gdyj",
+                ...common,
+                fixedTag: "jgcgz",
+                reportDate: input.reportDate,
+            };
+        case "DETAIL":
+            return {
+                entry: "TdxSharePCCW.tdxf10_gg_gdyj_jgcgmx",
+                ...common,
+                reportDate: input.reportDate,
+                sortType: input.sort,
+                typeValue: input.institutionType,
+            };
+        case "NORTHBOUND_FUNDS":
+            return {
+                entry: "TdxSharePCCW.tdxf10_gg_zlcc",
+                ...common,
+                fixedTag: "bszj",
+                date: input.date,
+            };
+        case "PRICE_COMPARISON":
+            return {
+                entry: "TdxShareCW.ph_agf10_gbgd_jgcc",
+                ...common,
+                queryKey: "00101",
+                compareFlag: input.comparison,
+            };
+        default:
+            throw unsupportedSection("institutional holdings", input.section);
+    }
+}
+function capitalAndTradingArguments(input) {
+    const code = input.code;
+    switch (input.section) {
+        case "CAPITAL_FLOW":
+            return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "zjlx");
+        case "NORTHBOUND_FUNDS":
+            return {
+                ...dataSection("TdxSharePCCW.tdxf10_gg_zlcc", code, "bszj"),
+                date: input.date,
+            };
+        case "BLOCK_TRADE":
+            return {
+                ...dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "dzjy"),
+                extra: input.date,
+            };
+        case "BLOCK_TRADE_INTENTION":
+            return dataSection("TdxSharePCCW.tdxf10_gg_iyds", code, "yxsbxx");
+        case "MARGIN_TRADING":
+            return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "rzrq");
+        case "REFINANCING":
+            return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "zrq");
+        case "LIMIT_UP_ANALYSIS":
+            return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "ztfx");
+        case "LIMIT_DOWN_ANALYSIS":
+            return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "dtfx");
+        case "SHAREHOLDER_CHANGE":
+            return {
+                ...dataSection("TdxSharePCCW.tdxf10_gg_gdyj", code, "cgbd"),
+                beginDate: input.startDate,
+                endDate: input.endDate,
+                pageNo: input.page,
+                pageSize: input.pageSize,
+            };
+        case "TOP_SHAREHOLDER_DETAIL":
+            return {
+                mode: "code-sort-report-type-click-page",
+                entry: "TdxSharePCCW.tdxf10_gg_gdyj_jgcgmx",
+                code,
+                reportDate: input.reportDate,
+                sortType: input.sort,
+                typeValue: input.shareholderType,
+                clickIndex: input.selectedIndex,
+                pageNo: input.page,
+                pageSize: input.pageSize,
+                responseTransform: { kind: "preset", preset: "top_shareholder_detail" },
+            };
+        default:
+            throw unsupportedSection("capital and trading", input.section);
+    }
+}
+function valuationAndRankingArguments(input) {
+    switch (input.section) {
+        case "VALUATION_HISTORY":
+            return {
+                entry: "TdxShareCW.ph_agf10_gzfx",
+                code: input.code,
+                extraOne: input.timeRange,
+                extraTwo: input.valuationMetric,
+            };
+        case "INDUSTRY_FINANCIAL_RANK":
+            return {
+                entry: "TdxShareCW.ph_agf10_hypm",
+                code: input.code,
+                queryKey: "00102",
+                extra: input.reportDate,
+            };
+        case "INDUSTRY_VALUATION_RANK":
+            return {
+                entry: "TdxShareCW.ph_agf10_hypm",
+                code: input.code,
+                queryKey: "00105",
+                extra: input.reportDate,
+            };
+        case "FINANCIAL_SECTOR_INDICATORS":
+            return {
+                entry: "TdxShareCW.ph_agf10_cw_zxzbxq",
+                code: input.code,
+                extra: input.reportDate,
+            };
+        case "BOARD_RELATIVE_VALUATION":
+            return {
+                entry: "TdxSharePCCW.skef10_hy_hydw_gzsppm",
+                queryType: "01",
+                targetCode: input.boardCode,
+                stockCode: input.code,
+            };
+        case "BOARD_HISTORY_VALUATION":
+            return {
+                entry: "TdxSharePCCW.skef10_hy_hydw_gzsppm",
+                queryType: "02",
+                targetCode: input.boardCode,
+                stockCode: "",
+            };
+        default:
+            throw unsupportedSection("valuation and ranking", input.section);
+    }
+}
+function boardAndIndustryArguments(input) {
+    switch (input.section) {
+        case "BOARD_BASIC_INFORMATION":
+            return boardSection(input.code, "001", "");
+        case "BOARD_DETAIL":
+            return boardSection(input.code, "002", "");
+        case "BOARD_STAGE_RETURN":
+            return boardSection(input.code, "003", input.period ?? "1m");
+        case "BOARD_MARKET_STATISTICS":
+            return boardSection(input.code, "004", "");
+        case "INDUSTRY_CHAIN":
+            return {
+                entry: "TdxSharePCCW.cfg_tk_gethy",
+                industryCode: input.code,
+            };
+        case "INDUSTRY_IMPORTANT_EVENTS":
+            return {
+                entry: "TdxSharePCCW.skef10_hy_zxdt_hyzysj",
+                industryCode: input.code,
+                title: input.title,
+            };
+        default:
+            throw unsupportedSection("board and industry", input.section);
+    }
+}
+function dataSection(entry, code, fixedTag) {
+    return { entry, code, fixedTag };
+}
+function boardSection(code, branch, timeType) {
+    return {
+        entry: "TdxSharePCCW.skef10_bk_cpbd_jczl",
+        code,
+        branch,
+        timeType,
+    };
+}
+function unsupportedSection(label, value) {
+    return providerInputError(`unsupported Tongdaxin ${label} section: ${String(value)}`);
+}

package/src/providers/tongdaxin/named-actions.d.ts

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