Phone Call

# Fluents.ai API Configuration
FLUENTS_API_KEY=your_api_key_here
FLUENTS_API_URL=https://api.fluents.ai

# Webhook Configuration (optional)
WEBHOOK_URL=https://your-webhook.com/callback

# Default Settings
DEFAULT_LANGUAGE=en-US
DEFAULT_VOICE_STYLE=professional

# Logging
LOG_LEVEL=INFO

# Environment variables
.env
.env.local
.env.*.local

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# Virtual environments
venv/
env/
ENV/
env.bak/
venv.bak/

# IDE
.vscode/
.idea/
*.swp
*.swo
*~
.DS_Store

# Logs
*.log
logs/

# Test coverage
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/

# Temporary files
tmp/
temp/
*.tmp

# Call records (for privacy)
call_records/
transcripts/

#!/bin/bash
# Example: Create an outbound call agent to make a restaurant reservation
# This uses the new best practices prompt builder

python3 scripts/create_agent.py \
  --name "Restaurant Reservation - Outbound" \
  --call-type outbound \
  --objective "make a dinner reservation at the restaurant" \
  --initial-message "Hi, I'd like to make a reservation for dinner tonight." \
  --key-info-dict '{
    "name": "Lee (spelled L-E-E)",
    "party_size": "2 people",
    "preferred_time": "7:00 PM tonight",
    "backup_times": "8:00 PM or 9:00 PM",
    "phone_for_callback": "310-555-1234"
  }' \
  --conversation-flow "Step 1: State you want a reservation
Step 2: If they ask for time, say 7 PM for 2 people
Step 3: If they ask for name, say Lee (L-E-E)
Step 4: If 7 PM unavailable, ask about 8 or 9 PM
Step 5: Confirm the final time and thank them" \
  --tone "friendly and casual" \
  --additional-instructions "If they are fully booked tonight, ask about tomorrow evening at the same times."

echo ""
echo "✅ Agent created with best practices for outbound calls!"
echo ""
echo "To test the agent, use:"
echo "  python3 scripts/make_call_simple.py --agent-id <AGENT_ID> --to-number +1234567890 --from-number +15103982646"

MIT License

Copyright (c) 2026 Phone Call Skill Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

requests>=2.31.0
python-dotenv>=1.0.0
pydantic>=2.5.0
aiohttp>=3.9.0

#!/usr/bin/env python3
"""
Intelligently analyze phone call results and provide actionable insights
"""

import os
import sys
import argparse
import requests
from dotenv import load_dotenv
import json
import re

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")


def get_call_details(call_id: str):
    """Get complete call details"""

    if not FLUENTS_API_KEY:
        raise ValueError("FLUENTS_API_KEY not found in environment variables")

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/calls",
            params={"id": call_id},
            headers=headers,
            timeout=30
        )
        response.raise_for_status()
        return response.json()

    except requests.exceptions.RequestException as e:
        print(f"✗ Failed to get call details: {e}", file=sys.stderr)
        return None


def calculate_duration(call_data):
    """Calculate call duration in seconds"""
    start = float(call_data.get('start_time', 0))
    end = float(call_data.get('end_time', 0))
    return int(end - start) if end > 0 else 0


def analyze_transcript(transcript):
    """Analyze transcript to extract insights"""
    if not transcript or transcript.strip() == "":
        return {
            "turns": 0,
            "bot_turns": 0,
            "human_turns": 0,
            "keywords": [],
            "has_confirmation": False,
            "is_one_sided": True
        }

    # Parse transcript lines
    lines = transcript.strip().split('\n')
    bot_turns = 0
    human_turns = 0
    keywords = []
    has_confirmation = False

    for line in lines:
        if '[' in line and ']' in line:
            if 'BOT:' in line:
                bot_turns += 1
                # Check for confirmation keywords
                if re.search(r'\b(confirm|confirmed|reservation|booked|set|scheduled)\b', line, re.I):
                    has_confirmation = True
                    keywords.append('confirmation')
            elif 'HUMAN:' in line:
                human_turns += 1

    return {
        "turns": len(lines),
        "bot_turns": bot_turns,
        "human_turns": human_turns,
        "keywords": keywords,
        "has_confirmation": has_confirmation,
        "is_one_sided": human_turns == 0 or bot_turns == 0
    }


def determine_success(call_data, transcript_analysis, duration):
    """
    Determine if the call successfully completed its objective
    Returns: (is_success, confidence, reason)
    """
    status = call_data.get('status')
    stage_outcome = call_data.get('stage_outcome')

    # Obvious failures
    if duration < 20:
        return False, 0.95, "Call too short (< 20 seconds) - likely immediate hangup"

    if status != 'ended':
        return False, 0.9, f"Call status: {status} (not properly ended)"

    if transcript_analysis['is_one_sided']:
        if transcript_analysis['bot_turns'] > 0 and transcript_analysis['human_turns'] == 0:
            return False, 0.85, "No human responses detected - one-sided conversation"
        elif transcript_analysis['human_turns'] > 0 and transcript_analysis['bot_turns'] <= 1:
            return False, 0.85, "Bot only said greeting - conversation not completed"

    # Check for confirmation
    if transcript_analysis['has_confirmation']:
        return True, 0.8, "Confirmation keywords detected in conversation"

    # Check conversation length and turns
    if duration > 60 and transcript_analysis['human_turns'] >= 2:
        return True, 0.7, "Meaningful conversation detected (60+ seconds, multiple exchanges)"

    # Uncertain cases
    if duration >= 30 and transcript_analysis['human_turns'] >= 1:
        return None, 0.5, "Unclear - short conversation with minimal exchange"

    return False, 0.6, "No clear success indicators"


