Servidor MCP de pagos del agente Twilio

Un servidor MCP (Protocolo de contexto de modelo) que permite gestionar pagos asistidos por agente a través de la API de Twilio, con funciones mejoradas para devoluciones de llamadas asincrónicas y flujo de trabajo guiado a través de indicaciones contextuales.

Características

Procesa pagos seguros durante llamadas de voz a través de Twilio
Capturar información de pago (número de tarjeta, código de seguridad, fecha de vencimiento)
Tokenizar la información de pago para el cumplimiento de PCI
Devoluciones de llamadas asincrónicas a través de recursos MCP
Flujo de trabajo guiado con indicaciones de MCP para cada paso del proceso de pago
Soporte para reingreso de información de pago
Se integra con clientes MCP como Claude Desktop
Manejo seguro de credenciales
Utiliza claves API de Twilio para mejorar la seguridad
Arquitectura de registro basada en eventos

Instalación

Puedes utilizar este servidor directamente a través de npx:

npx twilio-agent-payments-mcp-server <accountSid> <apiKey> <apiSecret>

O instálelo globalmente:

npm install -g twilio-agent-payments-mcp-server
twilio-agent-payments-mcp-server <accountSid> <apiKey> <apiSecret>

Parámetros ambientales

Al instalar el servidor, debe proporcionar los siguientes parámetros:

Argumentos de la línea de comandos (obligatorios):
- accountSid : SID de su cuenta de Twilio
- apiKey : Su clave API de Twilio
- apiSecret : Tu secreto de API de Twilio
Variables de entorno (establecidas antes de ejecutar el servidor):
- TOKEN_TYPE : Tipo de token a utilizar para pagos (por ejemplo, 'reutilizable', 'de un solo uso')
- CURRENCY : Moneda para pagos (por ejemplo, 'USD', 'EUR')
- PAYMENT_CONNECTOR : Conector de pago para usar con Twilio
- NGROK_AUTH_TOKEN : Su token de autenticación de Ngrok (necesario para el manejo de devoluciones de llamadas)
- NGROK_CUSTOM_DOMAIN : Dominio personalizado opcional para Ngrok

Ejemplo con variables de entorno:

TOKEN_TYPE=reusable CURRENCY=USD PAYMENT_CONNECTOR=your_connector NGROK_AUTH_TOKEN=your_token npx twilio-agent-payments-mcp-server <accountSid> <apiKey> <apiSecret>

Consulte la sección Configuración a continuación para obtener más detalles sobre estos parámetros.

Configuración

El servidor requiere los siguientes parámetros:

accountSid : Su SID de cuenta de Twilio (debe comenzar con 'AC', se validará)
apiKey : su clave API de Twilio (comienza con 'SK')
apiSecret : Tu secreto de API de Twilio

Variables de entorno

Las siguientes variables de entorno se utilizan para la configuración:

TOKEN_TYPE : Tipo de token a utilizar para pagos (por ejemplo, 'reutilizable', 'de un solo uso')
CURRENCY : Moneda para pagos (por ejemplo, 'USD', 'EUR')
PAYMENT_CONNECTOR : Conector de pago para usar con Twilio
NGROK_AUTH_TOKEN : Su token de autenticación de Ngrok (necesario para el manejo de devoluciones de llamadas)
NGROK_CUSTOM_DOMAIN : Dominio personalizado opcional para Ngrok

Nota: Las credenciales de Twilio (accountSid, apiKey, apiSecret) se proporcionan como argumentos de la línea de comandos, no como variables de entorno.

Nota de seguridad

Este servidor utiliza claves API y secretos en lugar de tokens de autenticación para mejorar la seguridad. Este enfoque proporciona un mejor control de acceso y la posibilidad de revocar credenciales si es necesario. Para más información, consulte la documentación sobre claves API de Twilio .

Uso con Claude Desktop

Desarrollo local

