@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/session/provider/provider-catalog-session.js

@@ -0,0 +1,343 @@
+import { getErrorMessage } from "@hyperdrive.bot/paseo-protocol/error-utils";
+import { isGlobalProviderSnapshotKey, } from "../../agent/provider-snapshot-manager.js";
+import { expandTilde } from "../../../utils/path.js";
+// COMPAT(customModeIcons): the only mode icons known to clients before v0.1.84. Any
+// other icon name is downgraded to "ShieldCheck" for those clients.
+const LEGACY_MODE_ICONS = new Set([
+    "ShieldCheck",
+    "ShieldAlert",
+    "ShieldOff",
+    "ShieldQuestionMark",
+]);
+/**
+ * A client's provider catalog surface: model / mode / feature listing, the providers
+ * snapshot push + pull, provider diagnostics, and usage. The snapshot PUSH (start) and
+ * every PULL handler gate visibility and downgrade mode icons through the SAME predicates,
+ * so an older client sees one consistent provider set across both paths — the COMPAT
+ * invariant the shell could only enforce by code proximity before this carve.
+ */
+export class ProviderCatalogSession {
+    constructor(options) {
+        this.unsubscribeSnapshotEvents = null;
+        this.host = options.host;
+        this.providerSnapshotManager = options.providerSnapshotManager;
+        this.providerUsageService = options.providerUsageService;
+        this.logger = options.logger;
+    }
+    start() {
+        const handleProviderSnapshotChange = (entries, cwd) => {
+            // COMPAT(providersSnapshot): keep provider visibility gating for older clients.
+            const visibleEntries = entries.filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
+            const snapshotCwd = isGlobalProviderSnapshotKey(cwd) ? undefined : cwd;
+            this.host.emit({
+                type: "providers_snapshot_update",
+                payload: {
+                    ...(snapshotCwd ? { cwd: snapshotCwd } : {}),
+                    entries: this.downgradeEntryModesForClient(visibleEntries),
+                    generatedAt: new Date().toISOString(),
+                },
+            });
+        };
+        this.providerSnapshotManager.on("change", handleProviderSnapshotChange);
+        this.unsubscribeSnapshotEvents = () => {
+            this.providerSnapshotManager.off("change", handleProviderSnapshotChange);
+        };
+    }
+    dispose() {
+        if (this.unsubscribeSnapshotEvents) {
+            this.unsubscribeSnapshotEvents();
+            this.unsubscribeSnapshotEvents = null;
+        }
+    }
+    // COMPAT(customModeIcons): rewrite icons unknown to v0.1.83 clients (whose MODE_ICONS
+    // map is a closed enum and would render `undefined`, crashing in render). Drop
+    // this and the cap gate when floor >= v0.1.84.
+    downgradeModeIconsForClient(modes) {
+        if (this.host.supportsCustomModeIcons())
+            return modes;
+        return modes.map((mode) => mode.icon && !LEGACY_MODE_ICONS.has(mode.icon) ? { ...mode, icon: "ShieldCheck" } : mode);
+    }
+    downgradeEntryModesForClient(entries) {
+        if (this.host.supportsCustomModeIcons())
+            return entries;
+        return entries.map((entry) => entry.modes ? { ...entry, modes: this.downgradeModeIconsForClient(entry.modes) } : entry);
+    }
+    emitProviderDisabledResponse(kind, provider, requestId, fetchedAt) {
+        const payload = {
+            provider,
+            error: `Provider ${provider} is disabled`,
+            fetchedAt,
+            requestId,
+        };
+        if (kind === "models") {
+            this.host.emit({ type: "list_provider_models_response", payload });
+        }
+        else {
+            this.host.emit({ type: "list_provider_modes_response", payload });
+        }
+    }
+    async handleListProviderModelsRequest(msg) {
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
+        const fetchedAt = new Date().toISOString();
+        const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
+        if (!entry) {
+            this.host.emit({
+                type: "list_provider_models_response",
+                payload: {
+                    provider: msg.provider,
+                    error: `Unknown provider: ${msg.provider}`,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        if (!entry.enabled) {
+            this.emitProviderDisabledResponse("models", msg.provider, msg.requestId, fetchedAt);
+            return;
+        }
+        if (entry.status === "ready") {
+            this.host.emit({
+                type: "list_provider_models_response",
+                payload: {
+                    provider: msg.provider,
+                    models: entry.models ?? [],
+                    error: null,
+                    fetchedAt: entry.fetchedAt ?? fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        const errorMessage = entry.status === "error"
+            ? (entry.error ?? `Failed to list models for ${msg.provider}`)
+            : `Provider ${msg.provider} is not available`;
+        this.host.emit({
+            type: "list_provider_models_response",
+            payload: {
+                provider: msg.provider,
+                error: errorMessage,
+                fetchedAt,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async handleListProviderModesRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
+        const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
+        if (!entry) {
+            this.host.emit({
+                type: "list_provider_modes_response",
+                payload: {
+                    provider: msg.provider,
+                    error: `Unknown provider: ${msg.provider}`,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        if (!entry.enabled) {
+            this.emitProviderDisabledResponse("modes", msg.provider, msg.requestId, fetchedAt);
+            return;
+        }
+        if (entry.status === "ready") {
+            this.host.emit({
+                type: "list_provider_modes_response",
+                payload: {
+                    provider: msg.provider,
+                    modes: this.downgradeModeIconsForClient(entry.modes ?? []),
+                    error: null,
+                    fetchedAt: entry.fetchedAt ?? fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        const errorMessage = entry.status === "error"
+            ? (entry.error ?? `Failed to list modes for ${msg.provider}`)
+            : `Provider ${msg.provider} is not available`;
+        this.host.emit({
+            type: "list_provider_modes_response",
+            payload: {
+                provider: msg.provider,
+                error: errorMessage,
+                fetchedAt,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async getProviderSnapshotEntryForRead(cwd, provider) {
+        const manager = this.providerSnapshotManager;
+        const findEntry = () => manager.getSnapshot(cwd).find((candidate) => candidate.provider === provider);
+        let entry = findEntry();
+        if (entry && !entry.enabled) {
+            return entry;
+        }
+        if (!entry || entry.status === "loading") {
+            // Awaits the in-flight warmup (deduped per-cwd) so old clients still get
+            // a resolved answer rather than a loading placeholder.
+            await manager.warmUpSnapshotForCwd({ cwd, providers: [provider] });
+            entry = findEntry();
+        }
+        return entry;
+    }
+    buildDraftAgentSessionConfig(draftConfig) {
+        return {
+            provider: draftConfig.provider,
+            cwd: expandTilde(draftConfig.cwd),
+            ...(draftConfig.modeId ? { modeId: draftConfig.modeId } : {}),
+            ...(draftConfig.model ? { model: draftConfig.model } : {}),
+            ...(draftConfig.thinkingOptionId ? { thinkingOptionId: draftConfig.thinkingOptionId } : {}),
+            ...(draftConfig.featureValues ? { featureValues: draftConfig.featureValues } : {}),
+        };
+    }
+    async handleListProviderFeaturesRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        try {
+            const sessionConfig = this.buildDraftAgentSessionConfig(msg.draftConfig);
+            const features = await this.host.listDraftFeatures(sessionConfig);
+            this.host.emit({
+                type: "list_provider_features_response",
+                payload: {
+                    provider: msg.draftConfig.provider,
+                    features,
+                    error: null,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, provider: msg.draftConfig.provider, draftConfig: msg.draftConfig }, `Failed to list features for ${msg.draftConfig.provider}`);
+            this.host.emit({
+                type: "list_provider_features_response",
+                payload: {
+                    provider: msg.draftConfig.provider,
+                    error: getErrorMessage(error),
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleListAvailableProvidersRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        try {
+            const providers = (await this.host.listProviderAvailability()).filter((provider) => this.host.isProviderVisibleToClient(provider.provider));
+            this.host.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers,
+                    error: null,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to list provider availability");
+            this.host.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers: [],
+                    error: getErrorMessage(error),
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleGetProvidersSnapshotRequest(msg) {
+        // COMPAT(providersSnapshot): keep legacy provider-list RPCs alongside snapshot flow.
+        const entries = this.providerSnapshotManager
+            .getSnapshot(msg.cwd ? expandTilde(msg.cwd) : undefined)
+            .filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
+        this.host.emit({
+            type: "get_providers_snapshot_response",
+            payload: {
+                entries: this.downgradeEntryModesForClient(entries),
+                generatedAt: new Date().toISOString(),
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async handleRefreshProvidersSnapshotRequest(msg) {
+        if (msg.cwd) {
+            await this.providerSnapshotManager.refreshSnapshotForCwd({
+                cwd: expandTilde(msg.cwd),
+                providers: msg.providers,
+            });
+        }
+        else {
+            await this.providerSnapshotManager.refreshSettingsSnapshot({
+                providers: msg.providers,
+            });
+        }
+        this.host.emit({
+            type: "refresh_providers_snapshot_response",
+            payload: {
+                acknowledged: true,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async handleProviderDiagnosticRequest(msg) {
+        try {
+            const { diagnostic } = await this.providerSnapshotManager.getProviderDiagnostic(msg.provider);
+            this.host.emit({
+                type: "provider_diagnostic_response",
+                payload: {
+                    provider: msg.provider,
+                    diagnostic,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({ err, provider: msg.provider }, `Failed to get provider diagnostic for ${msg.provider}`);
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: msg.type,
+                    error: `Failed to get provider diagnostic: ${err.message}`,
+                    code: "provider_diagnostic_failed",
+                },
+            });
+        }
+    }
+    async handleProviderUsageListRequest(msg) {
+        try {
+            const usage = await this.providerUsageService.listUsage();
+            this.host.emit({
+                type: "provider.usage.list.response",
+                payload: {
+                    requestId: msg.requestId,
+                    fetchedAt: usage.fetchedAt,
+                    providers: usage.providers,
+                },
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({ err }, "Failed to list provider usage");
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: msg.type,
+                    error: `Failed to list provider usage: ${err.message}`,
+                    code: "provider_usage_list_failed",
+                },
+            });
+        }
+    }
+}
+function resolveCatalogRequestCwd(cwd) {
+    const trimmed = cwd?.trim();
+    return trimmed ? expandTilde(trimmed) : undefined;
+}
+//# sourceMappingURL=provider-catalog-session.js.map

package/dist/server/server/session/session-rename-route.d.ts

@@ -0,0 +1,4 @@
+import type express from "express";
+import type pino from "pino";
+export declare function registerSessionRenameRoute(app: express.Express, logger: pino.Logger): void;
+//# sourceMappingURL=session-rename-route.d.ts.map

package/dist/server/server/session/session-rename-route.js

@@ -0,0 +1,71 @@
+import { homedir as getHomedir } from "node:os";
+import * as path from "node:path";
+import { renameSession, SessionRenameHookFailedError, SessionRenameHookUnavailableError, } from "./session-rename-service.js";
+// Story PASEO-CHAT-ACTIONS-V1-story-3.2: tab rename persistence.
+//
+// Loopback-bound, single-user trust model — same as the other /api/* routes.
+// The endpoint is a thin shell-out to the agent's session-rename hook
+// (`~/.claude/hooks/session-rename.sh`), which is the sole writer of the JSONL
+// custom-title record. This provider-specific wiring is deliberately kept out
+// of the generic bootstrap so provider names don't leak into shared code.
+// The hook path can be overridden via PASEO_SESSION_RENAME_HOOK_PATH for tests.
+const sessionIdPattern = /^[a-zA-Z0-9_-]+$/;
+function resolveRenameHookPath() {
+    return (process.env.PASEO_SESSION_RENAME_HOOK_PATH ??
+        path.join(process.env.HOME ?? getHomedir(), ".claude", "hooks", "session-rename.sh"));
+}
+export function registerSessionRenameRoute(app, logger) {
+    app.post("/api/sessions/:sessionId/rename", (req, res) => {
+        const handle = async () => {
+            const sessionId = req.params.sessionId;
+            if (!sessionIdPattern.test(sessionId)) {
+                res.status(400).json({ error: "invalid sessionId" });
+                return;
+            }
+            const body = (req.body ?? {});
+            const newName = typeof body.newName === "string" ? body.newName.trim() : "";
+            if (newName.length === 0) {
+                res.status(400).json({ error: "newName required" });
+                return;
+            }
+            let cwd = null;
+            if (body.cwd !== undefined) {
+                if (typeof body.cwd !== "string" || !path.isAbsolute(body.cwd)) {
+                    res.status(400).json({ error: "cwd must be an absolute path" });
+                    return;
+                }
+                cwd = body.cwd;
+            }
+            const effectiveCwd = cwd ?? process.cwd();
+            const hookPath = resolveRenameHookPath();
+            logger.info({ sessionId, newNameLength: newName.length, cwdProvided: cwd !== null }, "session rename requested");
+            try {
+                const result = await renameSession({
+                    sessionId,
+                    newName,
+                    cwd: effectiveCwd,
+                    hookPath,
+                    logger,
+                });
+                res.status(200).json({ ok: true, sessionId, customTitle: result.customTitle });
+            }
+            catch (err) {
+                if (err instanceof SessionRenameHookUnavailableError) {
+                    res.status(500).json({ error: "session-rename hook unavailable" });
+                    return;
+                }
+                if (err instanceof SessionRenameHookFailedError) {
+                    res.status(500).json({
+                        error: "session-rename hook failed",
+                        details: { exitCode: err.exitCode, stderr: err.stderr.slice(0, 500) },
+                    });
+                    return;
+                }
+                logger.error({ err }, "session rename failed with unexpected error");
+                res.status(500).json({ error: "session rename failed" });
+            }
+        };
+        void handle();
+    });
+}
+//# sourceMappingURL=session-rename-route.js.map

package/dist/server/server/session/session-rename-service.d.ts

@@ -0,0 +1,25 @@
+import type { Logger } from "pino";
+export declare class SessionRenameHookUnavailableError extends Error {
+    readonly hookPath: string;
+    readonly cause?: unknown | undefined;
+    constructor(hookPath: string, cause?: unknown | undefined);
+}
+export declare class SessionRenameHookFailedError extends Error {
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    readonly stdoutTail: string;
+    constructor(exitCode: number | null, stderr: string, stdoutTail: string);
+}
+export interface RenameSessionInput {
+    sessionId: string;
+    newName: string;
+    cwd: string;
+    hookPath: string;
+    logger: Logger;
+    timeoutMs?: number;
+}
+export interface RenameSessionResult {
+    customTitle: string;
+}
+export declare function renameSession(input: RenameSessionInput): Promise<RenameSessionResult>;
+//# sourceMappingURL=session-rename-service.d.ts.map

package/dist/server/server/session/session-rename-service.js

@@ -0,0 +1,76 @@
+import { execFile } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+// Story PASEO-CHAT-ACTIONS-V1-story-3.2: thin shell-out to ~/.claude/hooks/session-rename.sh.
+// The hook is the SOLE persistence path for the Claude Code JSONL custom-title record —
+// this service does not parse or write the JSONL itself.
+export class SessionRenameHookUnavailableError extends Error {
+    constructor(hookPath, cause) {
+        super(`session-rename hook unavailable at ${hookPath}`);
+        this.hookPath = hookPath;
+        this.cause = cause;
+        this.name = "SessionRenameHookUnavailableError";
+    }
+}
+export class SessionRenameHookFailedError extends Error {
+    constructor(exitCode, stderr, stdoutTail) {
+        super(`session-rename hook failed (exitCode=${exitCode ?? "null"}): ${stderr.slice(0, 200)}`);
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+        this.stdoutTail = stdoutTail;
+        this.name = "SessionRenameHookFailedError";
+    }
+}
+const DEFAULT_TIMEOUT_MS = 5000;
+export async function renameSession(input) {
+    const { sessionId, newName, cwd, hookPath, logger, timeoutMs = DEFAULT_TIMEOUT_MS } = input;
+    try {
+        const hookStat = await stat(hookPath);
+        if (!hookStat.isFile()) {
+            throw new SessionRenameHookUnavailableError(hookPath);
+        }
+        await access(hookPath, fsConstants.X_OK);
+    }
+    catch (cause) {
+        if (cause instanceof SessionRenameHookUnavailableError) {
+            throw cause;
+        }
+        throw new SessionRenameHookUnavailableError(hookPath, cause);
+    }
+    const result = await runHook({ hookPath, sessionId, newName, cwd, timeoutMs });
+    if (result.exitCode !== 0 || result.stderr.trim().length > 0) {
+        logger.warn({
+            sessionId,
+            exitCode: result.exitCode,
+            stderrLength: result.stderr.length,
+        }, "session-rename hook returned non-success");
+        throw new SessionRenameHookFailedError(result.exitCode, result.stderr, result.stdout.slice(-200));
+    }
+    return { customTitle: newName };
+}
+function runHook(params) {
+    return new Promise((resolve) => {
+        const child = execFile(params.hookPath, [params.sessionId, params.newName, params.cwd], {
+            timeout: params.timeoutMs,
+            maxBuffer: 1024 * 1024,
+            shell: false,
+        }, (error, stdout, stderr) => {
+            if (error && error.code === "ETIMEDOUT") {
+                resolve({
+                    exitCode: null,
+                    stdout: stdout?.toString() ?? "",
+                    stderr: `hook timed out after ${params.timeoutMs}ms`,
+                });
+                return;
+            }
+            const exitCode = child.exitCode;
+            resolve({
+                exitCode,
+                stdout: stdout?.toString() ?? "",
+                stderr: stderr?.toString() ?? "",
+            });
+        });
+    });
+}
+//# sourceMappingURL=session-rename-service.js.map

package/dist/server/server/session/voice/voice-session.d.ts

@@ -0,0 +1,166 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { SpeechToTextProvider, TextToSpeechProvider } from "../../speech/speech-provider.js";
+import type { TurnDetectionProvider } from "../../speech/turn-detection-provider.js";
+import type { VoiceCallerContext, VoiceSpeakHandler } from "../../voice-types.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import type { AgentSessionConfig } from "../../agent/agent-sdk-types.js";
+import { type Resolvable } from "../../speech/provider-resolver.js";
+import type { SpeechReadinessSnapshot } from "../../speech/speech-runtime.js";
+/**
+ * The agent-facing operations VoiceSession needs from the session that owns it.
+ * VoiceSession owns all voice/audio state; it reaches back through this narrow
+ * seam only to deliver transcripts to the agent, drive TTS playback, and
+ * abort/inspect the active agent run.
+ */
+export interface VoiceSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    loadAgent(agentId: string): Promise<ManagedAgent>;
+    reloadAgentSession(agentId: string, overrides: Partial<AgentSessionConfig>): Promise<ManagedAgent>;
+    sendSpokenInput(agentId: string, text: string): Promise<void>;
+    interruptAgentIfRunning(agentId: string): Promise<void>;
+    hasActiveAgentRun(agentId: string | null): boolean;
+}
+export interface VoiceSessionOptions {
+    host: VoiceSessionHost;
+    logger: pino.Logger;
+    sessionId: string;
+    sttLanguage?: string;
+    tts: Resolvable<TextToSpeechProvider | null>;
+    stt: Resolvable<SpeechToTextProvider | null>;
+    voice?: {
+        turnDetection?: Resolvable<TurnDetectionProvider | null>;
+    };
+    voiceBridge?: {
+        registerVoiceSpeakHandler?: (agentId: string, handler: VoiceSpeakHandler) => void;
+        unregisterVoiceSpeakHandler?: (agentId: string) => void;
+        registerVoiceCallerContext?: (agentId: string, context: VoiceCallerContext) => void;
+        unregisterVoiceCallerContext?: (agentId: string) => void;
+    };
+    dictation?: {
+        finalTimeoutMs?: number;
+        stt?: Resolvable<SpeechToTextProvider | null>;
+        sttLanguage?: string;
+        getSpeechReadiness?: () => SpeechReadinessSnapshot;
+    };
+}
+/**
+ * Owns the voice half of a client session: speech-to-text/text-to-speech
+ * managers, dictation streaming, the barge-in audio-buffering state machine,
+ * voice-turn detection, and the MCP voice bridge. The session delegates the
+ * voice/dictation/abort message types here and otherwise knows nothing about
+ * audio buffering or processing phases.
+ */
+export declare class VoiceSession {
+    private readonly host;
+    private readonly sessionLogger;
+    private readonly sessionId;
+    private readonly sttLanguage;
+    private abortController;
+    private processingPhase;
+    private isVoiceMode;
+    private speechInProgress;
+    private readonly dictationStreamManager;
+    private readonly resolveVoiceTurnDetection;
+    private voiceTurnController;
+    private voiceInputChunkCount;
+    private voiceInputBytes;
+    private voiceInputWindowStartedAt;
+    private pendingAudioSegments;
+    private bufferTimeout;
+    private audioBuffer;
+    private readonly ttsDebugStreams;
+    private readonly ttsManager;
+    private readonly sttManager;
+    private readonly registerVoiceSpeakHandler?;
+    private readonly unregisterVoiceSpeakHandler?;
+    private readonly registerVoiceCallerContext?;
+    private readonly unregisterVoiceCallerContext?;
+    private readonly getSpeechReadiness?;
+    private voiceModeAgentId;
+    private voiceModeBaseConfig;
+    constructor(options: VoiceSessionOptions);
+    isActiveForAgent(agentId: string): boolean;
+    handleDictationChunk(params: {
+        dictationId: string;
+        seq: number;
+        audioBase64: string;
+        format: string;
+    }): Promise<void>;
+    handleDictationFinish(dictationId: string, finalSeq: number): Promise<void>;
+    handleDictationCancel(dictationId: string): void;
+    handleDictationStreamStart(msg: Extract<SessionInboundMessage, {
+        type: "dictation_stream_start";
+    }>): Promise<void>;
+    private toVoiceFeatureUnavailableContext;
+    private resolveModeReadinessState;
+    private getVoiceFeatureUnavailableResponseMetadata;
+    private resolveVoiceFeatureUnavailableContext;
+    /**
+     * Handle voice mode toggle
+     */
+    handleSetVoiceMode(enabled: boolean, agentId?: string, requestId?: string): Promise<void>;
+    private parseVoiceTargetAgentId;
+    private enableVoiceModeForAgent;
+    private disableVoiceModeForActiveAgent;
+    private handleDictationManagerMessage;
+    private startVoiceTurnController;
+    private stopVoiceTurnController;
+    private handleVoiceSpeechStopped;
+    private ensureAudioBufferForFormat;
+    private forwardAudioChunkToVoiceTurn;
+    handleAudioChunk(msg: Extract<SessionInboundMessage, {
+        type: "voice_audio_chunk";
+    }>): Promise<void>;
+    private finalizeBufferedAudio;
+    private processCompletedAudio;
+    private flushPendingAudioSegments;
+    /**
+     * Process audio through STT and then LLM
+     */
+    private processAudio;
+    private handleTranscriptionResultPayload;
+    private registerVoiceBridgeForAgent;
+    /**
+     * Handle abort request from client
+     */
+    handleAbort(): Promise<void>;
+    /**
+     * Handle audio playback confirmation from client
+     */
+    handleAudioPlayed(id: string): void;
+    /**
+     * Mark speech detection start and abort any active playback/agent run.
+     */
+    private handleVoiceSpeechStart;
+    /**
+     * Clear speech-in-progress flag once the user turn has completed
+     */
+    private clearSpeechInProgress;
+    /**
+     * Create new AbortController, aborting the previous one
+     */
+    private createAbortController;
+    /**
+     * Set the processing phase
+     */
+    private setPhase;
+    /**
+     * Set timeout to process buffered audio segments
+     */
+    private setBufferTimeout;
+    /**
+     * Clear buffer timeout
+     */
+    private clearBufferTimeout;
+    /**
+     * Emit a message to the client. Captures TTS audio_output frames for optional
+     * debug persistence before forwarding to the session emitter.
+     */
+    private emit;
+    /**
+     * Tear down all voice resources.
+     */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=voice-session.d.ts.map