const response = await fetch('https://your-api-url.com/api/v1/agents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Support Router Agent",
    isEnabled: true,
    config: {
      primaryLanguage: "en-US",
      llmConfig: {
        vendor: "openai",
        model: "gpt-4.1-mini",
        prompt: `You are a support routing agent. When users request billing help,
say "Let me transfer you to our billing department" then transfer them.
When they need technical support, transfer to technical support.`,
        options: { temperature: 0.7 }
      },
      ttsConfig: {
        provider: "Dasha",
        providerVoiceId: "default-voice",
        model: "common"
      },
      sttConfig: { vendor: "Auto" },
      transfer: {
        type: "cold",
        endpointDestination: "+1-555-0100",
        isEnabled: true
      }
    }
  })
});

const agent = await response.json();
console.log('Agent created with cold transfer:', agent.agentId);

{
  config: {
    transfer: {
      type: "cold",
      isEnabled: true,
      endpointDestination: "+1-555-0100", // Default destination
      transferRoutes: [
        {
          name: "billing_department",
          destination: "+1-555-0100",
          description: "Billing and payment inquiries"
        },
        {
          name: "technical_support",
          destination: "+1-555-0101",
          description: "Technical product support"
        },
        {
          name: "sales_team",
          destination: "sip:sales@company.com",
          description: "New sales and product demos"
        },
        {
          name: "emergency_line",
          destination: "+1-555-0911",
          description: "Urgent issues requiring immediate attention"
        }
      ]
    }
  }
}

You are a customer service routing agent for Acme Corp.

# Your Role
Route callers to the appropriate department quickly and accurately.

# Transfer Instructions
When transferring calls, follow these steps:
1. Confirm you understand the caller's need
2. Tell them which department you're transferring to
3. Set expectations for the transfer
4. Execute the transfer

# Transfer Routes
- Billing questions → transfer to billing_department
- Technical problems → transfer to technical_support
- Sales inquiries → transfer to sales_team
- Urgent emergencies → transfer to emergency_line immediately

# Example Conversation
Caller: "I have a question about my bill"
You: "I can help connect you to our billing department. They'll be
able to assist with your billing question. Please hold while I
transfer you."
[Transfer to billing_department]

const response = await fetch('https://your-api-url.com/api/v1/agents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Premium Support Agent",
    isEnabled: true,
    config: {
      primaryLanguage: "en-US",
      llmConfig: {
        vendor: "openai",
        model: "gpt-4.1",
        prompt: `You are a premium customer support agent. For complex issues,
transfer to a human specialist with full context. During consultation,
brief the specialist on: customer name, issue description, steps already
tried, and urgency level.`,
        options: { temperature: 0.7 }
      },
      ttsConfig: {
        provider: "ElevenLabs",
        providerVoiceId: "21m00Tcm4TlvDq8ikWAM",
        model: "eleven_turbo_v2_5"
      },
      sttConfig: { vendor: "Auto" },
      transfer: {
        type: "warm",
        isEnabled: true,
        endpointDestination: "+1-555-0200",
        sayPhraseToCustomer: "Please hold while I connect you with a specialist who can help.",
        continueAfterOperatorDisconnected: true,
        continueRecordingInTransfer: true,
        callerIdMode: "userPhoneNumber", // Human agent sees the customer's phone number
        interactionWithOperator: {
          type: "smart_v1",
          briefing: "Brief the specialist on caller's name, issue, and urgency"
        }
      }
    }
  })
});

const agent = await response.json();
console.log('Agent created with warm transfer:', agent.agentId);

{
  config: {
    transfer: {
      type: "warm",
      isEnabled: true,
      endpointDestination: "sip:specialist@company.com",
      sayPhraseToCustomer: "One moment please, I'm getting a specialist for you.",
      continueAfterOperatorDisconnected: true,
      continueRecordingInTransfer: false,
      callerIdMode: "agentPhoneNumber", // Human agent sees the company's internal number
      interactionWithOperator: {
        type: "static",
        script: "Hello, this is the AI agent. I have a customer on the line who needs advanced technical support. The issue involves network connectivity problems. Are you able to assist?"
      }
    }
  }
}

You are a technical support agent for TechCorp.

# Your Role
Handle basic technical questions and escalate complex issues to human specialists.

# When to Transfer
Transfer to a human specialist when:
- Issue requires advanced troubleshooting (above tier 1)
- Customer has tried basic steps without success
- Customer explicitly requests human assistance
- Issue involves account security or sensitive data
- Problem affects critical business operations

# Warm Transfer Process
1. Gather Context:
   - Customer name and account ID
   - Detailed issue description
   - Steps already attempted
   - Urgency level (low, medium, high, critical)
   - Impact on customer's business

