Vogent

https://docs.vogent.ai
Admin
Vogent is a platform for building, testing, and deploying conversational voice AI agents, offering...
Tokens:83,340
Snippets:475
Trust Score:7.5
Update:10 months ago
Show doc for...
Tokens:
Raw
### Quick Start: Initiate Call and Monitor Transcripts

Source: https://docs.vogent.ai/sdk/web-sdk

A comprehensive example demonstrating how to initiate a call using the Vogent API, initialize the VogentCall instance, start the session, connect audio, and monitor transcripts in real-time. It also shows how to listen for status changes and clean up resources.

```typescript
import { VogentCall } from '@vogent/vogent-web-client';

// Step 1: Create a dial via the Vogent API
const response = await fetch('https://api.vogent.ai/api/dials', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer pub_vogent_...',  // Use your public API key
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    callAgentId: 'your_call_agent_id',
    browserCall: true  // Important: Enable browser call mode
  })
});

const { dialToken, sessionId, dialId } = await response.json();

// Step 2: Initialize the VogentCall instance
const call = new VogentCall({
  sessionId,
  dialId,
  token: dialToken
});

// Step 3: Start the call session
await call.start();

// Step 4: Connect audio
const audioConnection = await call.connectAudio();

// Step 5: Monitor transcripts in real-time
const unsubscribe = call.monitorTranscript((transcript) => {
  transcript.forEach(({ text, speaker }) => {
    console.log(`${speaker}: ${text}`);
  });
});

// Step 6: Listen for status changes
call.on('status', (status) => {
  console.log('Call status:', status);
});

// Cleanup when done
unsubscribe();
await call.hangup();

```

--------------------------------

### Real-time Streaming with WebSockets

Source: https://docs.vogent.ai/voicelab/quickstart

Utilize WebSockets for real-time text-to-speech streaming. Send text chunks and receive audio data incrementally.

```APIDOC
## WebSocket API for Real-time TTS

### Description
Connect to the WebSocket endpoint to stream text and receive audio chunks in real-time. This is ideal for applications requiring immediate audio feedback.

### Endpoint
`wss://api.vogent.ai/api/tts/websocket?apiKey={YOUR_API_KEY}`

### Parameters
#### Query Parameters
- **apiKey** (string) - Required - Your API key for authentication.

#### Request Body (JSON messages sent over WebSocket)
- **generationId** (string) - Required - A unique identifier for this generation request.
- **voiceId** (string) - Required - The unique identifier for the voice to be used.
- **text** (string) - Required - The text content to be synthesized.
- **finalText** (boolean) - Required - Set to `true` if this is the final text chunk for the current generation.
- **sampleRate** (integer) - Optional - The desired sample rate for the audio (e.g., 24000).
- **cancel** (boolean) - Optional - Set to `true` to cancel the current generation request.

### Response (JSON messages received over WebSocket)
- **type** (string) - The type of message received. Possible values: `chunk`, `error`, `finished`.
  - If `type` is `chunk`:
    - **audio** (string) - Base64 encoded audio data.
  - If `type` is `error`:
    - **error** (string) - An error message describing the issue.

### Request Example (Sending initial text chunk)
```json
{
  "generationId": "gen_uuid_123",
  "voiceId": "36b87413-6d7b-421d-8745-bc0897770d1e",
  "text": "Hello! This is a real-time streaming example.",
  "finalText": false,
  "sampleRate": 24000,
  "cancel": false
}
```

### Response Example (Receiving an audio chunk)
```json
{
  "type": "chunk",
  "audio": "BASE64_ENCODED_AUDIO_DATA"
}
```

### Response Example (Receiving finished signal)
```json
{
  "type": "finished"
}
```

### Response Example (Receiving error)
```json
{
  "type": "error",
  "error": "Invalid API key"
}
```
```

--------------------------------

### Install Vogent Web Client

Source: https://docs.vogent.ai/sdk/web-sdk

Install the Vogent Web Client SDK using various package managers like Bun, NPM, or Yarn. Ensure you have a package manager installed on your system.

```bash
bun add @vogent/vogent-web-client
```

```bash
npm install @vogent/vogent-web-client
```

```bash
yarn add @vogent/vogent-web-client
```

--------------------------------

### Create a Conversation (Multi-Speaker)

Source: https://docs.vogent.ai/voicelab/quickstart

This endpoint allows you to create a spoken conversation with multiple speakers, specifying the text and voice ID for each line.

```APIDOC
## POST /api/tts/multispeaker

### Description
Creates a conversation with multiple speakers by providing an array of text lines, each with an associated `voiceId`.

### Method
POST

### Endpoint
`https://api.vogent.ai/api/tts/multispeaker`

### Parameters
#### Request Body
- **lines** (array) - Required - An array of objects, where each object represents a line in the conversation.
  - **text** (string) - Required - The text content of the line.
  - **voiceId** (string) - Required - The unique identifier for the voice to be used for this line.

