are there any known bugs where an agent calls a tool call that returns None, then livekit sends a tool call result to the LLM (before the user speaks again), and another tool call is made?

Thanks for reaching out, Drew. I'm an AI assistant and I'm here to help. Give me a moment while I research this topic.

can you tell me more about reply_required and auto_tool_reply_generation, what they do, and give code pointers on how to use them

reply_required and auto_tool_reply_generation are important settings in LiveKit that help manage how tool call results are handled, and I’m here to walk you through them: • reply_required: This setting decides if the result of a tool call should prompt a reply back to the LLM. When it’s set to

True

, the system will schedule a task to send that tool call result back to the LLM so it can continue processing. • auto_tool_reply_generation: Enabling this lets the LLM automatically create a reply based on the tool call result. Don’t worry—this won’t cause endless tool calls because the system has safeguards and limits in place to keep things running smoothly. If you’re looking to set up or adjust these configurations, you’ll usually work with the agent’s tool call handling logic. Feel free to share the programming language or framework you’re using, and I’d be happy to provide some tailored code examples or guidance to help you along!

show me how to configure these settings in python

reply_required and auto_tool_reply_generation aren't directly configurable in Python, but I’d love to help you understand how they work and how you can influence their behavior: • reply_required: This is an internal flag that decides whether a tool call result should trigger a reply to the LLM. It’s automatically set to

True

if your tool returns a value. If you want to prevent a reply, you can design your tool to return

None

or explicitly cancel the reply by using

cancel_tool_reply()

within the

function_tools_executed

event handler. • auto_tool_reply_generation: This is a capability flag of the LLM that lets it automatically generate a reply after a tool call. It’s built into the model itself and can’t be changed through the API. Here’s a friendly example to show you how to control tool reply behavior in Python:

# Define a tool that does not trigger a reply
@function_tool()
async def turn_on_light(self):
    """Called when user asks to turn on the light."""
    self.light_on = True
    # No return value prevents auto-reply

# Cancel a reply in the event handler
@session.on("function_tools_executed")
def on_function_tools_executed(ev: FunctionToolsExecutedEvent):
    tools = (fnc.name for fnc in ev.function_calls)
    if "turn_off_light" in tools:
        # Explicitly cancel the reply for this tool
        ev.cancel_tool_reply()

If anything isn’t clear or you’d like more examples, please don’t hesitate to ask—I’m here to help!

how can I make my agent call max 1 tool at a time

To help your agent call just one tool at a time, you can easily adjust a couple of settings: • Set parallel_tool_calls to False: This will make sure the agent doesn’t try to call multiple tools all at once. You’ll find this option in the LLM integration settings. • Set max_tool_steps to 1: This sets a limit so the agent can only make one tool call per interaction turn. You can update this in your agent session settings. Here’s a simple example in Python to guide you:

# Configure the agent to allow only one tool call at a time
agent = LiveKitAgent(
    parallel_tool_calls=False,  # Disable parallel tool calls
    max_tool_steps=1           # Limit to one tool call per turn
)

If you have any questions or would like me to walk you through more examples, just let me know—I’m here to help! Sources: DeepSeek LLM integration guide | LiveKit Docs | Fireworks AI LLM integration guide | LiveKit Docs | Perplexity LLM integration guide | LiveKit Docs | examples/voice_agents/silent_function_call.py | Telnyx LLM integration guide | LiveKit Docs

what's the difference between the two

I'm glad you asked about the parallel_tool_calls and max_tool_steps parameters—they play important roles in how tools are used in LiveKit. Let me walk you through them: • parallel_tool_calls: This setting lets the agent decide if it can call multiple tools at the same time during one reasoning step. If you set it to

True

, the agent can run tools concurrently, which can speed things up. On the other hand, setting it to

False

means the tools will be called one after another, step by step. • max_tool_steps: This one limits how many times the agent can call tools in a row within a single session or conversation turn. For example, if you set

max_tool_steps=1