def identify_failure_cause(call_data, transcript_analysis, duration):
    """Identify the specific cause of failure"""
    stage_outcome = call_data.get('stage_outcome')

    if duration < 15:
        return "immediate_hangup", "Recipient hung up immediately (possibly recognized as robocall)"

    if transcript_analysis['bot_turns'] <= 1 and duration < 30:
        return "bot_stalled", "Bot only spoke once and call ended - likely a response/recognition issue"

    if transcript_analysis['human_turns'] == 0:
        return "no_human_response", "No human responses detected - recognition failure or silent line"

    if stage_outcome == "human_disconnected" and not transcript_analysis['has_confirmation']:
        return "task_incomplete", "Human hung up before task completion"

    return "unknown", "Failure cause unclear from available data"


def suggest_optimizations(failure_cause, call_data, duration):
    """Suggest specific optimizations based on failure analysis"""
    suggestions = []

    agent = call_data.get('agent', {})

    if failure_cause == "immediate_hangup":
        suggestions.extend([
            "⏰ Wait 30+ minutes before retrying (avoid spam detection)",
            "🎤 Consider using a different voice (currently: {})".format(
                agent.get('voice', {}).get('label', 'Unknown')
            ),
            "💬 Make opening message more human-like and natural",
            "📞 Verify number is correct and not on DNC list"
        ])

    elif failure_cause == "bot_stalled":
        suggestions.extend([
            "⏱️ Increase idle_time_seconds (current: {})".format(
                agent.get('idle_time_seconds', 'Not set')
            ),
            "🎯 Set endpointing_sensitivity to 'relaxed'",
            "✅ Enable ask_if_human_present_on_idle",
            "🔊 Enable noise_suppression"
        ])

    elif failure_cause == "no_human_response":
        suggestions.extend([
            "🎙️ Check if noise_suppression is enabled",
            "📡 Consider using better transcriber (Deepgram, AssemblyAI)",
            "⏰ Add initial_message_delay: 2000 (wait 2s before speaking)",
            "🔊 Adjust conversation_speed (try 0.9 or 1.1)"
        ])

    elif failure_cause == "task_incomplete":
        suggestions.extend([
            "📝 Improve prompt with explicit completion criteria",
            "⚠️ Add 'DO NOT HANG UP until [specific condition]' to prompt",
            "✅ List all required steps in prompt",
            "🔄 Add confirmation step at the end"
        ])

    # General suggestions
    if agent.get('llm_temperature', 0) > 0.7:
        suggestions.append("🎲 Lower llm_temperature to 0.5 for more consistent behavior")

    if not agent.get('noise_suppression'):
        suggestions.append("🔇 Enable noise_suppression: true")

    return suggestions


def generate_report(call_data, format='text'):
    """Generate comprehensive analysis report"""
    duration = calculate_duration(call_data)
    transcript = call_data.get('transcript', '')
    transcript_analysis = analyze_transcript(transcript)

    is_success, confidence, reason = determine_success(call_data, transcript_analysis, duration)

    report = {
        "call_id": call_data.get('id'),
        "duration_seconds": duration,
        "status": call_data.get('status'),
        "stage": call_data.get('stage'),
        "stage_outcome": call_data.get('stage_outcome'),
        "transcript_analysis": transcript_analysis,
        "success": is_success,
        "confidence": confidence,
        "reason": reason,
        "transcript": transcript
    }

    if is_success is False:
        failure_cause, cause_detail = identify_failure_cause(call_data, transcript_analysis, duration)
        report['failure_cause'] = failure_cause
        report['failure_detail'] = cause_detail
        report['optimizations'] = suggest_optimizations(failure_cause, call_data, duration)

    if format == 'json':
        return json.dumps(report, indent=2)

    # Text format
    output = []
    output.append("=" * 70)
    output.append("INTELLIGENT CALL ANALYSIS")
    output.append("=" * 70)
    output.append(f"Call ID: {report['call_id']}")
    output.append(f"Duration: {duration} seconds")
    output.append(f"Status: {report['status']}")
    output.append(f"Outcome: {report['stage_outcome']}")
    output.append("")

    # Success/Failure
    output.append("=" * 70)
    if is_success:
        output.append("✅ TASK SUCCESSFUL")
        output.append(f"Confidence: {int(confidence * 100)}%")
        output.append(f"Reason: {reason}")
    elif is_success is False:
        output.append("❌ TASK FAILED")
        output.append(f"Confidence: {int(confidence * 100)}%")
        output.append(f"Reason: {reason}")
        output.append("")
        output.append(f"Failure Type: {report['failure_cause']}")
        output.append(f"Details: {report['failure_detail']}")
    else:
        output.append("❓ UNCLEAR RESULT")
        output.append(f"Confidence: {int(confidence * 100)}%")
        output.append(f"Reason: {reason}")

    output.append("")

    # Transcript Analysis
    output.append("=" * 70)
    output.append("CONVERSATION ANALYSIS")
    output.append("=" * 70)
    output.append(f"Total exchanges: {transcript_analysis['turns']}")
    output.append(f"Bot spoke: {transcript_analysis['bot_turns']} times")
    output.append(f"Human responded: {transcript_analysis['human_turns']} times")
    output.append(f"Confirmation detected: {'Yes' if transcript_analysis['has_confirmation'] else 'No'}")
    output.append(f"One-sided: {'Yes' if transcript_analysis['is_one_sided'] else 'No'}")
    output.append("")

    # Transcript
    output.append("=" * 70)
    output.append("TRANSCRIPT")
    output.append("=" * 70)
    if transcript:
        output.append(transcript)
    else:
        output.append("(No transcript available)")
    output.append("")

    # Optimizations
    if 'optimizations' in report:
        output.append("=" * 70)
        output.append("RECOMMENDED OPTIMIZATIONS")
        output.append("=" * 70)
        for opt in report['optimizations']:
            output.append(f"  {opt}")
        output.append("")

    return '\n'.join(output)


