{selectedNodeId ?
: null}
{selectedNodeId &&
}
{globalLoading &&
Loading...
}
{
setSelectedNodeId(null);
}}
>
);
}
export default App;
```
### backend/calltest/main.py
```python
import os
import json
import base64
import asyncio
import argparse
from fastapi import FastAPI, WebSocket, BackgroundTasks
from fastapi.responses import JSONResponse
from fastapi.websockets import WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
from twilio.rest import Client
import websockets
from dotenv import load_dotenv
import uvicorn
import re
from typing import Optional
from pydantic import BaseModel
from openai import OpenAI
load_dotenv()
# Configuration
TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
PHONE_NUMBER_FROM = os.getenv("PHONE_NUMBER_FROM")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
raw_domain = os.getenv("NGROK_DOMAIN", "")
DOMAIN = re.sub(
r"(^\w+:|^)\/\/|\/+$", "", raw_domain
) # Strip protocols and trailing slashes from DOMAIN
print(f"TWILIO_ACCOUNT_SID: {TWILIO_ACCOUNT_SID}")
print(f"TWILIO_AUTH_TOKEN: {TWILIO_AUTH_TOKEN}")
print(f"PHONE_NUMBER_FROM: {PHONE_NUMBER_FROM}")
print(f"OPENAI_API_KEY: {OPENAI_API_KEY}")
print(f"DOMAIN: {DOMAIN}")
PORT = int(os.getenv("PORT", 6060))
SYSTEM_MESSAGE = (
"You are an AI voice assistant to ask the user questions and gather information. You are talking to an expert on the topic of the call: {topic}. You will not ask the user clarifying questions, you will ask the user to answer the question directly."
)
TOPIC = "Your day"
VOICE = "alloy"
LOG_EVENT_TYPES = [
"error",
"response.content.done",
"rate_limits.updated",
"response.done",
"input_audio_buffer.committed",
"input_audio_buffer.speech_stopped",
"input_audio_buffer.speech_started",
"session.created",
]
app = FastAPI()
# Add CORS middleware
app.add_middleware(
CORSMiddleware,
allow_origins=["*"], # Allows all origins
allow_credentials=True,
allow_methods=["*"], # Allows all methods
allow_headers=["*"], # Allows all headers
)
if not (
TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN and PHONE_NUMBER_FROM and OPENAI_API_KEY
):
raise ValueError(
"Missing Twilio and/or OpenAI environment variables. Please set them in the .env file."
)
# Initialize Twilio client
client = Client(
TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN
)
# Initialize OpenAI client
openai_client = OpenAI(api_key=OPENAI_API_KEY)
# Add this new class for the request body
class CallRequest(BaseModel):
phone_number: str
topic: str
max_duration: Optional[int] = 300 # default 5 minutes
# Add a dictionary to store call summaries
call_summaries = {}
@app.get("/", response_class=JSONResponse)
async def index_page():
return {"message": "Twilio Media Stream Server is running!"}
@app.websocket("/media-stream")
async def handle_media_stream(websocket: WebSocket):
"""Handle WebSocket connections between Twilio and OpenAI."""
print("Client connected")
await websocket.accept()
conversation_transcript = []
async with websockets.connect(
"wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview",
additional_headers={
"Authorization": f"Bearer {OPENAI_API_KEY}",
"OpenAI-Beta": "realtime=v1",
},
) as openai_ws:
await initialize_session(openai_ws)
stream_sid = None
async def receive_from_twilio():
"""Receive audio data from Twilio and send it to the OpenAI Realtime API."""
nonlocal stream_sid
try:
async for message in websocket.iter_text():
data = json.loads(message)
if data["event"] == "media":
audio_append = {
"type": "input_audio_buffer.append",
"audio": data["media"]["payload"],
}
await openai_ws.send(json.dumps(audio_append))
elif data["event"] == "start":
stream_sid = data["start"]["streamSid"]
print(f"Incoming stream has started {stream_sid}")
except WebSocketDisconnect:
print("Client disconnected.")
# if openai_ws.open:
# await openai_ws.close()
async def send_to_twilio():
"""Receive events from the OpenAI Realtime API, send audio back to Twilio."""
nonlocal stream_sid, conversation_transcript
try:
async for openai_message in openai_ws:
response = json.loads(openai_message)
if response["type"] in LOG_EVENT_TYPES:
print(f"Received event: {response['type']}", response)
pass
if response["type"] == "session.updated":
print("Session updated successfully:", response)
pass
if response["type"] == "response.audio.delta" and response.get(
"delta"
):
try:
audio_payload = base64.b64encode(
base64.b64decode(response["delta"])
).decode("utf-8")
audio_delta = {
"event": "media",
"streamSid": stream_sid,
"media": {"payload": audio_payload},
}
await websocket.send_json(audio_delta)
except Exception as e:
print(f"Error processing audio data: {e}")
if response["type"] == "response.content.delta":
if "delta" in response and "text" in response["delta"]:
conversation_transcript.append(response["delta"]["text"])
print(f"Total transcript: {conversation_transcript}")
# Handle end of call
[truncated — 7245 more characters]
```
### backend/end.sh
```shell
#!/bin/bash
if [ -f pid.txt ]; then
UVICORN_PID=$(cat pid.txt)
kill $(pgrep -P $UVICORN_PID)
rm pid.txt src/research.db
sleep 1
fi
```
### frontend/vite.config.ts
```typescript
import tailwindcss from "@tailwindcss/vite";
import react from "@vitejs/plugin-react";
import { defineConfig } from "vite";
// https://vite.dev/config/
export default defineConfig({
plugins: [react(), tailwindcss()],
});
```
### backend/start.sh
```shell
#!/bin/bash
# Start script for the application
if [ -f pid.txt ]; then
UVICORN_PID=$(cat pid.txt)
kill $(pgrep -P $UVICORN_PID)
rm pid.txt src/research.db
sleep 2
fi
nohup bash -c "source .venv/bin/activate && cd src && uvicorn main:app --reload" > output.log 2>&1 &
echo $! > pid.txt
```
### frontend/typegen.sh
```shell
#!/usr/bin/env bash
# This script generates TypeScript types for the APIs based on OpenAPI specifications.
# Add your commands below to implement the type generation functionality.
bash -c "cd ../backend && ./start.sh"
bun run openapi-typegen || {
echo "TypeScript types generation failed."
}
bash -c "cd ../backend && ./end.sh"
```
[22 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]