@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/templatedocs/runtime.js

@@ -0,0 +1,151 @@
+import { basename } from "node:path";
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { readBoundedResponseBytes } from "../../core/request.js";
+import { providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+export const templatedocsApiBaseUrl = "https://templatedocs.io/api";
+export const templatedocsActionHandlers = {
+    list_templates(input, context) {
+        const pageIndex = optionalInteger(input.pageIndex);
+        return requestTemplateDocsJson({
+            ...context,
+            path: `/v1/templates${pageIndex == null ? "" : `?pageIndex=${pageIndex}`}`,
+        });
+    },
+    get_template(input, context) {
+        return requestTemplateDocsJson({ ...context, path: templatePath(input.templateId) });
+    },
+    async update_template(input, context) {
+        const name = optionalString(input.name)?.trim();
+        const allowGenerationWithWarnings = input.allowGenerationWithWarnings;
+        if (!name && allowGenerationWithWarnings == null) {
+            throw providerInputError("name or allowGenerationWithWarnings is required");
+        }
+        await requestTemplateDocs({
+            ...context,
+            path: templatePath(input.templateId),
+            method: "PATCH",
+            body: compactObject({
+                name,
+                options: allowGenerationWithWarnings == null ? undefined : { allowGenerationWithWarnings },
+            }),
+        });
+        return { success: true };
+    },
+    async delete_template(input, context) {
+        await requestTemplateDocs({
+            ...context,
+            path: templatePath(input.templateId),
+            method: "DELETE",
+        });
+        return { success: true };
+    },
+    generate_document: generateDocument,
+};
+export async function validateTemplateDocsCredential(apiKey, fetcher, signal) {
+    const payload = await requestTemplateDocsJson({
+        apiKey,
+        fetcher,
+        signal,
+        path: "/v1/templates?pageIndex=1",
+    });
+    const record = optionalRecord(payload);
+    return {
+        profile: { displayName: "TemplateDocs API Key" },
+        grantedScopes: [],
+        metadata: compactObject({
+            apiBaseUrl: templatedocsApiBaseUrl,
+            validationEndpoint: "/v1/templates",
+            pageSize: optionalInteger(record?.pageSize),
+        }),
+    };
+}
+async function generateDocument(input, context) {
+    if (!context.transitFiles)
+        throw providerInputError("Transit file storage is not enabled.");
+    const format = optionalString(input.format) ?? "docx";
+    const response = await requestTemplateDocs({
+        ...context,
+        path: `${templatePath(input.templateId)}/generate`,
+        method: "POST",
+        body: {
+            data: optionalRecord(input.data) ?? {},
+            output: compactObject({
+                format,
+                filename: optionalString(input.filename)?.trim(),
+                email: optionalRecord(input.email),
+            }),
+        },
+    });
+    const name = generatedFileName(input.filename, format);
+    const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() ?? mimeTypeForFormat(format);
+    const bytes = await readBoundedResponseBytes(response, {
+        maxBytes: context.transitFiles.maxBytes,
+        fieldName: name,
+        createError: (message) => new ProviderRequestError(413, message),
+    });
+    if (bytes.byteLength === 0)
+        throw new ProviderRequestError(502, "TemplateDocs returned an empty document");
+    const stored = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
+    return {
+        document: {
+            name: stored.name,
+            mimeType: stored.mimeType,
+            downloadUrl: stored.downloadUrl,
+            sizeBytes: stored.sizeBytes,
+        },
+    };
+}
+async function requestTemplateDocsJson(input) {
+    const response = await requestTemplateDocs(input);
+    return readProviderJsonBody(response, {
+        emptyBody: undefined,
+        invalidJsonMessage: "TemplateDocs returned invalid JSON",
+    });
+}
+async function requestTemplateDocs(input) {
+    return runProviderRequest({ label: "TemplateDocs", signal: input.signal }, async (signal) => {
+        const headers = new Headers({
+            accept: "application/json",
+            authorization: `Bearer ${input.apiKey}`,
+            "user-agent": providerUserAgent,
+        });
+        if (input.body != null)
+            headers.set("content-type", "application/json");
+        const response = await input.fetcher(`${templatedocsApiBaseUrl}${input.path}`, {
+            method: input.method ?? "GET",
+            headers,
+            body: input.body == null ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        if (!response.ok)
+            throw await createTemplateDocsError(response);
+        return response;
+    });
+}
+async function createTemplateDocsError(response) {
+    let message = `TemplateDocs request failed with status ${response.status}`;
+    try {
+        const payload = optionalRecord(await readProviderJsonBody(response, {
+            emptyBody: undefined,
+            invalidJsonMessage: "TemplateDocs returned invalid JSON",
+        }));
+        message = optionalString(optionalRecord(payload?.error)?.message) ?? message;
+    }
+    catch { }
+    return new ProviderRequestError(response.status || 502, message);
+}
+function templatePath(value) {
+    return `/v1/templates/${encodeURIComponent(requiredInputString(value, "templateId"))}`;
+}
+function generatedFileName(value, format) {
+    const requested = optionalString(value)?.trim();
+    if (!requested)
+        return `templatedocs-document.${format}`;
+    const safeName = basename(requested.replaceAll("\\", "/"));
+    return safeName.toLowerCase().endsWith(`.${format}`) ? safeName : `${safeName}.${format}`;
+}
+function mimeTypeForFormat(format) {
+    return format === "pdf"
+        ? "application/pdf"
+        : "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+}

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

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

package/src/providers/terminus_app/executors.js

@@ -0,0 +1,15 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { terminusAppActionHandlers, validateTerminusAppCredential } from "./runtime.js";
+const service = "terminus_app";
+export const executors = defineApiKeyProviderExecutors(service, terminusAppActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: "https://api.terminusapp.com",
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTerminusAppCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const terminusAppApiBaseUrl = "https://api.terminusapp.com";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const terminusAppActionHandlers: ProviderActionHandlers<"terminus_app", Handler>;
+export declare function validateTerminusAppCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/terminus_app/runtime.js

@@ -0,0 +1,172 @@
+import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, recordOrEmpty, } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { basicAuthorizationHeader, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const terminusAppApiBaseUrl = "https://api.terminusapp.com";
+export const terminusAppActionHandlers = {
+    async list_projects(input, context) {
+        return normalizeList(await requestTerminusApp({
+            ...context,
+            path: "/v1/projects/",
+            phase: "execute",
+            query: buildPaginationQuery(input),
+        }), "projects");
+    },
+    async list_conventions(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        return normalizeList(await requestTerminusApp({
+            ...context,
+            path: `/v1/projects/${encodeURIComponent(projectId)}/conventions`,
+            phase: "execute",
+            query: buildPaginationQuery(input),
+        }), "conventions");
+    },
+    async get_convention(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        const payload = await requestTerminusApp({
+            ...context,
+            path: `/v1/projects/${encodeURIComponent(projectId)}/conventions/${optionalInteger(input.conventionId)}`,
+            phase: "execute",
+        });
+        return { convention: requiredResponseRecord(payload, "Terminus convention response") };
+    },
+    async list_links(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        const payload = await requestTerminusApp({
+            ...context,
+            path: `/v1/projects/${encodeURIComponent(projectId)}/links`,
+            phase: "execute",
+            query: {
+                ...buildPaginationQuery(input),
+                "created_at[gt]": stringifyInteger(optionalInteger(input.createdAfter)),
+                "updated_at[gt]": stringifyInteger(optionalInteger(input.updatedAfter)),
+            },
+        });
+        return normalizeList(payload, "links");
+    },
+    async create_link(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        const payload = await requestTerminusApp({
+            ...context,
+            method: "POST",
+            path: `/v1/projects/${encodeURIComponent(projectId)}/links`,
+            phase: "execute",
+            body: buildCreateLinkBody(input),
+        });
+        return { link: requiredResponseRecord(payload, "Terminus link response") };
+    },
+};
+export async function validateTerminusAppCredential(apiKey, fetcher, signal) {
+    const payload = await requestTerminusApp({
+        apiKey,
+        fetcher,
+        signal,
+        path: "/v1/projects/",
+        phase: "validate",
+        query: { items: "1" },
+    });
+    normalizeList(payload, "projects");
+    return {
+        profile: { accountId: "terminus-app", displayName: "Terminus App API Key" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: terminusAppApiBaseUrl, validationEndpoint: "/v1/projects/" },
+    };
+}
+function buildPaginationQuery(input) {
+    return { page: stringifyInteger(optionalInteger(input.page)), items: stringifyInteger(optionalInteger(input.items)) };
+}
+function stringifyInteger(value) {
+    return value === undefined ? undefined : String(value);
+}
+function buildCreateLinkBody(input) {
+    const convention = optionalRecord(input.convention);
+    const inputFields = Array.isArray(convention?.inputFields)
+        ? convention.inputFields.map((value) => {
+            const field = recordOrEmpty(value);
+            return { field_id: optionalInteger(field.fieldId), input_value: optionalString(field.inputValue) };
+        })
+        : undefined;
+    const utm = optionalRecord(input.utm);
+    return compactObject({
+        url: requiredInputString(input.url, "url"),
+        convention: convention ? { id: optionalInteger(convention.id), input_fields: inputFields } : undefined,
+        utm: utm ? mapTagObject(utm) : undefined,
+        custom: mapOptionalNamedTags(input.custom),
+        info: mapOptionalNamedTags(input.info),
+        label_names: Array.isArray(input.labelNames) ? input.labelNames : undefined,
+        description: optionalString(input.description),
+        skip_monitoring: optionalBoolean(input.skipMonitoring),
+        short_url_key: optionalString(input.shortUrlKey),
+        skip_url_validation: optionalBoolean(input.skipUrlValidation),
+    });
+}
+function mapTagObject(input) {
+    return compactObject({
+        campaign: optionalRecord(input.campaign),
+        medium: optionalRecord(input.medium),
+        source: optionalRecord(input.source),
+        content: optionalRecord(input.content),
+        term: optionalRecord(input.term),
+    });
+}
+function mapOptionalNamedTags(value) {
+    const record = optionalRecord(value);
+    return record ? Object.fromEntries(Object.entries(record)) : undefined;
+}
+async function requestTerminusApp(input) {
+    return runProviderRequest({ label: "Terminus App", signal: input.signal }, async (signal) => {
+        const url = new URL(input.path, terminusAppApiBaseUrl);
+        for (const [name, value] of Object.entries(input.query ?? {}))
+            if (value !== undefined)
+                url.searchParams.set(name, value);
+        const response = await input.fetcher(url, {
+            method: input.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                authorization: basicAuthorizationHeader(`${input.apiKey}:`),
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: input.body === undefined ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readPayload(response);
+        if (!response.ok)
+            throw createError(response.status, payload, input.phase);
+        return payload;
+    });
+}
+async function readPayload(response) {
+    const text = await readProviderTextBody(response, "Terminus App response");
+    if (!text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ProviderRequestError(502, "Terminus App returned invalid JSON");
+    }
+}
+function createError(status, payload, phase) {
+    const message = extractErrorMessage(payload) ?? `Terminus App request failed with status ${status}`;
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (status === 401)
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message, payload);
+    return new ProviderRequestError(status || 502, message, payload);
+}
+function extractErrorMessage(payload) {
+    const record = optionalRecord(payload);
+    return optionalString(record?.message) ?? optionalString(record?.error) ?? optionalString(record?.detail);
+}
+function normalizeList(payload, outputName) {
+    const record = requiredResponseRecord(payload, "Terminus list response");
+    return {
+        [outputName]: requireArray(record.data, "Terminus list response data"),
+        meta: requiredResponseRecord(record.meta, "Terminus list response meta"),
+    };
+}
+function requireArray(value, label) {
+    if (Array.isArray(value))
+        return value;
+    throw new ProviderRequestError(502, `${label} must be an array`);
+}

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

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

package/src/providers/ticket_tailor/executors.js

@@ -0,0 +1,15 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { ticketTailorActionHandlers, validateTicketTailorCredential } from "./runtime.js";
+const service = "ticket_tailor";
+export const executors = defineApiKeyProviderExecutors(service, ticketTailorActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: "https://api.tickettailor.com",
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTicketTailorCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const ticketTailorApiBaseUrl = "https://api.tickettailor.com";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const ticketTailorActionHandlers: ProviderActionHandlers<"ticket_tailor", Handler>;
+export declare function validateTicketTailorCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/ticket_tailor/runtime.js

@@ -0,0 +1,152 @@
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { basicAuthorizationHeader, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const ticketTailorApiBaseUrl = "https://api.tickettailor.com";
+const ticketTailorApiKeyHelpUrl = "https://help.tickettailor.com/en/articles/4593218-how-do-i-connect-to-the-ticket-tailor-api";
+const paginationFields = ["starting_after", "ending_before", "limit"];
+const actionRoutes = {
+    list_events: {
+        collectionPath: "/v1/events",
+        queryFields: [
+            ...paginationFields,
+            "start_at",
+            "start_at.gt",
+            "start_at.gte",
+            "start_at.lt",
+            "start_at.lte",
+            "end_at",
+            "end_at.gt",
+            "end_at.gte",
+            "end_at.lt",
+            "end_at.lte",
+            "status",
+            "name",
+            "venue",
+        ],
+    },
+    get_event: { collectionPath: "/v1/events", idField: "event_id" },
+    list_orders: {
+        collectionPath: "/v1/orders",
+        queryFields: [
+            ...paginationFields,
+            "created_at",
+            "created_at.gt",
+            "created_at.gte",
+            "created_at.lt",
+            "created_at.lte",
+            "name",
+            "email",
+            "txn_id",
+            "barcode",
+            "event_id",
+            "event_series_id",
+            "status",
+            "store_id",
+            "referral_tag",
+        ],
+    },
+    get_order: { collectionPath: "/v1/orders", idField: "order_id" },
+    list_issued_tickets: {
+        collectionPath: "/v1/issued_tickets",
+        queryFields: [
+            ...paginationFields,
+            "event_id",
+            "event_series_id",
+            "order_id",
+            "barcode",
+            "name",
+            "email",
+            "reference",
+            "status",
+            "created_at",
+            "created_at.gt",
+            "created_at.gte",
+            "created_at.lt",
+            "created_at.lte",
+        ],
+    },
+    get_issued_ticket: { collectionPath: "/v1/issued_tickets", idField: "issued_ticket_id" },
+};
+function createHandler(route) {
+    return async (input, context) => {
+        const path = route.idField
+            ? `${route.collectionPath}/${encodeURIComponent(requiredInputString(input[route.idField], route.idField))}`
+            : route.collectionPath;
+        const payload = await requestTicketTailorJson({
+            apiKey: context.apiKey,
+            path,
+            query: route.idField ? undefined : buildListQuery(input, route.queryFields ?? []),
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+        if (route.idField)
+            return requiredResponseRecord(payload, "Ticket Tailor resource response");
+        const response = requiredResponseRecord(payload, "Ticket Tailor list response");
+        return { ...response, data: requireArray(response.data, "Ticket Tailor list response data") };
+    };
+}
+export const ticketTailorActionHandlers = Object.fromEntries(Object.entries(actionRoutes).map(([name, route]) => [name, createHandler(route)]));
+export async function validateTicketTailorCredential(apiKey, fetcher, signal) {
+    await requestTicketTailorJson({ apiKey, path: "/v1/ping", fetcher, signal });
+    return {
+        profile: { accountId: "ticket-tailor", displayName: "Ticket Tailor Box Office" },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: ticketTailorApiBaseUrl,
+            validationEndpoint: "/v1/ping",
+            credentialHelpUrl: ticketTailorApiKeyHelpUrl,
+        },
+    };
+}
+function buildListQuery(input, fields) {
+    const query = {};
+    for (const field of fields)
+        query[field] =
+            field === "limit" || field.includes("_at") ? optionalInteger(input[field]) : optionalString(input[field]);
+    return compactObject(query);
+}
+async function requestTicketTailorJson(input) {
+    return runProviderRequest({ label: "Ticket Tailor", signal: input.signal }, async (signal) => {
+        const url = new URL(input.path, ticketTailorApiBaseUrl);
+        for (const [key, value] of Object.entries(input.query ?? {}))
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        const response = await input.fetcher(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                authorization: basicAuthorizationHeader(`${input.apiKey}:`),
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        const payload = await readPayload(response);
+        if (!response.ok)
+            throw createError(response, payload);
+        return payload;
+    });
+}
+async function readPayload(response) {
+    const text = await readProviderTextBody(response, "Ticket Tailor response");
+    if (!text.trim())
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ProviderRequestError(502, "Ticket Tailor returned invalid JSON");
+    }
+}
+function createError(response, payload) {
+    const record = optionalRecord(payload) ?? {};
+    const upstreamMessage = optionalString(record.message) ??
+        optionalString(record.error) ??
+        `Ticket Tailor request failed with HTTP ${response.status}`;
+    const code = optionalString(record.error_code);
+    return new ProviderRequestError(response.status || 502, code ? `[${code}] ${upstreamMessage}` : upstreamMessage, payload, code);
+}
+function requireArray(value, label) {
+    if (Array.isArray(value))
+        return value;
+    throw new ProviderRequestError(502, `${label} must be an array`);
+}

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

@@ -1,3 +1,4 @@
 import type { ActionDefinition } from "../../core/types.ts";
 export declare const tongdaxinReadOnlyToolNames: string[];
+export type TongdaxinReadOnlyToolName = (typeof tongdaxinReadOnlyToolNames)[number];
 export declare const tongdaxinActions: ActionDefinition[];

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,7 +30,7 @@ const mcpToolSummarySchema = s.object("A supported read-only financial data tool
 export const tongdaxinActions = [
     defineProviderAction(service, {
         name: "list_tools",
-        operationType: "read",
+        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"],
@@ -44,11 +46,12 @@ export const tongdaxinActions = [
         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,
 ];