def main():
    parser = argparse.ArgumentParser(description="Intelligently analyze phone call results")
    parser.add_argument("--call-id", required=True, help="Call ID to analyze")
    parser.add_argument("--format", choices=['text', 'json'], default='text',
                       help="Output format (default: text)")

    args = parser.parse_args()

    call_data = get_call_details(args.call_id)
    if not call_data:
        sys.exit(1)

    report = generate_report(call_data, format=args.format)
    print(report)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Create a phone agent using the fluents.ai API with scenario-based prompts
"""

import os
import sys
import argparse
import requests
from dotenv import load_dotenv

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")


def build_outbound_prompt(
    objective: str,
    key_info: dict = None,
    conversation_flow: str = None,
    tone: str = "friendly and professional",
    additional_instructions: str = None
) -> str:
    """
    Build an outbound call prompt following best practices

    This generates prompts optimized for OUTBOUND calls where the AI is the CALLER.

    Args:
        objective: What you need to accomplish (e.g., "make a dinner reservation")
        key_info: Dict of known information (e.g., {"name": "Lee", "party_size": 2})
        conversation_flow: Optional detailed conversation flow steps
        tone: Communication style (default: "friendly and professional")
        additional_instructions: Any special instructions

    Returns:
        str: Complete structured prompt for outbound calls
    """
    prompt_parts = [
        "# IDENTITY - WHO YOU ARE",
        "You are making an OUTBOUND phone call.",
        "You are the CALLER, not someone answering the phone.",
        "YOU initiated this call. THEY answered YOUR call.",
        "",
        "CRITICAL: You are NOT a receptionist or assistant answering calls.",
        "CRITICAL: You are NOT waiting for the other person to state their business.",
        "CRITICAL: You need to clearly state YOUR purpose for calling.",
        "",
        "# ROLE PROHIBITIONS - NEVER DO THESE",
        'NEVER say "How can I help you?" - YOU are the one who needs help',
        'NEVER say "Thank you for calling" - YOU are calling them',
        "NEVER wait for them to explain what they want - YOU explain what you want",
        "NEVER act like you are receiving this call - YOU are making this call",
        "",
        f"# YOUR TASK",
        f"Your goal is to {objective}.",
        "",
    ]

    # Add key information if provided
    if key_info and len(key_info) > 0:
        prompt_parts.extend([
            "# KEY INFORMATION (You already know this - don't ask for it!)",
        ])
        for key, value in key_info.items():
            prompt_parts.append(f"- {key}: {value}")
        prompt_parts.extend([
            "",
            "When they ask for this information, provide it directly.",
            'Do NOT say "let me check" - you already know this information.',
            "",
        ])

    # Add conversation flow if provided
    if conversation_flow:
        prompt_parts.extend([
            "# CONVERSATION FLOW",
            conversation_flow,
            "",
        ])

    # Add speaking style guidelines
    prompt_parts.extend([
        "# SPEAKING STYLE",
        "- Speak one short sentence at a time",
        "- Sound natural like a real person on the phone",
        "- Do NOT give long explanations or speeches",
        f"- Maintain a {tone} tone",
        "- Wait for their response after each sentence",
        "- Keep it conversational, not robotic",
        "",
    ])

    if additional_instructions:
        prompt_parts.extend([
            "# SPECIAL INSTRUCTIONS",
            additional_instructions,
            "",
        ])

    return "\n".join(prompt_parts)


def build_scenario_prompt(
    role: str,
    objective: str,
    scenario_context: str = None,
    key_info: list = None,
    tone: str = None,
    additional_instructions: str = None
) -> str:
    """
    Build a structured prompt based on caller-defined parameters

    NOTE: For outbound calls, consider using build_outbound_prompt() instead,
    as it follows best practices to avoid identity confusion.

    Args:
        role: Who you are (e.g., "restaurant reservation assistant")
        objective: What you need to accomplish (e.g., "confirm dinner reservation")
        scenario_context: Optional context about the scenario (e.g., "calling existing customers")
        key_info: List of key information to collect (e.g., ["date", "time", "number of guests"])
        tone: Communication style (e.g., "friendly and professional")
        additional_instructions: Any special instructions

    Returns:
        str: Complete structured prompt
    """
    # Build structured prompt
    prompt_parts = [
        f"# Role Definition",
        f"You are a {role}.",
        "",
    ]

    if scenario_context:
        prompt_parts.extend([
            f"# Scenario",
            f"{scenario_context}",
            "",
        ])

    prompt_parts.extend([
        f"# Objective",
        f"Your goal is to {objective}.",
        "",
    ])

    if tone:
        prompt_parts.extend([
            f"# Communication Style",
            f"Maintain a {tone} communication style.",
            "",
        ])

    if key_info and len(key_info) > 0:
        prompt_parts.extend([
            f"# Key Information",
            f"During the conversation, you need to collect or confirm the following information:",
        ])
        for info in key_info:
            prompt_parts.append(f"- {info}")
        prompt_parts.append("")

    prompt_parts.extend([
        f"# Conversation Guidelines",
        f"1. Keep it concise and clear - ask only one question at a time",
        f"2. If the customer doesn't understand, patiently repeat",
        f"3. When confirming important information, repeat it back to ensure accuracy",
        f"4. If unable to complete the task, politely explain why and offer alternatives",
        f"5. Thank the customer for their time at the end of the conversation",
    ])

    if additional_instructions:
        prompt_parts.extend([
            "",
            f"# Special Instructions",
            additional_instructions
        ])

    return "\n".join(prompt_parts)


def create_agent(
    name: str,
    prompt_text: str = None,
    language: str = "en",
    voice_provider: str = "elevenlabs",
    voice_id: str = None,
    initial_message: str = None,
    # Scenario builder parameters
    call_type: str = "outbound",  # "outbound" or "inbound"
    role: str = None,
    objective: str = None,
    scenario_context: str = None,
    key_info: list = None,
    key_info_dict: dict = None,
    conversation_flow: str = None,
    tone: str = None,
    additional_instructions: str = None
):
    """
    Create a phone agent with specified configuration

    Args:
        name: Name of the agent
        prompt_text: The system prompt (if not using scenario builder)
        language: Language code (en, es, de, hi, pt, fr, nl, id, it, ja, ko)
        voice_provider: Voice provider (elevenlabs, openai, etc.)
        voice_id: Specific voice ID to use
        initial_message: Greeting message (required for outbound calls)

        # Scenario builder parameters (alternative to prompt_text):
        call_type: "outbound" (default) or "inbound" - affects prompt generation
        role: Who the agent is (for inbound calls, e.g., "customer service representative")
        objective: What the agent needs to accomplish (e.g., "make a dinner reservation")
        scenario_context: Optional scenario context (e.g., "calling existing customers")
        key_info: List of key information to collect (for inbound)
        key_info_dict: Dict of known information (for outbound, e.g., {"name": "Lee", "party_size": 2})
        conversation_flow: Detailed conversation flow steps (for outbound)
        tone: Communication style (e.g., "friendly and professional")
        additional_instructions: Extra instructions to add to the prompt

    Returns:
        dict: Agent creation response with agent id
    """

    # If using scenario builder, generate prompt based on call type
    if objective:
        if call_type == "outbound":
            # Use outbound-optimized prompt builder (best practices)
            generated_prompt = build_outbound_prompt(
                objective=objective,
                key_info=key_info_dict,
                conversation_flow=conversation_flow,
                tone=tone or "friendly and professional",
                additional_instructions=additional_instructions
            )
            builder_type = "outbound call (best practices)"
        else:
            # Use traditional scenario builder for inbound calls
            generated_prompt = build_scenario_prompt(
                role=role or "assistant",
                objective=objective,
                scenario_context=scenario_context,
                key_info=key_info,
                tone=tone,
                additional_instructions=additional_instructions
            )
            builder_type = "inbound call (traditional)"

        # Use generated prompt unless custom prompt is provided
        if not prompt_text:
            prompt_text = generated_prompt
            print(f"📋 Building {builder_type} prompt")
            print(f"   Objective: {objective}")
            print(f"\n✨ Generated Prompt:")
            print("─" * 60)
            print(prompt_text)
            print("─" * 60)

    # Error if neither scenario builder nor prompt is provided
    if not prompt_text:
        raise ValueError("Must provide either --prompt or (--role + --objective) parameters")

    if not FLUENTS_API_KEY:
        raise ValueError("FLUENTS_API_KEY not found in environment variables")

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    # Get default voice if not specified
    if not voice_id:
        # Use a default voice - fetch the first available voice
        try:
            voices_response = requests.get(
                f"{FLUENTS_API_URL}/v1/voices/list",
                params={"page": 1, "size": 1},
                headers={"Authorization": f"Bearer {FLUENTS_API_KEY}"},
                timeout=10
            )
            if voices_response.status_code == 200:
                voices = voices_response.json().get('items', [])
                if voices:
                    voice_id = voices[0]['id']
                    print(f"Using default voice: {voices[0].get('label', 'Unknown')}")
        except:
            pass

    if not voice_id:
        print("✗ No voice specified and couldn't fetch default voice", file=sys.stderr)
        sys.exit(1)

    # Validate initial_message is provided
    if not initial_message:
        raise ValueError("--initial-message is required. Please specify what the agent should say when the call connects.")

    # Construct the payload according to fluents.ai API spec
    # IMPORTANT: Based on successful curl tests, the format must be:
    # - prompt.content (not prompt.text)
    # - voice as UUID string (not object)
    # - enable_dynamic_turns: true (CRITICAL for outbound!)
    # - initial_message_delay: 0 (speak immediately!)
    payload = {
        "name": name,
        "language": language,
        "initial_message": initial_message,
        "prompt": {
            "content": prompt_text  # ✅ FIXED: use "content" not "text"
        },
        "actions": [],
        "voice": voice_id,  # ✅ FIXED: direct UUID string, not object

        # ⚡ CRITICAL FOR OUTBOUND CALLS - Based on working Agent 1 config
        "wait_for_greeting": False,  # Agent speaks first (don't wait!)
        "enable_dynamic_turns": True,  # 🔥 CRITICAL: Enables proactive speaking!
        "initial_message_delay": 0,  # 🔥 Speak IMMEDIATELY when call connects

        # Conversation settings - Proven working config from Agent 1
        "endpointing_sensitivity": "auto",  # Auto detection (not too sensitive)
        "idle_time_seconds": 7,  # Give enough time for responses
        "conversation_speed": 1.0,  # Normal speech speed
        "interrupt_sensitivity": "low",  # Less sensitive to interruptions

        # Quality settings
        "provider": "openai",
        "llm_temperature": 0,  # Deterministic responses
        "noise_suppression": False,  # Match working config
        "ask_if_human_present_on_idle": True,  # Ask if still there
        "call_duration_sec": 600,  # 10 minutes max
        "max_idle_check_count": 3  # Check 3 times before giving up
    }

    try:
        response = requests.post(
            f"{FLUENTS_API_URL}/v1/agents/create",
            json=payload,
            headers=headers,
            timeout=30
        )
        response.raise_for_status()

        result = response.json()
        print(f"✓ Agent created successfully")
        print(f"  Agent ID: {result.get('id')}")
        print(f"  Name: {result.get('name')}")
        print(f"  Language: {result.get('language')}")

        return result

    except requests.exceptions.RequestException as e:
        print(f"✗ Failed to create agent: {e}", file=sys.stderr)
        if hasattr(e.response, 'text'):
            print(f"  Response: {e.response.text}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(
        description="Create scenario-based fluents.ai phone agents",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Usage Examples:

  # OUTBOUND call - Make a restaurant reservation (RECOMMENDED - uses best practices)
  python3 scripts/create_agent.py \\
    --name "Restaurant Reservation Agent" \\
    --call-type outbound \\
    --objective "make a dinner reservation at the restaurant" \\
    --initial-message "Hi, I'd like to make a reservation for dinner tonight." \\
    --key-info-dict '{"name": "Lee (L-E-E)", "party_size": "2 people", "preferred_time": "7 PM", "phone": "310-555-1234"}' \\
    --tone "friendly and casual"

  # OUTBOUND call - Appointment confirmation with conversation flow
  python3 scripts/create_agent.py \\
    --name "Appointment Reminder" \\
    --call-type outbound \\
    --objective "confirm the customer's appointment tomorrow at 3 PM" \\
    --initial-message "Hi, this is a reminder about your appointment tomorrow." \\
    --key-info-dict '{"appointment_time": "3 PM tomorrow", "customer_name": "John"}' \\
    --conversation-flow "1. Confirm they can still make it\\n2. If yes, thank them\\n3. If no, ask for alternative time"

  # INBOUND call - Customer service (traditional scenario builder)
  python3 scripts/create_agent.py \\
    --name "Support Agent" \\
    --call-type inbound \\
    --role "customer service representative" \\
    --objective "help customers with their questions" \\
    --initial-message "Hello, how can I help you today?" \\
    --key-info "customer name,order number,issue description"

  # Use fully custom prompt (maximum control)
  python3 scripts/create_agent.py \\
    --name "Custom Agent" \\
    --prompt "You are making an OUTBOUND call TO a restaurant..." \\
    --initial-message "Hi, I'd like to make a reservation."

  # See BEST_PRACTICES.md for detailed guidance on creating effective agents
        """
    )

    # Basic parameters
    parser.add_argument("--name", required=True,
                       help="Agent name")
    parser.add_argument("--initial-message", required=True,
                       help="Opening message when the call connects (what the agent says first)")
    parser.add_argument("--language", default="en",
                       help="Language code (default: en)")
    parser.add_argument("--voice-id",
                       help="Specific voice ID (uses default if not specified)")

    # Scenario builder parameters (recommended way)
    parser.add_argument("--call-type", default="outbound", choices=["outbound", "inbound"],
                       help="Type of call: 'outbound' (you call them) or 'inbound' (they call you). Default: outbound")
    parser.add_argument("--role",
                       help="Who the agent is (for inbound calls, e.g., 'customer service representative')")
    parser.add_argument("--objective", required=False,
                       help="What the agent needs to accomplish (e.g., 'make a dinner reservation')")
    parser.add_argument("--scenario-context",
                       help="Optional context (e.g., 'calling existing customers who made reservations online')")
    parser.add_argument("--key-info",
                       help="[Inbound] Comma-separated list of info to collect (e.g., 'date,time,number of guests')")
    parser.add_argument("--key-info-dict",
                       help="[Outbound] JSON dict of known info (e.g., '{\"name\": \"Lee\", \"party_size\": 2}')")
    parser.add_argument("--conversation-flow",
                       help="[Outbound] Detailed conversation flow steps")
    parser.add_argument("--tone",
                       help="Communication style (e.g., 'friendly and professional')")
    parser.add_argument("--additional-instructions",
                       help="Any special instructions for the agent")

    # Traditional parameter (backward compatible)
    parser.add_argument("--prompt",
                       help="Custom system prompt (alternative to using --role + --objective)")

    args = parser.parse_args()

    # Validate parameters
    if not args.prompt and not args.objective:
        parser.error("Must provide either --prompt OR --objective")

    # Parse key_info if provided (for inbound calls)
    key_info_list = None
    if args.key_info:
        key_info_list = [info.strip() for info in args.key_info.split(',')]

    # Parse key_info_dict if provided (for outbound calls)
    import json
    key_info_dict = None
    if args.key_info_dict:
        try:
            key_info_dict = json.loads(args.key_info_dict)
        except json.JSONDecodeError as e:
            parser.error(f"Invalid JSON in --key-info-dict: {e}")

    result = create_agent(
        name=args.name,
        prompt_text=args.prompt,
        language=args.language,
        voice_id=args.voice_id,
        initial_message=args.initial_message,
        call_type=args.call_type,
        role=args.role,
        objective=args.objective,
        scenario_context=args.scenario_context,
        key_info=key_info_list,
        key_info_dict=key_info_dict,
        conversation_flow=args.conversation_flow,
        tone=args.tone,
        additional_instructions=args.additional_instructions
    )

    # Output agent_id for use in subsequent scripts
    print(f"\n✅ Agent created successfully!")
    print(f"Agent ID: {result.get('id')}")
    print(f"\nYou can now make calls with:")
    print(f"  python3 scripts/make_call_simple.py \\")
    print(f"    --agent-id \"{result.get('id')}\" \\")
    print(f"    --to-number \"+1234567890\" \\")
    print(f"    --from-number \"+15103982646\"")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Diagnostic script to check fluents.ai setup and identify issues