2. Set Expectations:
   Say: "I'm going to connect you with a specialist who can help.
   Please hold while I brief them on your situation."

3. Brief the Specialist:
   During consultation, say: "Hi, this is the AI assistant. I have
   [customer name] on the line with [issue description]. They've tried
   [steps taken]. This is [urgency level]. Are you able to assist?"

4. Complete Transfer:
   After specialist confirms, complete the transfer.

# Example Conversation
Customer: "I've reset my router 3 times and still can't connect"
You: "I understand you've already tried basic troubleshooting. Let me
connect you with one of our technical specialists who can dive deeper
into this. Please hold while I brief them."
[Consult with specialist]
You (to specialist): "I have John Smith with persistent connectivity
issues. He's reset the router multiple times without success. Are you
able to help?"
Specialist: "Yes, transfer them over."
[Complete transfer]

const response = await fetch('https://your-api-url.com/api/v1/agents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Support Agent with Caller ID",
    isEnabled: true,
    config: {
      primaryLanguage: "en-US",
      llmConfig: {
        vendor: "openai",
        model: "gpt-4.1",
        prompt: "You are a customer support agent...",
        options: { temperature: 0.7 }
      },
      ttsConfig: {
        provider: "Dasha",
        providerVoiceId: "default-voice",
        model: "common"
      },
      sttConfig: { vendor: "Auto" },
      transfer: {
        type: "warm",
        isEnabled: true,
        endpointDestination: "+1-555-0200",
        // Use agent's phone number as caller ID
        callerIdMode: "agentPhoneNumber",
        sayPhraseToCustomer: "Please hold while I connect you with a specialist.",
        continueAfterOperatorDisconnected: true,
        interactionWithOperator: {
          type: "smart_v1",
          briefing: "Brief the specialist on the customer's issue"
        }
      }
    }
  })
});

const agent = await response.json();
console.log('Agent created with caller ID mode:', agent.agentId);

{
  config: {
    transfer: {
      type: "warm",
      isEnabled: true,
      endpointDestination: "+1-555-0200",
      // Use user's phone number instead of default agent phone number
      callerIdMode: "userPhoneNumber",
      sayPhraseToCustomer: "One moment please.",
      interactionWithOperator: {
        type: "static",
        script: "Incoming transfer from AI assistant."
      }
    }
  }
}

{
  config: {
    transfer: {
      type: "http",
      isEnabled: true,
      webhook: {
        url: "https://api.yourcompany.com/webhooks/transfer-routing"
      },
      fallback: {
        type: "warm",
        endpointDestination: "+1-555-0999",
        // Configure caller ID mode for the fallback transfer
        callerIdMode: "agentPhoneNumber",
        sayPhraseToCustomer: "Please hold while I find someone to help.",
        continueAfterOperatorDisconnected: true
      }
    }
  }
}

const response = await fetch('https://your-api-url.com/api/v1/agents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Smart Routing Agent",
    isEnabled: true,
    config: {
      primaryLanguage: "en-US",
      llmConfig: {
        vendor: "openai",
        model: "gpt-4.1-mini",
        prompt: `You are a smart routing agent. Gather customer information,
then transfer to the appropriate specialist based on their needs.`,
        options: { temperature: 0.7 }
      },
      ttsConfig: {
        provider: "Cartesia",
        providerVoiceId: "default-voice",
        model: "sonic"
      },
      sttConfig: { vendor: "Auto" },
      transfer: {
        type: "http",
        isEnabled: true,
        webhook: {
          url: "https://api.yourcompany.com/webhooks/transfer-routing",
          headers: {
            "Authorization": "Bearer YOUR_WEBHOOK_API_KEY",
            "Content-Type": "application/json"
          }
        },
        fallback: {
          type: "cold",
          endpointDestination: "+1-555-0100" // General support line
        }
      }
    }
  })
});

const agent = await response.json();
console.log('Agent created with HTTP transfer:', agent.agentId);

{
  config: {
    transfer: {
      type: "http",
      isEnabled: true,
      webhook: {
        url: "https://api.yourcompany.com/webhooks/intelligent-routing",
        headers: {
          "Authorization": "Bearer sk-abc123xyz",
          "X-API-Version": "v2"
        },
        customSettings: {
          timeout: 5000,
          retryAttempts: 2
        }
      },
      fallback: {
        type: "warm",
        endpointDestination: "+1-555-0999",
        sayPhraseToCustomer: "Please hold while I find someone to help you.",
        continueAfterOperatorDisconnected: true
      }
    }
  }
}

You are an intelligent routing agent for GlobalCorp.

# Your Role
Gather customer information and route to the appropriate specialist
using our intelligent routing system.

