Authorization: Bearer conto_agent_xxxxx...

const CONTO_API_KEY = process.env.CONTO_API_KEY;

type PaymentInput = {
  amount: number;
  recipientAddress: string;
  recipientName?: string;
  purpose: string;
  category?: string;
};

async function executeContoPayment(input: PaymentInput) {
  // Step 1: Request payment authorization (policy check)
  const request = await fetch('https://conto.finance/api/sdk/payments/request', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${CONTO_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ category: 'OPERATIONS', ...input }),
  }).then((r) => r.json());

  if (request.status === 'DENIED') {
    return { success: false, error: request.reasons.join(', ') };
  }

  if (request.status === 'REQUIRES_APPROVAL') {
    return {
      success: false,
      pending: true,
      requestId: request.requestId,
      message: 'Payment requires manual approval',
    };
  }

  // Step 2: Execute the approved payment
  const result = await fetch(
    `https://conto.finance/api/sdk/payments/${request.requestId}/execute`,
    {
      method: 'POST',
      headers: { Authorization: `Bearer ${CONTO_API_KEY}` },
    }
  ).then((r) => r.json());

  return {
    success: true,
    transactionHash: result.txHash,
    amount: result.amount,
    explorerUrl: result.explorerUrl,
  };
}

import os
import requests

CONTO_API_KEY = os.environ.get('CONTO_API_KEY')
CONTO_API_URL = 'https://conto.finance/api'

def make_payment(amount: float, recipient_address: str, purpose: str, recipient_name: str = None):
    """Make a payment via Conto API"""

    headers = {
        'Authorization': f'Bearer {CONTO_API_KEY}',
        'Content-Type': 'application/json'
    }

    # Step 1: Request authorization
    response = requests.post(
        f'{CONTO_API_URL}/sdk/payments/request',
        headers=headers,
        json={
            'amount': amount,
            'recipientAddress': recipient_address,
            'purpose': purpose,
            'recipientName': recipient_name,
            'category': 'OPERATIONS'
        }
    )
    request_data = response.json()

    if request_data.get('status') == 'DENIED':
        return {'success': False, 'error': ', '.join(request_data.get('reasons', []))}

    if request_data.get('status') == 'REQUIRES_APPROVAL':
        return {'success': False, 'pending': True, 'requestId': request_data['requestId']}

    # Step 2: Execute the payment
    result = requests.post(
        f'{CONTO_API_URL}/sdk/payments/{request_data["requestId"]}/execute',
        headers=headers
    ).json()

    return {
        'success': True,
        'transactionHash': result.get('txHash'),
        'amount': result.get('amount'),
        'explorerUrl': result.get('explorerUrl')
    }

import OpenAI from 'openai';

const openai = new OpenAI();

// Define the payment tool for your assistant
const tools = [
  {
    type: 'function',
    function: {
      name: 'make_payment',
      description: 'Make a payment to a recipient',
      parameters: {
        type: 'object',
        properties: {
          amount: { type: 'number', description: 'Payment amount in USD' },
          recipientAddress: { type: 'string', description: 'Recipient wallet address' },
          recipientName: { type: 'string', description: 'Recipient name' },
          purpose: { type: 'string', description: 'Payment purpose' },
        },
        required: ['amount', 'recipientAddress', 'purpose'],
      },
    },
  },
];

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

const tools = [
  {
    name: 'make_payment',
    description: 'Make a payment to a recipient using Conto',
    input_schema: {
      type: 'object',
      properties: {
        amount: { type: 'number', description: 'Payment amount in USD' },
        recipientAddress: { type: 'string', description: 'Recipient wallet address' },
        recipientName: { type: 'string', description: 'Recipient name' },
        purpose: { type: 'string', description: 'Payment purpose' },
      },
      required: ['amount', 'recipientAddress', 'purpose'],
    },
  },
];

async function runAgent(userMessage: string) {
  const response = await anthropic.messages.create({
    model: 'claude-opus-4-8',
    max_tokens: 1024,
    tools: tools,
    messages: [{ role: 'user', content: userMessage }],
  });

  for (const block of response.content) {
    if (block.type === 'tool_use' && block.name === 'make_payment') {
      const result = await executeContoPayment(block.input as PaymentInput);
      // Continue conversation with tool result...
    }
  }
}

import { Tool } from '@langchain/core/tools';

class ContoPaymentTool extends Tool {
  name = 'conto_payment';
  description =
    'Make a payment using Conto. Input should be JSON with amount, recipientAddress, and purpose.';

  async _call(input: string): Promise<string> {
    const params = JSON.parse(input) as PaymentInput;
    return JSON.stringify(await executeContoPayment(params));
  }
}