{isOnHold ? (
) : (
)}
);
}
```
# Speak First
Source: https://docs.outspeed.com/features/speak-first
Control whether the agent initiates conversation or waits for user input
## Overview
The `first_message` field allows your AI agent to start the conversation automatically with a predefined greeting, instead of waiting for the user to speak first.
## Basic Usage
Add `first_message` to your session configuration:
```javascript
const sessionConfig = {
// rest of config...
first_message: "Hello! How can I help you today?",
};
```
When the session starts, the agent will immediately speak this message to greet the user.
## Examples
### Professional Assistant
```javascript
first_message: "Good morning! I'm your AI assistant. What can I help you with today?"
```
### Customer Support
```javascript
first_message: "Hi there! Welcome to our support chat. How can I assist you?"
```
### Interview Bot
```javascript
first_message: "Hello! I'm excited to conduct your interview today. Shall we get started?"
```
### Casual Companion
```javascript
first_message: "Hey! Great to see you. What's on your mind?"
```
## Best Practices
* **Keep it brief**: Short, welcoming messages work best
* **Match your brand**: Use language that fits your application's tone
* **Stay consistent**: Use similar greetings across sessions
## Optional Field
The `first_message` field is optional. If you don't include it, the session will start in listening mode, waiting for the user to speak first.
# System Tools
Source: https://docs.outspeed.com/features/system-tools
Pre-built tools that run on Outspeed's servers for conversation management
## Overview
System tools are pre-built tools that run on Outspeed's servers. They handle common conversation management tasks and require no implementation on your part - simply enable them in your session configuration.
System tools help agents manage conversation flow intelligently:
* **Server-side execution**: No client-side implementation needed
* **Automatic decisions**: Agents call tools based on conversation context
* **Override capabilities**: Customize tool behavior with custom descriptions
* **Zero maintenance**: Tools are maintained and updated by Outspeed
## Available System Tools
### Skip turn
Allows agents to intelligently skip their speaking turn when users aren't directly addressing them.
**Use Cases:**
* User is singing or humming
* Background conversations
* User talking to someone else
* Self-talk or thinking aloud
👉 **[Learn about Skip Turn →](skip-turn)**
### End session
Enables agents to gracefully terminate conversations when users explicitly say goodbye.
**Use Cases:**
* User says "goodbye", "bye", "farewell"
* Clear conversation conclusion
* Explicit requests to end the call
👉 **[Learn about End Session →](end-session)**
## Basic sonfiguration
Enable system tools in your session configuration:
```javascript
const sessionConfig = {
// rest of config...
system_tools: [
{ name: "skip_turn", enabled: true },
{ name: "end_call", enabled: true }
],
};
```
## Override tool descriptions
You can customize how system tools behave by overriding their descriptions:
```javascript
const sessionConfig = {
// rest of config...
system_tools: [
{
name: "skip_turn",
enabled: true,
description: "Skip turns more conservatively - only when user is clearly singing or talking to others",
parameter_descriptions: {
reason: "Specific reason for skipping (singing or talking to others only)",
},
},
{
name: "end_call",
enabled: true,
description: "End calls only on very explicit goodbye phrases like 'goodbye' or 'bye'",
parameter_descriptions: {
farewell_message: "Brief, professional farewell message",
reason: "Specific goodbye phrase that triggered the end",
},
}
],
};
```
## Best practices
### When to enable
* **Skip Turn**: Recommended for most applications to handle natural conversation flow
* **End Session**: Essential for applications where users initiate call termination
### Override examples
**More Restrictive Skip Turn:**
```javascript
{
name: "skip_turn",
description: "Only skip when absolutely certain user is not addressing the agent",
parameter_descriptions: {
reason: "Very specific reason with high confidence",
},
}
```
**More Permissive End Session:**
```javascript
{
name: "end_call",
description: "End calls when users show any sign of wanting to conclude",
parameter_descriptions: {
farewell_message: "Warm, understanding farewell",
reason: "Any indication user wants to end conversation",
},
}
```
## Troubleshooting
### Tools not working
1. **Check configuration**: Ensure tools are properly enabled
2. **Verify session**: Confirm tools are included in session config
3. **Review logs**: Check for error messages in session events
### Unexpected behavior
1. **Monitor context**: Review conversation context when tools trigger
2. **Adjust descriptions**: Override tool descriptions to fine-tune behavior
3. **System prompt**: Ensure your system prompt doesn't conflict with tool usage
### Performance impact
* System tools have minimal performance impact
* No client-side processing required
* Server-side execution is optimized and fast
# Tool Use
Source: https://docs.outspeed.com/features/tool-use
Enable AI agents to use external tools and APIs during conversations
## Overview
Tools extend your AI agents with external capabilities, allowing them to interact with APIs, perform actions, and access real-time information during voice conversations.
## Tool Types
Embed voice in your mobile or web app
Outspeed helps you add a voice interface to your mobile and web apps. Build an empathetic therapist, a chatty companion or a professional AI interviewer: possibilities are endless.
Templates
Capabilities
Voice session active!
Start talking to your AI assistant
Voice AI Assistant
Click the button to start talking
Connecting...
Please wait while we establish the connection.
🎙️ Voice Chat Active
You can now speak with the AI assistant!
Voice AI Assistant
Click the button below to start a voice conversation.
{/* ... other components */}
);
```
### Mute Control
Control the microphone state by passing `micMuted` prop to `useConversation`:
```tsx
const [isMicMuted, setIsMicMuted] = useState(false);
const conversation = useConversation({
micMuted: isMicMuted,
});
const toggleMute = () => {
setIsMicMuted(!isMicMuted);
};
return (
{/* ... other components */}
);
```
### Volume Control
Control the AI's voice volume by passing `volume` prop to `useConversation` (value between 0 and 1):
```tsx
const [volume, setVolume] = useState(0.8);
const conversation = useConversation({
volume: volume,
});
return (
{/* ... other components */}
);
```
## Complete Example with Error Handling
Here's a more complete example showing proper error and disconnect handling:
```tsx
const [error, setError] = useState❌ Error
{error}