### Request Example
```json
{
  "lines": [
    {
      "text": "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.",
      "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a"
    },
    {
      "text": "That's interesting, was it actually like super realistic or was it just not robotic.",
      "voiceId": "50c9287d-bcee-4f2a-943f-f0f2184a5d3b"
    }
  ]
}
```

### Response
#### Success Response (200)
The response contains the audio data for the generated conversation as a binary stream.

#### Response Example
(Binary audio data - typically saved to a file like `conversation.wav`)
```

--------------------------------

### Real-time Streaming TTS with Python WebSockets

Source: https://docs.vogent.ai/voicelab/quickstart

This Python script demonstrates how to use WebSockets for real-time text-to-speech streaming. It connects to the Vogent AI WebSocket API, sends text chunks with voice and sample rate information, and receives audio data in chunks. The received audio is then saved as a WAV file. This is ideal for applications requiring live audio generation.

```python
import asyncio
import websockets
import json
import base64
import uuid
import wave

SAMPLE_RATE = 24000
API_KEY = ""
async def stream_tts():
    # Connect to the WebSocket endpoint
    uri = f"wss://api.vogent.ai/api/tts/websocket?apiKey={API_KEY}"
    generation_id = f"gen_{uuid.uuid4()}"

    async with websockets.connect(uri) as websocket:
        print("🔗 Connected to Voicelab WebSocket")

        # Send initial text chunk
        await websocket.send(json.dumps({
            "generationId": generation_id,
            "voiceId": "36b87413-6d7b-421d-8745-bc0897770d1e",  # Mabel voice
            "text": "Hello! This is a real-time streaming example.",
            "finalText": False,
            "sampleRate": 24000,
            "cancel": False
        }))

        # Send final text chunk
        await websocket.send(json.dumps({
            "generationId": generation_id,
            "voiceId": "36b87413-6d7b-421d-8745-bc0897770d1e",
            "text": " This demonstrates real-time text-to-speech streaming!",
            "finalText": True,
            "cancel": False
        }))

        audio_chunks = []

        print("Listening for audio")
        # Listen for audio chunks
        async for message in websocket:
            data = json.loads(message)

            if data["type"] == "chunk":
                # Decode and store audio chunk
                audio_data = base64.b64decode(data["audio"])
                audio_chunks.append(audio_data)
                print("🎵 Received audio chunk")

            elif data["type"] == "error":
                print(f"❌ Error: {data['error']}")
                break

            elif data["type"] == "finished":
                print("✅ Streaming complete!")

                with wave.open("streaming_audio.wav", "wb") as wf:
                    wf.setnchannels(1)
                    wf.setsampwidth(2)
                    wf.setframerate(SAMPLE_RATE)

                    print("Chunks", len(audio_chunks))
                    for chunk in audio_chunks:
                        wf.writeframes(chunk)

                print("💾 Audio saved as 'streaming_audio.wav'")
                break

# Run the streaming example
asyncio.run(stream_tts())

```

--------------------------------

### VogentCall: start() Method

Source: https://docs.vogent.ai/sdk/web-sdk

Initiates the call session. This method should be called after initializing the VogentCall instance.

```typescript
await call.start();
```

--------------------------------

### Text-to-Speech Generation with Vogent AI

Source: https://docs.vogent.ai/voicelab/quickstart

Generate speech from text using the Vogent AI API. Requires an API key for authentication and specifies the text and voice ID for generation. The output is an audio file. Ensure to keep your API key private and do not expose it client-side.

```bash
curl -X POST "https://api.vogent.ai/api/tts" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "text": "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.",
      "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a"
    }' \
    --output my-first-voice.wav
```

```python
import requests

# Replace with your actual API key
api_key = "YOUR_API_KEY"

response = requests.post(
    "https://api.vogent.ai/api/tts",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "text": "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.",
        "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a"  # The CSM-1B professional voice clone "Mabel"
    }
)

if response.status_code == 200:
    with open("my-first-voice.wav", "wb") as f:
        f.write(response.content)
    print("✅ Audio file saved as 'my-first-voice.wav'")
else:
    print(f"❌ Error: {response.status_code} - {response.text}")
```

```javascript
const apiKey = "YOUR_API_KEY";

async function generateVoice() {
    try {
        const response = await fetch('https://api.vogent.ai/api/tts', {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                text: "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.",
                voiceId: "23b2186b-ed56-4185-998c-8d19e1bb227a"  // The CSM-1B professional voice clone "Mabel"
            })
        });

        if (response.ok) {
            const audioBlob = await response.blob();
            const audioUrl = URL.createObjectURL(audioBlob);

            // Play the audio
            const audio = new Audio(audioUrl);
            audio.play();

            console.log("✅ Audio generated and playing!");
        } else {
            console.error("❌ Error:", response.status);
        }
    } catch (error) {
        console.error("❌ Network error:", error);
    }
}

