shabaaspay-mcp-server 1.0.1

package/dist/tools/auth.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ShabaasApiClient } from '../api/client.js';
+import { Config } from '../config/index.js';
+export declare function createAuthTools(apiClient: ShabaasApiClient, config: Config): {
+    get_auth_token: {
+        name: string;
+        description: string;
+        inputSchema: z.ZodObject<{
+            include_token_in_response: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            include_token_in_response: boolean;
+        }, {
+            include_token_in_response?: boolean | undefined;
+        }>;
+        execute: (args: any) => Promise<import("../types/index.js").StandardResponse<unknown>>;
+    };
+};

package/dist/tools/auth.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthTools = createAuthTools;
+const zod_1 = require("zod");
+const response_helpers_js_1 = require("./response-helpers.js");
+function createAuthTools(apiClient, config) {
+    return {
+        get_auth_token: {
+            name: 'get_auth_token',
+            description: 'Call ShaBaas authorization endpoint using the configured UUID and return a Bearer token for debugging. ' +
+                'The MCP server automatically manages tokens for all other tools, so you typically do not need to call this.',
+            inputSchema: zod_1.z.object({
+                include_token_in_response: zod_1.z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe('If true, include the raw token string in the response data. Default false for safer logging.'),
+            }),
+            execute: async (args) => {
+                try {
+                    const includeToken = !!args?.include_token_in_response;
+                    const auth = await apiClient.getAuthToken();
+                    return {
+                        success: true,
+                        timestamp: new Date().toISOString(),
+                        data: includeToken ? auth : { fetchedAt: auth.fetchedAt },
+                        metadata: {
+                            requestId: `req_${Date.now()}`,
+                            processingTime: 0,
+                            environment: config.environment,
+                        },
+                        insights: {
+                            status: 'success',
+                            canProceed: true,
+                            nextActions: ['create_payment_agreement', 'get_payment_agreement', 'initiate_payment', 'get_payment_initiation'],
+                            warnings: includeToken
+                                ? ['Token is included in the response. Treat it as a secret.']
+                                : ['Token was fetched and cached inside the MCP server. It is not shown in this response.'],
+                        },
+                        summary: includeToken
+                            ? 'Authorization token fetched successfully. Token is included in response data.'
+                            : 'Authorization token fetched successfully and cached inside the MCP server.',
+                    };
+                }
+                catch (error) {
+                    return (0, response_helpers_js_1.toolErrorResponse)(error?.response?.data?.message || error.message || 'Failed to fetch auth token', config.environment, error?.response?.data);
+                }
+            },
+        },
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,159 @@
+import { ShabaasApiClient } from '../api/client.js';
+import { Config } from '../config/index.js';
+export declare function createAllTools(apiClient: ShabaasApiClient, config: Config): {
+    initiate_payment: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            payment_agreement_id: import("zod").ZodString;
+            amount: import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, string | number, string | number>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            enrich: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            include_raw: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            idempotency_key: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            payment_agreement_id: string;
+            amount: string | number;
+            enrich: boolean;
+            include_raw: boolean;
+            idempotency_key: string;
+            description?: string | undefined;
+        }, {
+            payment_agreement_id: string;
+            amount: string | number;
+            idempotency_key: string;
+            enrich?: boolean | undefined;
+            include_raw?: boolean | undefined;
+            description?: string | undefined;
+        }>;
+        execute: (args: any) => Promise<import("../types/index.js").StandardResponse<any> | {
+            raw?: import("../types/index.js").ApiResponse<any> | undefined;
+            success: boolean;
+            timestamp: string;
+            data: any;
+            metadata: {
+                requestId: string;
+                processingTime: number;
+                environment: "sandbox" | "production";
+            };
+            insights: {
+                status: any;
+                canProceed: boolean;
+                nextActions: string[];
+                warnings: string[];
+            };
+            summary: string;
+        }>;
+    };
+    get_payment_initiation: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            payment_initiation_id: import("zod").ZodString;
+            enrich: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            include_raw: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            payment_initiation_id: string;
+            enrich: boolean;
+            include_raw: boolean;
+        }, {
+            payment_initiation_id: string;
+            enrich?: boolean | undefined;
+            include_raw?: boolean | undefined;
+        }>;
+        execute: (args: any) => Promise<import("../types/index.js").StandardResponse<any> | {
+            raw?: import("../types/index.js").ApiResponse<any> | undefined;
+            success: boolean;
+            timestamp: string;
+            data: any;
+            metadata: {
+                requestId: string;
+                processingTime: number;
+                environment: "sandbox" | "production";
+            };
+            insights: {
+                status: any;
+                canProceed: boolean;
+                nextActions: string[];
+                warnings: string[];
+            };
+            summary: string;
+        }>;
+    };
+    get_payment_agreement: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            payment_agreement_id: import("zod").ZodString;
+            enrich: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            include_raw: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            payment_agreement_id: string;
+            enrich: boolean;
+            include_raw: boolean;
+        }, {
+            payment_agreement_id: string;
+            enrich?: boolean | undefined;
+            include_raw?: boolean | undefined;
+        }>;
+        execute: (args: unknown) => Promise<import("../types/index.js").StandardResponse<unknown>>;
+    };
+    create_payment_agreement: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            maximum_amount: import("zod").ZodString;
+            frequency: import("zod").ZodString;
+            number_of_transactions_permitted: import("zod").ZodNumber;
+            pay_id: import("zod").ZodString;
+            idempotency_key: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: string;
+            maximum_amount: string;
+            name: string;
+            frequency: string;
+            number_of_transactions_permitted: number;
+            pay_id: string;
+            idempotency_key: string;
+        }, {
+            type: string;
+            maximum_amount: string;
+            name: string;
+            frequency: string;
+            number_of_transactions_permitted: number;
+            pay_id: string;
+            idempotency_key: string;
+        }>;
+        execute: (args: unknown) => Promise<import("../types/index.js").StandardResponse<unknown> | {
+            success: boolean;
+            timestamp: string;
+            data: any;
+            metadata: {
+                requestId: string;
+                processingTime: number;
+                environment: "sandbox" | "production";
+            };
+            insights: {
+                status: any;
+                canProceed: boolean;
+                nextActions: string[];
+                warnings: string[];
+            };
+            summary: string;
+        }>;
+    };
+    get_auth_token: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            include_token_in_response: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            include_token_in_response: boolean;
+        }, {
+            include_token_in_response?: boolean | undefined;
+        }>;
+        execute: (args: any) => Promise<import("../types/index.js").StandardResponse<unknown>>;
+    };
+};

