@oomol-lab/open-connector 1.6.1 → 1.6.3

package/src/providers/tongdaxin/actions.js

@@ -1,5 +1,6 @@
 import { s } from "../../core/json-schema.js";
 import { defineProviderAction } from "../../core/provider-definition.js";
+import { tongdaxinNamedActions } from "./named-actions.js";
 const service = "tongdaxin";
 export const tongdaxinReadOnlyToolNames = [
     "tdx_lookup_stock",
@@ -11,6 +12,7 @@ export const tongdaxinReadOnlyToolNames = [
     "wenda_news_query",
     "wenda_notice_query",
     "wenda_report_query",
+    "wenda_macro_query",
 ];
 const toolAnnotationsSchema = s.looseObject("MCP behavior hints supplied by Tongdaxin.", {
     title: s.optional(s.string("A human-readable title for the tool.")),
@@ -20,7 +22,7 @@ const toolAnnotationsSchema = s.looseObject("MCP behavior hints supplied by Tong
     openWorldHint: s.optional(s.boolean("Whether the tool may interact with entities outside Tongdaxin.")),
 });
 const mcpToolSummarySchema = s.object("A supported read-only financial data tool currently exposed by Tongdaxin MCP.", {
-    name: s.stringEnum("The exact supported Tongdaxin MCP tool name to pass to call_tool.", tongdaxinReadOnlyToolNames),
+    name: s.nonWhitespaceString("The exact Tongdaxin MCP tool name to pass to call_tool."),
     description: s.string("The current tool description supplied by Tongdaxin MCP."),
     annotations: toolAnnotationsSchema,
     inputSchema: s.looseObject("The current JSON Schema for the tool arguments, supplied by Tongdaxin MCP."),
@@ -28,6 +30,7 @@ const mcpToolSummarySchema = s.object("A supported read-only financial data tool
 export const tongdaxinActions = [
     defineProviderAction(service, {
         name: "list_tools",
+        operationType: "destructive",
         description: "Discover the supported Tongdaxin market data, screening, news, announcement, and research MCP tools with their live input schemas.",
         requiredScopes: [],
         followUpActions: ["tongdaxin.call_tool"],
@@ -38,15 +41,17 @@ export const tongdaxinActions = [
     }),
     defineProviderAction(service, {
         name: "call_tool",
+        operationType: "read",
         description: "Call one supported read-only Tongdaxin financial data MCP tool with arguments matching its live input schema.",
         requiredScopes: [],
         followUpActions: ["tongdaxin.list_tools"],
         inputSchema: s.object("Input for invoking one supported read-only Tongdaxin MCP tool.", {
-            toolName: s.stringEnum("The supported Tongdaxin MCP tool to invoke.", tongdaxinReadOnlyToolNames),
+            toolName: s.nonWhitespaceString("The exact Tongdaxin MCP tool to invoke."),
             arguments: s.looseObject("JSON arguments matching the live inputSchema returned for the selected tool."),
         }, { optional: ["arguments"] }),
         outputSchema: s.object("The normalized result returned by Tongdaxin MCP.", {
             result: s.unknown("The tool result. Structured MCP content is returned directly; otherwise the MCP content envelope is preserved."),
         }),
     }),
+    ...tongdaxinNamedActions,
 ];

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 {};