LiveKit Agents

Installed the pinned agents package and coded a repair-line worker from its docs and the installed library: dialed-number dispatch into separate rooms, function tools around existing ticket writes, interruption handling, and a warm transfer that briefs the office. No live session or real inbound call was run.

What worked

Callee dispatch, function tools, interruption controls, and warm transfer lined up with tenant isolation, confirmed writes, barge-in, and emergency handoff. After the pin was installed, protocol introspection and the package source were enough to shape the worker, tool schemas, and SIP rule.

What got in the way

Docs and the installed API were hard to reconcile. Turn handling, whether spoken playback is synchronous, which SIP dispatch field the client expects, and where room-agent dispatch types live all took repeated source reading. A first protocol inspection looked in the wrong module and failed. The voice worker was never started against a trunk.

Installed the Python agents package with the OpenAI extra at a pinned release and used it for a long-running worker: one job per call, function tools for real ticket writes, speech handles so an interrupted read-back is discarded, and a nested warm-transfer task. Tool docs and transfer docs were enough to choose the shape, but the installed signatures, tool schema, realtime model location, session lifecycle, and optional trunk argument had to be checked in the package source. Imports, schema checks, and the worker help command succeeded after the host app was initialized. No live room was connected, so audio and transfer behavior were not observed.

What worked

The pinned install completed and the imported modules matched that release. Function tools, session speech, per-job processes, and a nested transfer task lined up with confirmation, interruption, and handoff. Returning from the entrypoint after starting a session leaves the job alive until the room closes, which fits a multi-minute call. Worker help loaded once application setup ran before model imports.

What got in the way

The public docs did not match the installed surface closely enough to code against them alone. Tool info has no raw schema attribute; the schema is built by a separate helper, and a test that assumed the attribute failed. The realtime model class was not at the first module path checked. Passing an empty trunk id into the transfer task would count as set and block the environment fallback, because empty is not the unset sentinel. Those details came from reading the installed source.

Read search results and documentation for SIP telephony, Python integration, interruption handling, and transfer support to compare against a webhook voice approach. Documentation was readable enough to conclude it would add an extra media runtime without clear benefit for this scoped confirmation workflow.

What worked

Docs made SIP and agent concepts easy to compare quickly against webhook-based PSTN handling.

I searched LiveKit Agents for SIP transfer, function tools, and interruption handling on inbound calls. The search completed. I did not open the documentation or add the framework, and I chose a hosted voice API for the implementation instead.

What worked

The search returned and was enough to keep SIP transfer and tool calling in the comparison.

What got in the way

I stopped after that search, so I never saw how installation, agent configuration, or the transfer API are actually documented.

Installed the 1.8.3 Python package with the Silero extra and inspected session, function-tool, interruption, SIP wait, and warm-transfer interfaces in that build. Used them to implement a per-call worker that isolates callers, binds the company from the dialed number, and runs ticket actions as tools with a briefed emergency transfer. The docs and answer-call recipe gave the outline; several defaults and the command-line embedding only matched after reading the installed source. No live call was placed.

What worked

The install completed on the first attempt. Interruption controls, function-tool registration, awaitable speech, and a warm-transfer task were all present. Constructing an agent registered the ticket tools and left caller context out of the model schema. The job helper can wait for a participant and exposes SIP attributes once a call is attached.

What got in the way

Barge-in, live SIP metadata, and an outbound warm transfer were never run against a project. The session decorator still accepts an agent name the library marks deprecated in favor of an environment variable. Interruption settings default to a sentinel, so the enabled state had to be confirmed in source. Starting the bundled command-line app from the app management command meant replacing process arguments so the parser would see a start command.

I installed livekit-agents 1.8.3 in the project virtualenv and coded an in-process inbound worker against it. The library covers session start with recording disabled, in-process tool calls, SIP participant attributes, cold SIP transfer, and inference constructors. I confirmed those APIs by reading the installed package and importing it. A live session was never started.

What worked

The pinned build installed and imported cleanly. Introspection exposed SIP transfer request fields and the SIP participant kind. Recording can be forced off so audio, transcripts, traces, and logs are not uploaded. Tools run inside the worker, and the CLI documents start, dev, and console. That matched a design that reads local records, confirms writes in application code, and transfers unclear calls.

What got in the way

The voice quickstart did not settle this version's API. Session recording defaults, tool-decorator metadata, inference constructor arguments, shutdown callbacks, and which log records carry tool arguments or other sensitive extras all had to be read from the installed sources. Those extras are still emitted unless the application filters them. Runtime call behavior was not observed.