"""

import os
import sys
import requests
from dotenv import load_dotenv
import json

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")


def check_env():
    """Check environment configuration"""
    print("=" * 70)
    print("1. ENVIRONMENT CHECK")
    print("=" * 70)

    if not FLUENTS_API_KEY:
        print("✗ FLUENTS_API_KEY not set")
        return False

    print(f"✓ FLUENTS_API_KEY: {FLUENTS_API_KEY[:10]}...{FLUENTS_API_KEY[-4:]}")
    print(f"✓ FLUENTS_API_URL: {FLUENTS_API_URL}")
    return True


def check_api_connection():
    """Test API connectivity"""
    print("\n" + "=" * 70)
    print("2. API CONNECTION TEST")
    print("=" * 70)

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/agents/list",
            params={"page": 1, "size": 1},
            headers=headers,
            timeout=10
        )

        if response.status_code == 200:
            print("✓ API connection successful")
            print(f"  Status: {response.status_code}")
            return True
        else:
            print(f"✗ API returned status {response.status_code}")
            print(f"  Response: {response.text[:200]}")
            return False

    except Exception as e:
        print(f"✗ Connection failed: {e}")
        return False


def check_agents():
    """Check available agents"""
    print("\n" + "=" * 70)
    print("3. AGENTS CHECK")
    print("=" * 70)

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/agents/list",
            params={"page": 1, "size": 10},
            headers=headers,
            timeout=10
        )
        response.raise_for_status()

        data = response.json()
        total = data.get('total', 0)
        items = data.get('items', [])

        print(f"✓ Total agents: {total}")
        if items:
            print(f"\nAvailable agents:")
            for i, agent in enumerate(items[:5], 1):
                print(f"  {i}. {agent.get('name')}")
                print(f"     ID: {agent.get('id')}")
                print(f"     Language: {agent.get('language')}")
        else:
            print("⚠ No agents found - you need to create one first")

        return len(items) > 0

    except Exception as e:
        print(f"✗ Failed to get agents: {e}")
        return False


def check_numbers():
    """Check phone numbers"""
    print("\n" + "=" * 70)
    print("4. PHONE NUMBERS CHECK")
    print("=" * 70)

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/numbers/list",
            params={"page": 1, "size": 10},
            headers=headers,
            timeout=10
        )
        response.raise_for_status()

        data = response.json()
        items = data.get('items', [])

        if items:
            print(f"✓ Found {len(items)} phone number(s):")
            for num in items:
                status = '✓ Active' if num.get('active') else '✗ Inactive'
                print(f"  {status}: {num.get('number')}")
                print(f"     Provider: {num.get('telephony_provider', 'Unknown')}")
        else:
            print("⚠ No phone numbers configured")
            print("  You need to add a phone number in fluents.ai dashboard")
            return False

        return True

    except Exception as e:
        print(f"✗ Failed to get numbers: {e}")
        return False


def check_recent_calls():
    """Check recent calls"""
    print("\n" + "=" * 70)
    print("5. RECENT CALLS")
    print("=" * 70)

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/calls/list",
            params={
                "page": 1,
                "size": 5,
                "sort_column": "start_time",
                "sort_desc": True,
                "filters": ""
            },
            headers=headers,
            timeout=10
        )
        response.raise_for_status()

        data = response.json()
        items = data.get('items', [])
        total = data.get('total', 0)

        print(f"✓ Total calls: {total}")
        if items:
            print(f"\nRecent calls:")
            for call in items[:3]:
                print(f"  • {call.get('to_number')} - {call.get('status')}")
                print(f"    ID: {call.get('id')}")
        else:
            print("  No calls yet")

        return True

    except Exception as e:
        print(f"✗ Failed to get calls: {e}")
        return False


def main():
    print("\n" + "=" * 70)
    print("FLUENTS.AI DIAGNOSTIC TOOL")
    print("=" * 70)

    results = []

    # Run all checks
    results.append(("Environment", check_env()))
    if not results[-1][1]:
        print("\n❌ Environment check failed - cannot continue")
        sys.exit(1)

    results.append(("API Connection", check_api_connection()))
    results.append(("Agents", check_agents()))
    results.append(("Phone Numbers", check_numbers()))
    results.append(("Recent Calls", check_recent_calls()))

    # Summary
    print("\n" + "=" * 70)
    print("DIAGNOSTIC SUMMARY")
    print("=" * 70)

    passed = sum(1 for _, result in results if result)
    total = len(results)

    for check, result in results:
        status = "✓ PASS" if result else "✗ FAIL"
        print(f"{status}: {check}")

    print(f"\nOverall: {passed}/{total} checks passed")

    if passed == total:
        print("\n✅ All checks passed! Your setup is ready.")
        sys.exit(0)
    else:
        print("\n⚠️  Some checks failed. Please review the issues above.")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Retrieve and analyze phone call results from fluents.ai
"""