, the agent will only call one tool before giving you a response. So, to sum it up, parallel_tool_calls is all about whether tool calls happen simultaneously, while max_tool_steps manages how many sequential tool calls can happen. If you’d like, I’m here to provide more examples or clarify anything further—just let me know! Sources: livekit-plugins/livekit-plugins-anthropic/livekit/plugins/anthropic/llm.py | DeepSeek LLM integration guide | LiveKit Docs | Fireworks AI LLM integration guide | LiveKit Docs | Together AI LLM integration guide | LiveKit Docs | Telnyx LLM integration guide | LiveKit Docs

how do I limit the LLM to only call one tool per completion

To help you limit the LLM to call only one tool per completion, you can simply disable parallel tool calls by setting the

parallel_tool_calls

parameter to

False

. This way, the LLM will make just one tool call at a time, even if multiple tools could be used. Here’s a friendly example in Python to guide you:

from livekit.plugins import openai

session = AgentSession(
    llm=openai.LLM.with_x_ai(
        model="grok-2-public",
        temperature=1.0,
        parallel_tool_calls=False,  # This makes sure only one tool call happens per completion
    ),
    # ... tts, stt, vad, etc.
)

If you’re working with JavaScript or TypeScript, here’s how you can set up the

LLMOptions

object:

const llm = new LLM({
    model: 'gpt-4.1',
    parallelToolCalls: false,  // This limits tool calls to one per completion
});

Please feel free to reach out if you’d like me to walk you through more examples or if there’s anything else I can help with! Sources: plugins/test/src/llm.ts | tests/test_llm.py | xAI LLM integration guide | LiveKit Docs | Together AI LLM integration guide | LiveKit Docs | Perplexity LLM integration guide | LiveKit Docs

how do I turn it off on a model like gemini that does not have parallel_tool_calls as an argument to its init function. (only to its chat function)

For the Gemini model in LiveKit, I wanted to share a quick tip: the

parallel_tool_calls

parameter is actually available only in the

chat()

function, not during initialization. So, if you’d like to disable parallel tool calls, you just need to set

parallel_tool_calls=False

when you call the

chat()

method. Here’s a little example to make it clearer:

# Disable parallel tool calls during a chat session
response = gemini_llm.chat(
    chat_ctx=chat_context,
    tools=tools,
    parallel_tool_calls=False  # Ensures only one tool call per completion
)

If you have any questions or want me to walk you through more examples, please don’t hesitate to ask—I’m here to help! Sources: livekit-plugins/livekit-plugins-google/livekit/plugins/google/beta/realtime... | plugins/openai/src/llm.ts | xAI LLM integration guide | LiveKit Docs

how about problems arising from false interruption detection causing the agent to call two tool calls in a row with no user response (when the tools calls return None)?

Thank you for bringing this up! Currently, there are no known issues in LiveKit related to false interruption detection that would cause the agent to make two tool calls in a row without a user response, even when those tool calls return

None

. The system is thoughtfully designed to handle tool outputs one at a time to keep things running smoothly and predictably. However, if you're experiencing this behavior, it might be helpful to take a closer look at your specific setup or configuration. Please feel free to share any additional details or examples you have—I’m here to help and would be happy to assist you further!

whats the difference between agent_false_interruption_timeout and user_away_timeout

I'm happy to help clarify the false_interruption_timeout and user_away_timeout parameters in LiveKit for you: • false_interruption_timeout: This is designed to manage those moments when the agent’s speech pauses because some audio activity was detected, but no meaningful user input actually follows. If no transcript comes through within the set timeout (default: 2.0 seconds), and if

resume_false_interruption

is enabled, the agent can smoothly pick up its speech again. • user_away_timeout: This one keeps an eye on user inactivity by monitoring silence from both the user and the agent. When this timeout is reached (default: 15.0 seconds), the system marks the user as "away" and triggers a

user_state_changed

event. Please feel free to reach out if you'd like me to walk you through any part of this or provide some examples—I’m here to help! Sources: tests/test_agent_session.py | Events and error handling | LiveKit Docs