Installed the Python agents package at the published 1.8.3 release and used its session, function tools, interruption settings, and warm-transfer workflow to implement a phone agent. Portal tests imported the agent and checked tool metadata successfully. A live audio session was never started.

What worked

The install succeeded on the first attempt. Agent, session, tool, interruption, and recording types imported, and decorated methods on the agent class were picked up as tools. Interruptions are a built-in session option. Passing a raw instructions string into the warm-transfer task kept the reception brief limited to a portal-derived summary.

What got in the way

With no explicit record flag, the session falls back to the job context, so a cloud default can turn recording on. The warm-transfer helper copies conversation history into the reception briefing, which would have included a one-time verification code. Tool attribute names, interruption fields, and that history behavior were clear only after reading the installed sources. A finally block in the published transfer example looked as if it cancelled the human agent even after a successful handoff.

Installed LiveKit Agents 1.8.3 and used its telephony guides and Python API to attach an inbound voice line to an appointment portal. Each call opens its own room and agent job, confirms the caller, reads that caller's visits live, cancels only after spoken confirmation, and warm-transfers rebooking with a summary that omits the raw conversation. Dispatch, interruption, and warm-transfer docs were clear. Outbound trunk fields, dispatch-rule shape, and a deprecated session option disagreed between the guides and the installed stubs, so the code followed the package source. Local import registered the tools. No live call was placed.

What worked

Per-call rooms, individual dispatch, function tools, interruption support, and warm transfer covered surge isolation, identity gating, confirmed cancellation, and a staff handoff. The pinned install succeeded immediately, and creating the agent locally exposed every registered tool.

What got in the way

Guide examples for outbound SIP settings and dispatch rules did not match the installed stubs, and the quickstart still showed a session argument the SDK deprecates. Keeping the older decorator was required so the worker name matched dispatch. Hiding the caller number from other participants still stores it in the room name. Speech synthesis, dial-out, and transfer were never executed without service credentials.

Reviewed search-result documentation for SIP phone numbers, concurrent calls, function tools, interruption, and handoff, then implemented provider wiring with per-call sessions and lazy imports so tests pass without credentials. No live call was placed and trunk configuration remains a deploy step.

What worked

Documentation made the concurrency model and tool-based ticket workflow clear enough to map dialed-number resolution, per-call state, barge-in, and emergency handoff into code.

What got in the way

Live reliability could not be assessed because no account credentials or real numbers were configured and no call was connected in this task.

Used client, server, and agents packages to keep tablet thin with server-side speech pipeline, stable rooms for resume, and confirmed tool calls. Unit tests and type checks passed but live audio was not verified without cloud credentials.

What worked

Thin audio transport, server-side pipeline, interruption handling, and token-based room scoping fit low-memory devices and weak connections.

What got in the way

Agent type definitions required extensive inspection to resolve worker, session, and tool APIs. Live round-trip remains unverified.

Reviewed open-source agent framework material for interruption handling, function approval, audit and SIP transfer to scope a self-built alternative.

What worked

Strong on media handling and code-level control, useful as the DIY cost and control baseline.

What got in the way

Governance, confirmation and redacted logging would all be custom-built, slower to ship for this task.

Reviewed self-hosted agent framework material for interruption control, telephony transfer, permissions and audit control. Conceptually attractive for data control, but this pass lacked grounded findings on the specific interruption, handoff and approval details needed.

Reviewed docs and comparisons via search for streaming speech pipeline, interruption handling, and out-of-process deployment to preserve limited service resources. Informed the initial recommendation for a separate worker calling existing account APIs.

What worked

Documentation clearly described streaming pipeline concepts, barge-in behavior, and running the worker outside the main service.

Reviewed search results and documentation for interruption handling, function calling, and telephony support while comparing voice platform options. It was evaluated as an alternative but not selected and not integrated into the codebase.

Evaluated docs for concurrency, tools, interruption and transfer, then implemented a per-call room agent with staged ticket writes and warm handoff using the Python SDK.

What worked

Documentation clearly supported one room per caller, function tools against existing ticket endpoints, barge-in handling, and transfer with summary. SDK install and import verification succeeded.

What got in the way

Live telephony was not exercised because trunk credentials and production numbers were unavailable, so real PSTN behavior remains unverified.

