@oomol-lab/open-connector 1.6.5 → 1.7.0

package/src/providers/linear_mcp/runtime-mcp.js

@@ -0,0 +1,238 @@
+import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
+import { compactObject, looseArray, optionalBoolean, optionalInteger, optionalRawString, optionalRecord, optionalString, pickOptionalString, } from "../../core/cast.js";
+import { withMcpClient } from "../mcp-client.js";
+import { providerResponseError, providerUserAgent, ProviderRequestError, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+import { linearMcpEndpoint } from "./endpoints.js";
+const service = "linear_mcp";
+/** The Linear MCP tool behind each action. Sign-in requires every one of them (see the validator). */
+export const linearMcpToolsByAction = {
+    get_self: "get_user",
+    list_issues: "list_issues",
+    get_issue: "get_issue",
+    list_comments: "list_comments",
+};
+const humanIdentifier = /^[A-Z][A-Z0-9]*-\d+$/;
+const uuidIdentifier = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const truncationMarker = /\(truncated\b/i;
+const maxToolListPages = 20;
+export const linearMcpActionHandlers = {
+    async get_self(_input, context) {
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.get_self, { query: "me" });
+        return { user: parseLinearMcpUser(result.payload) ?? null, raw: result.text };
+    },
+    async list_issues(input, context) {
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.list_issues, compactObject({
+            updatedAt: optionalString(input.updatedAt),
+            orderBy: optionalString(input.orderBy),
+            limit: optionalInteger(input.limit),
+            cursor: optionalString(input.cursor),
+        }));
+        return { ...parseLinearMcpIssuePage(result.payload), raw: result.text };
+    },
+    async get_issue(input, context) {
+        const id = requiredInputString(input.id, "id");
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.get_issue, { id });
+        return { issue: parseLinearMcpIssue(result.payload) ?? null, raw: result.text };
+    },
+    async list_comments(input, context) {
+        const issueId = requiredInputString(input.issueId, "issueId");
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.list_comments, { issueId });
+        return { comments: parseLinearMcpComments(result.payload), raw: result.text };
+    },
+};
+/**
+ * Validate the OAuth grant against the MCP server: every tool the actions map
+ * must be listed (a rename shows up here, at sign-in, never mid-poll), then the
+ * self tool supplies the profile with the same viewer ID the GraphQL API reports.
+ */
+export async function validateLinearMcpCredential(credential, options) {
+    const context = { accessToken: credential.accessToken, fetcher: options.fetcher, signal: options.signal };
+    return withLinearMcpClient(context, "validate", async (client, signal) => {
+        const available = await listLinearMcpToolNames(client, signal);
+        const missing = Object.values(linearMcpToolsByAction).filter((name) => !available.has(name));
+        if (missing.length > 0) {
+            throw new ProviderRequestError(502, `Linear MCP did not expose the ${missing.join(", ")} tool${missing.length > 1 ? "s" : ""} this connector needs; Linear may have renamed ${missing.length > 1 ? "them" : "it"}.`);
+        }
+        const result = readLinearMcpToolResult(linearMcpToolsByAction.get_self, await client.callTool({ name: linearMcpToolsByAction.get_self, arguments: { query: "me" } }, { signal }));
+        const user = parseLinearMcpUser(result.payload);
+        if (!user)
+            throw providerResponseError("Linear MCP did not return the signed-in user.");
+        return {
+            profile: { accountId: user.id, displayName: user.displayName ?? user.name ?? user.email ?? user.id },
+            grantedScopes: optionalString(credential.metadata.scope)?.split(" ") ?? [],
+            metadata: { mcpEndpoint: linearMcpEndpoint, discoveredToolCount: available.size },
+        };
+    });
+}
+async function listLinearMcpToolNames(client, signal) {
+    const names = new Set();
+    let cursor;
+    for (let page = 0; page < maxToolListPages; page += 1) {
+        const listed = await client.listTools(cursor ? { cursor } : {}, { signal });
+        for (const tool of listed.tools)
+            names.add(tool.name);
+        cursor = optionalString(listed.nextCursor);
+        if (!cursor)
+            break;
+    }
+    return names;
+}
+/** Call one tool in a fresh MCP session and return its text and parsed payload. */
+function callLinearMcpTool(context, phase, name, args) {
+    return withLinearMcpClient(context, phase, async (client, signal) => readLinearMcpToolResult(name, await client.callTool({ name, arguments: args }, { signal })));
+}
+/**
+ * Join the text blocks as `text` and read the JSON they carry as `payload`
+ * (structured content wins when the server sends it). Text that is not JSON
+ * is not an error: the typed fields stay empty and `raw` still reaches the caller.
+ */
+function readLinearMcpToolResult(name, result) {
+    if ("toolResult" in result) {
+        return { text: JSON.stringify(result.toolResult), payload: result.toolResult };
+    }
+    if (result.isError)
+        throw new ProviderRequestError(502, `Linear MCP tool ${name} failed.`, result);
+    const text = looseArray(result.content)
+        .map((block) => optionalRecord(block))
+        .filter((block) => block?.type === "text")
+        .map((block) => optionalRawString(block?.text) ?? "")
+        .join("\n");
+    return { text, payload: optionalRecord(result.structuredContent) ?? parseJsonText(text) };
+}
+function parseJsonText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseLinearMcpUser(payload) {
+    const record = optionalRecord(payload);
+    const user = record && (optionalRecord(record.user) ?? optionalRecord(record.viewer) ?? record);
+    const id = user && pickOptionalString(user, "id", "uuid");
+    if (!user || !id)
+        return undefined;
+    return {
+        id,
+        email: pickOptionalString(user, "email"),
+        displayName: pickOptionalString(user, "displayName", "display_name"),
+        name: pickOptionalString(user, "name"),
+    };
+}
+function parseLinearMcpIssuePage(payload) {
+    const record = optionalRecord(payload);
+    const items = Array.isArray(payload) ? payload : looseArray(record?.issues ?? record?.nodes ?? record?.results);
+    const issues = items.map(parseLinearMcpIssue).filter((issue) => issue !== undefined);
+    const cursor = record ? (pickOptionalString(record, "cursor", "nextCursor", "endCursor") ?? null) : null;
+    const hasNextPage = (record && (optionalBoolean(record.hasNextPage) ?? optionalBoolean(record.hasMore))) ?? cursor !== null;
+    return { issues, hasNextPage, cursor };
+}
+function parseLinearMcpIssue(value) {
+    const record = optionalRecord(value);
+    const issue = record && (optionalRecord(record.issue) ?? record);
+    const id = issue && pickOptionalString(issue, "id", "identifier", "uuid");
+    if (!issue || !id)
+        return undefined;
+    const description = optionalRawString(issue.description);
+    const assignee = optionalRecord(issue.assignee);
+    const creator = optionalRecord(issue.creator);
+    return {
+        id,
+        identifier: pickOptionalString(issue, "identifier") ?? (humanIdentifier.test(id) ? id : undefined),
+        uuid: pickOptionalString(issue, "uuid") ?? (uuidIdentifier.test(id) ? id : undefined),
+        title: optionalRawString(issue.title),
+        description,
+        descriptionTruncated: description === undefined ? undefined : truncationMarker.test(description),
+        url: pickOptionalString(issue, "url"),
+        state: labelOf(issue.state ?? issue.status),
+        priority: issue.priority,
+        assignee: labelOf(issue.assignee),
+        assigneeId: assignee && pickOptionalString(assignee, "id"),
+        creator: labelOf(issue.creator),
+        creatorId: creator && pickOptionalString(creator, "id"),
+        team: labelOf(issue.team),
+        project: labelOf(issue.project),
+        labels: parseLabels(issue.labels),
+        createdAt: pickOptionalString(issue, "createdAt", "created_at"),
+        updatedAt: pickOptionalString(issue, "updatedAt", "updated_at"),
+        archivedAt: pickOptionalString(issue, "archivedAt", "archived_at"),
+        completedAt: pickOptionalString(issue, "completedAt", "completed_at"),
+        dueDate: pickOptionalString(issue, "dueDate", "due_date"),
+    };
+}
+function parseLinearMcpComments(payload) {
+    const record = optionalRecord(payload);
+    const items = Array.isArray(payload) ? payload : looseArray(record?.comments ?? record?.nodes);
+    return items.flatMap((item) => {
+        const comment = optionalRecord(item);
+        const id = comment && pickOptionalString(comment, "id");
+        if (!comment || !id)
+            return [];
+        const user = optionalRecord(comment.user);
+        return [
+            {
+                id,
+                body: optionalRawString(comment.body),
+                user: labelOf(comment.user),
+                userId: user && pickOptionalString(user, "id"),
+                createdAt: pickOptionalString(comment, "createdAt", "created_at"),
+                updatedAt: pickOptionalString(comment, "updatedAt", "updated_at"),
+                url: pickOptionalString(comment, "url"),
+            },
+        ];
+    });
+}
+/** A name for a value Linear may return as a string or as an object such as `{ id, name }`. */
+function labelOf(value) {
+    const record = optionalRecord(value);
+    if (record)
+        return pickOptionalString(record, "name", "displayName", "title", "key", "id");
+    return optionalString(value);
+}
+function parseLabels(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((label) => {
+        const name = labelOf(label);
+        return name ? [name] : [];
+    });
+}
+function withLinearMcpClient(context, phase, run) {
+    return runProviderRequest({ signal: context.signal, label: "Linear MCP" }, (signal) => withMcpClient({
+        endpoint: new URL(linearMcpEndpoint),
+        transport: "streamable_http",
+        fetcher: context.fetcher,
+        headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
+        redirect: "manual",
+        signal,
+        mapError: (error) => mapLinearMcpError(error, phase),
+    }, (client) => run(client, signal)));
+}
+/**
+ * A rejected token is a bad credential (400) while validating and an expired
+ * authorization (401) while executing; other SDK failures keep a 4xx status or
+ * become 502. Aborts and unknown errors pass through for the request wrapper.
+ */
+function mapLinearMcpError(error, phase) {
+    if (error instanceof ProviderRequestError)
+        return error;
+    if (error instanceof UnauthorizedError)
+        return credentialError(phase);
+    if (error instanceof SdkHttpError) {
+        const status = error.status;
+        if (status === 401 || status === 403)
+            return credentialError(phase);
+        return new ProviderRequestError(400 <= status && status < 500 ? status : 502, `Linear MCP request failed: ${error.message}`, error);
+    }
+    if (error instanceof ProtocolError) {
+        return new ProviderRequestError(502, `Linear MCP request failed: ${error.message}`, error);
+    }
+    return error;
+}
+function credentialError(phase) {
+    return new ProviderRequestError(phase === "validate" ? 400 : 401, "Linear MCP credential is invalid or expired; reconnect Linear.");
+}