import os
import sys
import argparse
import requests
from dotenv import load_dotenv
import json

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")


def get_call_details(call_id: str):
    """Get complete call details"""

    if not FLUENTS_API_KEY:
        raise ValueError("FLUENTS_API_KEY not found in environment variables")

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/calls",
            params={"id": call_id},
            headers=headers,
            timeout=30
        )
        response.raise_for_status()
        return response.json()

    except requests.exceptions.RequestException as e:
        print(f"✗ Failed to get call details: {e}", file=sys.stderr)
        if hasattr(e, 'response') and hasattr(e.response, 'text'):
            print(f"  Response: {e.response.text}", file=sys.stderr)
        return None


def display_results(call_id: str, verbose: bool = False):
    """
    Retrieve and display call results

    Args:
        call_id: The call ID to retrieve
        verbose: Show all details
    """

    print(f"Retrieving results for call: {call_id}\n")

    call_data = get_call_details(call_id)
    if not call_data:
        return

    # Basic call information
    print("=" * 60)
    print("CALL DETAILS")
    print("=" * 60)
    print(f"Call ID: {call_data.get('id')}")
    print(f"Status: {call_data.get('status')}")
    print(f"Stage: {call_data.get('stage')}")
    print(f"Stage Outcome: {call_data.get('stage_outcome')}")
    print(f"From: {call_data.get('from_number')}")
    print(f"To: {call_data.get('to_number')}")
    print(f"Outgoing: {'Yes' if call_data.get('is_outgoing') else 'No'}")
    print(f"Started: {call_data.get('start_time')}")
    print(f"Ended: {call_data.get('end_time')}")

    # Human detection
    human_result = call_data.get('human_detection_result')
    if human_result:
        print(f"Human Detected: {human_result}")

    # Recording
    recording_available = call_data.get('recording_available')
    print(f"Recording Available: {'Yes' if recording_available else 'No'}")

    # Do not call detection
    dnc_result = call_data.get('do_not_call_result')
    if dnc_result is not None:
        print(f"Do Not Call: {dnc_result}")

    print()

    # Transcript
    transcript = call_data.get('transcript')
    if transcript:
        print("=" * 60)
        print("TRANSCRIPT")
        print("=" * 60)
        print(transcript)
        print()

    # Errors
    errors = call_data.get('errors', [])
    error_message = call_data.get('error_message')
    if errors or error_message:
        print("=" * 60)
        print("ERRORS")
        print("=" * 60)
        if error_message:
            print(f"Error Message: {error_message}")
        if errors:
            for error in errors:
                print(f"  • {error}")
        print()

    # Action history
    action_history = call_data.get('action_history', [])
    if action_history and verbose:
        print("=" * 60)
        print("ACTION HISTORY")
        print("=" * 60)
        for action in action_history:
            print(f"  • {action}")
        print()

    # Full data in verbose mode
    if verbose:
        print("=" * 60)
        print("FULL CALL DATA")
        print("=" * 60)
        print(json.dumps(call_data, indent=2))


