Delete agent

{
  "message": "Agent deleted successfully"
}

// Agent not found
{
  "error": "not_found",
  "message": "Agent not found"
}

// No access to agent
{
  "error": "forbidden", 
  "message": "You do not have access to this agent"
}

// Campaign import in progress
{
  "error": "campaign_busy",
  "message": "Wait for active prospect imports to finish before deleting this profile"
}

// Kakiyo-managed agent is not ended
{
  "error": "invalid_status",
  "message": "Agent can only be deleted when status is ended",
  "currentStatus": "running"
}

// Internal server error
{
  "error": "internal_error",
  "message": "An internal error occurred"
}

# Delete an agent
curl -X DELETE "https://api.kakiyo.com/v1/agents/agent_123" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

// JavaScript/Node.js
const deleteAgent = async (agentId) => {
  const response = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}`, {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to delete agent: ${error.message}`);
  }

  return await response.json();
};

// Usage with error handling
try {
  const result = await deleteAgent('agent_123');
  console.log('Agent deleted:', result.message);
} catch (error) {
  console.error('Delete failed:', error.message);
}

# Python
import requests

def delete_agent(agent_id):
    """Permanently delete an agent"""
    response = requests.delete(
        f'https://api.kakiyo.com/v1/agents/{agent_id}',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        }
    )
    
    if response.status_code == 200:
        return response.json()
    else:
        error_data = response.json()
        raise Exception(f"Failed to delete agent: {error_data['message']}")

# Usage with error handling
try:
    result = delete_agent('agent_123')
    print(f"Agent deleted: {result['message']}")
except Exception as e:
    print(f"Delete failed: {e}")

const safeDeleteAgent = async (agentId) => {
  try {
    const response = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      }
    });

    const data = await response.json();

    if (!response.ok) {
      switch (data.error) {
        case 'not_found':
          throw new Error('Agent not found. Please check the agent ID.');
        case 'forbidden':
          throw new Error('You do not have permission to delete this agent.');
        case 'campaign_busy':
          throw new Error('Agent cannot be deleted while a campaign import is active. Retry shortly.');
        case 'invalid_status':
          throw new Error(`Agent cannot be deleted. Current status: ${data.currentStatus}.`);
        case 'internal_error':
          throw new Error('Server error occurred. Please try again later.');
        default:
          throw new Error(`Unexpected error: ${data.message}`);
      }
    }

    return data;
  } catch (error) {
    console.error('Delete agent error:', error.message);
    throw error;
  }
};

const safeAgentDeletion = async (agentId) => {
  try {
    // Confirm deletion (in a real app, this would be user confirmation)
    const confirmed = true; // Replace with actual confirmation logic

    if (!confirmed) {
      return { success: false, reason: 'User cancelled' };
    }

    // Proceed with deletion
    const result = await deleteAgent(agentId);
    
    return { 
      success: true, 
      message: result.message 
    };

  } catch (error) {
    return { 
      success: false, 
      error: error.message 
    };
  }
};

const cleanupAgents = async (agentIds) => {
  try {
    const results = [];
    for (const agentId of agentIds) {
      try {
        await deleteAgent(agentId);
        results.push({ id: agentId, success: true });
        console.log(`✓ Deleted agent ${agentId}`);
      } catch (error) {
        results.push({ id: agentId, success: false, error: error.message });
        console.log(`✗ Failed to delete agent ${agentId}: ${error.message}`);
      }
    }

    return results;
  } catch (error) {
    console.error('Bulk cleanup failed:', error.message);
    throw error;
  }
};