Can you please help me understand difference between on_session_end and add_shutdown_callback?

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

i need to generate the call summary when call is ended and call a api to store it in DB

Thanks — this is a great use case. Based on what you said (generate a call summary when the call ends and call an API to store it), the simplest, most reliable place to do that is in

on_session_end

. That callback is designed for final session processing such as exporting/redacting transcripts and sending summaries to storage. How to implement this (high-level) 1. Use

on_session_end

on your

@server.rtc_session

decorator to run logic after the AgentSession ends. 2. In that callback, generate the call summary (e.g., from the session transcript, events, or precomputed summary data). 3. Call your storage API (HTTP request) with the summary payload to save it in your DB. 4. Optionally: use

ctx.add_shutdown_callback()

inside the session if you need any runtime-specific cleanup or additional async tasks to run during shutdown (but keep summary export in

on_session_end

for a single centralized handler). Example pattern (pseudo-code) • Register a single

on_session_end

function where you: ◦ Load or accept the session transcript / summary source. ◦ Perform any redaction or formatting needed for compliance. ◦ Make an HTTP POST to your API with the summary payload. ◦ Handle retries/errors (log failure or enqueue for retry). If you’d like, I can provide a concrete example in your preferred language (Python or Node). To make the example match your setup, please tell me: • Which language you’re using (Python or Node)? • Where the summary is produced today (full transcript, partial events, or do you need help creating the summary from raw transcript)? • Any requirements for redaction, retries, or response handling from your storage API? If you want a quick starter, tell me which language and I’ll give a compact code example showing

@server.rtc_session(on_session_end=...)

, summary generation, and an HTTP POST to store it. , with interactive elements

Can we access : llm = self.agent_instance.llm chat_ctx = self.agent_instance.chat_ctx in session_end

Thanks — that’s a clear question. You want to know if you can access

self.agent_instance.llm

and

self.agent_instance.chat_ctx

inside

on_session_end

so you can generate the call summary and call your API. Short answer • You cannot rely on direct access to

self.agent_instance

(and its `llm`/`chat_ctx`) inside

on_session_end

. That pattern is not documented as guaranteed. • Instead, use the

JobContext

passed into

on_session_end

to get the session data you need and generate/store the summary. Why and what to use instead •

on_session_end

receives a

JobContext

(

ctx

) and is intended for final session processing such as exporting/redacting transcripts or creating session reports. • Use

ctx.make_session_report()

or the session report data from the context to build your call summary. The session report contains the conversation history and session artifacts you need for summarization and storage. • The active session exposes useful runtime properties while the session is running (e.g.,

session.chat_ctx

,

session.llm

), but those are not documented as accessible via

self.agent_instance

inside the

on_session_end

callback. Recommended implementation options 1. Generate summary in

on_session_end

◦ Call

ctx.make_session_report()

inside your

on_session_end

handler to get the transcript/history. ◦ Create the summary (redact if required). ◦ POST the summary to your storage API and handle retries/errors. 1. If you need to run LLM calls that depend on in-memory runtime state ◦ Register runtime callbacks during the session using

ctx.add_shutdown_callback(my_coroutine)

so you can run async cleanup or finalization while runtime state is still available. ◦ Use

add_shutdown_callback

from inside the session code where

self.agent_instance

is available; those callbacks run during shutdown and can access runtime state you registered/closed over. Which approach to pick • Use

on_session_end

for a centralized, single final handler that uses session report data to create a summary and persist it. • Use

ctx.add_shutdown_callback

if your summary generation requires direct access to the live

llm

instance or in-memory chat context that isn’t available from the session report. If you want, I can: • Provide a compact Python example showing

on_session_end

that calls

ctx.make_session_report()

and POSTs the summary to your API. • Or show how to register an

add_shutdown_callback

from inside the session that has access to

self.agent_instance

and then sends the summary. Which example would you prefer and do you want redaction or retry logic included? Sources: Agent session | LiveKit Documentation | Redacting PII from agent logs and transcripts | LiveKit | Agents and handoffs | LiveKit Documentation | LLM-Powered Content Filter | LiveKit Documentation, with interactive elements