def main():
    parser = argparse.ArgumentParser(description="Get phone call results from fluents.ai")
    parser.add_argument("--call-id", required=True, help="Call ID to retrieve")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    parser.add_argument("--verbose", "-v", action="store_true", help="Show all details")

    args = parser.parse_args()

    if args.json:
        # Output everything as JSON
        result = get_call_details(args.call_id)
        if result:
            print(json.dumps(result, indent=2))
    else:
        # Display formatted results
        display_results(
            call_id=args.call_id,
            verbose=args.verbose
        )


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Download call recording from fluents.ai
"""

import os
import sys
import argparse
import requests
from dotenv import load_dotenv

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")


def get_recording(call_id: str, output_file: str = None):
    """
    Download call recording

    Args:
        call_id: The call ID
        output_file: Path to save the recording (default: recording_{call_id}.mp3)

    Returns:
        str: Path to the saved recording file
    """

    if not FLUENTS_API_KEY:
        raise ValueError("FLUENTS_API_KEY not found in environment variables")

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}"
    }

    # Default output filename
    if not output_file:
        output_file = f"recording_{call_id}.mp3"

    try:
        print(f"Downloading recording for call: {call_id}")

        response = requests.get(
            f"{FLUENTS_API_URL}/v1/calls/recording",
            params={"id": call_id},
            headers=headers,
            timeout=60,
            stream=True
        )
        response.raise_for_status()

        # Save the recording
        with open(output_file, 'wb') as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)

        file_size = os.path.getsize(output_file)
        print(f"✓ Recording downloaded successfully")
        print(f"  File: {output_file}")
        print(f"  Size: {file_size / 1024:.2f} KB")

        return output_file

    except requests.exceptions.RequestException as e:
        print(f"✗ Failed to download recording: {e}", file=sys.stderr)
        if hasattr(e, 'response') and hasattr(e.response, 'text'):
            print(f"  Response: {e.response.text}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="Download call recording from fluents.ai")
    parser.add_argument("--call-id", required=True, help="Call ID")
    parser.add_argument("--output", "-o", help="Output file path (default: recording_{call_id}.mp3)")

    args = parser.parse_args()

    recording_path = get_recording(
        call_id=args.call_id,
        output_file=args.output
    )

    print(f"\nRecording saved to: {recording_path}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Simplified make_call script - more robust and better error handling
"""

