# Process incoming calls with low latency
import telnyx
import os
import json

# Initialize Telnyx client (auto-configured via bindings)
telnyx.api_key = os.environ.get("TELNYX_API_KEY")

async def handler(request):
    try:
        call = await request.json()

        # Direct access to Voice API
        response = telnyx.Call.answer(
            call["id"],
            webhook_url="https://my-webhook-function-abc123.telnyxcompute.com/webhooks"
        )

        return Response(
            json.dumps({"call_id": response.id}),
            headers={"Content-Type": "application/json"}
        )
    except Exception as error:
        print(f"Voice API error: {error}")
        return Response(
            json.dumps({"error": "Failed to process call"}),
            status=500,
            headers={"Content-Type": "application/json"}
        )

# Real-time AI processing
import telnyx
import os
import json

# Initialize Telnyx client
telnyx_client = telnyx.Client(api_key=os.environ["TELNYX_API_KEY"])

async def handler(request):
    try:
        audio_data = await request.body()

        # Low-latency access to Telnyx AI
        result = await telnyx_client.ai.transcribe(audio_data)

        response = {
            "transcript": result.text,
            "confidence": result.confidence
        }

        return Response(
            json.dumps(response),
            headers={"Content-Type": "application/json"}
        )

    except Exception as error:
        print(f"AI processing error: {error}")
        return Response(
            json.dumps({"error": "Failed to process audio"}),
            status=500,
            headers={"Content-Type": "application/json"}
        )

// Process SMS with custom logic
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"

    "github.com/telnyx/telnyx-go"
)

type SMSWebhook struct {
    From string `json:"from"`
    Text string `json:"text"`
    To   string `json:"to"`
}

func handler(w http.ResponseWriter, r *http.Request) {
    var webhook SMSWebhook

    if err := json.NewDecoder(r.Body).Decode(&webhook); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }

    // Custom business logic
    response := processMessage(webhook.Text)

    // Initialize Telnyx client
    client := telnyx.NewClient(os.Getenv("TELNYX_API_KEY"))

    // Send reply via Telnyx
    _, err := client.Messages.Send(&telnyx.MessageRequest{
        From: webhook.To,
        To:   webhook.From,
        Text: response,
    })

    if err != nil {
        log.Printf("Failed to send SMS: %v", err)
        http.Error(w, "Failed to send message", http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "Message processed successfully")
}

func processMessage(text string) string {
    // Simple echo response - replace with actual business logic
    return fmt.Sprintf("Echo: %s", text)
}