# Anam Source: https://docs.zeroruntime.ai/api-reference/node-js/avatar/anam TypeScript API reference for the anam avatars provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AnamAvatar Initialize the Anam Avatar plugin. ```ts theme={null} import { AnamAvatar } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Simli Source: https://docs.zeroruntime.ai/api-reference/node-js/avatar/simli TypeScript API reference for the simli avatars provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## SimliAvatar Initialize the Simli Avatar plugin. ```ts theme={null} import { SimliAvatar } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Agent & Session Source: https://docs.zeroruntime.ai/api-reference/node-js/core/agent-and-session TypeScript API reference for Agent & Session. ## Agent What the agent is, what it can do, and how it behaves on a call. Subclass it to give the agent behaviour: fields holding `function_tool` callables are registered automatically, and the `on_*` hooks below are called by the session as the call progresses. An instance is inert until `serve` registers it and a session is started against it. The pipeline is the other half. This class carries the prompt, the tools and the call-shaped options; `Pipeline` carries the providers that hear and speak. ### Options ```ts theme={null} Agent(options: AgentOptions) ``` Required. The name `serve` registers under and the runtime routes sessions to. Other agents this one hands off to, kept on `alternates`. Nothing registers them for you: `serve` registers one `agent_id` per call, and `Session.add_handoff` names the target by that id. Summarise the conversation at teardown and POST it somewhere. Spoken on the way out, when the agent ends the call itself. Spoken as soon as the agent joins, before the caller says anything. Carry the chat history over when another agent hands off to this one. Off means it starts the conversation fresh. The system prompt. Persona, task, and the rules the model is expected to hold to. Hard ceiling on the call. The runtime ends the session when it is reached. `MCPServerStdio` and `MCPServerHTTP` whose tools join the agent's own. Connected on the first call to `initialize_mcp`, not here. Display name. Defaults to `agent_id`. The `Pipeline` this agent runs on. How long the runtime waits for one of this agent's tools to return before handing the model a timeout. `null` keeps the runtime's own default of 30 seconds. Raise it only for an agent whose tools genuinely run long. The case it exists for is a tool that awaits `Session.warm_transfer` -- that runs for `supervisor_join_timeout + briefing_timeout`, minutes rather than seconds, and the default would kill the round trip while the transfer carried on underneath. The cost is symmetric: a tool that hangs holds the turn for exactly this long. Tools defined elsewhere. Tools declared as fields on the agent are found on their own, so this is for the ones that are not. Seconds of caller silence before the agent nudges. 0 disables it; negative is rejected. What the nudge says. ### agent\_id ```ts theme={null} agent_id(): void ``` ### instructions ```ts theme={null} instructions(): void ``` ### session ```ts theme={null} session(): void ``` ### tools ```ts theme={null} tools(): void ``` ### add\_server ```ts theme={null} add_server(mcp_server: MCPServer): Promise ``` Connect one MCP server and append what it publishes to `tools`. Ignores anything that is not an `MCPServerStdio` or `MCPServerHTTP`. The server to connect. ### cleanup ```ts theme={null} cleanup(): Promise ``` Close the MCP connections and drop the tools they contributed. Called for you at teardown. Safe to call twice, and safe with no MCP servers configured. ### emit ```ts theme={null} emit(event: 'agent_started', args: unknown[]): void ``` Call every handler subscribed to `event`. Returns as soon as the handlers have been started, not when they finish, and never throws: an exception inside a handler is logged against the event name. Ignored once the emitter has been closed. The event name. Passed through to each handler. ### hangup ```ts theme={null} hangup(reason: string, farewell: string): Promise ``` End the call from the agent's side. A no-op with no live session. Recorded against the session. Spoken before hanging up. Empty uses the agent's own `farewell`. ### initialize\_mcp ```ts theme={null} initialize_mcp(): Promise ``` Connect every configured MCP server and adopt its tools. Runs once; later calls return immediately. `serve` calls it while building the agent, so a server that is down fails the build rather than the first tool call. ### off ```ts theme={null} off(event: 'agent_started', callback: EventHandler): void ``` Unsubscribe one handler. Matched by identity, so it has to be the same object that was registered -- a fresh arrow function will not match. Removing something that was never subscribed does nothing. ### on ```ts theme={null} on(event: 'agent_started', callback: EventHandler): EventHandler ``` Subscribe to an event. Handlers fire in the order they were registered, and registering the same one twice calls it twice. The event name. The handler. ### on\_enter ```ts theme={null} on_enter(): Promise ``` Called once the agent has joined and the session is live. Override it to open the conversation, prime the context, or set up standing configuration such as `Session.set_thinking_audio`. ### on\_exit ```ts theme={null} on_exit(): Promise ``` Called as the call is ending, before teardown finishes. ### on\_participant\_joined ```ts theme={null} on_participant_joined(participant: Participant): Promise ``` Called when somebody joins the room the agent is in. ### on\_participant\_left ```ts theme={null} on_participant_left(participant: Participant): Promise ``` Called when somebody leaves. The agent is not one of them. ### register\_tools ```ts theme={null} register_tools(): void ``` Collect the `function_tool` callables declared on this agent. Called for you the first time `tools` is read. Call it again after adding one at runtime; it never registers the same tool twice. ### toString ```ts theme={null} toString(): string ``` Returns a string representation of an object. ### update\_tools ```ts theme={null} update_tools(tools: FunctionTool[]): void ``` Replace the tool list outright. This drops the tools that were found on the agent and anything MCP added, so pass the full set you want. *** ## AgentContext What the runtime knows about a job, handed to the agent factory. `serve` passes one to your factory if it takes an argument, so the agent can be built around the call it is about to take -- a caller's number out of `metadata`, a different prompt per room. ### Options ```ts theme={null} AgentContext(options: AgentContextOptions) ``` Which registration the job was routed to. The runtime's id for this dispatch. Whatever the dispatcher attached -- the caller's number, a tenant id, anything the job was started with. The room the agent is joining. The `Room` the runtime resolved for this job. The auth token for this job. ### toString ```ts theme={null} toString(): string ``` *** ## CallSummary Summarise the conversation when it ends, and POST the result. ### Options ```ts theme={null} CallSummary(options: CallSummaryOptions) ``` Set false to carry the configuration without summarising. Where the summary is POSTed. Without one it is generated and logged but sent nowhere. Sent with the POST -- an auth header, usually. Replaces the built-in summarising prompt. A second model for the summary alone. `null` reuses the session's. Worth pointing at something cheap: it runs once, over the whole transcript, while the process is already shutting down. Seconds the summariser gets. 0 takes the runtime's default. Summarising is an LLM round trip over the whole conversation, so it is a different order of work from the rest of teardown. The ceiling is the runtime's SIGTERM grace, since this runs while the agent is shutting down -- asking for more than that gets the process killed mid-request rather than granting the time. *** ## serve ```ts theme={null} serve(agent: AgentFactory, options: ServeOptions): Promise ``` Register `agent` and serve every call dispatched to it. Every option left here describes *this worker* -- how many calls it takes, what it logs, where it answers probes. Nothing here describes the session: that is Room's job, and the twelve options which used to say it a second time are gone, because two spellings of `recording` that could disagree is a question with no right answer. The returned promise settles when the worker is interrupted or shut down. The agent is registered with the runtime's registry, and every call dispatched to that id builds a fresh agent from the factory -- one instance per call, never one shared across them. A callable returning an `Agent`. Your subclass is usually the callable. An instance is rejected: concurrent calls would share one conversation. *** ## invoke ```ts theme={null} invoke(agent_id: string, options: InvokeOptions): Promise> ``` Start a session against an agent this process is already serving. Resolves once the runtime has accepted the session, which is the point at which the room is joinable. An ordinary async function: `await` it from `on_ready`, or from anywhere else once `serve()` is running. The agent has to be registered in *this* process. There is no dispatch RPC to route a start to another one: the pipeline, credentials and tool schemas all live where `serve` was called. The id passed to `serve`. *** ## Session One live call, and everything you can do to it while it runs. You are handed one rather than constructing one: `invoke` returns it, and inside a `function_tool` or an `on_*` hook it is the session the agent is bound to. Every method here is a message to the agent process, so they are all awaited and none of them block the call. The object stays usable after the call ends -- `ended` goes true and the send methods become no-ops -- so a hook can read `ended_reason` without guarding first. ### Constructor ```ts theme={null} Session(stream: any, accepted: ProtoMessage, outbound: Outbound, options: object) ``` ### agent ```ts theme={null} agent(): void ``` ### ended ```ts theme={null} ended(): void ``` ### playground\_url ```ts theme={null} playground_url(): void ``` ### \[asyncDispose] ```ts theme={null} [asyncDispose](): Promise ``` ### aclose ```ts theme={null} aclose(): Promise ``` Release everything this call holds. Idempotent, and safe after any ending. Every way a call can finish routes here. Closing the transport is the part that cannot be skipped: the outbound queue feeds a writer this SDK holds, and a live writer keeps the stream -- and the process -- alive. ### add\_handoff ```ts theme={null} add_handoff(to_agent: string, __namedParameters: object): Promise ``` Hand the conversation to another agent, by id. The target has to be registered -- `serve` registers one `agent_id` per call -- and whether it inherits the history is that agent's `inherit_context`. The `agent_id` taking over. ### add\_message ```ts theme={null} add_message(role: string, content: string, __namedParameters: object): Promise ``` Write a message into the conversation without speaking it. Useful for handing the model something it should know -- a CRM lookup, a verification result -- without a turn being spent saying it out loud. `system`, `developer`, `user` or `assistant`. A `ChatRole` works too. The message body. ### change\_component ```ts theme={null} change_component(options: ChangeComponentOptions): Promise ``` Swap the named components and leave the rest of the call alone. ### change\_pipeline ```ts theme={null} change_pipeline(pipeline: Pipeline, __namedParameters: object): Promise ``` Replace the whole pipeline mid-call. Everything not named is rebuilt from the pipeline you pass, so state a complete one. To change a provider or two and leave the rest alone, use `change_component`. The `Pipeline` to switch to. ### destroy ```ts theme={null} destroy(reason: string): Promise ``` Tear the session down at the runtime, without a goodbye. The blunt one: no farewell, no teardown hooks worth waiting for. `end` is the polite version. ### detach ```ts theme={null} detach(): Promise ``` Stop watching this session without ending the call. The agent keeps running runtime-side; this process just stops listening. For a call that should actually stop, use `end` or `destroy`. ### emit ```ts theme={null} emit(event: string, args: unknown[]): void ``` Call every handler subscribed to `event`. Returns as soon as the handlers have been started, not when they finish, and never throws: an exception inside a handler is logged against the event name. Ignored once the emitter has been closed. The event name. Passed through to each handler. ### end ```ts theme={null} end(reason: string, farewell: string): Promise ``` Ask the runtime to end the call. A no-op once it has ended. Recorded against the session. Spoken before hanging up. ### events ```ts theme={null} events(): AsyncGenerator ``` Iterate everything the runtime reports, until the call ends. Keeps yielding briefly past the `ended` event so the last transcripts and metrics are not cut off mid-teardown. ### get\_context\_history ```ts theme={null} get_context_history(__namedParameters: object): Promise ``` Fetch the conversation as the agent process holds it. ### get\_metrics ```ts theme={null} get_metrics(__namedParameters: object): Promise ``` Fetch the per-turn latency metrics collected so far. ### get\_participants ```ts theme={null} get_participants(__namedParameters: object): Promise ``` Who is in the room right now, as `Participant` records. ### interrupt ```ts theme={null} interrupt(__namedParameters: object): Promise ``` Stop the agent talking. ### log\_playground ```ts theme={null} log_playground(): void ``` Announce the join URL on stdout, at most once per session. Both the direct-start path and the registry worker path call this, and `invoke` adds a third; the guard is what keeps one session to one URL. It prints rather than logs because the URL is the one line the operator is waiting to copy, and a log record buries it behind level and module columns that are noise for a value you paste into a browser. ### off ```ts theme={null} off(event: string, callback: EventHandler): void ``` Unsubscribe one handler. Matched by identity, so it has to be the same object that was registered -- a fresh arrow function will not match. Removing something that was never subscribed does nothing. ### on ```ts theme={null} on(event: string, callback: EventHandler): EventHandler ``` Subscribe to an event. Handlers fire in the order they were registered, and registering the same one twice calls it twice. The event name. The handler. ### play\_background\_audio ```ts theme={null} play_background_audio(file: string | object | null, __namedParameters: object): Promise ``` Start a sound bed under the call. Needs the room's mixing track, `Room({ background_audio: true })`. A path, or a `BackgroundAudio` carrying one along with its volume and looping. A disabled `BackgroundAudio` plays nothing. ### process\_text ```ts theme={null} process_text(text: string): Promise ``` Feed text to the agent as though the caller had said it. The full turn runs: the model answers and the answer is spoken. ### publish\_to\_pubsub ```ts theme={null} publish_to_pubsub(pubsub_config: PubSubPublishConfig): Promise ``` Publish one pubsub frame into the room. The topic, body and options to publish with. ### reply ```ts theme={null} reply(instructions: string, options: ReplyOptions): Promise ``` Ask the model for a line, generated against `instructions`. Unlike `say`, this is a generation: the model sees the conversation so far plus these instructions, and what it produces is spoken. What to tell the model for this turn alone. ### say ```ts theme={null} say(text: string, options: SayOptions): Promise ``` Speak an exact line. No model involved. What to say. ### set\_thinking\_audio ```ts theme={null} set_thinking_audio(file: string | null, __namedParameters: object): Promise ``` Play a sound while the agent is generating its reply. Standing configuration rather than a one-shot: once set, the session starts it at the top of every generation and stops it when the answer begins, for as long as the session lasts. Set it from `on_enter`. `file` omitted takes the runtime's own thinking sound. Any file libav can decode works -- wav, mp3, ogg, flac, m4a. Needs the room's mixing track, `Room({ background_audio: true })`, like all audio that is not speech. ### stop ```ts theme={null} stop(reason: string): Promise ``` End the call and release it. What `await using` calls. ### stop\_background\_audio ```ts theme={null} stop_background_audio(): Promise ``` Stop the sound bed. Leaves the thinking sound alone. ### subscribe\_to\_pubsub ```ts theme={null} subscribe_to_pubsub(pubsub_config: PubSubSubscribeConfig): Promise ``` Listen on one pubsub topic for the rest of the call. The topic and its handler. ### toString ```ts theme={null} toString(): string ``` Returns a string representation of an object. ### transfer\_call ```ts theme={null} transfer_call(transfer_to: string, __namedParameters: object): Promise> ``` Cold-transfer the call and leave. The caller is handed to `transfer_to` with no introduction and the agent drops out. Where to send them -- a SIP URI or a phone number. ### wait ```ts theme={null} wait(__namedParameters: object): Promise ``` Consume `events` until the call ends, logging as it goes. The usual last line of a script that started a session and has nothing else to do. *** ## current\_session ```ts theme={null} current_session(): Session ``` The session whose callback is currently running. Valid anywhere the SDK invokes your code on a session's behalf: a `function_tool`, a lifecycle hook, a pipeline hook. Useful for code that runs on the call without holding a reference to it -- a module-level `pipeline.on` handler, say. Anything defined on the agent should reach the call through `this.session` instead, and a pubsub handler subscribed with `Session.subscribe_to_pubsub` already has the session in hand. *** ## Participant ### Constructor ```ts theme={null} Participant(options: object) ``` *** ## PubSubSubscribeConfig One topic to listen on, and what to call for each frame. Passed to `Session.subscribe_to_pubsub` and `Room.subscribe_to_pubsub`. ### Options ```ts theme={null} PubSubSubscribeConfig(options: PubSubSubscribeConfigOptions) ``` Called once per frame with the raw frame as an object -- the whole thing as the transport delivered it, since pubsub promises no schema beyond `message`. Sync or async; a promise is awaited. A handler that declares a second parameter is additionally told whether the frame is backlog: ```ts theme={null} function cb(frame, backlog) { if (backlog) return; // already in the topic before we joined } ``` Subscribing replays whatever the topic already held, so a one-argument handler sees that history as ordinary traffic -- which is the transport's own shape, and worth knowing about before replying to it. The topic to subscribe to. *** ## PubSubPublishConfig One frame to publish into the room. Passed to `Session.publish_to_pubsub` and `Room.publish_to_pubsub`. ### Options ```ts theme={null} PubSubPublishConfig(options: PubSubPublishConfigOptions) ``` The text body. Transport options. Only `sendOnly` -- a list of participant ids to deliver to -- is carried; anything else is dropped, because the wire has nowhere to put it. Omitted, everyone subscribed to the topic gets the frame. Structured data alongside it, JSON-encoded on the way out. The topic to publish on. *** ## UtteranceHandle One thing the agent is saying, and how it went. Returned by `Session.say` and `Session.reply`. Call `wait()` to block until the line finishes -- it resolves whether the line played out or was cut off, so check `interrupted` rather than assuming it was heard. ```ts theme={null} const handle = await session.say('One moment while I look that up.'); await handle.wait(); if (handle.interrupted) { // ... } ``` The wait is a method rather than the handle itself being awaitable: a thenable would be unwrapped by `await session.say(...)`, so that line would not return until the audio had finished playing. As it is, `say()` hands the handle back the moment the request is on its way. Waiting is optional. Ignore the handle and the line still plays. ### Constructor ```ts theme={null} UtteranceHandle(utterance_id: string) ``` ### interrupted ```ts theme={null} interrupted(): void ``` ### state ```ts theme={null} state(): void ``` ### done ```ts theme={null} done(): boolean ``` Whether the utterance has settled, either way. Never blocks. ### toString ```ts theme={null} toString(): string ``` ### wait ```ts theme={null} wait(): Promise ``` Resolve once the line has settled, either way. Resolves to this handle. *** ## Room Which room the agent joins. `room_id: null` asks for a new one. ### Options ```ts theme={null} Room(options: RoomOptions) ``` The 0.1.2 spelling of `name`. Folded into it when set. Publish the agent under a fixed participant id. `null` lets the room mint one, which is what a single-agent session wants. Codec the room negotiates -- `"opus"` (the default when `null`), `"pcmu"`, `"pcma"`, `"g722"`. This is what tells a meeting from a phone call: opus is 48 kHz, pcmu/pcma are 8 kHz and g722 is 16 kHz, and that rate reaches the VAD and STT. Leave it `null` for meetings; set `"pcmu"` or `"pcma"` for SIP so the pipeline sizes itself to the narrowband audio instead of resampling it up to 48 kHz and back down again. VideoSDK token for the room. Falls back to the environment. It travels in `StartSession.credentials`, never in `params_json`. End the session when the last participant leaves. `null` leaves the runtime's default (TRUE) in place. Open the room's mixing audio track. Nothing plays by itself -- this is the track, not the sound. Start audio on it with `session.play_background_audio({ file, volume, looping })` and stop it with `session.stop_background_audio()`. Required before either call: without the track the SDK refuses, and the failure is a silent one from the caller's side. Seconds of silence before the session is considered idle. Whether the agent joins the meeting. `null` leaves the runtime's default (TRUE) in place. Display name the agent publishes under. Seconds with nobody attached before the session is reclaimed. Carried in `SessionLimits.inactivity_timeout_seconds`, same as above. Where this session's telemetry goes. `null` takes the runtime's defaults. Ask the runtime for a playground URL for this session. Record the session. Off unless asked for -- recording a call is a decision about the person on the other end, so the default has to be the safe one and the same runtime serves recorded and unrecorded sessions side by side. Audio is always captured when this is on; the two below add tracks to it. Also record the screen share. Needs `recording` and `vision` -- there is no screen-share track on a session that is not receiving video. Also record camera video. Needs `recording`. Existing room to join. A new room is created when `null`. Hard cap on session length, in seconds. Carried in `SessionLimits.max_session_duration_seconds` rather than in `RoomSpec`, so it is read by the transport and not by `to_proto`. `null` inherits the runtime's own ceiling. Override the signaling base URL. Deliver camera frames to the agent process. Whether the agent waits for someone to join before speaking. `null` leaves the runtime's default (TRUE) in place. ### explicitly\_set ```ts theme={null} explicitly_set(): void ``` *** ## Sip The telephony leg of a session -- who is being called, and from what. ### Options ```ts theme={null} Sip(options: SipOptions) ``` Caller id presented on the call. Identifier correlating the call. Destination number/address for an outbound call. Call direction/type. Additional key/values merged into the metadata map. URL to receive call-event callbacks. ### to\_metadata ```ts theme={null} to_metadata(): Record ``` This leg as the metadata dict the room is created with. *** ## UNSET ```ts theme={null} const UNSET: any ``` Annotated `any` so `recording: any = UNSET` type-checks while the honest default stays visible in the signature a reader sees. *** ## ZeroRuntimeChannel A connection to one runtime, and the sessions started over it. `serve` and `invoke` own one for you. Hold one directly to start sessions from async code, to reach a runtime other than the configured one, or to ask a runtime what capacity it has. Connect explicitly with `await channel.connect()`; every method connects on first use anyway. TLS is decided by the target unless `secure` says otherwise: local hosts are plaintext, port 443 is TLS. `ZERORUNTIME_INSECURE=1` forces plaintext. ### Options ```ts theme={null} ZeroRuntimeChannel(options: ZeroRuntimeChannelOptions) ``` ### auth\_token ```ts theme={null} auth_token(): void ``` ### connected ```ts theme={null} connected(): void ``` ### stub ```ts theme={null} stub(): void ``` ### aclose ```ts theme={null} aclose(): Promise ``` Close the connection. Sessions started over it stop being watched. ### attach ```ts theme={null} attach(session_id: string, __namedParameters: object): Promise ``` Attach to a session that is already running. The session to attach to. ### connect ```ts theme={null} connect(__namedParameters: object): Promise ``` Open the connection. Returns immediately if it is already open. ### destroy ```ts theme={null} destroy(session_id: string, reason: string): Promise ``` Tear a session down at the runtime, by id. The session to destroy. Recorded against it. ### session\_info ```ts theme={null} session_info(session_id: string): Promise ``` Look up one session's state, pid, room and uptime. Works for any session on this runtime, including ones this process did not start. ### start ```ts theme={null} start(options: StartOptions): Promise ``` Start a session and return it, ready to run. The async counterpart to `invoke`, and what to reach for inside async code, where `invoke` cannot be called. ### status ```ts theme={null} status(): Promise ``` Ask the runtime what capacity it has. ### use\_tls ```ts theme={null} use_tls(): boolean ``` Whether this channel will speak TLS. `secure` wins if it was set, then `ZERORUNTIME_INSECURE`, then the target itself: a local host is plaintext and port 443 is TLS. # Audio Source: https://docs.zeroruntime.ai/api-reference/node-js/core/audio TypeScript API reference for Audio. ## BackgroundAudio A sound bed the runtime plays into the room alongside the agent. Needs the room's mixing track, `Room({ background_audio: true })`, like all audio that is not speech. ### Options ```ts theme={null} BackgroundAudio(options: BackgroundAudioOptions) ``` Set false to keep the configuration and play nothing. The file to play. Anything libav decodes -- wav, mp3, ogg, flac, m4a. Empty is rejected. Restart when the file ends instead of falling silent. `mixing` or `playback`. Only `mixing` has a counterpart on the runtime today; `playback` is accepted, warned about, and treated as `mixing`. Gain. 1.0 is the file as recorded; must not be negative. *** ## run\_stt ```ts theme={null} run_stt(audio_stream?: AsyncIterable | null): AsyncGenerator ``` Yield the transcript an `stt` hook was called with. The shim that lets a hook written against a local STT run unchanged. STT itself runs in the agent process and only the transcript crosses, so the audio stream is empty here -- draining it is allowed and yields nothing. Filtering or rewriting the text works as written; transforming the audio does not. The hook's audio stream, if it takes one. Drained and discarded. # Errors & Enums Source: https://docs.zeroruntime.ai/api-reference/node-js/core/errors-and-config TypeScript API reference for Errors & Enums. ## ZeroRuntimeError Base for everything this SDK raises on its own behalf. Catch it to handle any ZeroRuntime failure without naming each one. Errors the language raises -- `TypeError` for a bad argument, `RangeError` for one out of bounds -- are left as themselves rather than wrapped. ### Constructor ```ts theme={null} ZeroRuntimeError(message: string) ``` *** ## SessionRejected The ZeroRuntime refused to create the session. ### Constructor ```ts theme={null} SessionRejected(message: string, options: object) ``` *** ## ProviderUnavailable A provider in the pipeline could not be reached or would not serve. Usually a missing or rejected vendor key, or a model the account is not entitled to. A fallback on the same slot is what keeps this from ending the call. ### Constructor ```ts theme={null} ProviderUnavailable(message: string) ``` *** ## ZeroRuntimeUnreachable The runtime could not be reached, or did not answer in time. A transport failure rather than a refusal: nothing was decided about the session, so retrying is reasonable. ### Constructor ```ts theme={null} ZeroRuntimeUnreachable(message: string) ``` *** ## ToolTimeout A `function_tool` did not return before its deadline. The turn continues without the tool's answer. A tool that calls out to a slow API wants its own timeout, so it can say something useful instead of being cut off. ### Constructor ```ts theme={null} ToolTimeout(message: string) ``` *** ## AgentState Where the agent is in a turn -- listening, thinking, speaking, or on its way in or out of the call. ```ts theme={null} enum AgentState { CLOSING = 'closing', IDLE = 'idle', LISTENING = 'listening', SPEAKING = 'speaking', STARTING = 'starting', THINKING = 'thinking', } ``` *** ## UserState What the caller is doing, as the runtime reports it. ```ts theme={null} enum UserState { IDLE = 'idle', LISTENING = 'listening', SPEAKING = 'speaking', } ``` *** ## ChatRole Who a message in the conversation came from. A plain string works anywhere one of these is accepted -- the members *are* strings -- so `'user'` and `ChatRole.USER` are interchangeable. ```ts theme={null} enum ChatRole { ASSISTANT = 'assistant', DEVELOPER = 'developer', SYSTEM = 'system', TOOL = 'tool', USER = 'user', } ``` # Events & Observability Source: https://docs.zeroruntime.ai/api-reference/node-js/core/events TypeScript API reference for Events & Observability. ## Observability Where this session's traces, metrics and logs go. Each stream is configured on its own, and a stream left `null` follows the runtime's own settings rather than being switched off. ### Options ```ts theme={null} Observability(options: ObservabilityOptions) ``` Level the agent process logs at. One of `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`. The agent process's log records. Latency and usage counters. Per-turn spans -- what the model was asked, what each provider took. *** ## Exporter Where one stream of telemetry is shipped. ### Options ```ts theme={null} Exporter(options: ExporterOptions) ``` Set false to turn this stream off while leaving the rest of the configuration in place. Sent with each export -- the collector's auth header, usually. An OTLP endpoint. `null` sends it wherever the runtime is configured to send its own. # Pipeline Source: https://docs.zeroruntime.ai/api-reference/node-js/core/pipeline TypeScript API reference for Pipeline. ## Pipeline The providers a call runs on: what hears, what thinks, what speaks. Two shapes are valid. A cascade names `stt`, `llm` and `tts` separately; a realtime pipeline names a speech-to-speech model in `llm` alone, because a realtime model is the language model. `realtime` is accepted as the older spelling of the same slot; naming both is rejected. A fallback slot -- `stt`, `llm`, `tts` -- also takes an array, in which case the head serves and the tail stands by. Wrap that array in `FallbackSTT`, `FallbackLLM` or `FallbackTTS` to say how it demotes as well as what it falls back to; each slot carries its own settings. ### Options ```ts theme={null} Pipeline(options: PipelineOptions) ``` A video avatar to render the agent's speech through. How a long conversation is kept inside the model's limit. Noise cancellation applied to the inbound audio. Deliver keypad tones to the agent. `null` drops them. How patiently the agent waits before answering. What counts as the caller barging in. The language model -- a text LLM for a cascade, a `FallbackLLM` chain of them, or a speech-to-speech model for a realtime pipeline. `PronunciationRule` substitutions applied to generated text on its way to TTS. The older spelling of a speech-to-speech `llm`. Speech-to-text, or a `FallbackSTT` chain. Omit it on a realtime pipeline. Text-to-speech, or a `FallbackTTS` chain. Omit it on a realtime pipeline. End-of-turn detection, for deciding when they finished. Voice activity detection -- what notices the caller is talking. Answering-machine detection, for outbound calls that may be picked up by one. ### is\_realtime ```ts theme={null} is_realtime(): void ``` ### mode ```ts theme={null} mode(): void ``` ### chain ```ts theme={null} chain(slot: string): void ``` Everything configured for one slot: the primary, then its fallbacks. Empty for a slot nothing was named for, and for a slot that is not one. ### fallback\_settings ```ts theme={null} fallback_settings(slot: string): _Fallback | null ``` How one slot demotes, or `null` where nothing was tuned. `fallbacks` is who a slot falls back to; this is how. ### fallbacks ```ts theme={null} fallbacks(slot: string): void ``` What a slot falls back to, in the order they are tried. ### hooks ```ts theme={null} hooks(event: string): function[] ``` The handlers registered for one event, in registration order. ### on ```ts theme={null} on(event: PipelineHookEvent, callback: H): H ``` Register a hook that runs in this process, mid-turn. The events are the transcript hooks `stt` and `llm`, and the turn hooks `user_turn_start`, `user_turn_end`, `agent_turn_start` and `agent_turn_end`. An async generator function registered on `llm` is filed as `llm_stream`: it is handed the model's output as a stream and yields what should be spoken, so it can buffer, rewrite or drop the turn. A plain async function on the same event sees the finished text instead. Per-component latency is a separate family, registered through its own namespace rather than by spelling the prefix here: ```ts theme={null} pipeline.metrics.on('stt', (data) => { ... }); ``` Which hook to attach to. The handler. ### primary ```ts theme={null} primary(slot: string): ProviderSpec | null ``` The provider a slot uses first, or `null` if it has none. ### providers ```ts theme={null} providers(): Iterable ``` Every provider in the pipeline, fallbacks included. ### toString ```ts theme={null} toString(): string ``` *** ## NO\_CHANGE ```ts theme={null} const NO_CHANGE: any ``` Annotated `any` on purpose: it lets `tts: any = NO_CHANGE` type-check while the honest annotation stays visible in the signature a reader sees. *** ## PronunciationRule Rewrite generated text on its way to TTS. Positional rather than an options object, because two strings in a fixed order read better than four words of keys: `PronunciationRule('nginx', 'engine x')`. ### Constructor ```ts theme={null} PronunciationRule(find: string, replace: string, case_sensitive: boolean) ``` *** ## ContextWindow Keep a long conversation inside the model's context, automatically. ### Options ```ts theme={null} ContextWindow(options: ContextWindowOptions) ``` Recent user turns kept verbatim. The SDK's default is 3, and it is worth keeping several -- summarising the sentence the caller just said is how an agent starts answering the wrong question. Or bound by item count. `null` for none. Compress once the context exceeds this. `null` for no token ceiling. The SDK's default is 10. The model that compresses. A second LLM, described here and built in the agent process like every other provider. *** ## EOUConfig When the caller is judged to have finished speaking. ### Options ```ts theme={null} EOUConfig(options: EOUConfigOptions) ``` Treat "mhm", "haan", "right" as listening noises rather than turns. `null` takes the runtime's default; the SDK's own default is on for detectors that support it. How sure the detector must be. Lower answers sooner and interrupts more. `[min, max]` seconds to wait before treating silence as the end of a turn. `[0.0, 0.0]` answers as soon as the detector says the turn is complete, which is snappy but cuts off anyone who pauses to think. `DEFAULT` waits a fixed time after speech stops. `ADAPTIVE` varies it with how certain the turn detector is -- longer when the sentence sounds unfinished. *** ## InterruptConfig What counts as the caller interrupting, rather than just making a noise. ### Options ```ts theme={null} InterruptConfig(options: InterruptConfigOptions) ``` How long to stay paused after an interruption that turned out to be nothing. Seconds to fade the agent's audio out over. An instant cut sounds like a dropped call. STT confidence floor for those words. Seconds of speech before it counts. Raising this is the usual fix for an agent that stops every time someone breathes. Words required before it counts. `2` ignores a stray "yeah". `VAD_ONLY` reacts to any speech-like audio -- fastest, and the most easily fooled by a cough or a door. `STT_ONLY` waits for words. `HYBRID` uses both. Pick the sentence back up when the interruption proves false, rather than dropping it. *** ## FallbackSTT Speech-to-text providers to try in order, and how they demote. ### Constructor ```ts theme={null} FallbackSTT(providers: , options: FallbackOptions) ``` ### SLOT ```ts theme={null} SLOT(): void ``` *** ## FallbackLLM Language models to try in order, and how they demote. ### Constructor ```ts theme={null} FallbackLLM(providers: , options: FallbackOptions) ``` ### SLOT ```ts theme={null} SLOT(): void ``` *** ## FallbackTTS Text-to-speech providers to try in order, and how they demote. ### Constructor ```ts theme={null} FallbackTTS(providers: , options: FallbackOptions) ``` ### SLOT ```ts theme={null} SLOT(): void ``` *** ## DTMFHandler Deliver the caller's keypad tones to the agent instead of dropping them. ### Options ```ts theme={null} DTMFHandler(options: DTMFHandlerOptions) ``` What runs per keypress, taking `(key)` or `(key, payload)`. Left `null`, the agent's `on_dtmf` method is called instead -- which is the usual shape, because a keypad menu almost always wants the agent's own state to accumulate a multi-digit entry into. The runtime delivers one key per call either way; a PIN is accumulated on your side, not handed over whole. *** ## VoiceMailDetector Detect an answering machine on an outbound call. The detector runs in the agent process the ZeroRuntime starts: it buffers the opening speech for `duration` seconds and asks `llm` whether it is a person or a greeting. ### Options ```ts theme={null} VoiceMailDetector(options: VoiceMailDetectorOptions) ``` What runs on detection. Left `null`, the agent's `on_voicemail` method is called instead. Either is awaited, so anything said in it finishes before the call is ended. Replace the built-in classification prompt. Seconds of speech to buffer before deciding. The default is 2.0 -- long enough for "Hi, you've reached...". Set false to configure it without turning it on. The classifier. Required: without one there is nothing to classify with, and the detector is simply not installed. *** ## PipelineMode Which shape a pipeline resolved to. Derived from the slots that were filled rather than set by hand; read it off `Pipeline.mode`. ```ts theme={null} enum PipelineMode { FULL_CASCADING = 'full_cascading', HYBRID = 'hybrid', LLM_ONLY = 'llm_only', LLM_TTS_ONLY = 'llm_tts_only', PARTIAL_CASCADING = 'partial_cascading', REALTIME = 'realtime', STT_LLM_ONLY = 'stt_llm_only', STT_ONLY = 'stt_only', STT_TTS_ONLY = 'stt_tts_only', TTS_ONLY = 'tts_only', } ``` # Tools & MCP Source: https://docs.zeroruntime.ai/api-reference/node-js/core/tools-and-mcp TypeScript API reference for Tools & MCP. ## function\_tool ```ts theme={null} function_tool(options: FunctionToolOptions): FunctionTool, R> ``` Expose a function to the model as a callable tool. ```ts theme={null} const lookup_order = function_tool({ name: 'lookup_order', description: 'Find an order by its id.', parameters: { order_id: { type: 'string', description: "The customer's order number." }, }, execute: async ({ order_id }) => find(order_id), }); ``` The name, description and parameter schema are stated rather than derived: JavaScript keeps neither comments nor type annotations at runtime, so there is nothing to read a tool schema off. What you write here is exactly what the model is shown. Tools declared as fields on an `Agent` subclass are registered automatically; tools defined elsewhere go in `Agent({ tools: [...] })`. *** ## MCPServerStdio A local MCP server, run as a subprocess and spoken to over stdio. ### Options ```ts theme={null} MCPServerStdio(options: MCPServerStdioOptions) ``` Environment for the child. `null` inherits this process's, which is usually what you want: the server needs the same API keys you already have. The program to run, e.g. `process.execPath`. Its arguments -- typically the server script. Seconds to wait for the connection and for each tool call. The vendor's default is 5, which is tight for a server that starts an interpreter; its own examples pass 30. Directory to run it in. ### toString ```ts theme={null} toString(): string ``` *** ## MCPServerHTTP A remote MCP server, reached over HTTP. ### Options ```ts theme={null} MCPServerHTTP(options: MCPServerHTTPOptions) ``` Seconds to wait for the connection. The server's URL. Sent with every request -- an API key usually lives here. Read in this process, so the credential stays with you. Seconds to wait for the session, and for each tool call. Seconds a quiet stream may stay open. Long by default: an MCP server that has nothing to say is not broken. ### transport\_mode ```ts theme={null} transport_mode(): void ``` ### toString ```ts theme={null} toString(): string ``` # Aicoustics Source: https://docs.zeroruntime.ai/api-reference/node-js/denoise/aicoustics TypeScript API reference for the aicoustics noise cancellation provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AICousticsDenoise Create a Denoise instance configured for AI-Coustics. ```ts theme={null} import { AICousticsDenoise } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key ``` ### Options # Rnnoise Source: https://docs.zeroruntime.ai/api-reference/node-js/denoise/rnnoise TypeScript API reference for the rnnoise noise cancellation provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## RNNoise Initialize the RNNoise denoise plugin. ```ts theme={null} import { RNNoise } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Sanas Source: https://docs.zeroruntime.ai/api-reference/node-js/denoise/sanas TypeScript API reference for the sanas noise cancellation provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## SanasDenoise Create a Denoise instance configured for Sanas. ```ts theme={null} import { SanasDenoise } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key ``` ### Options # Anthropic Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/anthropic TypeScript API reference for the anthropic llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AnthropicLLM Initialize the Anthropic LLM. ```ts theme={null} import { AnthropicLLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Aws Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/aws TypeScript API reference for the aws llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AWSBedrockLLM AWS Bedrock LLM (Converse API) plugin for VideoSDK Agents. ```ts theme={null} import { AWSBedrockLLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Cerebras Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/cerebras TypeScript API reference for the cerebras llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## CerebrasLLM Cerebras LLM implementation using the Cerebras Cloud SDK. ```ts theme={null} import { CerebrasLLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Cometapi Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/cometapi TypeScript API reference for the cometapi llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## CometAPILLM Initialize the CometAPI LLM plugin. ```ts theme={null} import { CometAPILLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Google Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/google TypeScript API reference for the google llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## GoogleLLM Create an LLM instance configured for Google Gemini. ```ts theme={null} import { GoogleLLM } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { GoogleLLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Openai Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/openai TypeScript API reference for the openai llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## OpenAILLM Initialize the OpenAI LLM plugin. ```ts theme={null} import { OpenAILLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options *** ## ZRTLLM Create an LLM instance configured for VideoSDK LLM. ```ts theme={null} import { ZRTLLM } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { ZRTLLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Sarvamai Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/sarvamai TypeScript API reference for the sarvamai llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## SarvamAILLM Create an LLM instance configured for Sarvam AI. ```ts theme={null} import { SarvamAILLM } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { SarvamAILLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Xai Source: https://docs.zeroruntime.ai/api-reference/node-js/llm/xai TypeScript API reference for the xai llm provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## XAILLM LLM Plugin for xAI (Grok) API. ```ts theme={null} import { XAILLM } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Node JS SDK Source: https://docs.zeroruntime.ai/api-reference/node-js/overview API reference for the Zero Runtime Node JS SDK. Reference for every public class, factory, function, and type in the Zero Runtime Node JS SDK. Start with **Core** for agents, sessions, pipelines, tools, and context, then browse the provider sections (Speech-to-text, LLM, Text-to-speech, and more) for the plugins you compose into a pipeline. Install, conventions, and end-to-end examples. # Aws Source: https://docs.zeroruntime.ai/api-reference/node-js/realtime/aws TypeScript API reference for the aws realtime models provider. ## NovaSonicRealtime Nova Sonic's realtime model implementation ```ts theme={null} import { NovaSonicRealtime } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Azure Source: https://docs.zeroruntime.ai/api-reference/node-js/realtime/azure TypeScript API reference for the azure realtime models provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AzureVoiceLive Azure Voice Live realtime model implementation ```ts theme={null} import { AzureVoiceLive } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Gemini Source: https://docs.zeroruntime.ai/api-reference/node-js/realtime/gemini TypeScript API reference for the gemini realtime models provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## GeminiRealtime Create a Realtime instance configured for Google Gemini. ```ts theme={null} import { GeminiRealtime } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { GeminiRealtime } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Openai Source: https://docs.zeroruntime.ai/api-reference/node-js/realtime/openai TypeScript API reference for the openai realtime models provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## OpenAIRealtime OpenAI's realtime model implementation. ```ts theme={null} import { OpenAIRealtime } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Ultravox Source: https://docs.zeroruntime.ai/api-reference/node-js/realtime/ultravox TypeScript API reference for the ultravox realtime models provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## UltravoxRealtime Ultravox's realtime model for audio-only communication ```ts theme={null} import { UltravoxRealtime } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Xai Source: https://docs.zeroruntime.ai/api-reference/node-js/realtime/xai TypeScript API reference for the xai realtime models provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## XAIRealtime xAI's Grok realtime model implementation ```ts theme={null} import { XAIRealtime } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Assemblyai Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/assemblyai TypeScript API reference for the assemblyai speech-to-text provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AssemblyAISTT Create an STT instance configured for AssemblyAI Universal Streaming. ```ts theme={null} import { AssemblyAISTT } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { AssemblyAISTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Azure Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/azure TypeScript API reference for the azure speech-to-text provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## AzureSTT Initialize the Azure STT plugin. ```ts theme={null} import { AzureSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Cartesia Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/cartesia TypeScript API reference for the cartesia speech-to-text provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## CartesiaSTT Create an STT instance configured for Cartesia (Ink) realtime STT. ```ts theme={null} import { CartesiaSTT } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { CartesiaSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Cometapi Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/cometapi TypeScript API reference for the cometapi speech-to-text provider. ## CometAPISTT Initialize the CometAPI STT plugin. ```ts theme={null} import { CometAPISTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Deepgram Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/deepgram TypeScript API reference for the deepgram speech-to-text provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## DeepgramSTT Create an STT instance configured for Deepgram. ```ts theme={null} import { DeepgramSTT } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { DeepgramSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options *** ## DeepgramSTTV2 Initialize the Deepgram STT plugin (Flux / v2 API). ```ts theme={null} import { DeepgramSTTV2 } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Elevenlabs Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/elevenlabs TypeScript API reference for the elevenlabs speech-to-text provider. ## ElevenLabsSTT ElevenLabs Realtime Speech-to-Text (STT) client. ```ts theme={null} import { ElevenLabsSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Gladia Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/gladia TypeScript API reference for the gladia speech-to-text provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## GladiaSTT Initialize the Gladia STT plugin with WebSocket support. ```ts theme={null} import { GladiaSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Google Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/google TypeScript API reference for the google speech-to-text provider. Setup, environment variables, and Python/JavaScript/Go usage examples. ## GoogleSTT Create an STT instance configured for Google Cloud Speech-to-Text. ```ts theme={null} import { GoogleSTT } from '@zeroruntime/js-sdk/inference'; // same fields, through the gateway, no vendor key import { GoogleSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options # Navana Source: https://docs.zeroruntime.ai/api-reference/node-js/stt/navana TypeScript API reference for the navana speech-to-text provider. ## NavanaSTT VideoSDK Agent Framework STT plugin for Navana's Bodhi API. ```ts theme={null} import { NavanaSTT } from '@zeroruntime/js-sdk/plugins'; // direct to the vendor, with your key ``` ### Options

Meeting Id: {meetingId}