generateVoice();
```

--------------------------------

### Python: Voice Pairing Guidelines Example

Source: https://docs.vogent.ai/voicelab/voice-synthesis/advanced-features

An example Python dictionary illustrating good voice pairing for a customer service scenario using the multispeaker TTS API. It shows how to assign different voice types (formal representative, casual customer) to lines for clarity and consistency. Requires the 'requests' library.

```python
# Good voice pairing example
customer_service_scenario = {
    "lines": [
        {"text": "Good morning, how may I help you?", "voiceId": "professional-female-1"},  # Formal representative
        {"text": "Hi, I need help with my account.", "voiceId": "conversational-male-1"},    # Casual customer
        {"text": "I'd be happy to assist you with that.", "voiceId": "professional-female-1"}  # Consistent representative
    ]
}
```

--------------------------------

### Create Multispeaker Conversation using Python and cURL

Source: https://docs.vogent.ai/voicelab/quickstart

This snippet shows how to create a conversation between multiple speakers using the Vogent AI API. It requires an API key and sends a JSON payload with text and voice IDs. The output is saved as a WAV file. This method is suitable for generating pre-recorded conversations.

```python
import requests

api_key = "YOUR_API_KEY"

# Create a conversation between two people
conversation = {
    "lines": [
        {
            "text": "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.",
            "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a"  # The CSM-1B professional voice clone "Mabel"
        },
        {
            "text": "That's interesting, was it actually like super realistic or was it just not robotic.",
            "voiceId": "50c9287d-bcee-4f2a-943f-f0f2184a5d3b"  # The CSM-1B professional voice clone "Kevin"
        },
        {
            "text": "I mean, it's hard to tell the difference from a real person speaking. The technology is incredible.",
            "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a"  # The CSM-1B professional voice clone "Mabel"
        },
        {
            "text": "Interesting, I've been looking for a new API to use in my app. I'll definitely check it out then.",
            "voiceId": "50c9287d-bcee-4f2a-943f-f0f2184a5d3b"  # The CSM-1B professional voice clone "Kevin"
        }
    ]
}

response = requests.post(
    "https://api.vogent.ai/api/tts/multispeaker",
    headers={"Authorization": f"Bearer {api_key}"},
    json=conversation
)

if response.status_code == 200:
    with open("conversation.wav", "wb") as f:
        f.write(response.content)
    print("✅ Conversation saved as 'conversation.wav'")
else:
    print(f"❌ Error: {response.status_code}")

```

```bash
curl -X POST "https://api.vogent.ai/api/tts/multispeaker" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "lines": [ { "text": "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.", "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a" }, { "text": "That'\''s interesting, was it actually like super realistic or was it just not robotic.", "voiceId": "50c9287d-bcee-4f2a-943f-f0f2184a5d3b" } ] }' \
  --output conversation.wav

```

--------------------------------

### Start Batch Dial Job via API (Bash)

Source: https://docs.vogent.ai/platform-overview/batch-dial-jobs

Start a previously created batch dial job that is in the 'INIT' state. This API call unpauses the job, allowing it to begin processing calls according to its schedule and configuration. Requires the job ID and API key.

```bash
curl -X POST "https://api.vogent.ai/api/batch_dial_jobs/{job-id}/paused" \
  -H "Content-Type: application/json" \
  -H "api_key: YOUR_API_KEY" \
  -d '{"paused": false}'
```

--------------------------------

### GET /models

Source: https://docs.vogent.ai/api-reference/list-models

Retrieves a list of AI models available on your account. Supports pagination using limit and cursor.

```APIDOC
## GET /models

### Description
List the models available on your account. Supports pagination.

### Method
GET

### Endpoint
/models

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - The maximum number of records to fetch. Defaults to 100.
- **cursor** (string) - Optional - The pagination cursor returned by the previous request. Feed the result provided by vogent verbatim.

### Request Example
```json
{
  "query": {
    "limit": 50,
    "cursor": "some_cursor_string"
  }
}
```

### Response
#### Success Response (200)
- **data** (array) - An array of AIModel objects.
- **cursor** (string) - A cursor for the next page of results, or null if no next page exists.

#### Response Example
```json
{
  "data": [
    {
      "id": "model_id_1",
      "name": "Model Name 1",
      "modelOptions": [
        {
          "id": "option_id_1",
          "name": "Option Name 1",
          "valueType": "STRING",
          "default": "default_value_1"
        }
      ]
    }
  ],
  "cursor": "next_cursor_string"
}
```

#### Error Responses
- **400** - Invalid input
- **422** - Validation exception
```

--------------------------------

### GET /voices

Source: https://docs.vogent.ai/api-reference/list-voices

Lists the AI voices available to the workspace. You can filter voices by name, voice type, and control pagination using limit and cursor.

```APIDOC
## GET /voices

