@getpaseo/server 0.1.74 → 0.1.75

package/dist/server/server/session.js

@@ -38,6 +38,7 @@ import { buildStoredAgentPayload, resolveEffectiveThinkingOptionId, resolveStore
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
 import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from "./agent/timeline-projection.js";
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent/agent-response-loop.js";
+import { getAgentStreamEventTurnId, } from "./agent/agent-sdk-types.js";
 import { ImportSessionsRequestError, importProviderSession, listImportableProviderSessions, normalizeImportAgentRequest, } from "./agent/import-sessions.js";
 import { checkoutLiteFromGitSnapshot, normalizeWorkspaceId as normalizePersistedWorkspaceId, deriveProjectGroupingName, classifyDirectoryForProjectMembership, deriveWorkspaceDisplayName, } from "./workspace-registry-model.js";
 import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
@@ -322,7 +323,7 @@ export class Session {
                 }
             },
         });
-        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, } = options;
+        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion ?? null;
         this.clientCapabilities = parseClientCapabilities(clientCapabilities);
@@ -367,6 +368,7 @@ export class Session {
         this.getDaemonTcpPort = getDaemonTcpPort ?? null;
         this.getDaemonTcpHost = getDaemonTcpHost ?? null;
         this.resolveScriptHealth = resolveScriptHealth ?? null;
+        this.sttLanguage = sttLanguage ?? "en";
         this.subscribeToOptionalManagers();
         this.bindVoiceBridges({ voice, voiceBridge, dictation });
         this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
@@ -381,11 +383,11 @@ export class Session {
             isProviderVisibleToClient: (provider) => this.isProviderVisibleToClient(provider),
             buildWorkspaceDescriptor: (input) => this.buildWorkspaceDescriptor(input),
         });
-        this.initializePerSessionManagers({ tts, stt, dictation });
+        this.initializePerSessionManagers({ tts, stt, sttLanguage, dictation });
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
-        this.sessionLogger.trace("Session created");
+        this.sessionLogger.trace({}, "agent.session.lifecycle.created");
     }
     updateAppVersion(appVersion) {
         if (appVersion && appVersion !== this.appVersion) {
@@ -477,12 +479,17 @@ export class Session {
     async interruptAgentIfRunning(agentId) {
         const snapshot = this.agentManager.getAgent(agentId);
         if (!snapshot) {
-            this.sessionLogger.trace({ agentId }, "interruptAgentIfRunning: agent not found");
+            this.sessionLogger.trace({ agentId }, "agent.session.interrupt.not_found");
             throw new Error(`Agent ${agentId} not found`);
         }
         const hasInFlightRun = this.agentManager.hasInFlightRun(agentId);
         if (!hasInFlightRun) {
-            this.sessionLogger.trace({ agentId, lifecycle: snapshot.lifecycle, hasInFlightRun }, "interruptAgentIfRunning: skipping because agent is not running");
+            this.sessionLogger.trace({
+                agentId,
+                provider: snapshot.provider,
+                lifecycle: snapshot.lifecycle,
+                hasInFlightRun,
+            }, "agent.session.interrupt.skip_not_running");
             return;
         }
         this.sessionLogger.debug({ agentId, lifecycle: snapshot.lifecycle, hasInFlightRun }, "interruptAgentIfRunning: interrupting");
@@ -507,14 +514,14 @@ export class Session {
             agentId,
             promptType: typeof prompt === "string" ? "string" : "structured",
             hasRunOptions: Boolean(runOptions),
-        }, "startAgentStream: requested");
+        }, "agent.session.start_stream.request");
         let iterator;
         try {
             const shouldReplace = this.agentManager.hasInFlightRun(agentId);
             iterator = shouldReplace
                 ? this.agentManager.replaceAgentRun(agentId, prompt, runOptions)
                 : this.agentManager.streamAgent(agentId, prompt, runOptions);
-            this.sessionLogger.trace({ agentId, shouldReplace }, "startAgentStream: agent iterator returned");
+            this.sessionLogger.trace({ agentId, shouldReplace }, "agent.session.start_stream.iterator_returned");
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, "Failed to start agent run");
@@ -525,10 +532,10 @@ export class Session {
                 for await (const _ of iterator) {
                     // Events are forwarded via the session's AgentManager subscription.
                 }
-                this.sessionLogger.trace({ agentId }, "startAgentStream: iterator drained");
+                this.sessionLogger.trace({ agentId }, "agent.session.iterator.drained");
             }
             catch (error) {
-                this.sessionLogger.trace({ agentId, err: error }, "startAgentStream: iterator threw");
+                this.sessionLogger.trace({ agentId, err: error }, "agent.session.iterator.error");
                 this.handleAgentRunError(agentId, error, "Agent stream failed");
             }
         })();
@@ -562,7 +569,7 @@ export class Session {
             });
             this.agentTools = (await this.agentMcpClient.tools());
             const agentToolCount = Object.keys(this.agentTools ?? {}).length;
