/** @internal Transport bridge for a single session. */
export declare class GrpcBridge {
    readonly addr: string;
    readonly agent: any;
    readonly pipeline: any;
    readonly session: any;
    readonly roomConfig: Record<string, any>;
    readonly recording: any;
    private client;
    private eventStream;
    private callMetadata;
    sessionId: string;
    private readonly outboundQueue;
    /** True once the session event stream has ended; later sends fail fast instead of vanishing. */
    private streamEnded;
    private readonly outboundDropCounts;
    private readonly outboundDropLastEmitTs;
    private readonly pumpWorkerErrorCounts;
    private readonly pumpWorkerErrorLastEmitTs;
    private running;
    private readonly pendingTasks;
    private llmStreamBridge;
    private llmStreamBridgeHook;
    private customSttPump;
    private customTtsPump;
    private observeQueue;
    private observeTask;
    constructor(runtimeAddr: string, agent: any, pipeline: any, session: any, roomConfig: Record<string, any>, recording?: any);
    private track;
    private openClient;
    createSession(): Promise<string>;
    private unaryCreateSession;
    /** Reject realtime configs against an engine that predates pipeline-mode derivation. */
    private guardStaleEngine;
    /** Queue an outbound command; fails fast when the session stream has already ended. */
    private putOutbound;
    /** Surface a fatal event-stream failure to session listeners as a `runtime_error`. */
    private emitStreamFailure;
    destroySession(opts?: {
        skipDestroyRpc?: boolean;
    }): Promise<void>;
    runEventLoop(): Promise<void>;
    sendGenerate(text: string): Promise<void>;
    sendCancelGeneration(): Promise<void>;
    sendSetUserInputEnabled(enabled: boolean): Promise<void>;
    sendSay(text: string, interruptCurrent?: boolean, voice?: string, interruptible?: boolean): Promise<void>;
    sendToolResult(callId: string, resultJson: string, isError?: boolean): Promise<void>;
    sendUpdateInstructions(instructions: string): Promise<void>;
    /** Retune the conversation context-window budget live; zeros leave a knob unchanged. */
    sendUpdateContextWindow(maxTokens: number, maxContextItems: number, keepRecentTurns: number): Promise<void>;
    /** Ask the session to summarize and compress the conversation now. */
    sendSummarizeContext(): Promise<void>;
    /**
     * Clear the running conversation history. With `keepSystemPrompt`, the agent's
     * instructions are kept and only the turns are cleared. Returns whether the
     * clear was applied.
     */
    clearContext(keepSystemPrompt?: boolean): Promise<boolean>;
    sendUpdateTools(tools: any[]): Promise<void>;
    sendPlayBackgroundAudio(fileUrl: string, volume?: number, looping?: boolean, playbackMode?: boolean, audioData?: Buffer | Uint8Array): Promise<void>;
    sendPreloadBackgroundAudio(fileUrl: string, volume?: number, audioData?: Buffer | Uint8Array): Promise<void>;
    sendStopBackgroundAudio(): Promise<void>;
    sendPushAudioFrame(pcm: Buffer | Uint8Array, sampleRate: number): Promise<void>;
    sendSendImage(mimeType: string, data: Buffer | Uint8Array): Promise<void>;
    sendPublishMessage(topic: string, message: string, optionsJson: string, payloadJson: string): Promise<void>;
    sendSubscribePubSub(topic: string): Promise<void>;
    sendSendMessageWithFrames(text: string | null, frames: Array<[string, Buffer | Uint8Array]>, numLatestFrames?: number): Promise<void>;
    sendRecordingStart(config: any): Promise<void>;
    sendRecordingStop(): Promise<void>;
    sendCallTransfer(transferTo: string, token?: string): Promise<void>;
    sendUpdateProvider(component: string, provider: string, params?: Record<string, any> | null): Promise<void>;
    /** Request a live pipeline-mode switch; components are (component, provider, params) triples. */
    sendReconfigurePipeline(pipelineMode: string, components: Array<[string, string, Record<string, string> | null]>): Promise<void>;
    sendModifyLlmToken(tokenId: number, replacement?: string, drop?: boolean): Promise<void>;
    private handleCustomSttAudio;
    private sendCustomSttResult;
    private handleCustomTtsSynthesize;
    private sendCustomTtsAudio;
    private emitOutboundQueueDrop;
    private emitPumpWorkerError;
    private handleRuntimeEvent;
    private enqueueObserve;
    private observePump;
    private handleErrorEvent;
    private handleObserveEvent;
    private handleLlmTokenForReview;
    private handleBeforeLlm;
    private _runSttStreamHookOnce;
    /**
     * Run the registered `tts` stream hook once over a one-item text stream and return
     * the rewritten text (joined from the hook's forwarded chunks). @internal
     */
    private _runTtsStreamHookOnce;
    private handleSttHook;
    private handleTtsHook;
    private handleToolCall;
    private dispatchRecordingStatus;
    private buildSessionConfig;
    private callHook;
    private setSessionField;
    private updateAgentState;
    private updateUserState;
    private currentUtterance;
    /** Resolve the oldest pending say()/reply() handle (FIFO). Falls back to the current one. */
    private resolveUtterance;
    private markUtteranceDone;
}
/** @internal Convert a `snake_case` config key to the `camelCase` transport form. */
export declare function toWireKey(key: string): string;
/** @internal Recursively rewrite keys to transport form; binary and string-map fields untouched. */
export declare function toWireKeys(value: any): any;