package/dist/tools/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAllTools = createAllTools;
+const payment_agreements_js_1 = require("./payment-agreements.js");
+const payment_initiations_js_1 = require("./payment-initiations.js");
+const auth_js_1 = require("./auth.js");
+function createAllTools(apiClient, config) {
+    return {
+        ...(0, auth_js_1.createAuthTools)(apiClient, config),
+        ...(0, payment_agreements_js_1.createPaymentAgreementTools)(apiClient, config),
+        ...(0, payment_initiations_js_1.createPaymentInitiationTools)(apiClient, config),
+        // Add more tool categories here
+    };
+}

package/dist/tools/payment-agreements.d.ts

@@ -0,0 +1,68 @@
+import { ShabaasApiClient } from "../api/client.js";
+import { Config } from "../config/index.js";
+export declare function createPaymentAgreementTools(apiClient: ShabaasApiClient, config: Config): {
+    get_payment_agreement: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            payment_agreement_id: import("zod").ZodString;
+            enrich: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            include_raw: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            payment_agreement_id: string;
+            enrich: boolean;
+            include_raw: boolean;
+        }, {
+            payment_agreement_id: string;
+            enrich?: boolean | undefined;
+            include_raw?: boolean | undefined;
+        }>;
+        execute: (args: unknown) => Promise<import("../types/index.js").StandardResponse<unknown>>;
+    };
+    create_payment_agreement: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            maximum_amount: import("zod").ZodString;
+            frequency: import("zod").ZodString;
+            number_of_transactions_permitted: import("zod").ZodNumber;
+            pay_id: import("zod").ZodString;
+            idempotency_key: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: string;
+            maximum_amount: string;
+            name: string;
+            frequency: string;
+            number_of_transactions_permitted: number;
+            pay_id: string;
+            idempotency_key: string;
+        }, {
+            type: string;
+            maximum_amount: string;
+            name: string;
+            frequency: string;
+            number_of_transactions_permitted: number;
+            pay_id: string;
+            idempotency_key: string;
+        }>;
+        execute: (args: unknown) => Promise<import("../types/index.js").StandardResponse<unknown> | {
+            success: boolean;
+            timestamp: string;
+            data: any;
+            metadata: {
+                requestId: string;
+                processingTime: number;
+                environment: "sandbox" | "production";
+            };
+            insights: {
+                status: any;
+                canProceed: boolean;
+                nextActions: string[];
+                warnings: string[];
+            };
+            summary: string;
+        }>;
+    };
+};