import os
import sys
import argparse
import requests
from dotenv import load_dotenv
import json

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")


def get_agent_safe(agent_id: str):
    """Safely retrieve agent details with proper error handling"""
    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    try:
        print(f"[1/3] Fetching agent details: {agent_id}")
        response = requests.get(
            f"{FLUENTS_API_URL}/v1/agents",
            params={"id": agent_id},
            headers=headers,
            timeout=30
        )

        if response.status_code == 404:
            print(f"✗ Agent not found: {agent_id}", file=sys.stderr)
            print(f"  Please verify the agent ID is correct", file=sys.stderr)
            return None

        response.raise_for_status()
        agent = response.json()
        print(f"✓ Agent found: {agent.get('name', 'Unknown')}")
        return agent

    except requests.exceptions.RequestException as e:
        print(f"✗ Failed to get agent: {e}", file=sys.stderr)
        if hasattr(e, 'response') and e.response is not None:
            print(f"  Status: {e.response.status_code}", file=sys.stderr)
            print(f"  Response: {e.response.text[:200]}", file=sys.stderr)
        return None


def make_call_safe(
    agent_id: str,
    to_number: str,
    from_number: str,
    telephony_provider: str = "twilio",
    context: dict = None
):
    """
    Safely initiate a phone call with comprehensive error handling
    """

    if not FLUENTS_API_KEY:
        print("✗ FLUENTS_API_KEY not found in environment variables", file=sys.stderr)
        return None

    # Step 1: Get agent details
    agent = get_agent_safe(agent_id)
    if not agent:
        return None

    # Step 2: Prepare call payload
    print(f"\n[2/3] Preparing call...")
    print(f"  From: {from_number}")
    print(f"  To: {to_number}")
    print(f"  Agent: {agent.get('name', 'Unknown')}")

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "to_number": to_number,
        "from_number": from_number,
        "agent_phone_number": from_number,
        "agent": agent,
        "telephony_provider": {
            "name": telephony_provider
        },
        "context": context or {},
        "telephony_params": {},
        "is_outgoing": True,
        "run_do_not_call_detection": False
    }

    # Step 3: Make the call
    try:
        print(f"\n[3/3] Initiating call...")
        response = requests.post(
            f"{FLUENTS_API_URL}/v1/calls/create",
            json=payload,
            headers=headers,
            timeout=30
        )

        # Better error handling
        if response.status_code == 500:
            print(f"✗ Server error (500) - This might be a temporary issue", file=sys.stderr)
            print(f"  Response: {response.text[:300]}", file=sys.stderr)
            print(f"\nTroubleshooting tips:", file=sys.stderr)
            print(f"  1. Check if your telephony provider is properly configured", file=sys.stderr)
            print(f"  2. Verify your from_number is valid and active", file=sys.stderr)
            print(f"  3. Try again in a few moments", file=sys.stderr)
            return None

        response.raise_for_status()

        result = response.json()
        print(f"\n✓ Call initiated successfully!")
        print(f"  Call ID: {result.get('id')}")
        print(f"  Status: {result.get('status')}")
        print(f"  Telephony ID: {result.get('telephony_id', 'N/A')}")

        return result

    except requests.exceptions.RequestException as e:
        print(f"\n✗ Failed to initiate call: {e}", file=sys.stderr)
        if hasattr(e, 'response') and e.response is not None:
            print(f"  Status: {e.response.status_code}", file=sys.stderr)
            try:
                error_data = e.response.json()
                print(f"  Error: {json.dumps(error_data, indent=2)}", file=sys.stderr)
            except:
                print(f"  Response: {e.response.text[:300]}", file=sys.stderr)
        return None