Para el desarrollo local (cuando el paquete no está publicado en npm), agregue lo siguiente a su archivo de configuración de Claude Desktop ( ~/Library/Application Support/Claude/claude_desktop_config.json en macOS o %APPDATA%\Claude\claude_desktop_config.json en Windows):

{
  "mcpServers": {
    "twilio-agent-payments": {
      "command": "node",
      "args": [
        "/PATHTONODE/twilio-agent-payments-mcp-server/build/index.js",
        "your_account_sid_here",
        "your_api_key_here",
        "your_api_secret_here"
      ],
      "env": {
        "TOKEN_TYPE": "reusable",
        "CURRENCY": "USD",
        "PAYMENT_CONNECTOR": "your_connector_name",
        "NGROK_AUTH_TOKEN": "your_ngrok_auth_token_here",
        "NGROK_CUSTOM_DOMAIN": "your_custom_domain_here" // Optional
      }
    }
  }
}

Reemplace los valores con sus credenciales y configuración reales de Twilio.

Después de publicar en npm

Una vez que el paquete se publica en npm, puedes usar la siguiente configuración:

{
  "mcpServers": {
    "twilio-agent-payments": {
      "command": "npx",
      "args": [
        "-y", 
        "twilio-agent-payments-mcp-server",
        "your_account_sid_here",
        "your_api_key_here",
        "your_api_secret_here"
      ],
      "env": {
        ...process.env,   // Include existing environment variables so child process has access to the path
        "TOKEN_TYPE": "reusable",
        "CURRENCY": "USD",
        "PAYMENT_CONNECTOR": "your_connector_name",
        "NGROK_AUTH_TOKEN": "your_ngrok_auth_token_here",
        "NGROK_CUSTOM_DOMAIN": "your_custom_domain_here" // Optional
      }
    }
  }
}

Integración con aplicaciones host

Una de las principales ventajas del Protocolo de Contexto de Modelo (MCP) es que elimina la necesidad de una extensa configuración manual del contexto LLM. El servidor MCP proporciona automáticamente todas las definiciones de herramientas, plantillas de recursos y capacidades necesarias al cliente LLM.

Configuración de su aplicación host

Para integrar este servidor MCP en su propia aplicación host:

Implementar un cliente MCP : utilice una biblioteca de cliente MCP existente o implemente el protocolo de cliente MCP en su aplicación.
Conectarse al servidor MCP : configure su aplicación para conectarse al servidor MCP de Twilio Agent Payments.
Deje que el protocolo se encargue del resto : el servidor MCP automáticamente:
- Registra sus herramientas y recursos con su cliente
- Proporcionar esquemas de entrada para todas las herramientas
- Proporcionar indicaciones contextuales para guiar al LLM a través del flujo de pago

No se requiere una definición manual de herramientas o recursos en el contexto de su LLM: el protocolo MCP maneja este descubrimiento automáticamente.

Código de integración de ejemplo

A continuación se muestra un ejemplo simplificado de cómo integrarse con un cliente MCP:

// Initialize your MCP client
const mcpClient = new McpClient();

// Connect to the Twilio Agent Payments MCP server
await mcpClient.connectToServer({
  name: "twilio-agent-payments",
  // Connection details depend on your specific MCP client implementation
  // This could be a WebSocket URL, stdio connection, or other transport
});

// The client will automatically discover available tools and resources

// When the LLM wants to use a tool, your application can handle it like this:
function handleLlmToolRequest(toolRequest) {
  // The toolRequest would contain:
  // - server_name: "twilio-agent-payments"
  // - tool_name: e.g., "startPaymentCapture"
  // - arguments: e.g., { callSid: "CA1234567890abcdef" }
  
  return mcpClient.callTool(toolRequest);
}

// Similarly for resources:
function handleLlmResourceRequest(resourceRequest) {
  // The resourceRequest would contain:
  // - server_name: "twilio-agent-payments"
  // - uri: e.g., "payment://CA1234567890abcdef/PA9876543210abcdef/status"
  
  return mcpClient.accessResource(resourceRequest);
}