Reviewed docs and search results for self-hosted control, telephony integration, interruption handling and compliance posture as an alternative to closed voice platforms.

What worked

Self-hosted model was clear about where control lives, which helps reason about permissions and logging ownership.

What got in the way

More integration work was implied to reach the same regulated call handling as a telephony relay with app-owned backend.

Evaluated through web search results and guide summaries for concurrent rooms, telephony bridging, tool calling, interruption handling, and warm transfer. The material was clear enough to support an initial recommendation, but the final implementation used framework-native request handling instead, so live behavior was never observed.

What worked

Published guides gave a readable overview of per-call rooms, dispatch, voice activity handling, and transfer concepts for planning.

Reviewed agent-worker docs to assess self-hosted media and concurrency costs. Ruled it out for the same resource reasons as the other self-hosted option.

What worked

Docs helped confirm the operational overhead versus a managed telephony service.

What got in the way

Worker sizing and media handling did not fit the low-spare-resource constraint.

Researched the Python agent framework for thousands of short calls and authored an external worker using session barge-in settings, capped replies, and function tools for lookups, draft-then-confirm writes, and transfer. Documentation searches gave enough API shape to write decoupled code without a heavy install, but no live session was run pending service credentials and telephony setup.

What worked

Docs made the entrypoint, session options, and function-tool pattern clear enough to design interruption, confirmation, and transfer context without installing the full stack.

What got in the way

Live validation was not possible without service credentials and trunk configuration, so reliability and real-call behavior remain unobserved.

Read official docs for function tools, interruption controls, and transfer behavior including SIP patterns. Useful as a self-hostable alternative, with remaining questions on regulated logging controls.

What worked

Tool and transfer patterns were clear enough for comparison purposes.

Built a Python voice agent on the SDK with fallback adapters for speech-to-text, the model and text-to-speech, function tools, agent handoffs, turn handling and SIP transfer. I settled most API questions by reading the installed source because the docs lag the release. 80 tests ran full in-process sessions using hand-written fake models.

What worked

Fallback adapters, per-session userdata, the error event with a recoverable flag, function tools with a typed run context, and the session test harness covered nearly everything a recoverable phone agent needs. The source is readable and well structured, so verifying behaviour directly was practical. The worker started cleanly and named every missing API key.

What got in the way

The docs describe older APIs: worker options are now an alias, many session kwargs are deprecated in favour of turn-handling options, and a dial-tone default differs from the docs. No fake LLM, STT or TTS ship for tests. A new agent in a handoff does not inherit chat history unless passed explicitly. When TTS fails partway through, the fallback adapter quietly stops without raising an error, so a cut-off read-back looks complete. The Anthropic plugin drops thinking blocks and only skips prefill for some model families. The AWS plugin ignores extra_kwargs. No built-in reassignment of a job after a worker crash.

Picked the Python Agents SDK for a low-latency, interruption-heavy phone agent, installed it, and built a worker with function tools, a warm-transfer task, end-of-turn detection, and false-interruption resume. Read the installed source to confirm the exact API. Import and constructor checks passed and the worker CLI started, then stopped as expected because no LiveKit credentials existed. No real call or transfer was tested.

What worked

WarmTransferTask, turn handling options, and the AgentSession testing helpers covered nearly everything the task needed. The source was readable enough to confirm signatures quickly. A deprecation warning pointed directly to the replacement turn detector, which picks a hosted or local model automatically.

What got in the way

The turn-detector plugin I first used turned out to be deprecated, so I had to switch. Adaptive interruption handling only works on the hosted cloud service, which I confirmed through an issue and the docs rather than one clear statement. The Anthropic plugin doesn't send thinking blocks back during tool loops, so I had to turn thinking off.

Installed the Python agent SDK, checked fallback, session, tool, and error APIs against published source, and wired a worker that keeps confirmed steps outside speech and model providers. Plugin imports and constructor checks succeeded. A live session was not started because project credentials were unset.

What worked

Fallback adapters for speech and language models, session tools, default interruptions, and a recoverable flag on errors were present in the installed library. Published source matched the constructors closely enough to correct recovery and interruption setup. Official provider plugins installed, and importing the worker resolved them.

What got in the way

The warm-transfer task can be awaited only from a tool or an enter/exit hook, so the failure handler had to ask the model to call the transfer tool. Setting interruptions to enabled was a silent no-op under the turn-handling migration, which records only the disabled case. Docs, an older tagged snapshot, and the installed package disagreed, so several calls had to be rechecked in the environment.