SDKs & Libraries

const { Amanah AI } = require('amanahagent-sdk');
// or
import { Amanah AI } from 'amanahagent-sdk';

// Initialize the client
const client = new Amanah AI({
  apiKey: 'your-api-key',
  baseURL: 'https://api.amanahagent.cloud/v1' // optional
});

// Send a message
async function sendMessage() {
  try {
    const message = await client.messages.send({
      to: '+1234567890',
      type: 'text',
      message: 'Hello from Amanah AI!'
    });
    
    console.log('Message sent:', message.message_id);
  } catch (error) {
    console.error('Error:', error.message);
  }
}

import { 
  Amanah AI, 
  Message, 
  Contact, 
  MessageType,
  WebhookEvent 
} from 'amanahagent-sdk';

const client = new Amanah AI({ apiKey: 'your-api-key' });

// Type-safe message sending
const message: Message = await client.messages.send({
  to: '+1234567890',
  type: MessageType.TEXT,
  message: 'Hello!'
});

// Webhook event handling
function handleWebhook(event: WebhookEvent) {
  switch (event.event) {
    case 'message.sent':
      console.log('Message sent:', event.data.message_id);
      break;
    case 'message.received':
      console.log('New message from:', event.data.from);
      break;
  }
}

from amanahagent import Amanah AI

# Initialize the client
client = Amanah AI(api_key='your-api-key')

# Send a message
try:
    message = client.messages.send(
        to='+1234567890',
        type='text',
        message='Hello from Amanah AI!'
    )
    print(f'Message sent: {message.message_id}')
except Exception as error:
    print(f'Error: {error}')

import asyncio
from amanahagent import AsyncAmanah AI

async def send_message():
    client = AsyncAmanah AI(api_key='your-api-key')
    
    try:
        message = await client.messages.send(
            to='+1234567890',
            type='text',
            message='Hello from async Amanah AI!'
        )
        print(f'Message sent: {message.message_id}')
    except Exception as error:
        print(f'Error: {error}')
    finally:
        await client.close()

# Run async function
asyncio.run(send_message())

# settings.py
AMANAHAGENT_API_KEY = 'your-api-key'

# views.py
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from amanahagent import Amanah AI
from django.conf import settings
import json

client = Amanah AI(api_key=settings.AMANAHAGENT_API_KEY)

@csrf_exempt
@require_http_methods(["POST"])
def send_message(request):
    data = json.loads(request.body)
    
    try:
        message = client.messages.send(
            to=data['to'],
            type=data['type'],
            message=data['message']
        )
        return JsonResponse({'message_id': message.message_id})
    except Exception as error:
        return JsonResponse({'error': str(error)}, status=400)

from flask import Flask, request, jsonify
from amanahagent import Amanah AI
import os

app = Flask(__name__)
client = Amanah AI(api_key=os.environ['AMANAHAGENT_API_KEY'])

@app.route('/send-message', methods=['POST'])
def send_message():
    data = request.json
    
    try:
        message = client.messages.send(
            to=data['to'],
            type=data['type'],
            message=data['message']
        )
        return jsonify({'message_id': message.message_id})
    except Exception as error:
        return jsonify({'error': str(error)}), 400

# Webhook handler with signature verification
@app.route('/webhooks/amanahagent', methods=['POST'])
def webhook_handler():
    signature = request.headers.get('X-Webhook-Signature')
    
    if client.webhooks.verify_signature(request.data, signature, 'your-secret'):
        event = request.json
        print(f"Received event: {event['event']}")
        return jsonify({'status': 'success'})
    else:
        return jsonify({'error': 'Invalid signature'}), 401

<?php
require_once 'vendor/autoload.php';

use Amanah AI\SDK\Amanah AI;

// Initialize the client
$client = new Amanah AI([
    'api_key' => 'your-api-key'
]);