Contexto mínimo de LLM requerido

El LLM solo necesita saber que puede usar el servidor MCP de Twilio Agent Payments para gestionar los pagos. Una simple instrucción en el indicador del sistema es suficiente:

You have access to a Twilio Agent Payments MCP server that can help process secure payments during voice calls. 
When a customer wants to make a payment, you can use the tools provided by this server to securely capture 
payment information while maintaining PCI compliance.

The server will guide you through the payment process with contextual prompts at each step.

El propio servidor MCP proporciona todas las definiciones detalladas de herramientas, esquemas de entrada y indicaciones contextuales para guiar al LLM a través del flujo de pago.

Notas de implementación para desarrolladores

Esta sección explica cómo se organiza la implementación del servidor MCP en diferentes componentes y archivos, centrándose en los patrones de arquitectura utilizados.

Organización de componentes

La implementación del servidor se divide en varios directorios:

src/index.ts : El punto de entrada principal que:
- Inicializa el servidor MCP
- Inicializa el singleton TwilioAgentPaymentServer
- Descubre y registra todos los componentes con el servidor MCP mediante descubrimiento automático
- Configura oyentes de eventos para el registro
- Conecta el servidor a la capa de transporte
src/tools/ : Contiene implementaciones de herramientas individuales
- Cada herramienta se implementa como una función de fábrica que devuelve un objeto con nombre, descripción, forma y propiedades de ejecución.
- Las herramientas manejan operaciones de pago específicas (por ejemplo, StartPaymentCaptureTool, CaptureCardNumberTool)
- Cada herramienta define su esquema de entrada utilizando Zod e implementa un método de ejecución
- Las herramientas acceden al singleton TwilioAgentPaymentServer a través de getInstance()
src/prompts/ : Contiene implementaciones de indicaciones
- Cada solicitud se implementa como una función de fábrica que devuelve un objeto con nombre, descripción y propiedades de ejecución.
- Las indicaciones brindan orientación contextual al LLM para cada paso del flujo de pago.
- Algunas indicaciones aceptan parámetros que pueden usarse para personalizar el contenido de la indicación.
src/resources/ : Contiene implementaciones de recursos
- Los recursos proporcionan acceso a los datos (por ejemplo, PaymentStatusResource)
- Cada recurso se implementa como una función de fábrica que devuelve un objeto con nombre, plantilla, descripción y propiedades de lectura.
- Los recursos acceden al singleton TwilioAgentPaymentServer a través de getInstance()
src/api-servers/ : Contiene la implementación del cliente API de Twilio
- Implementa TwilioAgentPaymentServer como un singleton
- Maneja la comunicación con la API de Twilio
- Gestiona el estado de la sesión de pago
- Proporciona métodos estáticos para acceder a la instancia singleton
src/utils/ : Contiene funciones de utilidad
- El archivo autoDiscovery.ts maneja el descubrimiento y registro automático de herramientas, indicaciones y recursos.

Patrón Singleton para TwilioAgentPaymentServer

Un patrón arquitectónico clave en esta base de código es el uso del patrón Singleton para TwilioAgentPaymentServer:

class TwilioAgentPaymentServer extends EventEmitter {
    // Singleton instance
    private static instance: TwilioAgentPaymentServer | null = null;

    /**
     * Static method to get the instance
     */
    public static getInstance(): TwilioAgentPaymentServer {
        if (!TwilioAgentPaymentServer.instance) {
            throw new Error('TwilioAgentPaymentServer not initialized. Call initialize() first.');
        }
        return TwilioAgentPaymentServer.instance;
    }
    
    /**
     * Static method to initialize the instance
     */
    public static initialize(accountSid: string, apiKey: string, apiSecret: string): TwilioAgentPaymentServer {
        if (!TwilioAgentPaymentServer.instance) {
            TwilioAgentPaymentServer.instance = new TwilioAgentPaymentServer(accountSid, apiKey, apiSecret);
        }
        return TwilioAgentPaymentServer.instance;
    }

