Build a voice agent

import { Photon } from "@photon-ai/api";

const { PHOTON_API_KEY, PHOTON_PROJECT_ID, PHOTON_VOICE_PROFILE_ID } = process.env;
if (!PHOTON_API_KEY || !PHOTON_PROJECT_ID || !PHOTON_VOICE_PROFILE_ID) {
  throw new Error("Set PHOTON_API_KEY, PHOTON_PROJECT_ID, and PHOTON_VOICE_PROFILE_ID");
}

const photon = new Photon({
  headers: { Authorization: `Bearer ${PHOTON_API_KEY}` },
});

try {
  const profile = await photon.projects.platforms.getVoiceProfile({
    path: { id: PHOTON_PROJECT_ID, profileId: PHOTON_VOICE_PROFILE_ID },
  });
  console.log(profile.configuration.inbound?.destinationUri ?? "Inbound is not enabled");
} catch {
  console.error("Could not read the Voice profile");
  process.exitCode = 1;
}

import os

from photon_api import Photon, PhotonError
from photon_api.rpc_generated import GetVoiceProfileInput

try:
    with Photon(headers={"Authorization": f"Bearer {os.environ['PHOTON_API_KEY']}"}) as photon:
        profile = photon.projects.platforms.get_voice_profile(
            GetVoiceProfileInput.model_validate({
                "path": {
                    "id": os.environ["PHOTON_PROJECT_ID"],
                    "profileId": os.environ["PHOTON_VOICE_PROFILE_ID"],
                }
            })
        )
        inbound = profile.configuration.inbound
        print(inbound.destinationUri if inbound is not None else "Inbound is not enabled")
except PhotonError:
    raise SystemExit("Could not read the Voice profile") from None

use photon_ai_api::{Credential, PhotonClientBuilder, SecretString};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PhotonClientBuilder::new()
        .credential(
            "projectApiKey",
            Credential::Bearer(SecretString::from(std::env::var("PHOTON_API_KEY")?)),
        )
        .build()?;
    let response = client
        .get_voice_profile(
            std::env::var("PHOTON_PROJECT_ID")?,
            std::env::var("PHOTON_VOICE_PROFILE_ID")?,
        )
        .await
        .map_err(|_| "Could not read the Voice profile")?;
    match &response.inner().configuration.inbound {
        Some(inbound) => println!("{}", inbound.destination_uri),
        None => println!("Inbound is not enabled"),
    }
    Ok(())
}

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    photonapi "github.com/photon-hq/api/packages/go"
)

func required(name string) string {
    value := os.Getenv(name)
    if value == "" {
        log.Fatalf("Set %s", name)
    }
    return value
}

func main() {
    client := photonapi.NewClient(photonapi.WithAPIKey(required("PHOTON_API_KEY")))
    profile, err := client.Projects.Platforms.GetVoiceProfile(
        context.Background(), &photonapi.GetVoiceProfileParams{
            ID: required("PHOTON_PROJECT_ID"),
            ProfileID: required("PHOTON_VOICE_PROFILE_ID"),
        },
    )
    if err != nil {
        log.Fatal("Could not read the Voice profile")
    }
    if profile.Configuration.Inbound == nil {
        fmt.Println("Inbound is not enabled")
        return
    }
    fmt.Println(profile.Configuration.Inbound.DestinationURI)
}

node voice.ts

python voice.py

cargo run --bin photon-first-agent

go run main.go