Agent & Session

new Agent(instructions: string, options?: AgentOptions)

addServer(_mcpServer: unknown): Promise<void>

captureFrames(numOfFrames = 1): unknown[]

cleanup(): Promise<void>

closeEmitter(): Promise<void>

emit(event: string, ...args: any[]): void

hangup(): Promise<void>

initializeMcp(): Promise<void>

interrupt(opts?: Record<string, unknown>): Promise<unknown>

listenerCount(event: string): number

off(event: string, handler: EventHandler): void

on(event: string, handler: EventHandler): EventHandler

once(event: string, handler: EventHandler): EventHandler

onEnter(): Promise<void>

onExit(): Promise<void>

playBackgroundAudio(file?: string | null, volume = 1.0, looping = false, overrideThinking = true): Promise<void>

preloadBackgroundAudio(file?: string | null, volume = 1.0): Promise<void>

registerA2a(_card: unknown): Promise<void>

registerTools(): void

removeAllListeners(event?: string): void

reply(instructions: string, opts?: Record<string, unknown>): Promise<unknown>

say(message: string, opts?: Record<string, unknown>): Promise<unknown>

setThinkingAudio(file?: string | null, volume = 0.3): void

stopBackgroundAudio(): Promise<void>

unregisterA2a(): Promise<void>

updateTools(tools: FunctionTool[]): void

new AgentSession(agent: Agent, pipeline: Pipeline, opts: AgentSessionOptions)

activeAgent(): Agent

addShutdownCallback(callback: () => unknown): void

callTransfer(token: string, transferTo: string): Promise<void>

cancelGeneration(): Promise<void>

changePipeline(pipelineMode: string, components: Array<[string, string, Record<string, string> | null]>): Promise<void>

clearContext(opts: { keepSystemPrompt?: boolean } = {}): Promise<boolean>

close(opts: { reason?: string } = {}): Promise<void>

closeEmitter(): Promise<void>

contextToAnthropic(): Promise<{ messages: Array<Record<string, any>>; system: string | null; }>

contextToDict(): Promise<Record<string, any>>

contextToGoogle(): Promise<{ contents: Array<Record<string, any>>; systemInstruction: string | null; }>

contextToOpenai(opts: { reasoningModel?: boolean } = {}): Promise<Array<Record<string, any>>>

emit(event: string, ...args: any[]): void

fetchChatContext(opts: { lastN?: number } = {}): Promise<ChatContext>

fetchContextHistory(opts: { lastN?: number; includeFunctionCalls?: boolean; includeSystemMessages?: boolean } = {}): Promise<Record<string, any>[]>

generate(text: string): Promise<void>

getContextHistory(opts: { lastN?: number; includeFunctionCalls?: boolean; includeSystemMessages?: boolean } = {}): _HistoryAwaitable

handoffs(): AgentHandoff[]

hangup(reason = 'manual_hangup'): Promise<void>

injectContext(ctx: ChatContext): Promise<boolean>

injectMessage(message: | ChatMessage | { role: ChatRole | string; content: string; messageId?: string; images?: ImageContent[] }, opts: { position?: string } = {}): Promise<boolean>

interceptToolResult(result: any): any

interrupt(opts: { force?: boolean } = {}): void

lastHandoffReason(): string

leave(): Promise<void>

listenerCount(event: string): number

off(event: string, handler: EventHandler): void

on(event: string, handler: EventHandler): EventHandler

once(event: string, handler: EventHandler): EventHandler

playBackgroundAudio(config: any = null, _overrideThinking = true): Promise<void>

preloadBackgroundAudio(config: any = null): Promise<void>

publishMessage(config: { topic: string; message?: unknown; options?: Record<string, unknown> | null; payload?: unknown; }): Promise<void>

pushAudioFrame(pcm: Buffer | Uint8Array, sampleRate = 48000): Promise<void>

registerHandoffAgent(agent: Agent): string

removeAllListeners(event?: string): void

removeMessage(messageId: string): Promise<boolean>

reply(instructions: string, opts: { waitForPlayback?: boolean; // eslint-disable-next-line @typescript-eslint/no-explicit-any frames?: any[]; latestFrames?: number; interruptible?: boolean; } = {}): Promise<UtteranceHandle>

say(message: string, opts: { interruptible?: boolean; voice?: string; // eslint-disable-next-line @typescript-eslint/no-explicit-any audioData?: any; addToChatContext?: boolean; // eslint-disable-next-line @typescript-eslint/no-explicit-any [k: string]: any; } = {}): Promise<UtteranceHandle>

sendA2A(targetAgentId: string, messageJson: string, correlationId = ''): Promise<void>

sendImage(data: any, mimeType = 'image/jpeg'): Promise<void>

sendMessageWithFrames(message: string | null, frames: any[], opts: { defaultMimeType?: string; numLatestFrames?: number } = {}): Promise<void>

setUserInputEnabled(enabled: boolean): Promise<void>

start(opts: AgentSessionStartOptions = {}): Promise<void>

startRecording(config: any = null): Promise<void>

startThinkingAudio(): Promise<void>

stopBackgroundAudio(): Promise<void>

stopRecording(): Promise<void>

stopThinkingAudio(): Promise<void>

subscribeA2A(): Promise<void>

subscribePubSub(topic: string, callback?: (msg: { topic: string; message: string; sender_id: string; sender_name: string; timestamp: string; payload: unknown; }) => void): Promise<((msg: any) => void) | null>

summarizeContext(): Promise<void>

updateAgentState(state: AgentState): void

updateContextWindow(opts: { maxTokens?: number; maxContextItems?: number; keepRecentTurns?: number } = {}): Promise<void>

updateInstructions(instructions: string): Promise<void>

updateInterruptConfig(opts: { mode?: string; interruptMinDuration?: number; interruptMinWords?: number; cooldownMs?: number; falseInterruptPauseDurationMs?: number; resumeOnFalseInterrupt?: boolean; } = {}): Promise<void>

updateProvider(component: string, provider: string, params: Record<string, any> | null = null): Promise<void>

updateRecordingState(status: Record<string, any>): void

updateTools(tools: any[]): Promise<void>

updateUserState(state: UserState): void

waitForParticipantArrived(): Promise<void>

waitForSynthesisDone(timeout?: number): Promise<boolean>

warmTransfer(..._args: any[]): Promise<never>

function serve(agent: Agent | AgentFactory | AgentClass, options: ServeOptions = {}): Promise<void>

function invoke(agentId: string, options: InvokeOptions = {}): Promise<InvokeResult>

new Room(init: Room)

new Sip(init: Sip)