@getpaseo/server 0.1.100 → 0.1.102-beta.2

package/dist/server/server/speech/providers/openai/config.d.ts

@@ -2,17 +2,16 @@ import type { PersistedConfig } from "../../../persisted-config.js";
 import type { RequestedSpeechProviders } from "../../speech-types.js";
 import type { STTConfig } from "./stt.js";
 import type { TTSConfig } from "./tts.js";
-export declare const DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL = "gpt-4o-transcribe";
 export declare const DEFAULT_OPENAI_TTS_MODEL = "tts-1";
 export interface OpenAiSpeechProviderConfig {
     apiKey?: string;
+    baseUrl?: string;
     stt?: Partial<STTConfig> & {
         apiKey?: string;
     };
     tts?: Partial<TTSConfig> & {
         apiKey?: string;
     };
-    realtimeTranscriptionModel?: string;
 }
 export declare function resolveOpenAiSpeechConfig(params: {
     env: NodeJS.ProcessEnv;

package/dist/server/server/speech/providers/openai/config.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-export const DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL = "gpt-4o-transcribe";
 export const DEFAULT_OPENAI_TTS_MODEL = "tts-1";
 const OpenAiTtsVoiceSchema = z.enum(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]);
 const OpenAiTtsModelSchema = z.enum(["tts-1", "tts-1-hd"]);
@@ -12,6 +11,7 @@ const OptionalTrimmedStringSchema = z
     .transform((value) => (value && value.length > 0 ? value : undefined));
 const OpenAiSpeechResolutionSchema = z.object({
     apiKey: OptionalTrimmedStringSchema,
+    baseUrl: OptionalTrimmedStringSchema,
     sttConfidenceThreshold: OptionalFiniteNumberSchema,
     sttModel: OptionalTrimmedStringSchema,
     ttsVoice: z.string().trim().toLowerCase().pipe(OpenAiTtsVoiceSchema).default("alloy"),
@@ -21,7 +21,6 @@ const OpenAiSpeechResolutionSchema = z.object({
         .toLowerCase()
         .pipe(OpenAiTtsModelSchema)
         .default(DEFAULT_OPENAI_TTS_MODEL),
-    realtimeTranscriptionModel: OptionalTrimmedStringSchema.default(DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL),
 });
 function isOpenAiProviderActive(provider) {
     return provider.enabled !== false && provider.provider === "openai";
@@ -49,11 +48,6 @@ function buildOpenAiSttInput(params) {
             pickIfOpenAi(providers.voiceStt, persisted.features?.voiceMode?.stt?.model),
             pickIfOpenAi(providers.dictationStt, persisted.features?.dictation?.stt?.model),
         ]),
-        realtimeTranscriptionModel: firstDefined([
-            env.OPENAI_REALTIME_TRANSCRIPTION_MODEL,
-            pickIfOpenAi(providers.dictationStt, persisted.features?.dictation?.stt?.model),
-            DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL,
-        ]),
     };
 }
 function buildOpenAiTtsInput(params) {
@@ -74,8 +68,16 @@ function buildOpenAiTtsInput(params) {
 function buildOpenAiResolutionInput(params) {
     return {
         apiKey: firstDefined([
-            params.env.OPENAI_API_KEY,
+            params.persisted.providers?.openai?.voice?.apiKey,
+            params.env.OPENAI_VOICE_API_KEY,
             params.persisted.providers?.openai?.apiKey,
+            params.env.OPENAI_API_KEY,
+        ]),
+        baseUrl: firstDefined([
+            params.persisted.providers?.openai?.voice?.baseUrl,
+            params.env.OPENAI_VOICE_BASE_URL,
+            params.persisted.providers?.openai?.baseUrl,
+            params.env.OPENAI_BASE_URL,
         ]),
         ...buildOpenAiSttInput(params),
         ...buildOpenAiTtsInput(params),
@@ -88,8 +90,10 @@ export function resolveOpenAiSpeechConfig(params) {
     }
     return {
         apiKey: parsed.apiKey,
+        ...(parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {}),
         stt: {
             apiKey: parsed.apiKey,
+            ...(parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {}),
             ...(parsed.sttConfidenceThreshold !== undefined
                 ? { confidenceThreshold: parsed.sttConfidenceThreshold }
                 : {}),
@@ -97,11 +101,11 @@ export function resolveOpenAiSpeechConfig(params) {
         },
         tts: {
             apiKey: parsed.apiKey,
+            ...(parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {}),
             voice: parsed.ttsVoice,
             model: parsed.ttsModel,
             responseFormat: "pcm",
         },
-        realtimeTranscriptionModel: parsed.realtimeTranscriptionModel,
     };
 }
 //# sourceMappingURL=config.js.map

package/dist/server/server/speech/providers/openai/runtime.js

@@ -1,5 +1,4 @@
-import { DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL, DEFAULT_OPENAI_TTS_MODEL, } from "./config.js";
-import { OpenAIRealtimeTranscriptionSession } from "./realtime-transcription-session.js";
+import { DEFAULT_OPENAI_TTS_MODEL } from "./config.js";
 import { OpenAISTT } from "./stt.js";
 import { OpenAITTS } from "./tts.js";
 function resolveOpenAiCredentials(openaiConfig) {
@@ -62,19 +61,6 @@ function createOpenAiTts(apiKey, openaiConfig, logger) {
         ...ttsConfig,
     }, logger);
 }
-function createOpenAiDictationService(apiKey, openaiConfig) {
-    return {
-        id: "openai",
-        createSession: ({ logger: sessionLogger, language, prompt }) => new OpenAIRealtimeTranscriptionSession({
-            apiKey,
-            logger: sessionLogger,
-            transcriptionModel: openaiConfig?.realtimeTranscriptionModel ?? DEFAULT_OPENAI_REALTIME_TRANSCRIPTION_MODEL,
-            ...(language ? { language } : {}),
-            ...(prompt ? { prompt } : {}),
-            turnDetection: null,
-        }),
-    };
-}
 export function initializeOpenAiSpeechServices(params) {
     const { providers, openaiConfig, existing, logger } = params;
     const openAiCredentials = resolveOpenAiCredentials(openaiConfig);
@@ -100,7 +86,7 @@ export function initializeOpenAiSpeechServices(params) {
             ttsService = createOpenAiTts(openAiCredentials.openaiTtsApiKey, openaiConfig, logger);
         }
         if (needsOpenAiDictation && openAiCredentials.openaiDictationApiKey) {
-            dictationSttService = createOpenAiDictationService(openAiCredentials.openaiDictationApiKey, openaiConfig);
+            dictationSttService = createOpenAiStt(openAiCredentials.openaiDictationApiKey, openaiConfig, logger);
         }
     }
     else if (needsAnyOpenAi) {

package/dist/server/server/speech/providers/openai/stt.d.ts

@@ -3,6 +3,7 @@ import type { LogprobToken, SpeechToTextProvider, StreamingTranscriptionSession,
 export type { LogprobToken, TranscriptionResult };
 export interface STTConfig {
     apiKey: string;
+    baseUrl?: string;
     model?: "whisper-1" | "gpt-4o-transcribe" | "gpt-4o-mini-transcribe" | (string & {});
     confidenceThreshold?: number;
 }

package/dist/server/server/speech/providers/openai/stt.js

@@ -33,6 +33,7 @@ export class OpenAISTT {
         this.logger = parentLogger.child({ module: "agent", provider: "openai", component: "stt" });
         this.openaiClient = new OpenAI({
             apiKey: sttConfig.apiKey,
+            ...(sttConfig.baseUrl ? { baseURL: sttConfig.baseUrl } : {}),
         });
         this.logger.info({ model: sttConfig.model || "whisper-1" }, "STT (OpenAI Whisper) initialized");
     }
@@ -102,7 +103,7 @@ export class OpenAISTT {
                             return;
                         }
                         const wav = convertPCMToWavBuffer(pcm16);
-                        const result = await transcribeAudio(wav, "audio/wav", params.language ?? "en", logger);
+                        const result = await transcribeAudio(wav, "audio/wav", params.language ?? "en", logger, params.prompt);
                         emitter.emit("transcript", {
                             segmentId: committedId,
                             transcript: result.text,
@@ -137,7 +138,7 @@ export class OpenAISTT {
             },
         };
     }
-    async transcribeAudioInternal(audioBuffer, format, language, logger) {
+    async transcribeAudioInternal(audioBuffer, format, language, logger, prompt) {
         const startTime = Date.now();
         let tempFilePath = null;
         try {
@@ -152,6 +153,7 @@ export class OpenAISTT {
                 file: await import("fs").then((fs) => fs.createReadStream(tempFilePath)),
                 language,
                 model: modelToUse,
+                ...(prompt ? { prompt } : {}),
                 ...(supportsLogprobs ? { include: includeLogprobs } : {}),
                 response_format: "json",
             });

package/dist/server/server/speech/providers/openai/tts.d.ts

@@ -3,6 +3,7 @@ import type { SpeechStreamResult, TextToSpeechProvider } from "../../speech-prov
 export type { SpeechStreamResult };
 export interface TTSConfig {
     apiKey: string;
+    baseUrl?: string;
     model?: "tts-1" | "tts-1-hd";
     voice?: "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer";
     responseFormat?: "mp3" | "opus" | "aac" | "flac" | "wav" | "pcm";

package/dist/server/server/speech/providers/openai/tts.js

@@ -10,6 +10,7 @@ export class OpenAITTS {
         this.logger = parentLogger.child({ module: "agent", provider: "openai", component: "tts" });
         this.openaiClient = new OpenAI({
             apiKey: ttsConfig.apiKey,
+            ...(ttsConfig.baseUrl ? { baseURL: ttsConfig.baseUrl } : {}),
         });
         this.logger.info({ voice: this.config.voice, model: this.config.model, format: this.config.responseFormat }, "TTS (OpenAI) initialized");
     }

package/dist/server/server/web-ui.d.ts

@@ -0,0 +1,10 @@
+import type { RequestHandler } from "express";
+import type { Logger } from "pino";
+export interface WebUiMiddlewareOptions {
+    enabled: boolean;
+    distDir: string | null;
+    label: string;
+    logger: Logger;
+}
+export declare function createWebUiMiddleware(options: WebUiMiddlewareOptions): RequestHandler;
+//# sourceMappingURL=web-ui.d.ts.map

package/dist/server/server/web-ui.js

@@ -0,0 +1,205 @@
+import { createReadStream, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const EXCLUDED_PATH_PREFIXES = ["/api/", "/mcp/", "/public/"];
+const EXCLUDED_PATHS = new Set(["/api", "/mcp", "/public"]);
+function isExcludedPath(requestPath) {
+    for (const prefix of EXCLUDED_PATH_PREFIXES) {
+        if (requestPath.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return EXCLUDED_PATHS.has(requestPath);
+}
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".mjs": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".eot": "application/vnd.ms-fontobject",
+    ".map": "application/json",
+};
+function getContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function selectEncoding(acceptEncoding) {
+    if (!acceptEncoding) {
+        return null;
+    }
+    const normalized = acceptEncoding.toLowerCase();
+    if (normalized.includes("br")) {
+        return "br";
+    }
+    if (normalized.includes("gzip")) {
+        return "gzip";
+    }
+    return null;
+}
+function isHashedAsset(filePath) {
+    const base = path.basename(filePath);
+    // Match content hashes like index-abc123def456.js or main.abc123def456.css.
+    return /[-.][0-9a-f]{16,}[-.]/i.test(base);
+}
+function isInsideDir(targetPath, dirPath) {
+    const resolvedDir = path.resolve(dirPath);
+    const resolvedTarget = path.resolve(targetPath);
+    return resolvedTarget === resolvedDir || resolvedTarget.startsWith(resolvedDir + path.sep);
+}
+function resolveTargetFile(distDir, requestPath) {
+    const safePath = path.normalize(requestPath).replace(/^(\.\.[/\\])+/, "");
+    let filePath = path.join(distDir, safePath);
+    const stat = safeStat(filePath);
+    if (stat?.isDirectory()) {
+        filePath = path.join(filePath, "index.html");
+    }
+    const finalStat = safeStat(filePath);
+    if (!finalStat?.isFile()) {
+        filePath = path.join(distDir, "index.html");
+        const fallbackStat = safeStat(filePath);
+        if (!fallbackStat?.isFile()) {
+            return null;
+        }
+    }
+    if (!isInsideDir(filePath, distDir)) {
+        return null;
+    }
+    const resolvedFile = path.resolve(filePath);
+    const isIndexHtml = path.basename(resolvedFile).toLowerCase() === "index.html";
+    return { resolvedFile, isIndexHtml };
+}
+function safeStat(filePath) {
+    try {
+        return statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveContentEncoding(resolvedFile, acceptEncoding) {
+    const encoding = selectEncoding(acceptEncoding);
+    if (!encoding) {
+        return { finalFile: resolvedFile, contentEncoding: null };
+    }
+    const compressedFile = `${resolvedFile}.${encoding === "br" ? "br" : "gz"}`;
+    const compressedStat = safeStat(compressedFile);
+    if (compressedStat?.isFile()) {
+        return { finalFile: compressedFile, contentEncoding: encoding };
+    }
+    return { finalFile: resolvedFile, contentEncoding: null };
+}
+function setResponseCacheHeaders(res, isIndexHtml, resolvedFile) {
+    if (isIndexHtml) {
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+    }
+    else if (isHashedAsset(resolvedFile)) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    }
+    else {
+        res.setHeader("Cache-Control", "no-cache");
+    }
+}
+export function createWebUiMiddleware(options) {
+    const { enabled, distDir, label, logger } = options;
+    const childLogger = logger.child({ module: "web-ui" });
+    if (!enabled || !distDir) {
+        childLogger.info({ enabled, hasDistDir: !!distDir }, "Daemon web UI disabled or missing dist directory");
+    }
+    else {
+        childLogger.info({ distDir }, "Daemon web UI mounted");
+    }
+    return (req, res, next) => {
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            next();
+            return;
+        }
+        if (isExcludedPath(req.path)) {
+            next();
+            return;
+        }
+        if (!enabled || !distDir) {
+            res.status(404).end();
+            return;
+        }
+        serveWebUiFile({ distDir, requestPath: req.path, label, req, res });
+    };
+}
+function serveWebUiFile(options) {
+    const { distDir, requestPath, label, req, res } = options;
+    const target = resolveTargetFile(distDir, requestPath);
+    if (!target) {
+        res.status(404).end();
+        return;
+    }
+    const { resolvedFile, isIndexHtml } = target;
+    const acceptEncoding = isIndexHtml ? undefined : req.headers["accept-encoding"];
+    const { finalFile, contentEncoding } = resolveContentEncoding(resolvedFile, acceptEncoding);
+    res.setHeader("Content-Type", getContentType(resolvedFile));
+    if (contentEncoding) {
+        res.setHeader("Content-Encoding", contentEncoding);
+        res.setHeader("Vary", "Accept-Encoding");
+    }
+    setResponseCacheHeaders(res, isIndexHtml, resolvedFile);
+    if (req.method === "HEAD") {
+        res.status(200).end();
+        return;
+    }
+    if (isIndexHtml) {
+        sendIndexHtml(res, finalFile, req, label);
+        return;
+    }
+    const stream = createReadStream(finalFile);
+    stream.on("error", () => {
+        if (!res.headersSent) {
+            res.status(500).end();
+        }
+        else {
+            res.end();
+        }
+    });
+    stream.pipe(res);
+}
+function sendIndexHtml(res, filePath, req, label) {
+    try {
+        const html = readFileSync(filePath, "utf-8");
+        const injected = injectConnectionHint(html, req, label);
+        res.status(200).send(injected);
+    }
+    catch {
+        res.status(500).end();
+    }
+}
+function serializeInlineScriptJson(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003C")
+        .replace(/>/g, "\\u003E")
+        .replace(/&/g, "\\u0026");
+}
+function injectConnectionHint(html, req, label) {
+    const host = typeof req.headers.host === "string" ? req.headers.host : "";
+    const useTls = req.protocol === "https";
+    const hint = {
+        listen: host,
+        useTls,
+        label,
+    };
+    const script = `<script>window.__PASEO_INITIAL_DAEMON_CONNECTION__=${serializeInlineScriptJson(hint)}</script>`;
+    const headClose = /<\/head>/i;
+    if (headClose.test(html)) {
+        return html.replace(headClose, `${script}</head>`);
+    }
+    return script + html;
+}
+//# sourceMappingURL=web-ui.js.map

package/dist/server/server/websocket/runtime-metrics.d.ts

@@ -1,4 +1,5 @@
 import type { WSOutboundMessage } from "../messages.js";
+import type { ProcessMemoryDiagnostics } from "../process-diagnostics.js";
 export interface WebSocketRuntimeCounters {
     connectedAwaitingHello: number;
     helloResumed: number;
@@ -39,6 +40,28 @@ export interface WebSocketRuntimeMetricsSnapshot {
         totalMs: number;
     }>;
 }
+export interface WebSocketRuntimeDiagnosticSnapshot<TRuntime = unknown, TAgents = unknown> extends WebSocketRuntimeMetricsSnapshot {
+    collectedAt: string;
+    final: boolean;
+    sessions: {
+        activeConnections: number;
+        externalSessionKeys: number;
+        reconnectGraceSessions: number;
+    };
+    sockets: {
+        activeSockets: number;
+        pendingConnections: number;
+    };
+    eventLoopDelay: {
+        p50Ms: number;
+        p99Ms: number;
+        maxMs: number;
+    } | null;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
+    runtime: TRuntime;
+    agents: TAgents;
+}
 type Clock = () => number;
 export declare class WebSocketRuntimeMetricsWindow {
     private readonly clock;

package/dist/server/server/websocket-server.d.ts

@@ -26,6 +26,7 @@ import { type DaemonAuthConfig } from "./auth.js";
 export interface ExternalSocketMetadata {
     transport: "relay";
     externalSessionKey?: string;
+    relayConnectionId?: string;
 }
 interface WebSocketServerConfig {
     allowedOrigins: Set<string>;
@@ -50,8 +51,8 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly wss;
     private readonly pendingConnections;
     private readonly sessions;
+    private readonly socketIdentities;
     private readonly externalSessionsByKey;
-    private readonly socketMessageQueues;
     private readonly serverId;
     private readonly daemonVersion;
     private readonly daemonRuntimeConfig;
@@ -89,6 +90,7 @@ export declare class VoiceAssistantWebSocketServer {
     private onBranchChanged;
     private serverCapabilities;
     private readonly runtimeMetrics;
+    private lastRuntimeMetricsSnapshot;
     private runtimeMetricsInterval;
     private eventLoopDelayMonitor;
     private unsubscribeSpeechReadiness;
@@ -135,7 +137,6 @@ export declare class VoiceAssistantWebSocketServer {
     private broadcastCapabilitiesUpdate;
     private broadcastDaemonConfigChanged;
     private bindSocketHandlers;
-    private enqueueRawMessage;
     resolveVoiceSpeakHandler(callerAgentId: string): VoiceSpeakHandler | null;
     resolveVoiceCallerContext(callerAgentId: string): VoiceCallerContext | null;
     private detachSocket;
@@ -157,5 +158,6 @@ export declare class VoiceAssistantWebSocketServer {
     private broadcastAgentAttention;
     private broadcastTerminalAttention;
 }
+export declare function isWebSocketSameOrigin(origin: string | undefined, requestHost: string | null): boolean;
 export {};
 //# sourceMappingURL=websocket-server.d.ts.map