# Information to Collect
Before transferring, gather:
- Customer name
- Account number or email
- Nature of inquiry (sales, support, billing)
- Urgency level
- Preferred language (if not English)

# Transfer Process
1. Greet customer and identify their need
2. Collect required information
3. Say: "Let me connect you with the best person to help. One moment."
4. Initiate transfer (webhook will determine destination)
5. Transfer completes automatically

# Example Conversation
Customer: "I need help with my premium account"
You: "I can help you with that. Can I get your account email?"
Customer: "john@example.com"
You: "Thank you. What can we help you with today?"
Customer: "I want to upgrade my plan"
You: "Perfect. Let me connect you with our account specialist who can
help with upgrades. One moment please."
[Webhook routes to appropriate sales rep based on account data]

from flask import Flask, request, jsonify
from datetime import datetime
import logging

app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

@app.route('/webhooks/transfer-routing', methods=['POST'])
def transfer_routing():
    try:
        data = request.get_json()
        call_id = data.get('callId')
        caller_number = data.get('callerNumber')
        context = data.get('conversationContext', {})
        additional_data = data.get('additionalData', {})

        # Routing logic
        account_tier = additional_data.get('accountTier', 'standard')
        inquiry_type = context.get('inquiryType')

        # Determine destination
        if account_tier == 'premium':
            # Premium customers to dedicated rep
            transfer_to = get_assigned_rep(additional_data.get('customerId'))
            transfer_type = 'warm'
            briefing = f"Premium customer {context.get('customerName')} needs help with {inquiry_type}"
        elif inquiry_type == 'billing':
            transfer_to = '+1-555-0100'
            transfer_type = 'cold'
            briefing = None
        elif inquiry_type == 'technical':
            transfer_to = get_next_available_agent('technical')
            transfer_type = 'warm'
            briefing = f"Technical support needed for {context.get('customerName')}"
        else:
            transfer_to = '+1-555-0200'
            transfer_type = 'cold'
            briefing = None

        response = {
            'transferTo': transfer_to,
            'transferType': transfer_type,
            'context': {
                'routingReason': f"{account_tier} tier - {inquiry_type} inquiry",
                'assignedAt': datetime.utcnow().isoformat()
            }
        }

        if briefing:
            response['briefing'] = briefing

        logging.info(f"Routed call {call_id} to {transfer_to}")
        return jsonify(response), 200

    except Exception as e:
        logging.error(f"Routing error: {str(e)}")
        return jsonify({
            'error': 'Routing failed',
            'errorCode': 'INTERNAL_ERROR',
            'useFallback': True
        }), 500

def get_assigned_rep(customer_id):
    # Example: Query CRM for assigned representative
    # In production, this would hit your CRM API
    return '+1-555-0301'

def get_next_available_agent(skill):
    # Example: Get next available agent from queue
    # In production, this would check agent availability
    return '+1-555-0401'

if __name__ == '__main__':
    app.run(port=3000)

// Example: Generic webhook integration pattern for connecting to any CRM
// Flow: Dasha BlackBox webhook → Your backend → Your CRM API
const express = require('express');
const app = express();
app.use(express.json());

// Connect to your CRM system (example using generic HTTP client)
const fetchCustomerData = async (customerEmail) => {
  // Replace with your CRM's API endpoint
  const response = await fetch(`${process.env.CRM_API_URL}/customers?email=${customerEmail}`, {
    headers: {
      'Authorization': `Bearer ${process.env.CRM_API_KEY}`
    }
  });
  return response.json();
};

app.post('/webhooks/transfer-routing', async (req, res) => {
  try {
    const { conversationContext, additionalData } = req.body;
    const customerEmail = conversationContext?.accountEmail;

    // Query your CRM for customer and account owner details
    const customerData = await fetchCustomerData(customerEmail);

    if (customerData) {
      const ownerPhone = customerData.accountOwner?.phone;
      const ownerName = customerData.accountOwner?.name;
      const accountType = customerData.accountType || 'Standard';

      // Route to account owner for enterprise, general support for others
      if (accountType === 'Enterprise') {
        return res.json({
          transferTo: ownerPhone,
          transferType: 'warm',
          context: {
            accountOwner: ownerName,
            accountType: accountType,
            source: 'CRM'
          },
          briefing: `Enterprise customer ${conversationContext.customerName}. Account owner: ${ownerName}.`
        });
      } else {
        return res.json({
          transferTo: '+1-555-0200', // General support
          transferType: 'cold'
        });
      }
    } else {
      // Customer not found, use fallback
      return res.status(404).json({
        error: 'Customer not found in CRM',
        useFallback: true
      });
    }

  } catch (error) {
    console.error('CRM routing error:', error);
    res.status(500).json({
      error: 'CRM lookup failed',
      useFallback: true
    });
  }
});

app.listen(3000);