package/dist/tools/payment-agreements.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPaymentAgreementTools = createPaymentAgreementTools;
+const index_js_1 = require("../enricher/index.js");
+const index_js_2 = require("../types/index.js");
+const validator_js_1 = require("../security/validator.js");
+const response_helpers_js_1 = require("./response-helpers.js");
+function createPaymentAgreementTools(apiClient, config) {
+    return {
+        get_payment_agreement: {
+            name: "get_payment_agreement",
+            description: "Retrieve a payment agreement. If enrich is true, return business insights such as readiness, next steps, customer copy and PayTo references.",
+            inputSchema: index_js_2.GetPaymentAgreementInputSchema,
+            execute: async (args) => {
+                const startTime = Date.now();
+                const validation = (0, validator_js_1.validateInput)(index_js_2.GetPaymentAgreementInputSchema, args);
+                if (!validation.success) {
+                    return (0, response_helpers_js_1.validationErrorResponse)(validation.errors ?? [], config.environment);
+                }
+                try {
+                    const { payment_agreement_id, enrich } = validation.data;
+                    const include_raw = validation.data.include_raw ?? false;
+                    const response = await apiClient.getPaymentAgreement(payment_agreement_id);
+                    if (!response.data) {
+                        return (0, response_helpers_js_1.toolErrorResponse)("Payment agreement not found", config.environment, response);
+                    }
+                    const agreementData = index_js_2.PaymentAgreementSchema.parse(response.data);
+                    if (!enrich) {
+                        return {
+                            success: true,
+                            timestamp: new Date().toISOString(),
+                            data: agreementData,
+                            metadata: {
+                                requestId: `req_${Date.now()}`,
+                                processingTime: Date.now() - startTime,
+                                environment: config.environment,
+                            },
+                            insights: {
+                                status: agreementData.status,
+                                canProceed: agreementData.status?.toLowerCase?.() === "active",
+                                nextActions: ["get_payment_agreement"],
+                                warnings: ["Enrichment disabled"],
+                            },
+                            summary: "Enrichment disabled. Returning agreement data only.",
+                            ...(include_raw ? { raw: response } : {}),
+                        };
+                    }
+                    return (0, index_js_1.enrichPaymentAgreement)(agreementData, include_raw, response, config.environment);
+                }
+                catch (error) {
+                    return (0, response_helpers_js_1.toolErrorResponse)(error.message || "Failed to get payment agreement", config.environment);
+                }
+            },
+        },
+        create_payment_agreement: {
+            name: "create_payment_agreement",
+            description: "Create a new payment agreement. The payer must authorise it in their banking app before it becomes active.",
+            inputSchema: index_js_2.CreatePaymentAgreementInputSchema,
+            execute: async (args) => {
+                const startTime = Date.now();
+                const validation = (0, validator_js_1.validateInput)(index_js_2.CreatePaymentAgreementInputSchema, args);
+                if (!validation.success) {
+                    return (0, response_helpers_js_1.validationErrorResponse)(validation.errors ?? [], config.environment);
+                }
+                try {
+                    const data = validation.data;
+                    const response = await apiClient.createPaymentAgreement(data);
+                    return {
+                        success: true,
+                        timestamp: new Date().toISOString(),
+                        data: response.data,
+                        metadata: {
+                            requestId: `req_${Date.now()}`,
+                            processingTime: Date.now() - startTime,
+                            environment: config.environment,
+                        },
+                        insights: {
+                            status: response.data?.status || "created",
+                            canProceed: false,
+                            nextActions: ["get_payment_agreement"],
+                            warnings: ["Customer must authorise this payment agreement in their banking app"],
+                        },
+                        summary: `Payment agreement created. ID ${response.data?.payment_agreement_id}. Awaiting customer authorisation.`,
+                    };
+                }
+                catch (error) {
+                    return (0, response_helpers_js_1.toolErrorResponse)("Failed to create payment agreement", config.environment);
+                }
+            },
+        },
+    };
+}

package/dist/tools/payment-initiations.d.ts