### Description
Lists the AI voices available to the workspace.

### Method
GET

### Endpoint
/voices

### Parameters
#### Query Parameters
- **name** (string) - Optional - Filter voices by name.
- **voiceType** (string) - Optional - The provider (for third party voices), or model type (for Vogent hosted voices).
- **limit** (integer) - Optional - The maximum number of voices to return.
- **cursor** (string) - Optional - The pagination cursor returned by the previous request. Feed the result provided by vogent verbatim.

### Request Example
```json
{
  "example": ""
}
```

### Response
#### Success Response (200)
- **voices** (array) - A list of AI voices.
  - **id** (string) - The voice ID.
  - **name** (string) - The voice name.
  - **voiceType** (string) - The type of voice (provider or model).
  - **voiceTier** (VoiceTier) - The tier of the voice (STANDARD or PREMIUM).
  - **description** (string) - A description of the voice.
- **cursor** (string) - A cursor for fetching the next page of results. Null if no next page exists.

#### Response Example
```json
{
  "voices": [
    {
      "id": "voice-123",
      "name": "Standard Female",
      "voiceType": "vogent",
      "voiceTier": "STANDARD",
      "description": "A clear and neutral female voice."
    }
  ],
  "cursor": "next-page-cursor-abc"
}
```

#### Error Responses
- **400** - Invalid input
- **422** - Validation exception
```

--------------------------------

### POST /api/tts

Source: https://docs.vogent.ai/voicelab/quickstart

Generates audio from provided text using a specified voice ID. This endpoint is used for basic text-to-speech requests.

```APIDOC
## POST /api/tts

### Description
Generates audio from provided text using a specified voice ID. This endpoint is used for basic text-to-speech requests.

### Method
POST

### Endpoint
https://api.vogent.ai/api/tts

### Parameters
#### Request Body
- **text** (string) - Required - The text to be converted to speech.
- **voiceId** (string) - Required - The ID of the voice to use for generation.

### Request Example
```json
{
  "text": "So I tried this new thing called Voicelab that I found online, and the voices that it generated were super realistic.",
  "voiceId": "23b2186b-ed56-4185-998c-8d19e1bb227a"
}
```

### Response
#### Success Response (200)
- **audio** (file) - The generated audio file in WAV format.

#### Response Example
(Binary audio data)
```

--------------------------------

### POST /agents

Source: https://docs.vogent.ai/api-reference/create-agent

Creates a new agent with specified configurations for voice, prompts, and call behavior.

```APIDOC
## POST /agents

### Description
Creates a new agent. This endpoint allows for detailed configuration of an agent, including its name, default voice, prompts, call duration limits, and more.

### Method
POST

### Endpoint
https://api.vogent.ai/api/agents

### Parameters
#### Request Body
- **name** (string) - Required - The name of the agent.
- **defaultVoiceId** (string) - Required - The ID of the voice to use.
- **defaultVersionedPrompt** (object) - Required - The default versioned prompt to use for this agent. Refer to `CreateVersionedPromptInput` schema.
- **defaultExtractor** (object) - Optional - The default extractor to use for this agent. Refer to `CreateCallAgentExtractorInput` schema.
- **inboundWebhookResponse** (boolean) - Required - Specifies if inbound webhook responses are enabled.
- **inboundWebhookUrl** (string) - Required - The URL for inbound webhook responses.
- **maxDurationSeconds** (integer) - Optional - The maximum duration of the call in seconds. Defaults to 10800.
- **openingLine** (object) - Optional - Details about the Agent's opening line. If unspecified, or null no opening line will be created.
  - **lineType** (object) - Required - An indication of when the opening line should be used. Refer to `OpeningLineType` schema.
  - **content** (string) - Required - The content of the opening line.
- **voiceVolumeLevel** (integer) - Optional - A value, generally between -300 and 300, indicating the volume level to use for the voice. The default is -100.
- **backgroundNoiseType** (string) - Optional - The background audio that's used by the agent. Enum: `noise`, `office`, `silence`. Defaults to `office`.
- **linkedFunctionDefinitionIds** (array) - Optional - The function definitions that should be available to this agent (deprecated, use linkedFunctionDefinitionInputs instead).
  - items: (string)
- **linkedFunctionDefinitionInputs** (array) - Optional - The function definitions that should be available to this agent with optional lifecycle message overrides. Refer to `LinkedFunctionDefinition` schema.
  - items: (object)