// Send a message
try {
    $message = $client->messages->send([
        'to' => '+1234567890',
        'type' => 'text',
        'message' => 'Hello from Amanah AI!'
    ]);
    
    echo "Message sent: " . $message->message_id;
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
?>

// config/services.php
'amanahagent' => [
    'api_key' => env('AMANAHAGENT_API_KEY'),
],

// app/Services/WhatsAppService.php
<?php
namespace App\Services;

use Amanah AI\SDK\Amanah AI;

class WhatsAppService
{
    private $client;
    
    public function __construct()
    {
        $this->client = new Amanah AI([
            'api_key' => config('services.amanahagent.api_key')
        ]);
    }
    
    public function sendMessage($to, $message)
    {
        return $this->client->messages->send([
            'to' => $to,
            'type' => 'text',
            'message' => $message
        ]);
    }
}

// app/Http/Controllers/WhatsAppController.php
<?php
namespace App\Http\Controllers;

use App\Services\WhatsAppService;
use Illuminate\Http\Request;

class WhatsAppController extends Controller
{
    public function sendMessage(Request $request, WhatsAppService $whatsapp)
    {
        $request->validate([
            'to' => 'required|string',
            'message' => 'required|string'
        ]);
        
        try {
            $message = $whatsapp->sendMessage(
                $request->to,
                $request->message
            );
            
            return response()->json(['message_id' => $message->message_id]);
        } catch (Exception $e) {
            return response()->json(['error' => $e->getMessage()], 400);
        }
    }
}

<?php
// webhook.php
require_once 'vendor/autoload.php';

use Amanah AI\SDK\Amanah AI;

$client = new Amanah AI(['api_key' => 'your-api-key']);

// Get the raw POST data
$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';

// Verify signature
if ($client->webhooks->verifySignature($payload, $signature, 'your-secret')) {
    $event = json_decode($payload, true);
    
    // Handle different event types
    switch ($event['event']) {
        case 'message.delivered':
            // Handle message delivered
            error_log("Message delivered: " . $event['data']['message_id']);
            break;
            
        case 'message.received':
            // Handle incoming message
            $from = $event['data']['from'];
            $message = $event['data']['message'];
            error_log("Received message from {$from}: {$message}");
            break;
    }
    
    http_response_code(200);
    echo 'OK';
} else {
    http_response_code(401);
    echo 'Unauthorized';
}
?>

import com.amanahagent.sdk.Amanah AI;
import com.amanahagent.sdk.models.Message;
import com.amanahagent.sdk.models.SendMessageRequest;

public class WhatsAppExample {
    public static void main(String[] args) {
        // Initialize the client
        Amanah AI client = Amanah AI.builder()
            .apiKey("your-api-key")
            .build();
        
        // Send a message
        try {
            SendMessageRequest request = SendMessageRequest.builder()
                .to("+1234567890")
                .type("text")
                .message("Hello from Amanah AI!")
                .build();
            
            Message message = client.messages().send(request);
            System.out.println("Message sent: " + message.getMessageId());
        } catch (Exception error) {
            System.err.println("Error: " + error.getMessage());
        }
    }
}

// application.yml
amanahagent:
  api-key: your-api-key

// Amanah AIConfig.java
@Configuration
public class Amanah AIConfig {
    @Value("${amanahagent.api-key}")
    private String apiKey;
    
    @Bean
    public Amanah AI amanahAgent() {
        return Amanah AI.builder()
            .apiKey(apiKey)
            .build();
    }
}

// WhatsAppService.java
@Service
public class WhatsAppService {
    private final Amanah AI client;
    
    public WhatsAppService(Amanah AI client) {
        this.client = client;
    }
    
    public Message sendMessage(String to, String message) {
        SendMessageRequest request = SendMessageRequest.builder()
            .to(to)
            .type("text")
            .message(message)
            .build();
            
        return client.messages().send(request);
    }
}

// WhatsAppController.java
@RestController
@RequestMapping("/api/whatsapp")
public class WhatsAppController {
    private final WhatsAppService whatsAppService;
    
    public WhatsAppController(WhatsAppService whatsAppService) {
        this.whatsAppService = whatsAppService;
    }
    
    @PostMapping("/send")
    public ResponseEntity<MessageResponse> sendMessage(@RequestBody MessageRequest request) {
        try {
            Message message = whatsAppService.sendMessage(request.getTo(), request.getMessage());
            return ResponseEntity.ok(new MessageResponse(message.getMessageId()));
        } catch (Exception e) {
            return ResponseEntity.badRequest()
                .body(new MessageResponse(null, e.getMessage()));
        }
    }
}

package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/amanahagent/go-sdk"
)

func main() {
    // Initialize the client
    client := amanahagent.New("your-api-key")
    
    // Send a message
    ctx := context.Background()
    message, err := client.Messages.Send(ctx, &amanahagent.SendMessageRequest{
        To:      "+1234567890",
        Type:    "text",
        Message: "Hello from Amanah AI!",
    })
    
    if err != nil {
        log.Fatal("Error sending message:", err)
    }
    
    fmt.Printf("Message sent: %s\n", message.MessageID)
}

package main

import (
    "net/http"
    "os"
    
    "github.com/gin-gonic/gin"
    "github.com/amanahagent/go-sdk"
)

type MessageRequest struct {
    To      string `json:"to" binding:"required"`
    Message string `json:"message" binding:"required"`
}

func main() {
    // Initialize Amanah AI client
    client := amanahagent.New(os.Getenv("AMANAHAGENT_API_KEY"))
    
    r := gin.Default()
    
    r.POST("/send-message", func(c *gin.Context) {
        var req MessageRequest
        if err := c.ShouldBindJSON(&req); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        
        message, err := client.Messages.Send(c.Request.Context(), &amanahagent.SendMessageRequest{
            To:      req.To,
            Type:    "text",
            Message: req.Message,
        })
        
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        
        c.JSON(http.StatusOK, gin.H{"message_id": message.MessageID})
    })
    
    r.Run(":8080")
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "strings"
    
    "github.com/amanahagent/go-sdk"
)

func verifySignature(payload []byte, signature, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(payload)
    calculatedSignature := "sha256=" + hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(signature), []byte(calculatedSignature))
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    payload, err := ioutil.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Error reading request body", http.StatusBadRequest)
        return
    }
    
    signature := r.Header.Get("X-Webhook-Signature")
    secret := os.Getenv("WEBHOOK_SECRET")
    
    if !verifySignature(payload, signature, secret) {
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
        return
    }
    
    var event amanahagent.WebhookEvent
    if err := json.Unmarshal(payload, &event); err != nil {
        http.Error(w, "Error parsing JSON", http.StatusBadRequest)
        return
    }
    
    // Handle different event types
    switch event.Event {
    case "message.delivered":
        fmt.Printf("Message delivered: %s\n", event.Data.MessageID)
    case "message.received":
        fmt.Printf("Received message from %s: %s\n", event.Data.From, event.Data.Message)
    }
    
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("OK"))
}

func main() {
    http.HandleFunc("/webhooks/amanahagent", webhookHandler)
    log.Println("Webhook server listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}