package/src/providers/lingxing_mcp/runtime.js

@@ -174,7 +174,7 @@ async function withLingxingMcpClient(context, run) {
         transport: "streamable_http",
         fetcher: createLingxingRateLimitedFetch(context.fetcher, hashLingxingRateLimitKey(context)),
         headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapLingxingMcpError,
     }, run);

package/src/providers/mcdonalds_cn_mcp/runtime.js

@@ -65,7 +65,7 @@ async function withMcdonaldsCnMcpClient(context, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         protocolVersion: "legacy",
         mapError: mapMcdonaldsCnMcpError,

package/src/providers/metabase/mcp-runtime.js

@@ -12,7 +12,7 @@ export async function runMetabaseMcp(context, run) {
         endpoint: new URL(`${context.apiBaseUrl}/metabase-mcp`),
         transport: "streamable_http",
         headers: { "x-api-key": context.apiKey, "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         fetcher: context.fetcher,
         signal,
         mapError(error) {

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

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

package/src/providers/moneyforward_mcp/executors.js

@@ -0,0 +1,11 @@
+import { createProviderFetch, defineApiKeyProviderExecutors } from "../provider-runtime.js";
+import { moneyforwardService } from "./manifest.js";
+import { moneyforwardMcpActionHandlers, validateMoneyforwardMcpCredential } from "./runtime.js";
+// No proxy on purpose: a raw proxy could send any tools/call to Money Forward and bypass the
+// office check, schema check and write-outcome handling the actions enforce.
+export const executors = defineApiKeyProviderExecutors(moneyforwardService, moneyforwardMcpActionHandlers);
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateMoneyforwardMcpCredential(input.apiKey, createProviderFetch({ fetch: fetcher }), signal);
+    },
+};

package/src/providers/moneyforward_mcp/manifest.d.ts

@@ -0,0 +1,31 @@
+export declare const moneyforwardService = "moneyforward_mcp";
+export declare const moneyforwardMcpEndpoint = "https://beta.mcp.developers.biz.moneyforward.com/mcp/ca/v3";
+export declare const officeCodePattern = "^[0-9]{4}-[0-9]{4}$";
+export declare const currentOfficeToolName = "mfc_ca_currentOffice";
+/** One Money Forward MCP tool and the action that wraps it. */
+export interface MoneyforwardToolEntry {
+    actionName: string;
+    toolName: string;
+    isWrite: boolean;
+    requiresOfficeCode: boolean;
+    /**
+     * SHA-256 of the RFC 8785 canonical form of the tool's input schema as the server published it
+     * when this provider was written. Only the hash is kept; a write is refused when the live schema
+     * hashes differently, so any server-side change is reviewed before writes resume.
+     */
+    schemaDigest: string;
+}
+export declare const moneyforwardTools: readonly MoneyforwardToolEntry[];
+/**
+ * SHA-256 of the RFC 8785 canonical form of the whole schema. Nothing is stripped: every stripping
+ * rule considered had a counterexample (fields named `description`, data inside `const`/`enum`),
+ * so a wording change on the server also blocks writes until reviewed.
+ */
+export declare function schemaDigest(schema: unknown): string;
+/** RFC 8785 JSON Canonicalization for the JSON values a tool schema can hold. */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * Normalize an office name for the write guard: NFKC, drop all whitespace, and expand the explicit
+ * legal-form abbreviations. No fuzzy matching: a name that differs otherwise is refused.
+ */
+export declare function canonicalOfficeName(name: string): string;

package/src/providers/moneyforward_mcp/manifest.js

@@ -0,0 +1,204 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+export const moneyforwardService = "moneyforward_mcp";
+export const moneyforwardMcpEndpoint = "https://beta.mcp.developers.biz.moneyforward.com/mcp/ca/v3";
+export const officeCodePattern = "^[0-9]{4}-[0-9]{4}$";
+export const currentOfficeToolName = "mfc_ca_currentOffice";
+export const moneyforwardTools = [
+    {
+        actionName: "current_office",
+        toolName: "mfc_ca_currentOffice",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "2bbfa71baa94a486be83265529c2f9a39071b5b0518ff5fea1c4c3f2488029be",
+    },
+    {
+        actionName: "en_ja_dictionary",
+        toolName: "mfc_ca_en_ja_dictionary",
+        isWrite: false,
+        requiresOfficeCode: false,
+        schemaDigest: "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49",
+    },
+    {
+        actionName: "get_accessible_offices",
+        toolName: "mfc_ca_getAccessibleOffices",
+        isWrite: false,
+        requiresOfficeCode: false,
+        schemaDigest: "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49",
+    },
+    {
+        actionName: "get_accounts",
+        toolName: "mfc_ca_getAccounts",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "66ffd56141dc57fdaf68ca9be911ce5db97a7929f68e1ffe79b9cddb019fa69f",
+    },
+    {
+        actionName: "get_connected_accounts",
+        toolName: "mfc_ca_getConnectedAccounts",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "2bbfa71baa94a486be83265529c2f9a39071b5b0518ff5fea1c4c3f2488029be",
+    },
+    {
+        actionName: "get_departments",
+        toolName: "mfc_ca_getDepartments",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "2bbfa71baa94a486be83265529c2f9a39071b5b0518ff5fea1c4c3f2488029be",
+    },
+    {
+        actionName: "get_journal_by_id",
+        toolName: "mfc_ca_getJournalById",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "c290ddfd2081cef2c119d8ee37ce8207e1dbda4407437870868c5c3c046e321d",
+    },
+    {
+        actionName: "get_journals",
+        toolName: "mfc_ca_getJournals",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "9f3dbbc4efcf6e6783677ac737a293bd7d4ccea768be8d50f783a4a706b60821",
+    },
+    {
+        actionName: "get_reports_transition_balance_sheet",
+        toolName: "mfc_ca_getReportsTransitionBalanceSheet",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "171c891292cc5f0e8c9300654a9977d3eeed0067f630076708274c6eb4b4aa5f",
+    },
+    {
+        actionName: "get_reports_transition_profit_loss",
+        toolName: "mfc_ca_getReportsTransitionProfitLoss",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "171c891292cc5f0e8c9300654a9977d3eeed0067f630076708274c6eb4b4aa5f",
+    },
+    {
+        actionName: "get_reports_trial_balance_balance_sheet",
+        toolName: "mfc_ca_getReportsTrialBalanceBalanceSheet",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "23e330f0fac53ef01afbbc34f04c8017f6974859bde7d28c0b941f6c177fdda9",
+    },
+    {
+        actionName: "get_reports_trial_balance_profit_loss",
+        toolName: "mfc_ca_getReportsTrialBalanceProfitLoss",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "23e330f0fac53ef01afbbc34f04c8017f6974859bde7d28c0b941f6c177fdda9",
+    },
+    {
+        actionName: "get_sub_accounts",
+        toolName: "mfc_ca_getSubAccounts",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "6f55eb15f3ad3d127bbc272cc4a93ebcad9834cc871539df38809a4dc73bf3b2",
+    },
+    {
+        actionName: "get_taxes",
+        toolName: "mfc_ca_getTaxes",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "66ffd56141dc57fdaf68ca9be911ce5db97a7929f68e1ffe79b9cddb019fa69f",
+    },
+    {
+        actionName: "get_term_settings",
+        toolName: "mfc_ca_getTermSettings",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "2bbfa71baa94a486be83265529c2f9a39071b5b0518ff5fea1c4c3f2488029be",
+    },
+    {
+        actionName: "get_trade_partners",
+        toolName: "mfc_ca_getTradePartners",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "66ffd56141dc57fdaf68ca9be911ce5db97a7929f68e1ffe79b9cddb019fa69f",
+    },
+    {
+        actionName: "get_transactions",
+        toolName: "mfc_ca_getTransactions",
+        isWrite: false,
+        requiresOfficeCode: true,
+        schemaDigest: "84ee966ac02851949650f79293e46b2355fe907305f1ed1a4376fa42ad4808c5",
+    },
+    {
+        actionName: "post_journals",
+        toolName: "mfc_ca_postJournals",
+        isWrite: true,
+        requiresOfficeCode: true,
+        schemaDigest: "1fefc534d2dc71eba534851b611783618d9587c2dac33110480df2175326cf36",
+    },
+    {
+        actionName: "post_trade_partners",
+        toolName: "mfc_ca_postTradePartners",
+        isWrite: true,
+        requiresOfficeCode: true,
+        schemaDigest: "1f9466a7f72dd6dc7c84c657e533165462f899cc0dd1050c8a061729b3a3fcec",
+    },
+    {
+        actionName: "post_transaction_journalize",
+        toolName: "mfc_ca_postTransactionJournalize",
+        isWrite: true,
+        requiresOfficeCode: true,
+        schemaDigest: "139d06e6030ec46fee2eaf3f59a9f8f9e0b3e543f490b8469e9b8018454ff3b0",
+    },
+    {
+        actionName: "post_transactions",
+        toolName: "mfc_ca_postTransactions",
+        isWrite: true,
+        requiresOfficeCode: true,
+        schemaDigest: "0fd32a246c8478db7cb475fa2bb66d01ea076d8fa484c174ca3ebc311805bb48",
+    },
+    {
+        actionName: "put_journals",
+        toolName: "mfc_ca_putJournals",
+        isWrite: true,
+        requiresOfficeCode: true,
+        schemaDigest: "cb4219b165eac7d685122a203d501d9c50223b1c522f2549ae3a98d0ff7c369f",
+    },
+];
+/**
+ * SHA-256 of the RFC 8785 canonical form of the whole schema. Nothing is stripped: every stripping
+ * rule considered had a counterexample (fields named `description`, data inside `const`/`enum`),
+ * so a wording change on the server also blocks writes until reviewed.
+ */
+export function schemaDigest(schema) {
+    return sha256Hex(canonicalJson(schema));
+}
+/** RFC 8785 JSON Canonicalization for the JSON values a tool schema can hold. */
+export function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        const members = Object.keys(record)
+            .filter((key) => record[key] !== undefined)
+            .sort(compareUtf16)
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`);
+        return `{${members.join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+// Legal-form abbreviations Money Forward and users write interchangeably. NFKC has already
+// folded full-width brackets and the enclosed forms into these half-width spellings.
+const legalFormAbbreviations = [
+    ["(株)", "株式会社"],
+    ["(有)", "有限会社"],
+    ["(同)", "合同会社"],
+];
+/**
+ * Normalize an office name for the write guard: NFKC, drop all whitespace, and expand the explicit
+ * legal-form abbreviations. No fuzzy matching: a name that differs otherwise is refused.
+ */
+export function canonicalOfficeName(name) {
+    const folded = name.normalize("NFKC").replace(/\s/gu, "");
+    return legalFormAbbreviations.reduce((text, [short, full]) => text.split(short).join(full), folded);
+}
+// RFC 8785 orders member names by UTF-16 code units, which is what `<` on JS strings compares.
+function compareUtf16(left, right) {
+    if (left === right)
+        return 0;
+    return left < right ? -1 : 1;
+}

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

@@ -0,0 +1,18 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
+export interface MoneyforwardRuntimeOptions {
+    /** One budget for the whole action: office check, tools/list and the tool call share it. */
+    deadlineMs: number;
+    /** Extra wait past the deadline before giving up on an SDK cleanup that never settles. */
+    closeGraceMs: number;
+    /** Write actions allowed per key per rolling minute, so a looping agent cannot flood the ledger. */
+    writesPerMinute?: number;
+    /** Expected input-schema digests by tool name, replacing the manifest's (tests use synthetic schemas). */
+    schemaDigests?: Readonly<Record<string, string>>;
+}
+type Handler = ProviderRuntimeHandler<ApiKeyProviderContext>;
+export declare function createMoneyforwardMcpHandlers(timing?: MoneyforwardRuntimeOptions): Record<string, Handler>;
+export declare const moneyforwardMcpActionHandlers: Record<string, Handler>;
+/** Accept the key when the server exposes every captured tool; report schema drift without refusing. */
+export declare function validateMoneyforwardMcpCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal, schemaDigests?: Readonly<Record<string, string>>): Promise<CredentialValidationResult>;
+export {};