- **metadata** (object) - Optional - Custom metadata for the agent.
- **transcriberParams** (object) - Optional - Parameters for the transcriber. Refer to `TranscriberParams` schema.
- **idleMessageConfig** (object) - Optional - Configuration for idle messages. Refer to `IdleMessageConfig` schema.
- **utteranceDetectorConfig** (object) - Optional - Configuration for utterance detection. Refer to `UtteranceDetectorConfig` schema.
- **endpointDetectorConfig** (object) - Optional - Configuration for endpoint detection to determine when a user has finished speaking. If not specified, will default to a semantic detector in the default mode. Refer to `EndpointDetectorConfig` schema.
- **ivrConfiguration** (object) - Optional - The configuration for IVR detection and navigation including detection type, prompt, voice, and tagging settings. Refer to `IVRConfiguration` schema.
- **language** (string) - Optional - The language to use for the agent. Defaults to `en`.
- **fillEmptyStringVariables** (boolean) - Optional - Placeholder for future use.

### Request Example
```json
{
  "name": "Customer Support Bot",
  "defaultVoiceId": "voice_abc123",
  "defaultVersionedPrompt": {
    "versionId": "v1",
    "prompt": "You are a helpful assistant."
  },
  "inboundWebhookResponse": false,
  "inboundWebhookUrl": "",
  "maxDurationSeconds": 7200,
  "backgroundNoiseType": "silence",
  "language": "en"
}
```

### Response
#### Success Response (200)
- **Agent** (object) - Details of the created agent. Refer to `Agent` schema.

#### Response Example
```json
{
  "agentId": "agent_xyz789",
  "name": "Customer Support Bot",
  "createdAt": "2023-10-27T10:00:00Z"
}
```
```

--------------------------------

### VogentCall Constructor

Source: https://docs.vogent.ai/sdk/web-sdk

Initializes a new VogentCall instance with the necessary session and call identifiers, and an authentication token.

```APIDOC
## VogentCall Constructor

### Description
Initialize a new call instance with session, dial, and authentication details.

### Method
`new VogentCall(options)`

### Parameters
#### Request Body
- **sessionId** (string) - Required - Unique identifier for the session
- **dialId** (string) - Required - Unique identifier for the dial/call
- **token** (string) - Required - Authentication token (dial token)

### Request Example
```typescript
const call = new VogentCall({
  sessionId: "your_session_id",
  dialId: "your_dial_id",
  token: "your_dial_token"
});
```

### Response
#### Success Response (200)
N/A (Constructor does not return a value, it initializes an object)

#### Response Example
N/A
```

--------------------------------

### CreateVersionedPromptInput Object Definition

Source: https://docs.vogent.ai/api-reference/create-agent

Defines the structure for input when creating a versioned prompt.

```APIDOC
## CreateVersionedPromptInput Object Definition

### Description
Defines the structure for input when creating a versioned prompt.

### Properties
- **aiModelId** (string) - Required - The ID of the AI model to use.
- **agentType** (AgentType) - Required - The type of agent this prompt represents.
- **prompt** (string) - Optional - The prompt content.
- **flowDefinition** (FlowDefinitionInput) - Required - The flow definition for CUSTOM_FLOW agents.
- **name** (string) - Required - The name of the versioned prompt.
- **modelOptionValues** (array) - Optional - Model option values for the prompt.
```

--------------------------------

### GET /phone_numbers/{id}

Source: https://docs.vogent.ai/api-reference/get-phone-number

Retrieves a specific phone number by its ID.

```APIDOC
## GET /phone_numbers/{id}

### Description
Retrieve a phone number by its unique identifier.

### Method
GET

### Endpoint
`/phone_numbers/{id}`

### Parameters
#### Path Parameters
- **id** (string) - Required - ID of the phone number to retrieve.

### Request Example
```json
{
  "example": ""
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the phone number.
- **number** (string) - The phone number in E.164 format or SIP username.
- **type** (PhoneNumberType) - The type of the phone number (e.g., PSTN, SIP_USERNAME).
- **agentId** (string) - Optional - The ID of the linked agent, if any.

#### Response Example
```json
{
  "id": "phone_123abc",
  "number": "+18001234567",
  "type": "PSTN",
  "agentId": "agent_xyz789"
}
```

#### Error Responses
- **400** - Invalid input.
- **422** - Validation exception.
```

--------------------------------

### POST /api/batch_dial_jobs/{job-id}/paused

Source: https://docs.vogent.ai/platform-overview/batch-dial-jobs

Starts or pauses a batch dial job. Setting `paused` to `false` will start the job.