@@ -0,0 +1,84 @@
+import { ShabaasApiClient } from '../api/client.js';
+import { Config } from '../config/index.js';
+import { StandardResponse } from '../types/index.js';
+export declare function createPaymentInitiationTools(apiClient: ShabaasApiClient, config: Config): {
+    initiate_payment: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            payment_agreement_id: import("zod").ZodString;
+            amount: import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, string | number, string | number>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            enrich: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            include_raw: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            idempotency_key: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            payment_agreement_id: string;
+            amount: string | number;
+            enrich: boolean;
+            include_raw: boolean;
+            idempotency_key: string;
+            description?: string | undefined;
+        }, {
+            payment_agreement_id: string;
+            amount: string | number;
+            idempotency_key: string;
+            enrich?: boolean | undefined;
+            include_raw?: boolean | undefined;
+            description?: string | undefined;
+        }>;
+        execute: (args: any) => Promise<StandardResponse<any> | {
+            raw?: import("../types/index.js").ApiResponse<any> | undefined;
+            success: boolean;
+            timestamp: string;
+            data: any;
+            metadata: {
+                requestId: string;
+                processingTime: number;
+                environment: "sandbox" | "production";
+            };
+            insights: {
+                status: any;
+                canProceed: boolean;
+                nextActions: string[];
+                warnings: string[];
+            };
+            summary: string;
+        }>;
+    };
+    get_payment_initiation: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            payment_initiation_id: import("zod").ZodString;
+            enrich: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            include_raw: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            payment_initiation_id: string;
+            enrich: boolean;
+            include_raw: boolean;
+        }, {
+            payment_initiation_id: string;
+            enrich?: boolean | undefined;
+            include_raw?: boolean | undefined;
+        }>;
+        execute: (args: any) => Promise<StandardResponse<any> | {
+            raw?: import("../types/index.js").ApiResponse<any> | undefined;
+            success: boolean;
+            timestamp: string;
+            data: any;
+            metadata: {
+                requestId: string;
+                processingTime: number;
+                environment: "sandbox" | "production";
+            };
+            insights: {
+                status: any;
+                canProceed: boolean;
+                nextActions: string[];
+                warnings: string[];
+            };
+            summary: string;
+        }>;
+    };
+};

