@getpaseo/server 0.1.98 → 0.1.99

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

@@ -0,0 +1,339 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { resolveSnapshotCwd, } 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 = cwd === resolveSnapshotCwd() ? 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 = resolveSnapshotCwd(msg.cwd ? expandTilde(msg.cwd) : undefined);
+        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 = resolveSnapshotCwd(msg.cwd ? expandTilde(msg.cwd) : undefined);
+        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",
+                },
+            });
+        }
+    }
+}
+//# sourceMappingURL=provider-catalog-session.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