```APIDOC
## POST /api/batch_dial_jobs/{job-id}/paused

### Description
Starts or pauses a batch dial job. Setting `paused` to `false` will start the job.

### Method
POST

### Endpoint
/api/batch_dial_jobs/{job-id}/paused

### Parameters
#### Path Parameters
- **job-id** (string) - Required - The ID of the batch dial job.

#### Request Body
- **paused** (boolean) - Required - Set to `false` to start the job, `true` to pause it.

### Request Example
```json
{
  "paused": false
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.

#### Response Example
```json
{
  "message": "Job state updated successfully."
}
```
```

--------------------------------

### VogentCall Methods

Source: https://docs.vogent.ai/sdk/web-sdk

Provides essential methods for managing the call lifecycle, including starting, connecting audio, monitoring transcripts, pausing AI, and ending the call.

```APIDOC
## VogentCall Methods

### `start()`

#### Description
Initiates the call session.

#### Method
`call.start()`

#### Endpoint
N/A (Method on VogentCall instance)

#### Parameters
None

#### Request Example
```typescript
await call.start();
```

#### Response
##### Success Response (200)
- **N/A** (void)

##### Response Example
N/A

***

### `connectAudio()`

#### Description
Establishes the audio connection for the call.

#### Method
`call.connectAudio()`

#### Endpoint
N/A (Method on VogentCall instance)

#### Parameters
None

#### Request Example
```typescript
const audioConnection = await call.connectAudio();
```

#### Response
##### Success Response (200)
- **audioConnection** (AudioConnection) - Represents the established audio connection.

##### Response Example
```json
{
  "status": "connected"
}
```

***

### `monitorTranscript(callback)`

#### Description
Monitors the call transcript in real-time, invoking a callback function with transcript updates.

#### Method
`call.monitorTranscript(callback)`

#### Endpoint
N/A (Method on VogentCall instance)

#### Parameters
#### Request Body
- **callback** (function) - Required - Function called with transcript updates. Receives an array of `TranscriptItem` objects.

**TranscriptItem Object:**
- **text** (string) - The transcribed text.
- **speaker** (string) - Speaker identifier (e.g., "user", "agent").

#### Request Example
```typescript
const unsubscribe = call.monitorTranscript((transcript) => {
  transcript.forEach(({ text, speaker }) => {
    console.log(`${speaker}: ${text}`);
  });
});
```

#### Response
##### Success Response (200)
- **unsubscribe** (function) - A function to call to stop monitoring transcripts.

##### Response Example
N/A

***

### `setPaused(paused)`

#### Description
Pauses or resumes AI interaction during the call.

#### Method
`call.setPaused(paused)`

#### Endpoint
N/A (Method on VogentCall instance)

#### Parameters
#### Request Body
- **paused** (boolean) - Required - `true` to pause AI interaction, `false` to resume.

#### Request Example
```typescript
await call.setPaused(true); // Pause AI
await call.setPaused(false); // Resume AI
```

#### Response
##### Success Response (200)
- **N/A** (void)

##### Response Example
N/A

***

### `hangup()`

#### Description
Ends the call session.

#### Method
`call.hangup()`

#### Endpoint
N/A (Method on VogentCall instance)

#### Parameters
None

#### Request Example
```typescript
await call.hangup();
```

#### Response
##### Success Response (200)
- **N/A** (void)

##### Response Example
N/A

***
```

--------------------------------

### OpenAPI Specification for Get Phone Number

Source: https://docs.vogent.ai/api-reference/get-phone-number

This OpenAPI 3.0 specification defines the GET /phone_numbers/{id} endpoint. It details how to request a specific phone number by its ID, including required parameters, possible responses (success and error codes), and the structure of the PhoneNumber schema.

```yaml
openapi: 3.0.3
info:
  title: Vogent - OpenAPI 3.0
  description: Test Description
  version: 1.0.11
servers:
  - url: https://api.vogent.ai/api
security:
  - bearerAuth: []
paths:
  /phone_numbers/{id}:
    parameters:
      - in: path
        name: id
        schema:
          type: string
        required: true
        description: ID of the versioned prompt.
    get:
      summary: Get Phone Number
      description: Retrieve a phone number
      operationId: getPhoneNumber
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PhoneNumber'
        '400':
          description: Invalid input
        '422':
          description: Validation exception
components:
  schemas:
    PhoneNumber:
      type: object
      properties:
        id:
          type: string
        number:
          type: string
          example: '+18001234567'
          description: >-
            The number in e.164 format, or the SIP username, if the type is
            SIP_USERNAME.
        type:
          $ref: '#/components/schemas/PhoneNumberType'
        agentId:
          type: string
          nullable: true
          description: The ID of the linked agent, if the phone number is linked to one.
      required:
        - id
        - number
        - agentId
        - type
    PhoneNumberType:
      type: string
      enum:
        - PSTN
        - SIP_USERNAME
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        In the form `Bearer <api_key_here>`. You can find your api key in your
        dashboard.

```

--------------------------------

### Example Dial Extractor Payload

Source: https://docs.vogent.ai/developers/webhooks/dial-extractor

An example of the JSON payload received when the dial extractor completes. It includes the event type, dial ID, and the AI extraction results.

```json
{
    "event": "dial.extractor",
    "payload": {
        "ai_result": {
            "summary": "This call was successful in getting the information."
        },
        "dial_id": "5a6c6190-db20-4d8e-86a9-79a6af292dea"
    }
}
```

--------------------------------

### POST /tts - Run TTS Model

Source: https://docs.vogent.ai/api-reference/run-tts-model

Runs a text to speech model and generates audio. Audio bytes are streamed to the client as they are generated.

```APIDOC
## POST /tts

### Description
Runs a text to speech model and generates audio. Bytes will be streamed to the client as they are generated.

### Method
POST

### Endpoint
/tts

### Parameters
#### Query Parameters
None

#### Request Body
- **text** (string) - Required - The text to generate.
- **voiceId** (string) - Required - The voice ID to use to generate the text.
- **voiceOptionValues** (array) - Optional - An optional configuration for the voice being used.
  - **optionId** (string) - Required - The ID of option.
  - **value** (string) - Required - The value for the option.
- **format** (object) - Optional - The output format for the generated audio. Defaults to WAV_PCM16 at 24000 Hz.
  - **outputType** (string) - Required - The type of output format. Enum: RAW_PCM16, WAV_PCM16, MP3.
  - **sampleRate** (integer) - Required - The sample rate for the audio output. Must be one of 8000, 16000, 22050, 24000, 41500, or 48000.

### Request Example
```json
{
  "text": "Hello, this is a test.",
  "voiceId": "example-voice-id",
  "format": {
    "outputType": "WAV_PCM16",
    "sampleRate": 24000
  }
}
```

### Response
#### Success Response (200)
- **Binary Audio Data** (binary) - Returns a file with the audio.

#### Error Responses
- **400** - Invalid input
- **422** - Validation exception

#### Response Example
(Binary audio data stream)
```

--------------------------------

### Get Agent Versioned Prompt OpenAPI Definition (YAML)

Source: https://docs.vogent.ai/api-reference/get-versioned-prompt

This YAML snippet defines the OpenAPI 3.0 specification for the GET endpoint '/agents/{agentId}/versioned_prompts/{id}'. It details the path parameters, the GET operation's summary, description, operation ID, and possible responses (200, 400, 422). It also includes the schemas for VersionedPrompt and its related components.

```yaml
openapi: 3.0.3
info:
  title: Vogent - OpenAPI 3.0
  description: Test Description
  version: 1.0.11
servers:
  - url: https://api.vogent.ai/api
security:
  - bearerAuth: []
paths:
  /agents/{agentId}/versioned_prompts/{id}:
    parameters:
      - in: path
        name: agentId
        schema:
          type: string
        required: true
        description: ID of the agent.
      - in: path
        name: id
        schema:
          type: string
        required: true
        description: ID of the versioned prompt.
    get:
      summary: Get versioned prompt
      description: Gets a specific versioned prompt for a given agent.
      operationId: getAgentVersionedPrompt
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VersionedPrompt'
        '400':
          description: Invalid input
        '422':
          description: Validation exception
components:
  schemas:
    VersionedPrompt:
      type: object
      properties:
        id:
          type: string
          nullable: false
          description: Unique identifier for the versioned prompt
        name:
          type: string
          nullable: false
          description: Human-readable name for the versioned prompt
        agentType:
          $ref: '#/components/schemas/AgentType'
          description: >-
            The type of agent this prompt is designed for (STANDARD or
            CUSTOM_FLOW)
        prompt:
          type: string
          nullable: true
          description: >-
            The actual prompt content that will be used by the agent. Can be
            null for CUSTOM_FLOW agent types
        flowDefinition:
          $ref: '#/components/schemas/FlowDefinition'
          nullable: true
          description: >-
            The flow definition for the agent. Only defined for CUSTOM_FLOW
            agent types.
        aiModelId:
          type: string
          description: The AI model ID to use for the agent.
        modelOptionValues:
          x-go-type-skip-optional-pointer: true
          type: array
          items:
            $ref: '#/components/schemas/ModelOptionValue'
      required:
        - id
        - name
        - agentType
        - prompt
    AgentType:
      type: string
      enum:
        - STANDARD
        - CUSTOM_FLOW
    FlowDefinition:
      type: object
      properties:
        nodes:
          type: array
          items:
            $ref: '#/components/schemas/ApiFlowNode'
          nullable: false
        globalContext:
          type: string
          nullable: true
        aiOpen:
          type: boolean
          nullable: false
          description: Deprecated, use openingLineType instead.
        openingLineType:
          $ref: '#/components/schemas/OpeningLineType'
          nullable: false
      required:
        - nodes
        - globalContext
        - aiOpen
        - openingLineType
    ModelOptionValue:
      type: object
      description: >-
        A configuration value for the model. You can get a list of available
        models and their configuration values from /models. All configuration
        values, with defaults will be returned when you retrieve a versioned
        prompt.
      properties:
        optionId:
          type: string
          description: The ID of option.
          nullable: false
        value:
          type: string
          nullable: false
      required:
        - optionId
        - value
    ApiFlowNode:
      type: object
      properties:
        id:
          type: string
          nullable: false
        name:
          type: string
          nullable: false
        type:
          type: string
          nullable: false
          description: >-
            The node type. View the available types at
            https://docs.vogent.ai/flow.
        transitionRules:
          type: array
          items:
            $ref: '#/components/schemas/FlowTransitionRule'
          nullable: false
          x-go-type-skip-optional-pointer: true
        outputSchema:
          type: string
          nullable: true
          description: >-
            The JSON schema describing the output of this node. This is
            generated automatically from the node type and node data.
        nodeData:
          type: object
          nullable: false
          description: >-
            The node-specific configuration. View the schemas by type at
            https://docs.vogent.ai/flow.
      required:
        - id
        - name
        - type
        - transitionRules
        - nodeData
    OpeningLineType:
      type: string
      enum:
        - INBOUND_ONLY
        - INBOUND_OUTBOUND
        - NONE
    FlowTransitionRule:
      type: object
      properties:
        conditionType:

```

--------------------------------

### Agent Configuration Schema

Source: https://docs.vogent.ai/api-reference/list-batch-dials

Defines the structure for configuring an agent, including default settings and linked functions.

```APIDOC
## Agent Configuration Schema

### Description
Represents the configuration for an AI agent, including its default prompt and extractor IDs, linked function definitions, and behavior for handling empty string variables.

### Properties

- **id** (string) - Required - The unique identifier for the agent.
- **name** (string) - Required - The name of the agent.
- **language** (string) - Required - The primary language the agent operates in.
- **defaultPromptId** (string) - Optional - The default versioned prompt ID to use for the agent.
- **defaultExtractorId** (string) - Optional (nullable) - The default extractor ID to use for the agent.
- **linkedFunctionDefinitions** (array) - Optional - An array of `LinkedFunctionDefinition` objects that should be available to this agent.
- **fillEmptyStringVariables** (boolean) - Optional - If true, variables that are not specified will be filled with empty strings instead of being left as template placeholders.
```

--------------------------------

### Utterance Detector Configuration

Source: https://docs.vogent.ai/api-reference/create-agent

Configure the utterance detector settings, which determine how the system detects user speech. This includes setting the sensitivity level.

```APIDOC
## POST /websites/vogent_ai/config/utterance_detector

### Description
Configures the utterance detector sensitivity for an agent.

### Method
POST

### Endpoint
/websites/vogent_ai/config/utterance_detector

### Parameters
#### Request Body
- **sensitivity** (string) - Required - The sensitivity level for the utterance detector. Allowed values: ULTRA_FAST, FAST, MEDIUM, SLOW.

### Request Example
```json
{
  "sensitivity": "FAST"
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.

#### Response Example
```json
{
  "message": "Utterance detector configuration updated successfully."
}
```
```

--------------------------------

### Example Dial Recording Created Webhook Payload

Source: https://docs.vogent.ai/developers/webhooks/dial-recording

This is an example of the JSON payload received when a new dial recording is created. It includes the event type and the details of the recording, such as the recording URL and the associated dial ID.

```json
{
    "event": "dial.recording_created",
    "payload": {
        "recording_url": "https://api.getelto.com/api/recordings/de3ee23e-ce58-4e05-9e7b-fcb96ba440a6",
        "dial_id": "5a6c6190-db20-4d8e-86a9-79a6af292dea"
    }
}
```

--------------------------------

### Example Dial Status Updated Webhook Payload

Source: https://docs.vogent.ai/developers/webhooks/dial-status-updated

This example demonstrates the JSON payload received when a dial status is updated. It includes the event type and the specific details of the update, such as session ID, dial ID, and the new status.

```json
{
    "event": "dial.updated",
    "payload": {
        "dial_session_id": "de3ee23e-ce58-4e05-9e7b-fcb96ba440a6",
        "dial_id": "5a6c6190-db20-4d8e-86a9-79a6af292dea",
        "status": "completed"
    }
}
```

--------------------------------

### VogentCall: connectAudio() Method

Source: https://docs.vogent.ai/sdk/web-sdk

Establishes the audio connection for the call, enabling real-time audio streaming.

```typescript
const audioConnection = await call.connectAudio();
```

--------------------------------

### Inbound Dial Webhook Example Response (JSON)

Source: https://docs.vogent.ai/developers/webhooks/dial-inbound

An example of a JSON response that can be sent back to the inbound dial webhook to pre-fill agent parameters and provide keywords. This response must be sent within 3 seconds.

```json
{
    "call_agent_input": {
        "name": "John Doe"
    },
    "keywords": ["John", "Doe"]
}
```
Tokens:
Raw