package/dist/tools/payment-initiations.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPaymentInitiationTools = createPaymentInitiationTools;
+const index_js_1 = require("../types/index.js");
+const validator_js_1 = require("../security/validator.js");
+const response_helpers_js_1 = require("./response-helpers.js");
+function createPaymentInitiationTools(apiClient, config) {
+    return {
+        initiate_payment: {
+            name: 'initiate_payment',
+            description: 'Initiate a payment against an existing payment agreement.',
+            inputSchema: index_js_1.InitiatePaymentInputSchema,
+            execute: async (args) => {
+                const validation = (0, validator_js_1.validateInput)(index_js_1.InitiatePaymentInputSchema, args);
+                if (!validation.success) {
+                    return (0, response_helpers_js_1.validationErrorResponse)(validation.errors ?? [], config.environment);
+                }
+                try {
+                    const start = Date.now();
+                    const { enrich = true, include_raw = false, ...payload } = validation.data;
+                    const response = await apiClient.initiatePayment(payload);
+                    if (!enrich) {
+                        return {
+                            success: true,
+                            timestamp: new Date().toISOString(),
+                            data: response.data,
+                            metadata: {
+                                requestId: `req_${Date.now()}`,
+                                processingTime: Date.now() - start,
+                                environment: config.environment,
+                            },
+                            insights: {
+                                status: response.data?.status || 'submitted',
+                                canProceed: true,
+                                nextActions: ['get_payment_initiation'],
+                                warnings: ['Enrichment disabled'],
+                            },
+                            summary: 'Payment initiation request submitted successfully.',
+                            ...(include_raw ? { raw: response } : {}),
+                        };
+                    }
+                    return enrichPaymentInitiation(response.data, include_raw ? response : undefined, Date.now() - start, config.environment, 'initiate');
+                }
+                catch (error) {
+                    return (0, response_helpers_js_1.toolErrorResponse)('Failed to initiate payment', config.environment);
+                }
+            },
+        },
+        get_payment_initiation: {
+            name: 'get_payment_initiation',
+            description: 'Retrieve a payment initiation by ID.',
+            inputSchema: index_js_1.GetPaymentInitiationInputSchema,
+            execute: async (args) => {
+                const validation = (0, validator_js_1.validateInput)(index_js_1.GetPaymentInitiationInputSchema, args);
+                if (!validation.success) {
+                    return (0, response_helpers_js_1.validationErrorResponse)(validation.errors ?? [], config.environment);
+                }
+                try {
+                    const start = Date.now();
+                    const { payment_initiation_id, enrich = true, include_raw = false } = validation.data;
+                    const response = await apiClient.getPaymentInitiation(payment_initiation_id);
+                    // Best effort validation for structured output
+                    let parsed = response.data;
+                    const maybe = index_js_1.PaymentInitiationSchema.safeParse(response.data);
+                    if (maybe.success)
+                        parsed = maybe.data;
+                    if (!enrich) {
+                        return {
+                            success: true,
+                            timestamp: new Date().toISOString(),
+                            data: parsed,
+                            metadata: {
+                                requestId: `req_${Date.now()}`,
+                                processingTime: Date.now() - start,
+                                environment: config.environment,
+                            },
+                            insights: {
+                                status: parsed?.status || 'unknown',
+                                canProceed: true,
+                                nextActions: ['get_payment_initiation'],
+                                warnings: ['Enrichment disabled'],
+                            },
+                            summary: `Payment initiation ${payment_initiation_id} retrieved successfully.`,
+                            ...(include_raw ? { raw: response } : {}),
+                        };
+                    }
+                    return enrichPaymentInitiation(parsed, include_raw ? response : undefined, Date.now() - start, config.environment, 'retrieve');
+                }
+                catch (error) {
+                    return (0, response_helpers_js_1.toolErrorResponse)(error?.response?.data?.message || error.message || 'Failed to get payment initiation', config.environment, error?.response?.data);
+                }
+            },
+        },
+    };
+}
+function enrichPaymentInitiation(data, raw, processingTime, environment, mode) {
+    const status = data?.status || 'submitted';
+    const lower = (status || '').toString().toLowerCase();
+    const canProceed = ['acsc', 'submitted', 'pending'].includes(lower);
+    const nextActions = lower === 'acsc'
+        ? ['get_payment_initiation']
+        : ['get_payment_initiation'];
+    const warnings = [];
+    if (mode === 'initiate') {
+        warnings.push('Verify payment initiation status before assuming funds have settled');
+    }
+    if (['failed', 'rejected'].includes(lower)) {
+        warnings.push('Payment initiation failed or was rejected. Review agreement limits and payer status.');
+    }
+    const reconciliationNotes = [
+        'Use the payment_agreement_id to correlate settlement events to the originating agreement.',
+        'PayTo payment initiations can be tracked via get_payment_initiation until settlement completes.',
+    ];
+    return {
+        success: true,
+        timestamp: new Date().toISOString(),
+        data,
+        metadata: {
+            requestId: `req_${Date.now()}`,
+            processingTime,
+            environment,
+        },
+        insights: {
+            status,
+            canProceed,
+            nextActions,
+            warnings,
+            business: {
+                product: 'PayTo',
+                meaning: 'Payment initiation against a PayTo agreement',
+                readiness: {
+                    canInitiatePayment: canProceed,
+                    reason: canProceed
+                        ? 'Payment initiation accepted; track status until settled.'
+                        : 'Payment initiation requires review.',
+                },
+                limits: {
+                    currency: 'AUD',
+                },
+                cadence: {},
+                timing: {},
+                payerControls: [
+                    'Payer can view and manage PayTo agreements in their banking app.',
+                    'If the payer pauses/cancels the agreement, future initiations will fail.',
+                ],
+                reconciliationNotes,
+                operationalChecks: [
+                    'Check initiation status via get_payment_initiation until completion.',
+                    'If initiation fails, confirm agreement status and limits before retrying.',
+                ],
+                riskFlags: [],
+                references: [
+                    { title: 'PayTo overview', url: 'https://www.auspayplus.com.au/solutions/payto' },
+                ],
+            },
+        },
+        summary: mode === 'initiate'
+            ? 'Payment initiation submitted. Track status with get_payment_initiation.'
+            : `Payment initiation ${data?.payment_initiation_id || ''} retrieved.`,
+        ...(raw ? { raw } : {}),
+    };
+}

package/dist/tools/response-helpers.d.ts

@@ -0,0 +1,4 @@
+import { StandardResponse } from '../types/index.js';
+import { Config } from '../config/index.js';
+export declare function validationErrorResponse<T>(errors: string[], environment: Config['environment']): StandardResponse<T | null>;
+export declare function toolErrorResponse<T>(message: string, environment: Config['environment'], raw?: any): StandardResponse<T | null>;