def main():
    parser = argparse.ArgumentParser(description="Make a phone call with fluents.ai (robust version)")
    parser.add_argument("--agent-id", required=True, help="Phone agent ID")
    parser.add_argument("--to-number", required=True, help="Target phone number with country code")
    parser.add_argument("--from-number", required=True, help="Caller ID number with country code")
    parser.add_argument("--telephony-provider", default="twilio", help="Telephony provider")
    parser.add_argument("--context", help="JSON string with call context data")

    args = parser.parse_args()

    # Parse context if provided
    context = None
    if args.context:
        try:
            context = json.loads(args.context)
        except json.JSONDecodeError as e:
            print(f"⚠ Warning: Invalid JSON for context: {e}", file=sys.stderr)
            print(f"  Using empty context", file=sys.stderr)

    result = make_call_safe(
        agent_id=args.agent_id,
        to_number=args.to_number,
        from_number=args.from_number,
        telephony_provider=args.telephony_provider,
        context=context
    )

    if result:
        print(f"\n📞 Call ID for tracking: {result.get('id')}")
        sys.exit(0)
    else:
        print(f"\n❌ Call failed - see errors above", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Make a phone call using the fluents.ai API
"""

import os
import sys
import argparse
import requests
from dotenv import load_dotenv

load_dotenv()

FLUENTS_API_KEY = os.getenv("FLUENTS_API_KEY")
FLUENTS_API_URL = os.getenv("FLUENTS_API_URL", "https://api.fluents.ai")
WEBHOOK_URL = os.getenv("WEBHOOK_URL")


def get_agent(agent_id: str):
    """Retrieve agent details"""
    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    response = requests.get(
        f"{FLUENTS_API_URL}/v1/agents",
        params={"id": agent_id},
        headers=headers,
        timeout=30
    )
    response.raise_for_status()
    return response.json()


def make_call(
    agent_id: str,
    to_number: str,
    from_number: str,
    telephony_provider: str = "twilio",
    context: dict = None
):
    """
    Initiate a phone call with the specified agent

    Args:
        agent_id: The ID of the phone agent to use
        to_number: Target phone number (with country code, e.g., +1234567890)
        from_number: Caller ID number (with country code, e.g., +0987654321)
        telephony_provider: Telephony provider name (default: twilio)
        context: Optional context data for the call

    Returns:
        dict: Call initiation response with call_id
    """

    if not FLUENTS_API_KEY:
        raise ValueError("FLUENTS_API_KEY not found in environment variables")

    headers = {
        "Authorization": f"Bearer {FLUENTS_API_KEY}",
        "Content-Type": "application/json"
    }

    # Get agent details
    print(f"Fetching agent details for: {agent_id}")
    agent = get_agent(agent_id)

    # Construct the payload according to fluents.ai API spec
    payload = {
        "to_number": to_number,
        "from_number": from_number,
        "agent_phone_number": from_number,
        "agent": agent,
        "telephony_provider": {
            "name": telephony_provider
        },
        "context": context or {},
        "telephony_params": {},
        "is_outgoing": True,
        "run_do_not_call_detection": False
    }

    try:
        response = requests.post(
            f"{FLUENTS_API_URL}/v1/calls/create",
            json=payload,
            headers=headers,
            timeout=30
        )
        response.raise_for_status()

        result = response.json()
        print(f"✓ Call initiated successfully")
        print(f"  Call ID: {result.get('id')}")
        print(f"  Status: {result.get('status')}")
        print(f"  From: {from_number}")
        print(f"  To: {to_number}")

        return result

    except requests.exceptions.RequestException as e:
        print(f"✗ Failed to initiate call: {e}", file=sys.stderr)
        if hasattr(e.response, 'text'):
            print(f"  Response: {e.response.text}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="Make a phone call with fluents.ai")
    parser.add_argument("--agent-id", required=True, help="Phone agent ID")
    parser.add_argument("--to-number", required=True, help="Target phone number with country code (e.g., +1234567890)")
    parser.add_argument("--from-number", required=True, help="Caller ID number with country code (e.g., +0987654321)")
    parser.add_argument("--telephony-provider", default="twilio", help="Telephony provider (default: twilio)")
    parser.add_argument("--context", help="JSON string with call context data")

    args = parser.parse_args()

    # Parse context if provided
    context = None
    if args.context:
        import json
        try:
            context = json.loads(args.context)
        except json.JSONDecodeError:
            print("Warning: Invalid JSON for context, using empty context", file=sys.stderr)

    result = make_call(
        agent_id=args.agent_id,
        to_number=args.to_number,
        from_number=args.from_number,
        telephony_provider=args.telephony_provider,
        context=context
    )

    # Output call_id for tracking
    print(f"\nCall ID: {result.get('id')}")


if __name__ == "__main__":
    main()