    // Private constructor to prevent direct instantiation
    private constructor(accountSid: string, apiKey: string, apiSecret: string) {
        // Initialization code...
    }
}

Beneficios de este enfoque:

Garantiza que solo haya una instancia de TwilioAgentPaymentServer en toda la aplicación
Elimina la necesidad de pasar la instancia a través de múltiples funciones
Proporciona una API más limpia con firmas de funciones más simples
Facilita el acceso a TwilioAgentPaymentServer desde cualquier lugar del código base

Patrón de función de fábrica

Las herramientas, indicaciones y recursos se implementan utilizando el patrón de función de fábrica:

En Herramientas :
// Example from StartPaymentCaptureTool.ts export function startPaymentCaptureTool() { // Get the TwilioAgentPaymentServer instance const twilioAgentPaymentServer = TwilioAgentPaymentServer.getInstance(); // Create an event emitter for logging const emitter = new EventEmitter(); return { name: "startPaymentCapture", description: "Start a new payment capture session", shape: schema.shape, execute: async function execute(params: z.infer<typeof schema>, extra: any): Promise<ToolResult> { // Implementation that calls Twilio API and returns result }, emitter // For attaching event listeners } }
En Recursos :
// Example from PaymentStatusResource.ts export function paymentStatusResource() { // Get the TwilioAgentPaymentServer instance const twilioAgentPaymentServer = TwilioAgentPaymentServer.getInstance(); // Create an event emitter for logging const emitter = new EventEmitter(); return { name: "PaymentStatus", template: new ResourceTemplate("payment://{callSid}/{paymentSid}/status", { list: undefined }), description: "Get the current status of a payment session", read: async (uri: URL, variables: Record<string, string | string[]>, extra: any): Promise<ResourceReadResult> => { // Implementation that retrieves and formats payment status data }, emitter // For attaching event listeners }; }
En indicaciones :
// Example from a prompt factory function export function startCapturePrompt() { return { name: "StartCapture", description: "Prompt for starting the payment capture process", execute: (args: { callSid: string }, extra: RequestHandlerExtra): GetPromptResult | Promise<GetPromptResult> => { // Return prompt content } }; }

Descubrimiento automático y registro

El servidor utiliza un mecanismo de descubrimiento automático para encontrar y registrar todos los componentes:

// In src/utils/autoDiscovery.ts
export async function discoverComponents(mcpServer: McpServer) {
    // Get the current directory path
    const basePath: string = path.dirname(fileURLToPath(import.meta.url));

    await Promise.all([
        discoverTools(mcpServer, path.join(basePath, '../tools')),
        discoverPrompts(mcpServer, path.join(basePath, '../prompts')),
        discoverResources(mcpServer, path.join(basePath, '../resources'))
    ]);
}

Este enfoque:

Encuentra automáticamente todas las herramientas, indicaciones y recursos en sus respectivos directorios.
Los importa dinámicamente y los registra con el servidor MCP
Facilita la adición de nuevos componentes sin modificar el archivo principal
Reduce el código repetitivo y mejora la capacidad de mantenimiento

Parámetros en los avisos

Algunos avisos aceptan parámetros que permiten personalizar su contenido. StartCapturePrompt es un buen ejemplo:

