@receiz/mcp-server/dist/v127SdkOperations.js

MCP server for agents building and verifying Receiz proof-native applications through the canonical Receiz SDK rails.

import { createHash, randomUUID } from "node:crypto";
import { RECEIZ_HTTP_OPERATION_SUPPORT } from "@receiz/sdk";
import { assertReceizMarketplaceToolCall, wrapReceizMarketplaceClient } from "./marketplaceExecutionPolicy.js";
import { assertReceizMarketplaceNonfinancialTool } from "./marketplaceNonfinancialPolicy.js";
const authority = "MCP is not authority. MCP transport and confirmation are not proof authority. Existing SDK admission, delegated permissions, sealed artifacts, and verified appends govern the result.";
// Closed dispatch: no caller-selected property traversal, method, URL, or arbitrary invoke.
const definitions = [
    { name: "receiz_twin_market_mandate", sdkMethod: "twin.marketMandate", arguments: [], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, _args) => client.twin.marketMandate() },
    { name: "receiz_twin_market_intents", sdkMethod: "twin.marketIntents", arguments: [], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, _args) => client.twin.marketIntents() },
    { name: "receiz_twin_import_mind_summary", sdkMethod: "twin.importMindSummary", arguments: [], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, _args) => client.twin.importMindSummary() },
    { name: "receiz_twin_approval", sdkMethod: "twin.approval", arguments: [], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, _args) => client.twin.approval() },
    { name: "receiz_twin_save_market_mandate", sdkMethod: "twin.saveMarketMandate", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.twin.saveMarketMandate(args.body) },
    { name: "receiz_twin_create_market_intent", sdkMethod: "twin.createMarketIntent", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: ["marketItemId", "side"], invoke: (client, args) => client.twin.createMarketIntent(args.body) },
    { name: "receiz_twin_approve_market_intent", sdkMethod: "twin.approveMarketIntent", arguments: ["intentId"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.twin.approveMarketIntent(args.intentId) },
    { name: "receiz_twin_approve_promotion", sdkMethod: "twin.approvePromotion", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: ["performance"], invoke: (client, args) => client.twin.approvePromotion(args.body) },
    { name: "receiz_customers_bootstrap_session", sdkMethod: "customers.bootstrapSession", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.customers.bootstrapSession(args.body, (args.options ?? {})) },
    { name: "receiz_customers_bootstrap", sdkMethod: "customers.bootstrap", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.customers.bootstrap(args.body, (args.options ?? {})) },
    { name: "receiz_customers_session", sdkMethod: "customers.session", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.customers.session(args.body, (args.options ?? {})) },
    { name: "receiz_customers_portal", sdkMethod: "customers.portal", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.customers.portal(args.body) },
    { name: "receiz_customers_orders", sdkMethod: "customers.orders", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.customers.orders((args.query ?? {})) },
    { name: "receiz_customers_rewards", sdkMethod: "customers.rewards", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.customers.rewards((args.query ?? {})) },
    { name: "receiz_customers_assets", sdkMethod: "customers.assets", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.customers.assets((args.query ?? {})) },
    { name: "receiz_merchants_onboard", sdkMethod: "merchants.onboard", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.merchants.onboard(args.body, (args.options ?? {})) },
    { name: "receiz_merchants_profile", sdkMethod: "merchants.profile", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.merchants.profile((args.query ?? {})) },
    { name: "receiz_merchants_capabilities", sdkMethod: "merchants.capabilities", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.merchants.capabilities((args.query ?? {})) },
    { name: "receiz_commerce_one_click_checkout", sdkMethod: "commerce.oneClickCheckout", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost", "amountUsd"], invoke: (client, args) => client.commerce.oneClickCheckout(args.body) },
    { name: "receiz_commerce_refunds_create", sdkMethod: "commerce.refunds.create", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.refunds.create(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_subscriptions_create", sdkMethod: "commerce.subscriptions.create", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.subscriptions.create(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_shipping_update", sdkMethod: "commerce.shipping.update", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.shipping.update(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_discounts_create", sdkMethod: "commerce.discounts.create", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.discounts.create(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_discounts_redeem", sdkMethod: "commerce.discounts.redeem", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.discounts.redeem(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_gift_cards_issue", sdkMethod: "commerce.giftCards.issue", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.giftCards.issue(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_gift_cards_redeem", sdkMethod: "commerce.giftCards.redeem", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.giftCards.redeem(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_access_passes_issue", sdkMethod: "commerce.accessPasses.issue", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.accessPasses.issue(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_inventory_reserve", sdkMethod: "commerce.inventory.reserve", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.inventory.reserve(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_inventory_adjust", sdkMethod: "commerce.inventory.adjust", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.inventory.adjust(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_fulfillment_update", sdkMethod: "commerce.fulfillment.update", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.fulfillment.update(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_payouts_create", sdkMethod: "commerce.payouts.create", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.payouts.create(args.body, (args.options ?? {})) },
    { name: "receiz_commerce_subscriptions_cancel", sdkMethod: "commerce.subscriptions.cancel", arguments: ["subscriptionId", "body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.subscriptions.cancel(args.subscriptionId, args.body, (args.options ?? {})) },
    { name: "receiz_commerce_shipping_quote", sdkMethod: "commerce.shipping.quote", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.shipping.quote(args.body) },
    { name: "receiz_commerce_tax_quote", sdkMethod: "commerce.tax.quote", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.tax.quote(args.body) },
    { name: "receiz_commerce_access_passes_verify", sdkMethod: "commerce.accessPasses.verify", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.commerce.accessPasses.verify(args.body) },
    { name: "receiz_commerce_payouts_status", sdkMethod: "commerce.payouts.status", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.commerce.payouts.status((args.query ?? {})) },
    { name: "receiz_domains_reserve_subdomain", sdkMethod: "domains.reserveSubdomain", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.domains.reserveSubdomain(args.body, (args.options ?? {})) },
    { name: "receiz_domains_verify_custom_domain", sdkMethod: "domains.verifyCustomDomain", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.domains.verifyCustomDomain(args.body, (args.options ?? {})) },
    { name: "receiz_domains_status", sdkMethod: "domains.status", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.domains.status((args.query ?? {})) },
    { name: "receiz_events_subscribe", sdkMethod: "events.subscribe", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: ["types"], invoke: (client, args) => client.events.subscribe(args.body) },
    { name: "receiz_events_replay", sdkMethod: "events.replay", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.events.replay(args.body) },
    { name: "receiz_events_list", sdkMethod: "events.list", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.events.list((args.query ?? {})) },
    { name: "receiz_events_ack", sdkMethod: "events.ack", arguments: ["eventId", "body?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.events.ack(args.eventId, (args.body ?? {})) },
    { name: "receiz_jobs_enqueue", sdkMethod: "jobs.enqueue", arguments: ["body"], mutation: true, requiresDelegated: true, requiredPayload: ["kind", "payload"], invoke: (client, args) => client.jobs.enqueue(args.body) },
    { name: "receiz_jobs_status", sdkMethod: "jobs.status", arguments: ["jobId"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.jobs.status(args.jobId) },
    { name: "receiz_jobs_cancel", sdkMethod: "jobs.cancel", arguments: ["jobId", "body?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.jobs.cancel(args.jobId, (args.body ?? {})) },
    { name: "receiz_jobs_list", sdkMethod: "jobs.list", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.jobs.list((args.query ?? {})) },
    { name: "receiz_permissions_grant", sdkMethod: "permissions.grant", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost", "actorReceizId", "role"], invoke: (client, args) => client.permissions.grant(args.body, (args.options ?? {})) },
    { name: "receiz_permissions_revoke", sdkMethod: "permissions.revoke", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost", "actorReceizId", "role"], invoke: (client, args) => client.permissions.revoke(args.body, (args.options ?? {})) },
    { name: "receiz_permissions_check", sdkMethod: "permissions.check", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: ["tenantHost", "actorReceizId", "permission"], invoke: (client, args) => client.permissions.check(args.body) },
    { name: "receiz_permissions_roles", sdkMethod: "permissions.roles", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.permissions.roles((args.query ?? {})) },
    { name: "receiz_audit_append", sdkMethod: "audit.append", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost", "action"], invoke: (client, args) => client.audit.append(args.body, (args.options ?? {})) },
    { name: "receiz_audit_query", sdkMethod: "audit.query", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.audit.query((args.query ?? {})) },
    { name: "receiz_audit_export", sdkMethod: "audit.export", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.audit.export((args.query ?? {})) },
    { name: "receiz_risk_score_payment", sdkMethod: "risk.scorePayment", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.risk.scorePayment(args.body) },
    { name: "receiz_risk_score_account_recovery", sdkMethod: "risk.scoreAccountRecovery", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.risk.scoreAccountRecovery(args.body) },
    { name: "receiz_risk_velocity", sdkMethod: "risk.velocity", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.risk.velocity(args.body) },
    { name: "receiz_risk_proof_activity", sdkMethod: "risk.proofActivity", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.risk.proofActivity(args.body) },
    { name: "receiz_compliance_export_orders", sdkMethod: "compliance.exportOrders", arguments: ["query"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.compliance.exportOrders(args.query) },
    { name: "receiz_compliance_export_taxes", sdkMethod: "compliance.exportTaxes", arguments: ["query"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.compliance.exportTaxes(args.query) },
    { name: "receiz_compliance_export_payouts", sdkMethod: "compliance.exportPayouts", arguments: ["query"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.compliance.exportPayouts(args.query) },
    { name: "receiz_compliance_export_customers", sdkMethod: "compliance.exportCustomers", arguments: ["query"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.compliance.exportCustomers(args.query) },
    { name: "receiz_compliance_export_audit", sdkMethod: "compliance.exportAudit", arguments: ["query"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.compliance.exportAudit(args.query) },
    { name: "receiz_portability_export_store", sdkMethod: "portability.exportStore", arguments: ["query"], mutation: false, requiresDelegated: true, requiredPayload: ["tenantHost"], invoke: (client, args) => client.portability.exportStore(args.query) },
    { name: "receiz_portability_import_store", sdkMethod: "portability.importStore", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.portability.importStore(args.body, (args.options ?? {})) },
    { name: "receiz_search_query", sdkMethod: "search.query", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.query(args.body) },
    { name: "receiz_search_products", sdkMethod: "search.products", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.products(args.body) },
    { name: "receiz_search_pages", sdkMethod: "search.pages", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.pages(args.body) },
    { name: "receiz_search_blog", sdkMethod: "search.blog", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.blog(args.body) },
    { name: "receiz_search_orders", sdkMethod: "search.orders", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.orders(args.body) },
    { name: "receiz_search_customers", sdkMethod: "search.customers", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.customers(args.body) },
    { name: "receiz_search_proof_objects", sdkMethod: "search.proofObjects", arguments: ["body"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.search.proofObjects(args.body) },
    { name: "receiz_notifications_send", sdkMethod: "notifications.send", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.notifications.send(args.body, (args.options ?? {})) },
    { name: "receiz_notifications_subscribe", sdkMethod: "notifications.subscribe", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.notifications.subscribe(args.body, (args.options ?? {})) },
    { name: "receiz_notifications_templates", sdkMethod: "notifications.templates", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.notifications.templates((args.query ?? {})) },
    { name: "receiz_releases_pin", sdkMethod: "releases.pin", arguments: ["body", "options?"], mutation: true, requiresDelegated: true, requiredPayload: ["tenantHost", "rails"], invoke: (client, args) => client.releases.pin(args.body, (args.options ?? {})) },
    { name: "receiz_releases_check", sdkMethod: "releases.check", arguments: ["query?"], mutation: false, requiresDelegated: true, requiredPayload: [], invoke: (client, args) => client.releases.check((args.query ?? {})) },
    { name: "receiz_releases_supported", sdkMethod: "releases.supported", arguments: [], mutation: false, requiresDelegated: false, requiredPayload: [], invoke: (client, _args) => client.releases.supported() },
    { name: "receiz_webhook_endpoints_list", sdkMethod: "webhookEndpoints.list", arguments: [], mutation: false, requiresDelegated: false, requiredPayload: [], invoke: (client, _args) => client.webhookEndpoints.list() },
    { name: "receiz_webhook_endpoints_update", sdkMethod: "webhookEndpoints.update", arguments: ["endpointId", "body"], mutation: true, requiresDelegated: false, requiredPayload: [], invoke: (client, args) => client.webhookEndpoints.update(args.endpointId, args.body) },
    { name: "receiz_webhook_endpoints_delete", sdkMethod: "webhookEndpoints.delete", arguments: ["endpointId"], mutation: true, requiresDelegated: false, requiredPayload: [], invoke: (client, args) => client.webhookEndpoints.delete(args.endpointId) },
];
export const RECEIZ_V127_SDK_OPERATION_MAP = Object.freeze(Object.fromEntries(definitions.map((definition) => {
    const support = RECEIZ_HTTP_OPERATION_SUPPORT[definition.sdkMethod];
    if (!support)
        throw new Error(`receiz_v127_sdk_http_classification_required:${definition.sdkMethod}`);
    return [definition.name, Object.freeze({ ...definition, ...support, arguments: Object.freeze([...definition.arguments]), requiredPayload: Object.freeze([...definition.requiredPayload]) })];
})));
const closedQueries = Object.freeze({
    "merchants.profile": ["tenantHost"], "merchants.capabilities": ["tenantHost"],
    "commerce.payouts.status": ["tenantHost", "payoutId"], "domains.status": ["host", "domain"],
    "permissions.roles": ["tenantHost"], "portability.exportStore": ["tenantHost"],
    "notifications.templates": ["tenantHost"], "releases.check": ["tenantHost"],
});
function payloadSchema(definition, key) {
    const closedKeys = key === "query" ? closedQueries[definition.sdkMethod] : undefined;
    const fields = closedKeys ?? definition.requiredPayload;
    return {
        type: "object", additionalProperties: !closedKeys,
        properties: Object.fromEntries(fields.map((field) => [field,
            ["rails", "payload", "performance"].includes(field) ? { type: "object", additionalProperties: true }
                : field === "types" ? { type: "array", items: { type: "string", minLength: 1 } }
                    : { type: "string", minLength: 1 },
        ])),
        ...(definition.requiredPayload.length ? { required: definition.requiredPayload } : {}),
    };
}
function schema(definition) {
    const properties = {};
    const required = [];
    for (const argument of definition.arguments) {
        const key = argument.replace(/\?$/, "");
        properties[key] = key.endsWith("Id") ? { type: "string", minLength: 1 }
            : key === "options" ? { type: "object", additionalProperties: false, properties: { idempotencyKey: { type: "string", minLength: 1 } } }
                : payloadSchema(definition, key);
        if (!argument.endsWith("?"))
            required.push(key);
    }
    if (definition.mutation)
        properties.confirmation = { type: "string", minLength: 1, description: "Exact single-use confirmationDigest from this tool's preview with identical arguments." };
    return { type: "object", additionalProperties: false, properties, required };
}
function deepFreeze(value) {
    if (value && typeof value === "object") {
        for (const child of Object.values(value))
            deepFreeze(child);
        Object.freeze(value);
    }
    return value;
}
export const RECEIZ_V127_SDK_TOOLS = deepFreeze(definitions.map((definition) => ({
    name: definition.name,
    description: `Compose Receiz SDK ${definition.sdkMethod}. ${RECEIZ_HTTP_OPERATION_SUPPORT[definition.sdkMethod]?.executionMode === "historical-http" ? "Historical v106 compatibility HTTP: these routes are absent from the current Receiz server. Requires explicit legacyConnectTransport http and a separately configured compatibility host; credentials alone do not enable execution. " : "Current HTTP route implementation is present; authentication and operation admission still apply. "}${definition.sdkMethod === "commerce.oneClickCheckout" ? "Creates a card checkout session, not completed payment. Positive proposed wallet funding fails with wallet_settlement_execution_required before any card charge; wallet funds are never reported applied without settlement. " : ""}${definition.mutation ? "Returns a mutation preview; execute only after explicit user confirmation of its exact digest. " : ""}${authority}`,
    inputSchema: schema(definition),
    annotations: { readOnlyHint: !definition.mutation, destructiveHint: definition.mutation, openWorldHint: true },
})));
function assertJson(value, seen = new Set()) {
    if (value === null || typeof value === "string" || typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value)))
        return;
    if (!value || typeof value !== "object" || seen.has(value))
        throw new Error("receiz_v127_sdk_json_required");
    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
        throw new Error("receiz_v127_sdk_json_required");
    seen.add(value);
    for (const [key, child] of Object.entries(value)) {
        if (["__proto__", "prototype", "constructor"].includes(key))
            throw new Error("receiz_v127_sdk_argument_forbidden");
        assertJson(child, seen);
    }
    seen.delete(value);
}
function object(value) {
    if (!value || typeof value !== "object" || Array.isArray(value))
        throw new Error("receiz_v127_sdk_object_required");
}
function validate(definition, raw) {
    assertJson(raw);
    object(raw);
    const allowed = new Set(definition.arguments.map((argument) => argument.replace(/\?$/, "")));
    if (definition.mutation)
        allowed.add("confirmation");
    for (const key of Object.keys(raw))
        if (!allowed.has(key))
            throw new Error(`receiz_v127_sdk_unknown_argument:${key}`);
    for (const argument of definition.arguments) {
        const key = argument.replace(/\?$/, "");
        const value = raw[key];
        if (value === undefined && argument.endsWith("?"))
            continue;
        if (key.endsWith("Id")) {
            if (typeof value !== "string" || !value.trim())
                throw new Error(`receiz_v127_sdk_required:${key}`);
        }
        else {
            object(value);
            if (key === "options") {
                for (const option of Object.keys(value))
                    if (option !== "idempotencyKey")
                        throw new Error(`receiz_v127_sdk_unknown_option:${option}`);
                if (value.idempotencyKey !== undefined && (typeof value.idempotencyKey !== "string" || !value.idempotencyKey.trim()))
                    throw new Error("receiz_v127_sdk_idempotency_key_invalid");
            }
            else {
                const closedKeys = key === "query" ? closedQueries[definition.sdkMethod] : undefined;
                if (closedKeys)
                    for (const [field, entry] of Object.entries(value)) {
                        if (!closedKeys.includes(field))
                            throw new Error(`receiz_v127_sdk_unknown_query:${field}`);
                        if (typeof entry !== "string" || !entry.trim())
                            throw new Error(`receiz_v127_sdk_query_invalid:${field}`);
                    }
                for (const field of definition.requiredPayload) {
                    if (field === "rails" || field === "payload" || field === "performance") {
                        object(value[field]);
                        continue;
                    }
                    if (field === "types") {
                        if (!Array.isArray(value[field]) || !value[field].every((entry) => typeof entry === "string" && entry.trim()))
                            throw new Error("receiz_v127_sdk_event_types_invalid");
                        continue;
                    }
                    if (typeof value[field] !== "string" || !value[field].trim())
                        throw new Error(`receiz_v127_sdk_required:${field}`);
                }
            }
        }
    }
    if (raw.confirmation !== undefined && (typeof raw.confirmation !== "string" || !raw.confirmation.trim()))
        throw new Error("receiz_v127_sdk_confirmation_invalid");
    return structuredClone(raw);
}
function canonical(value) {
    if (Array.isArray(value))
        return `[${value.map(canonical).join(",")}]`;
    if (value && typeof value === "object")
        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${canonical(child)}`).join(",")}}`;
    return JSON.stringify(value);
}
/** Confirmation is local consent custody, never admission or proof authority. */
export function createReceizV127SdkOperations(input) {
    if (input.executionProfile !== undefined && input.executionProfile !== "marketplace-phi" && input.executionProfile !== "marketplace-nonfinancial")
        throw new TypeError("RECEIZ_MCP_EXECUTION_PROFILE_INVALID");
    const marketplacePhi = input.executionProfile === "marketplace-phi";
    const marketplaceNonfinancial = input.executionProfile === "marketplace-nonfinancial";
    const client = marketplacePhi ? wrapReceizMarketplaceClient(input.client) : input.client;
    const plans = new Map();
    return {
        handles(name) { return Object.hasOwn(RECEIZ_V127_SDK_OPERATION_MAP, name); },
        requiresDelegated(name) { return Object.hasOwn(RECEIZ_V127_SDK_OPERATION_MAP, name) && RECEIZ_V127_SDK_OPERATION_MAP[name].requiresDelegated; },
        async call(name, raw = {}) {
            if (marketplaceNonfinancial)
                assertReceizMarketplaceNonfinancialTool(name);
            if (!Object.hasOwn(RECEIZ_V127_SDK_OPERATION_MAP, name))
                throw new Error("receiz_v127_sdk_unknown_operation");
            if (marketplacePhi)
                assertReceizMarketplaceToolCall(name, raw);
            const definition = RECEIZ_V127_SDK_OPERATION_MAP[name];
            const args = validate(definition, raw);
            if (definition.executionMode === "historical-http" && !client.httpTransport?.legacyConnectHttp) {
                throw new Error(`RECEIZ_HISTORICAL_CONNECT_HOST_REQUIRED:${definition.sdkMethod}`);
            }
            if (definition.requiresDelegated)
                input.ensureDelegated();
            const confirmation = args.confirmation;
            delete args.confirmation;
            if (!definition.mutation)
                return definition.invoke(client, args);
            const identity = canonical({ operation: definition.sdkMethod, args });
            if (confirmation === undefined) {
                const confirmationDigest = createHash("sha256").update("receiz.mcp.sdk-consent.v127:" + randomUUID() + identity).digest("hex");
                plans.set(confirmationDigest, identity);
                return { schema: "receiz.mcp.sdk-preview.v127", status: "planned", operation: definition.sdkMethod, arguments: args, confirmationDigest, confirmationRequired: true, writesPerformed: 0, authority };
            }
            if (plans.get(confirmation) !== identity)
                throw new Error("receiz_v127_sdk_confirmation_invalid");
            // Consume before calling the SDK, including failed/unknown outcomes.
            plans.delete(confirmation);
            const result = await definition.invoke(client, args);
            return { schema: "receiz.mcp.sdk-result.v127", operation: definition.sdkMethod, result, authority };
        },
    };
}
//# sourceMappingURL=v127SdkOperations.js.map