-            this.sessionLogger.trace({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
+            this.sessionLogger.trace({ agentToolCount }, "agent.session.mcp_init");
         }
         catch (error) {
             this.sessionLogger.error({ err: error }, "Failed to initialize Agent MCP");
@@ -602,14 +609,17 @@ export class Session {
         this.getSpeechReadiness = dictation?.getSpeechReadiness;
     }
     initializePerSessionManagers(params) {
-        const { tts, stt, dictation } = params;
+        const { tts, stt, sttLanguage, dictation } = params;
         this.ttsManager = new TTSManager(this.sessionId, this.sessionLogger, tts);
-        this.sttManager = new STTManager(this.sessionId, this.sessionLogger, stt);
+        this.sttManager = new STTManager(this.sessionId, this.sessionLogger, stt, {
+            language: sttLanguage,
+        });
         this.dictationStreamManager = new DictationStreamManager({
             logger: this.sessionLogger,
             sessionId: this.sessionId,
             emit: (msg) => this.handleDictationManagerMessage(msg),
             stt: dictation?.stt ?? null,
+            language: dictation?.sttLanguage,
             finalTimeoutMs: dictation?.finalTimeoutMs,
         });
     }
@@ -619,6 +629,13 @@ export class Session {
         }
         this.unsubscribeAgentEvents = this.agentManager.subscribe((event) => {
             if (event.type === "agent_state") {
+                this.sessionLogger.trace({
+                    agentId: event.agent.id,
+                    provider: event.agent.provider,
+                    providerSessionId: event.agent.persistence?.sessionId ?? undefined,
+                    turnId: event.agent.activeForegroundTurnId ?? undefined,
+                    lifecycle: event.agent.lifecycle,
+                }, "agent.session.forward_update");
                 void this.forwardAgentUpdate(event.agent);
                 return;
             }
@@ -661,6 +678,14 @@ export class Session {
             if (!serializedEvent) {
                 return;
             }
+            this.sessionLogger.trace({
+                agentId: event.agentId,
+                provider: event.event.provider,
+                turnId: getAgentStreamEventTurnId(event.event),
+                seq: event.seq,
+                epoch: event.epoch,
+                event: event.event,
+            }, "agent.session.forward_stream");
             const payload = {
                 agentId: event.agentId,
                 event: serializedEvent,
@@ -933,7 +958,10 @@ export class Session {
             this.peakInflightRequests = this.inflightRequests;
         }
         try {
-            this.sessionLogger.trace({ messageType: msg.type, payloadBytes: JSON.stringify(msg).length }, "inbound message");
+            this.sessionLogger.trace({
+                messageType: msg.type,
+                payloadBytes: JSON.stringify(msg).length,
+            }, "agent.session.inbound");
             try {
                 await this.dispatchInboundMessage(msg);
             }
@@ -1857,6 +1885,7 @@ export class Session {
             logger: this.sessionLogger.child({ component: "voice-turn-controller" }),
             turnDetection,
             stt,
+            sttLanguage: this.sttLanguage,
             callbacks: {
                 onSpeechStarted: async () => {
                     this.sessionLogger.debug("Voice VAD speech_started");
@@ -2079,6 +2108,17 @@ export class Session {
         const { handle, overrides, requestId } = msg;
         if (!handle) {
             this.sessionLogger.warn("Resume request missing persistence handle");
+            if (requestId) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId,
+                        requestType: msg.type,
+                        error: "Unable to resume agent: missing persistence handle",
+                        code: "agent_resume_failed",
+                    },
+                });
+            }
             this.emit({
                 type: "activity_log",
                 payload: {
@@ -2113,14 +2153,26 @@ export class Session {
             }
         }
         catch (error) {
+            const message = getErrorMessage(error);
             this.sessionLogger.error({ err: error }, "Failed to resume agent");
+            if (requestId) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId,
+                        requestType: msg.type,
+                        error: message,
+                        code: "agent_resume_failed",
+                    },
+                });
+            }
             this.emit({
                 type: "activity_log",
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
                     type: "error",
-                    content: `Failed to resume agent: ${getErrorMessage(error)}`,
+                    content: `Failed to resume agent: ${message}`,
                 },
             });
         }
@@ -2228,14 +2280,26 @@ export class Session {
             }
         }
         catch (error) {
+            const message = getErrorMessage(error);
             this.sessionLogger.error({ err: error, agentId }, `Failed to refresh agent ${agentId}`);
+            if (requestId) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId,
+                        requestType: msg.type,
+                        error: message,
+                        code: "agent_refresh_failed",
+                    },
+                });
+            }
             this.emit({
                 type: "activity_log",
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
                     type: "error",
-                    content: `Failed to refresh agent: ${getErrorMessage(error)}`,
+                    content: `Failed to refresh agent: ${message}`,
                 },
             });
         }
@@ -5459,7 +5523,11 @@ export class Session {
         try {
             const agentId = resolved.agentId;
             const prompt = this.buildAgentPrompt(msg.text, msg.images, msg.attachments);
-            this.sessionLogger.trace({ agentId, messageId: msg.messageId, textPrefix: msg.text.slice(0, 80) }, "send_agent_message_request: dispatching shared sendPromptToAgent");
+            this.sessionLogger.trace({
+                agentId,
+                messageId: msg.messageId,
+                textPrefix: msg.text.slice(0, 80),
+            }, "agent.session.send_agent_message");
             let dispatchResult;
             try {
                 dispatchResult = await sendPromptToAgent({
@@ -6082,7 +6150,10 @@ export class Session {
      * Emit a message to the client
      */
     emit(msg) {
-        this.sessionLogger.trace({ messageType: msg.type, payloadBytes: JSON.stringify(msg).length }, "outbound message");
+        this.sessionLogger.trace({
+            messageType: msg.type,
+            payloadBytes: JSON.stringify(msg).length,
+        }, "agent.session.outbound");
         if (msg.type === "audio_output" &&
             (process.env.TTS_DEBUG_AUDIO_DIR || isPaseoDictationDebugEnabled()) &&
             msg.payload.groupId &&
@@ -6137,7 +6208,7 @@ export class Session {
      * Clean up session resources
      */
     async cleanup() {
-        this.sessionLogger.trace("Cleaning up");
+        this.sessionLogger.trace({}, "agent.session.lifecycle.cleanup");
         if (this.unsubscribeAgentEvents) {
             this.unsubscribeAgentEvents();
             this.unsubscribeAgentEvents = null;