Definición de parámetros :
// In the prompt factory function return { name: "StartCapture", description: "Prompt for starting the payment capture process", schema: { callSid: z.string().describe("The Twilio Call SID") }, // Parameter schema execute: (args: { callSid: string }, extra: RequestHandlerExtra) => { // Implementation } };
- La propiedad de esquema define el parámetro esquema usando Zod
- En este caso, se requiere un parámetro callSid de tipo cadena.
Uso de parámetros en el mensaje :
execute: (args: { callSid: string }, extra: RequestHandlerExtra): GetPromptResult | Promise<GetPromptResult> => { const { callSid } = args; if (!callSid) { throw new Error("callSid parameter is required"); } return { messages: [ { role: "assistant", content: { type: "text", text: getStartCapturePromptText(callSid), // Use the parameter in the prompt text } } ] }; }
- El método de ejecución acepta los parámetros como su primer argumento.
- Puede validar los parámetros y usarlos para personalizar el contenido del mensaje.
- En este caso, callSid se utiliza en el texto del mensaje para proporcionar contexto.

Este patrón permite que los avisos sean dinámicos y contextuales, brindando orientación personalizada según el estado actual del flujo de pago.

Herramientas disponibles

iniciarCaptura de Pago

Inicia un proceso de captura de pago para una llamada activa.

Parámetros:

callSid : El SID de llamada de Twilio para la llamada activa

IMPORTANTE: El archivo StartCapturePrompt.ts requiere que el usuario introduzca un SID de llamada desde el cliente MCP. Este parámetro es obligatorio y, si no se proporciona, el mensaje generará un error.

NOTA: Al gestionar llamadas de Twilio, es necesario comprender con qué segmento de llamada se está trabajando. Los pagos de Twilio deben estar vinculados al segmento de llamada del lado PSTN. Si se aplican al lado del cliente de Twilio, no se capturarán los dígitos DTMF. Por lo tanto, este servidor MCP asume que se está utilizando el segmento de llamada correcto. Normalmente, se verifica como se indica a continuación:

 // Pseudo code: direction of the call
  if (event.CallDirection === "toPSTN") {
    theCallSid = event.CallSid;
  }

  if (event.CallDirection == "toSIP") {
    theCallSid = event.ParentCallSid;
  }

Devoluciones:

paymentSid : El SID de pago de Twilio para la nueva sesión de pago

capturarNúmeroDeTarjeta

Inicia la captura del número de tarjeta de pago.

Parámetros:

callSid : El SID de llamada de Twilio para la llamada activa
paymentSid : El SID de pago de Twilio para la sesión de pago
captureType : Establezca en 'número de tarjeta de pago'

Devoluciones:

Estado de la operación de captura del número de tarjeta

capturarCódigoDeSeguridad

Inicia la captura del código de seguridad de la tarjeta.

Parámetros:

callSid : El SID de llamada de Twilio para la llamada activa
paymentSid : El SID de pago de Twilio para la sesión de pago
captureType : Establecido en 'código de seguridad'

Devoluciones:

Estado de la operación de captura del código de seguridad

Fecha de caducidad de la captura

Inicia la captura de la fecha de vencimiento de la tarjeta.

Parámetros:

callSid : El SID de llamada de Twilio para la llamada activa
paymentSid : El SID de pago de Twilio para la sesión de pago
captureType : Establecido en 'fecha de caducidad'

Devoluciones:

Estado de la operación de captura de fecha de vencimiento

Captura de pago completa

Completa una sesión de captura de pago.

Parámetros:

callSid : El SID de llamada de Twilio para la llamada activa
paymentSid : El SID de pago de Twilio para la sesión de pago

Devoluciones:

Estado de la operación de finalización del pago

Recursos disponibles

pago://{callSid}/{paymentSid}/estado

Obtenga el estado actual de una sesión de pago como un objeto JSON. Este recurso proporciona información detallada sobre el estado actual del proceso de captura de pagos, incluyendo:

SID de pago
Número de tarjeta de pago (enmascarado)
Tipo de tarjeta de pago
Estado del código de seguridad
Fecha de expiración
Código de confirmación de pago
Resultado del pago
Token de pago

Indicaciones de MCP

El servidor proporciona indicaciones contextuales para guiar al LLM a través de cada paso del flujo de pago:

Indicador de inicio de captura

Proporciona orientación sobre cómo iniciar el proceso de captura de pagos, incluyendo:

Instrucciones para preguntar al cliente si está listo para proporcionar información de pago
Explicación del procesamiento seguro y tokenización
Pasos para utilizar la herramienta startPaymentCapture
IMPORTANTE : Requiere que el usuario ingrese un SID de llamada desde el lado del cliente MCP, que es un parámetro obligatorio

Solicitud de número de tarjeta

Orienta al LLM sobre cómo manejar el proceso de captura de números de tarjeta, incluyendo:

Instrucciones para explicar al cliente qué información necesita
Consejos para gestionar las preguntas o inquietudes de los clientes
Pasos para utilizar la herramienta captureCardNumber

Aviso de código de seguridad

Proporciona orientación sobre cómo capturar el código de seguridad de la tarjeta, que incluye:

Instrucciones para explicar qué es el código de seguridad
Consejos para gestionar las preguntas o inquietudes de los clientes
Pasos para utilizar la herramienta captureSecurityCode

Aviso de fecha de vencimiento

Orienta al LLM sobre cómo capturar la fecha de vencimiento de la tarjeta, incluyendo:

Instrucciones para explicar el formato necesario (MM/AA)
Consejos para gestionar las preguntas o inquietudes de los clientes
Pasos para utilizar la herramienta captureExpirationDate

Solicitud de finalización de captura

Proporciona orientación sobre cómo completar el proceso de captura de pagos, que incluye:

Instrucciones para confirmar que se ha recopilado toda la información
Pasos para utilizar la herramienta completePaymentCapture

Aviso de finalización

Orienta al LLM sobre qué hacer después de que el pago se haya procesado exitosamente, incluyendo:

Instrucciones para confirmar que el pago fue exitoso
Sugerencias para los próximos pasos en la conversación

Mensaje de error

Proporciona orientación sobre el manejo de errores durante el proceso de captura de pagos, incluyendo:

Instrucciones para explicar el error al cliente
Sugerencias para solucionar problemas comunes
Pasos para reintentar el proceso de captura de pago

Arquitectura

Este servidor MCP implementa una arquitectura mejorada para gestionar los flujos de pago:

Arquitectura basada en eventos

El servidor utiliza una arquitectura basada en eventos con EventEmitter para la comunicación entre componentes:

Cada herramienta, recurso y componente de servidor extiende EventEmitter
Los componentes emiten eventos para registro y devoluciones de llamadas
Los oyentes de eventos reenvían registros al sistema de registro del servidor MCP

Manejo de devoluciones de llamadas

El servidor utiliza el paquete @deshartman/mcp-status-callback para manejar devoluciones de llamadas asincrónicas de Twilio:

Crea un túnel seguro usando Ngrok para recibir devoluciones de llamadas
Procesa devoluciones de llamadas para diferentes etapas de pago
Actualiza el almacén de estados en función de los datos de devolución de llamada
Maneja condiciones de error y escenarios de reingreso

Gestión del Estado

El estado del pago se gestiona a través de una tienda basada en mapas:

El statusCallbackMap almacena datos de la sesión de pago indexados por SID de pago
Cada devolución de llamada actualiza el estado con la información más reciente
PaymentStatusResource proporciona acceso a estos datos de estado

Integración MCP

El servidor se integra con el protocolo MCP a través de:

Herramientas: definidas con esquemas Zod para la validación de entrada
Recursos: Proporcionar acceso a los datos del estado de pago
Indicaciones: Orientación contextual para cada paso del flujo de pago
Registro: registro basado en eventos reenviado al servidor MCP

Desarrollo

Para construir el proyecto:

npm install
npm run build

Prerrequisitos

Node.js 18+
Express (para el manejo de devoluciones de llamadas)
Kit de desarrollo de software de Twilio
Cuenta de Ngrok con token de autorización

Ejecutar el servidor manualmente

Para iniciar el servidor manualmente para realizar pruebas (fuera de Claude Desktop):

# Run with actual credentials
node build/index.js "your_account_sid_here" "your_api_key_here" "your_api_secret"

# Or use the npm script (which uses ts-node for development)
npm run dev -- "your_account_sid_here" "your_api_key_here" "your_api_secret"

El servidor se iniciará y esperará conexiones de cliente MCP.

Al usar Claude Desktop, el servidor se inicia automáticamente cuando Claude carga el archivo de configuración. No es necesario iniciarlo manualmente.

Cumplimiento de PCI

Este servidor facilita el cumplimiento de PCI mediante la tokenización de la información de las tarjetas de pago. Twilio gestiona los datos de la tarjeta y nunca se almacenan en su sistema. Para obtener más información sobre el cumplimiento de PCI de Twilio, consulte la documentación de Twilio sobre pagos seguros .

Licencia

Instituto Tecnológico de Massachusetts (MIT)

Compatibilidad del inspector MCP

Al usar este servidor con el Inspector MCP, tenga en cuenta que todo el registro se realiza mediante la función de registro de MCP en lugar de console.log() . Esto es intencional y necesario para la compatibilidad con el protocolo MCP, que utiliza la salida estándar para la comunicación JSON.

Si está ampliando este servidor o depurando problemas:

Utilice el sistema de registro basado en eventos emitiendo eventos LOG_EVENT
Evite usar console.log() ya que interferirá con los mensajes JSON del protocolo MCP en la salida estándar
Para depurar fuera del contexto MCP, puede usar console.error() que genera un error en stderr.

Arquitectura de registro basada en eventos

El servidor utiliza una arquitectura de registro basada en eventos:

Emisores de eventos : todas las clases de herramientas y recursos extienden EventEmitter de Node.js y emiten eventos de 'registro' con datos de nivel y mensaje.
Reenvío de registros : estos eventos son capturados por los escuchas de eventos y reenviados al sistema de registro del servidor MCP:
// Set up event listeners for tool logs startPaymentCaptureTool.on(LOG_EVENT, logToMcp); captureCardNumberTool.on(LOG_EVENT, logToMcp); // ... other tools
Integración con MCP : la función logToMcp transforma estos eventos en mensajes de registro compatibles con MCP:
const logToMcp = (data: { level: string, message: string }) => { // Only use valid log levels: info, error, debug // If level is 'warn', treat it as 'info' const mcpLevel = data.level === 'warn' ? 'info' : data.level as "info" | "error" | "debug"; // Send the log message to the MCP server's underlying Server instance mcpServer.server.sendLoggingMessage({ level: mcpLevel, data: data.message, }); };

Niveles de registro admitidos

El servidor admite los siguientes niveles de registro:

info : Mensajes de información general
error : Mensajes de error y excepciones
debug : información de depuración detallada
warn : Mensajes de advertencia (convertidos automáticamente a 'info' para compatibilidad con MCP)

Estructura de datos de devolución de llamada de pago

El servidor procesa dos tipos principales de datos de devolución de llamada de Twilio:

Datos iniciales del conector

Cuando se crea por primera vez una sesión de pago, Twilio envía datos del conector:

{
  "PaymentConnector": "PGP_MOCK",
  "DateCreated": "2021-08-10T03:55:53.408Z",
  "PaymentMethod": "credit-card",
  "CallSid": "CAzzzzz",
  "ChargeAmount": "9.99",
  "AccountSid": "ACxxxxx",
  "Sid": "PKxxxx"
}

Capturar datos

A medida que se captura la información de pago, Twilio envía datos actualizados:

{ 
  "SecurityCode": "xxx",
  "PaymentCardType": "visa",
  "Sid": "PKxxxx",
  "PaymentConfirmationCode": "ch_a9dc6297cd1a4fb095e61b1a9cf2dd1d",
  "CallSid": "CAxxxxx",
  "Result": "success",
  "AccountSid": "AC75xxxxxx",
  "ProfileId": "",
  "DateUpdated": "2021-08-10T03:58:27.290Z",
  "PaymentToken": "",
  "PaymentMethod": "credit-card",
  "PaymentCardNumber": "xxxxxxxxxxxx1111",
  "ExpirationDate": "1225"
}

El servidor almacena estos datos en el statusCallbackMap, indexado por el SID de pago, y los pone a disposición a través de PaymentStatusResource.

Integrations