@oomol-lab/open-connector 1.6.5 → 1.8.0

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

package/src/providers/moneyforward_mcp/runtime.js

@@ -0,0 +1,296 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { compactObject, looseArray, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { createProviderTimeout, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
+import { canonicalOfficeName, currentOfficeToolName, moneyforwardMcpEndpoint, moneyforwardService, moneyforwardTools, officeCodePattern, schemaDigest, } from "./manifest.js";
+const defaultOptions = { deadlineMs: 90_000, closeGraceMs: 5_000 };
+const defaultWritesPerMinute = 30;
+const rateWindowMs = 60_000;
+const maxResponseBytes = 8 * 1024 * 1024;
+const officeCodeRegExp = new RegExp(officeCodePattern, "u");
+// A Money Forward API 4xx relayed by the MCP server. Enough to call a read invalid input, but not
+// proof that a write did nothing: batch writes can fail part-way and retries can hide a success.
+const apiClientErrorPattern = /^API request failed: client error\b/u;
+// The only answers that prove the tool handler never ran: the arguments failed the tool's input
+// schema, or the tool does not exist. Output validation runs after the handler, so it is excluded.
+const notExecutedPattern = /^(?:MCP error -32602: )?Input validation error\b|^MCP error -32601\b/u;
+export function createMoneyforwardMcpHandlers(timing = defaultOptions) {
+    const takeWriteSlot = createWriteLimiter(timing.writesPerMinute ?? defaultWritesPerMinute);
+    const toolHandlers = moneyforwardTools.map((entry) => [
+        entry.actionName,
+        entry.isWrite
+            ? async (input, context) => {
+                takeWriteSlot(context.apiKey);
+                return runWrite(entry, input, context, timing);
+            }
+            : (input, context) => runRead(entry, input, context, timing),
+    ]);
+    const listTools = (_input, context) => withDeadline(context.signal, timing, async (signal) => ({
+        tools: await listMcpTools(toolOptions(context, signal, timing), { includeAnnotations: true }),
+    }));
+    return Object.fromEntries([...toolHandlers, ["list_tools", listTools]]);
+}
+export const moneyforwardMcpActionHandlers = createMoneyforwardMcpHandlers();
+/** Accept the key when the server exposes every captured tool; report schema drift without refusing. */
+export async function validateMoneyforwardMcpCredential(apiKey, fetcher, signal, schemaDigests) {
+    const tools = await withDeadline(signal, defaultOptions, (deadlineSignal) => listMcpTools(toolOptions({ apiKey, fetcher }, deadlineSignal, defaultOptions)));
+    const byName = new Map(tools.map((tool) => [tool.name, tool]));
+    const missing = moneyforwardTools.filter((entry) => !byName.has(entry.toolName)).map((entry) => entry.toolName);
+    if (missing.length > 0) {
+        throw providerInputError(`Money Forward MCP does not expose these tools for this key: ${missing.join(", ")}`);
+    }
+    const schemaDrift = moneyforwardTools
+        .filter((entry) => schemaDigest(byName.get(entry.toolName)?.inputSchema) !== expectedDigest(entry, schemaDigests))
+        .map((entry) => entry.toolName);
+    const keyHash = sha256Hex(apiKey).slice(0, 16);
+    return {
+        profile: {
+            accountId: `${moneyforwardService}:${keyHash}`,
+            displayName: `Money Forward MCP · ${keyHash.slice(-6)}`,
+        },
+        grantedScopes: [],
+        metadata: { mcpEndpoint: moneyforwardMcpEndpoint, schemaDrift },
+    };
+}
+async function runRead(entry, input, context, timing) {
+    const args = toolArguments(entry, input);
+    return withDeadline(context.signal, timing, async (signal) => {
+        const result = await callToolWithoutWaitingForClose({
+            ...toolOptions(context, signal, timing),
+            toolName: entry.toolName,
+            arguments: args,
+        });
+        return readPayload(entry.toolName, result);
+    });
+}
+async function runWrite(entry, input, context, timing) {
+    const args = toolArguments(entry, input);
+    const expectedName = optionalString(input.expected_office_name);
+    if (!expectedName)
+        throw writeError(providerInputError("expected_office_name is required"), "definitely_not_sent");
+    // Flipped by the authorizeTool hook, the last step before callMcpTool sends tools/call.
+    const phase = { dispatched: false };
+    try {
+        return await withDeadline(context.signal, timing, async (signal) => {
+            const options = toolOptions(context, signal, timing);
+            await confirmOffice(String(args.office_code), expectedName, options);
+            const result = await callToolWithoutWaitingForClose({
+                ...options,
+                toolName: entry.toolName,
+                arguments: args,
+                authorizeTool(tool) {
+                    // A late tools/list must not dispatch after the backstop has already reported definitely_not_sent.
+                    if (signal.aborted) {
+                        throw providerResponseError("The Money Forward write was cancelled before it was sent; nothing was written.");
+                    }
+                    assertSchemaUnchanged(entry, tool, expectedDigest(entry, timing.schemaDigests));
+                    phase.dispatched = true;
+                },
+            });
+            return readPayload(entry.toolName, result);
+        });
+    }
+    catch (error) {
+        throw classifyWriteFailure(entry, args, phase.dispatched, error);
+    }
+}
+async function confirmOffice(officeCode, expectedName, options) {
+    const office = await callToolWithoutWaitingForClose({
+        ...options,
+        toolName: currentOfficeToolName,
+        arguments: { office_code: officeCode },
+    });
+    const payload = optionalRecord(readPayload(currentOfficeToolName, office));
+    const actualName = optionalString(payload?.name);
+    if (payload?.code !== officeCode || !actualName) {
+        throw providerInputError(`Money Forward did not confirm office ${officeCode}; nothing was written.`);
+    }
+    if (canonicalOfficeName(actualName) !== canonicalOfficeName(expectedName)) {
+        throw providerInputError(`Office ${officeCode} is "${actualName}" in Money Forward, not "${expectedName}"; nothing was written.`);
+    }
+}
+function expectedDigest(entry, overrides) {
+    return overrides?.[entry.toolName] ?? entry.schemaDigest;
+}
+function assertSchemaUnchanged(entry, tool, expected) {
+    if (!tool) {
+        throw providerResponseError(`Money Forward MCP no longer exposes ${entry.toolName}; nothing was written.`);
+    }
+    if (schemaDigest(tool.inputSchema) !== expected) {
+        throw providerResponseError(`Money Forward changed the ${entry.toolName} input schema; writes stay blocked until the change is reviewed and the provider is updated. Nothing was written.`);
+    }
+}
+function classifyWriteFailure(entry, args, dispatched, error) {
+    const cause = error instanceof ProviderRequestError ? error : providerResponseError("Money Forward request failed");
+    if (readWriteOutcome(cause) !== undefined)
+        return cause;
+    if (!dispatched)
+        return writeError(cause, "definitely_not_sent");
+    const submitted = summarizeSubmission(entry, args);
+    if (optionalRecord(cause.details)?.notExecuted === true) {
+        // The pattern proves the MCP layer refused the call; a batch is still worth checking by hand.
+        const batchNote = Object.values(args).some(Array.isArray)
+            ? " This was a batch write: confirm that no item was applied before resubmitting."
+            : "";
+        const rejected = new ProviderRequestError(cause.status, `${cause.message}${batchNote}`, cause.details, cause.code);
+        return writeError(rejected, "rejected", submitted);
+    }
+    return new ProviderRequestError(502, `OUTCOME UNKNOWN: ${entry.toolName} may have been applied. Check the ledger with get_journals / get_transactions for the submitted content before retrying. Cause: ${cause.message}`, { writeOutcome: "outcome_unknown", submitted }, "provider_error");
+}
+function writeError(error, outcome, submitted) {
+    const details = { ...optionalRecord(error.details), writeOutcome: outcome, submitted };
+    return new ProviderRequestError(error.status, error.message, details, error.code);
+}
+/** What was submitted, so an unknown outcome can be reconciled by hand. Never includes credentials. */
+function summarizeSubmission(entry, args) {
+    const journal = optionalRecord(args.journal);
+    const branches = Array.isArray(journal?.branches) ? journal.branches : undefined;
+    const arrayCounts = Object.fromEntries(Object.entries(args)
+        .filter(([, value]) => Array.isArray(value))
+        .map(([key, value]) => [`${key}_count`, value.length]));
+    return compactObject({
+        tool: entry.toolName,
+        office_code: args.office_code,
+        id: args.id,
+        transaction_id: args.transaction_id,
+        transaction_date: journal?.transaction_date,
+        branch_count: branches?.length,
+        debit_total: branches ? sumDebits(branches) : undefined,
+        ...arrayCounts,
+    });
+}
+function sumDebits(branches) {
+    return branches.reduce((total, branch) => total + (optionalNumber(optionalRecord(optionalRecord(branch)?.debitor)?.value) ?? 0), 0);
+}
+/**
+ * Validate office_code and drop the guard-only field before it reaches Money Forward. The action
+ * schema already requires both, but executors can be invoked without schema validation (tests, direct
+ * loader callers), and these checks are what keep a write from going to an unnamed office.
+ */
+function toolArguments(entry, input) {
+    const { expected_office_name: _guard, ...args } = input;
+    if (entry.requiresOfficeCode && !(typeof args.office_code === "string" && officeCodeRegExp.test(args.office_code))) {
+        throw entry.isWrite
+            ? writeError(providerInputError("office_code is required in the form XXXX-XXXX"), "definitely_not_sent")
+            : providerInputError("office_code is required in the form XXXX-XXXX");
+    }
+    return args;
+}
+/**
+ * Rolling one-minute write budget per key (hashed, so the map never holds the key itself). Best-effort:
+ * it counts within one process, so separate processes or isolates each keep their own budget.
+ */
+function createWriteLimiter(writesPerMinute) {
+    const recent = new Map();
+    return (apiKey) => {
+        const now = Date.now();
+        // Timestamps are appended in order, so a bucket is idle once its newest one has aged out.
+        for (const [key, times] of recent) {
+            if (now - (times.at(-1) ?? 0) >= rateWindowMs)
+                recent.delete(key);
+        }
+        const bucket = sha256Hex(apiKey);
+        const inWindow = (recent.get(bucket) ?? []).filter((at) => now - at < rateWindowMs);
+        if (inWindow.length >= writesPerMinute) {
+            throw new ProviderRequestError(429, `More than ${writesPerMinute} Money Forward writes in a minute; nothing was written. Wait and confirm with the user before continuing.`, { writeOutcome: "definitely_not_sent" }, "rate_limited");
+        }
+        recent.set(bucket, [...inWindow, now]);
+    };
+}
+// protocolVersion is deliberately left unset (legacy): in modern mode the SDK re-sends tools/call
+// on a SEP-2243 header mismatch, which would be a silent write retry.
+function toolOptions(context, signal, timing) {
+    return {
+        endpoint: moneyforwardMcpEndpoint,
+        service: "Money Forward",
+        fetcher: context.fetcher,
+        headers: { "mf-api-key": context.apiKey },
+        // Never follow a redirect: a cross-origin hop drops the key but would replay the ledger payload.
+        redirect: "manual",
+        signal,
+        terminateSession: true,
+        requestTimeoutMs: timing.deadlineMs,
+        maxResponseBytes,
+        toolListMaxBytes: 1024 * 1024,
+        toolListMaxPages: 5,
+        toolListMaxTools: 200,
+    };
+}
+/**
+ * Resolve as soon as the tool result arrives instead of after the SDK closes the session:
+ * the upstream cleanup awaits close() without a timeout, and a finished write must not be
+ * reported as unknown because a DELETE hung. Later cleanup errors are ignored.
+ */
+function callToolWithoutWaitingForClose(input) {
+    return new Promise((resolve, reject) => {
+        callMcpTool({
+            ...input,
+            transformToolResult(result) {
+                resolve(result);
+                return result;
+            },
+        }).then(() => undefined, (error) => reject(error));
+    });
+}
+function readPayload(toolName, result) {
+    const text = readText(result);
+    if ("isError" in result && result.isError) {
+        const notExecuted = notExecutedPattern.test(text);
+        const isClientError = notExecuted || apiClientErrorPattern.test(text);
+        throw new ProviderRequestError(isClientError ? 400 : 502, `Money Forward ${toolName} failed: ${text.slice(0, 500)}`, { notExecuted }, isClientError ? "invalid_input" : "provider_error");
+    }
+    if ("structuredContent" in result && result.structuredContent !== undefined)
+        return result.structuredContent;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { text };
+    }
+}
+function readText(result) {
+    return looseArray(optionalRecord(result)?.content)
+        .map((item) => {
+        const content = optionalRecord(item);
+        return content?.type === "text" && typeof content.text === "string" ? content.text : "";
+    })
+        .join("")
+        .trim();
+}
+/**
+ * Run with one deadline shared by every step. The grace timer is a backstop for SDK cleanup
+ * that ignores the abort; the losing promise is caught so it cannot become an unhandled rejection.
+ * Every Money Forward call goes through here, so auth failures are normalized in this one place.
+ */
+async function withDeadline(parentSignal, timing, run) {
+    if (parentSignal?.aborted) {
+        throw new ProviderRequestError(504, "The Money Forward request was cancelled before it was sent", undefined, "provider_error");
+    }
+    const deadline = createProviderTimeout(parentSignal, timing.deadlineMs);
+    let grace;
+    const work = run(deadline.signal);
+    work.catch(() => undefined);
+    const backstop = new Promise((_resolve, reject) => {
+        grace = setTimeout(() => reject(new ProviderRequestError(504, "The Money Forward request timed out", undefined, "provider_error")), timing.deadlineMs + timing.closeGraceMs);
+    });
+    try {
+        return await Promise.race([work, backstop]);
+    }
+    catch (error) {
+        throw withAuthorizationCode(error);
+    }
+    finally {
+        deadline.cleanup();
+        clearTimeout(grace);
+    }
+}
+// The shared MCP error mapper reports 401/403 as provider_error; surface them as auth failures.
+function withAuthorizationCode(error) {
+    if (error instanceof ProviderRequestError && (error.status === 401 || error.status === 403)) {
+        return new ProviderRequestError(error.status, error.message, error.details, "authorization_failed");
+    }
+    return error;
+}
+function readWriteOutcome(error) {
+    return optionalRecord(error.details)?.writeOutcome;
+}

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 interface NotionActionContext {
     accessToken: string;
@@ -18,4 +20,5 @@ export declare const notionActionHandlers: ProviderActionHandlers<"notion", Noti
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/notion/executors.js

@@ -1,5 +1,6 @@
 import { compactObject } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireBearerCredential, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerInputError, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireBearerCredential, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { notionDatabasePageEvent } from "./trigger-on-database-page-event.js";
 const service = "notion";
 const notionApiBaseUrl = "https://api.notion.com/v1";
 const notionFetch = createProviderFetch({ skipDnsValidation: true });
@@ -83,6 +84,12 @@ export const notionActionHandlers = {
     list_data_source_templates(input, context) {
         return notionListDataSourceTemplates(input, context.accessToken, context.fetcher);
     },
+    list_comments(input, context) {
+        return notionListComments(input, context.accessToken, context.fetcher);
+    },
+    create_comment(input, context) {
+        return notionCreateComment(input, context.accessToken, context.fetcher);
+    },
 };
 export const executors = defineProviderExecutors({
     service,
@@ -121,7 +128,7 @@ export const proxy = async (input, context) => {
         const response = await notionFetch(url, init);
         if (!response.ok) {
             const text = await readProviderProxyErrorMessage(response, "");
-            throw new ProviderRequestError(response.status, text || `Notion request failed with HTTP ${response.status}`);
+            throw new ProviderRequestError(response.status, text || `Notion request failed with HTTP ${response.status}`, withRetryAfterSeconds(response));
         }
         return { ok: true, response: await readProviderProxyResponse(response) };
     }
@@ -595,6 +602,36 @@ async function notionListDataSourceTemplates(input, accessToken, fetcher) {
     }, fetcher);
     return payload ?? {};
 }
+async function notionListComments(input, accessToken, fetcher) {
+    const payload = await notionRequest(accessToken, {
+        path: "/comments",
+        query: compactQuery({
+            block_id: String(input.blockId),
+            page_size: asNumber(input.pageSize),
+            start_cursor: asNonEmptyString(input.startCursor),
+        }),
+    }, fetcher);
+    return payload ?? {};
+}
+async function notionCreateComment(input, accessToken, fetcher) {
+    const parent = asObject(input.parent);
+    const discussionId = asNonEmptyString(input.discussion_id);
+    if (!parent === !discussionId) {
+        throw providerInputError("exactly one of parent or discussion_id is required");
+    }
+    const payload = await notionRequest(accessToken, {
+        method: "POST",
+        path: "/comments",
+        body: compactObject({
+            parent,
+            discussion_id: discussionId,
+            rich_text: Array.isArray(input.rich_text) ? input.rich_text : [],
+            attachments: Array.isArray(input.attachments) ? input.attachments : undefined,
+            display_name: asObject(input.display_name),
+        }),
+    }, fetcher);
+    return payload ?? {};
+}
 async function notionRequest(accessToken, input, fetcher) {
     const url = new URL(`https://api.notion.com/v1${input.path}`);
     for (const [key, value] of Object.entries(input.query ?? {})) {
@@ -653,7 +690,7 @@ async function assertNotionResponse(response) {
         throw new ProviderRequestError(403, message);
     }
     if (response.status === 429) {
-        throw new ProviderRequestError(429, message);
+        throw new ProviderRequestError(429, message, withRetryAfterSeconds(response));
     }
     throw new ProviderRequestError(response.status, message);
 }
@@ -769,3 +806,4 @@ function asNumber(value) {
 function asNonEmptyString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+export const triggers = [notionDatabasePageEvent];