@wingman-ai/gateway 0.2.5 → 0.3.1

package/dist/gateway/server.js

@@ -10,6 +10,7 @@ import { SessionManager } from "../cli/core/sessionManager.js";
 import { createLogger } from "../logger.js";
 import { DiscordGatewayAdapter } from "./adapters/discord.js";
 import { GatewayAuth } from "./auth.js";
+import { BrowserRelayServer } from "./browserRelayServer.js";
 import { BroadcastGroupManager } from "./broadcast.js";
 import { MDNSDiscoveryService, TailscaleDiscoveryService } from "./discovery/index.js";
 import { getGatewayTokenFromEnv } from "./env.js";
@@ -49,6 +50,19 @@ function withApiCors(response) {
         headers
     });
 }
+function resolveExecutionWorkspaceOverride(payload) {
+    const rawWorkspace = payload?.execution?.workspace;
+    if ("string" != typeof rawWorkspace) return null;
+    const trimmed = rawWorkspace.trim();
+    if (!trimmed || !isAbsolute(trimmed)) return null;
+    return normalize(trimmed);
+}
+function resolveExecutionConfigDirOverride(payload) {
+    const rawConfigDir = payload?.execution?.configDir;
+    if ("string" != typeof rawConfigDir) return null;
+    const trimmed = rawConfigDir.trim();
+    return trimmed || null;
+}
 class GatewayServer {
     async start() {
         if (void 0 === globalThis.Bun) throw new Error("Gateway server requires Bun runtime. Start with `bun ./bin/wingman gateway start`.");
@@ -106,6 +120,7 @@ class GatewayServer {
             if (!this.uiDistDir) this.log("warn", "Control UI is enabled but build assets were not found. Run `bun run webui:build`.");
             this.log("info", `Control UI available on ${this.config.host}:${this.config.port}`);
         }
+        this.browserRelayServer?.start();
         if (this.config.discovery?.enabled) await this.startDiscovery();
         await this.startAdapters();
         this.log("info", `Gateway started on ${this.config.host}:${this.config.port}`);
@@ -134,6 +149,7 @@ class GatewayServer {
             this.uiServer.stop();
             this.uiServer = null;
         }
+        if (this.browserRelayServer) this.browserRelayServer.stop();
         this.terminalSessionManager.dispose();
         this.log("info", "Gateway stopped");
     }
@@ -326,6 +342,8 @@ class GatewayServer {
         const payload = msg.payload;
         const content = "string" == typeof payload?.content ? payload.content : "";
         const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
+        const workspaceOverride = resolveExecutionWorkspaceOverride(payload);
+        const configDirOverride = resolveExecutionConfigDirOverride(payload);
         const hasContent = content.trim().length > 0;
         const hasAttachments = attachments.length > 0;
         if (!hasContent && !hasAttachments) return void this.sendAgentError(ws, msg.id, "Missing agent content");
@@ -336,12 +354,29 @@ class GatewayServer {
         const sessionManager = await this.getSessionManager(agentId);
         const existingSession = sessionManager.getSession(sessionKey);
         const session = existingSession || sessionManager.getOrCreateSession(sessionKey, agentId);
+        const requestId = msg.id || `req-${Date.now()}`;
         const workdir = session.metadata?.workdir ?? null;
         const defaultOutputDir = this.resolveDefaultOutputDir(agentId);
         const preview = hasContent ? content.trim() : buildAttachmentPreview(attachments);
         sessionManager.updateSession(session.id, {
+            messageCount: (session.messageCount ?? 0) + 1,
             lastMessagePreview: preview.substring(0, 200)
         });
+        try {
+            sessionManager.persistPendingMessage({
+                sessionId: sessionKey,
+                requestId,
+                message: {
+                    id: `user-${requestId}`,
+                    role: "user",
+                    content,
+                    attachments: attachments.length > 0 ? mapAttachmentsForPendingMessage(attachments) : void 0,
+                    createdAt: Date.now()
+                }
+            });
+        } catch (error) {
+            this.logger.warn("Failed to persist pending user message", error);
+        }
         if (!existingSession) this.internalHooks?.emit({
             type: "session",
             action: "start",
@@ -394,7 +429,9 @@ class GatewayServer {
             attachments,
             sessionManager,
             workdir,
-            defaultOutputDir
+            defaultOutputDir,
+            workspaceOverride,
+            configDirOverride
         };
         this.requestSessionKeys.set(msg.id, sessionQueueKey);
         const queueIfBusy = false !== payload.queueIfBusy;
@@ -440,13 +477,19 @@ class GatewayServer {
         this.executeAgentRequest(request);
     }
     async executeAgentRequest(request) {
-        const { ws, msg, agentId, sessionKey, sessionQueueKey, content, attachments, sessionManager, workdir, defaultOutputDir } = request;
+        const { ws, msg, agentId, sessionKey, sessionQueueKey, content, attachments, sessionManager, workdir, defaultOutputDir, workspaceOverride, configDirOverride } = request;
         this.activeSessionRequests.set(sessionQueueKey, msg.id);
         const outputManager = new OutputManager("interactive");
         let emittedAgentError = false;
+        let streamedCompletionResult;
         const outputHandler = (event)=>{
             const payloadWithSession = this.attachSessionContext(event, sessionKey, agentId);
-            if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "agent-error" === payloadWithSession.type) emittedAgentError = true;
+            const payloadType = payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "string" == typeof payloadWithSession.type ? payloadWithSession.type : "";
+            if ("agent-complete" === payloadType) {
+                if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession)) streamedCompletionResult = payloadWithSession.result;
+                return;
+            }
+            if ("agent-error" === payloadType) emittedAgentError = true;
             const baseMessage = {
                 type: "event:agent",
                 id: msg.id,
@@ -460,10 +503,11 @@ class GatewayServer {
             this.broadcastSessionEvent(sessionKey, baseMessage, ws);
         };
         outputManager.on("output-event", outputHandler);
-        const workspace = this.resolveAgentWorkspace(agentId);
+        const workspace = workspaceOverride || this.resolveAgentWorkspace(agentId);
+        const configDir = configDirOverride || this.configDir;
         const invoker = new AgentInvoker({
             workspace,
-            configDir: this.configDir,
+            configDir,
             outputManager,
             logger: this.logger,
             sessionManager,
@@ -477,17 +521,43 @@ class GatewayServer {
             abortController
         });
         try {
-            await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
+            const invocationResult = await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
                 signal: abortController.signal
             });
-            const updated = sessionManager.getSession(sessionKey);
-            if (updated) sessionManager.updateSession(sessionKey, {
-                messageCount: updated.messageCount + 1
+            if (msg.id) sessionManager.clearPendingMessagesForRequest(sessionKey, msg.id);
+            if (emittedAgentError) return;
+            const invocationCancelled = abortController.signal.aborted || "object" == typeof invocationResult && null !== invocationResult && !Array.isArray(invocationResult) && true === invocationResult.cancelled;
+            if (invocationCancelled) return void this.sendAgentError(ws, msg.id, "Request cancelled", {
+                sessionId: sessionKey,
+                agentId,
+                broadcastToSession: true,
+                exclude: ws
+            });
+            const completionResult = void 0 === streamedCompletionResult ? invocationResult : streamedCompletionResult;
+            this.sendAgentComplete(ws, msg.id, completionResult, {
+                sessionId: sessionKey,
+                agentId,
+                broadcastToSession: true,
+                exclude: ws
             });
         } catch (error) {
             this.logger.error("Agent invocation failed", error);
+            const message = error instanceof Error ? error.message : String(error);
+            if (msg.id) try {
+                sessionManager.persistPendingMessage({
+                    sessionId: sessionKey,
+                    requestId: msg.id,
+                    message: {
+                        id: msg.id,
+                        role: "assistant",
+                        content: message,
+                        createdAt: Date.now()
+                    }
+                });
+            } catch (persistError) {
+                this.logger.warn("Failed to persist pending assistant error message", persistError);
+            }
             if (!emittedAgentError) {
-                const message = error instanceof Error ? error.message : String(error);
                 const stack = error instanceof Error ? error.stack : void 0;
                 this.sendAgentError(ws, msg.id, message, {
                     sessionId: sessionKey,
@@ -563,6 +633,12 @@ class GatewayServer {
                 },
                 timestamp: Date.now()
             });
+            this.sendAgentError(ws, requestId, "Request cancelled", {
+                sessionId: queued.sessionKey,
+                agentId: queued.agentId,
+                broadcastToSession: true,
+                exclude: ws
+            });
             return;
         }
         this.sendMessage(ws, {
@@ -737,11 +813,25 @@ class GatewayServer {
     }
     sendMessage(ws, message) {
         try {
-            ws.send(JSON.stringify(message));
+            const result = ws.send(JSON.stringify(message));
+            if ("number" == typeof result && result <= 0) return false;
+            return true;
         } catch (error) {
             this.log("error", "Failed to send message", error);
+            return false;
         }
     }
+    sendMessageWithRetry(ws, message, attempt = 0) {
+        if (this.sendMessage(ws, message)) return;
+        if (attempt >= 2) return void this.log("warn", "Dropping websocket message after retry attempts", {
+            type: message.type,
+            id: message.id
+        });
+        const delayMs = 25 * (attempt + 1);
+        setTimeout(()=>{
+            this.sendMessageWithRetry(ws, message, attempt + 1);
+        }, delayMs);
+    }
     sendError(ws, code, message) {
         const errorPayload = {
             code,
@@ -753,6 +843,25 @@ class GatewayServer {
             timestamp: Date.now()
         });
     }
+    sendAgentComplete(ws, requestId, result, options) {
+        let payload = {
+            type: "agent-complete",
+            result: result ?? null,
+            timestamp: new Date().toISOString()
+        };
+        if (options?.sessionId && options?.agentId) payload = this.attachSessionContext(payload, options.sessionId, options.agentId);
+        const baseMessage = {
+            type: "event:agent",
+            id: requestId,
+            payload,
+            timestamp: Date.now()
+        };
+        this.sendMessageWithRetry(ws, {
+            ...baseMessage,
+            clientId: ws.data.clientId
+        });
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude, true);
+    }
     sendAgentError(ws, requestId, message, options) {
         let payload = {
             type: "agent-error",
@@ -767,11 +876,11 @@ class GatewayServer {
             payload,
             timestamp: Date.now()
         };
-        this.sendMessage(ws, {
+        this.sendMessageWithRetry(ws, {
             ...baseMessage,
             clientId: ws.data.clientId
         });
-        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude);
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude, true);
     }
     cancelSocketAgentRequests(ws) {
         for (const [requestId, active] of this.activeAgentRequests)if (active.socket === ws) {
@@ -800,12 +909,13 @@ class GatewayServer {
             agentId
         };
     }
-    broadcastSessionEvent(sessionId, message, exclude) {
+    broadcastSessionEvent(sessionId, message, exclude, reliable = false) {
         const subscribers = this.sessionSubscriptions.get(sessionId);
         if (!subscribers || 0 === subscribers.size) return 0;
         let sent = 0;
         for (const ws of subscribers)if (!exclude || ws !== exclude) {
-            this.sendMessage(ws, message);
+            if (reliable) this.sendMessageWithRetry(ws, message);
+            else this.sendMessage(ws, message);
             sent++;
         }
         return sent;
@@ -1294,6 +1404,7 @@ class GatewayServer {
         _define_property(this, "controlUiPort", 18790);
         _define_property(this, "controlUiSamePort", false);
         _define_property(this, "uiDistDir", null);
+        _define_property(this, "browserRelayServer", null);
         _define_property(this, "webhookStore", void 0);
         _define_property(this, "routineStore", void 0);
         _define_property(this, "internalHooks", null);
@@ -1356,6 +1467,15 @@ class GatewayServer {
         this.controlUiPort = controlUi?.port || 18790;
         this.controlUiSamePort = this.controlUiEnabled && this.controlUiPort === this.config.port;
         this.uiDistDir = this.controlUiEnabled ? this.resolveControlUiDir() : null;
+        const relayConfig = this.wingmanConfig.browser?.relay;
+        if (relayConfig?.enabled) this.browserRelayServer = new BrowserRelayServer({
+            enabled: relayConfig.enabled,
+            host: relayConfig.host || "127.0.0.1",
+            port: relayConfig.port || 18792,
+            requireAuth: relayConfig.requireAuth ?? true,
+            authToken: relayConfig.authToken,
+            maxMessageBytes: relayConfig.maxMessageBytes || 262144
+        }, this.logger);
         this.terminalSessionManager = new TerminalSessionManager();
     }
 }
@@ -1379,6 +1499,18 @@ function buildAttachmentPreview(attachments) {
     if (hasAudio) return count > 1 ? "Audio attachments" : "Audio attachment";
     return count > 1 ? "Image attachments" : "Image attachment";
 }
+function mapAttachmentsForPendingMessage(attachments) {
+    return attachments.map((attachment)=>{
+        const kind = isFileAttachment(attachment) ? "file" : isAudioAttachment(attachment) ? "audio" : "image";
+        return {
+            kind,
+            dataUrl: attachment.dataUrl,
+            name: attachment.name,
+            mimeType: attachment.mimeType,
+            size: attachment.size
+        };
+    });
+}
 function isAudioAttachment(attachment) {
     if ("audio" === attachment.kind) return true;
     if (attachment.mimeType?.startsWith("audio/")) return true;
@@ -1389,4 +1521,4 @@ function isFileAttachment(attachment) {
     if ("file" === attachment.kind) return true;
     return "string" == typeof attachment.textContent;
 }
-export { GatewayServer };
+export { GatewayServer, resolveExecutionConfigDirOverride, resolveExecutionWorkspaceOverride };

package/dist/gateway/transport/websocket.cjs

@@ -24,7 +24,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    WebSocketTransport: ()=>WebSocketTransport
+    WebSocketTransport: ()=>WebSocketTransport,
+    describeWebSocketError: ()=>describeWebSocketError
 });
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 function _define_property(obj, key, value) {
@@ -38,19 +39,47 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+function describeWebSocketError(error, url) {
+    if (error instanceof Error) {
+        const message = error.message.trim();
+        return message ? `WebSocket connection failed to ${url}: ${message}` : `WebSocket connection failed to ${url}.`;
+    }
+    if ("string" == typeof error && error.trim()) return `WebSocket connection failed to ${url}: ${error.trim()}`;
+    if (error && "object" == typeof error) {
+        const typed = error;
+        const eventType = "string" == typeof typed.type && typed.type.trim() ? typed.type.trim() : "error";
+        const message = "string" == typeof typed.message && typed.message.trim() ? typed.message.trim() : null;
+        const reason = "string" == typeof typed.reason && typed.reason.trim() ? typed.reason.trim() : null;
+        const detail = message || reason;
+        return detail ? `WebSocket ${eventType} while connecting to ${url}: ${detail}` : `WebSocket ${eventType} while connecting to ${url}.`;
+    }
+    return `WebSocket connection failed to ${url}.`;
+}
 class WebSocketTransport {
     async connect() {
         return new Promise((resolve, reject)=>{
+            let settled = false;
+            const rejectOnce = (reason)=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeout);
+                reject(reason);
+            };
+            const resolveOnce = ()=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeout);
+                resolve();
+            };
             const timeout = setTimeout(()=>{
                 if (this.ws) this.ws.close();
-                reject(new Error("Connection timeout"));
+                rejectOnce(new Error(`WebSocket connection timeout after ${this.options.connectionTimeout}ms (${this.url}).`));
             }, this.options.connectionTimeout);
             try {
                 this.ws = new WebSocket(this.url);
                 this.ws.onopen = ()=>{
-                    clearTimeout(timeout);
                     this.reconnectAttempts = 0;
-                    resolve();
+                    resolveOnce();
                 };
                 this.ws.onmessage = (event)=>{
                     try {
@@ -61,16 +90,20 @@ class WebSocketTransport {
                     }
                 };
                 this.ws.onerror = (error)=>{
-                    clearTimeout(timeout);
-                    reject(error);
+                    rejectOnce(new Error(describeWebSocketError(error, this.url)));
                 };
-                this.ws.onclose = ()=>{
+                this.ws.onclose = (event)=>{
+                    if (!settled) {
+                        const code = event && "number" == typeof event.code ? String(event.code) : "unknown";
+                        const reason = event && "string" == typeof event.reason && event.reason.trim() ? ` (${event.reason.trim()})` : "";
+                        rejectOnce(new Error(`WebSocket closed before connection was established (${this.url}, code=${code})${reason}.`));
+                        return;
+                    }
                     this.ws = null;
                     if (this.options.autoReconnect && this.reconnectAttempts < (this.options.maxReconnectAttempts || 5)) this.scheduleReconnect();
                 };
             } catch (error) {
-                clearTimeout(timeout);
-                reject(error);
+                rejectOnce(new Error(describeWebSocketError(error, this.url)));
             }
         });
     }
@@ -124,8 +157,10 @@ class WebSocketTransport {
     }
 }
 exports.WebSocketTransport = __webpack_exports__.WebSocketTransport;
+exports.describeWebSocketError = __webpack_exports__.describeWebSocketError;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "WebSocketTransport"
+    "WebSocketTransport",
+    "describeWebSocketError"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/gateway/transport/websocket.d.ts

@@ -1,5 +1,6 @@
 import type { GatewayMessage } from "../types.js";
 import type { TransportClient, TransportOptions } from "./types.js";
+export declare function describeWebSocketError(error: unknown, url: string): string;
 /**
  * WebSocket transport client
  */

package/dist/gateway/transport/websocket.js

@@ -10,19 +10,47 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const logger = createLogger();
+function describeWebSocketError(error, url) {
+    if (error instanceof Error) {
+        const message = error.message.trim();
+        return message ? `WebSocket connection failed to ${url}: ${message}` : `WebSocket connection failed to ${url}.`;
+    }
+    if ("string" == typeof error && error.trim()) return `WebSocket connection failed to ${url}: ${error.trim()}`;
+    if (error && "object" == typeof error) {
+        const typed = error;
+        const eventType = "string" == typeof typed.type && typed.type.trim() ? typed.type.trim() : "error";
+        const message = "string" == typeof typed.message && typed.message.trim() ? typed.message.trim() : null;
+        const reason = "string" == typeof typed.reason && typed.reason.trim() ? typed.reason.trim() : null;
+        const detail = message || reason;
+        return detail ? `WebSocket ${eventType} while connecting to ${url}: ${detail}` : `WebSocket ${eventType} while connecting to ${url}.`;
+    }
+    return `WebSocket connection failed to ${url}.`;
+}
 class WebSocketTransport {
     async connect() {
         return new Promise((resolve, reject)=>{
+            let settled = false;
+            const rejectOnce = (reason)=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeout);
+                reject(reason);
+            };
+            const resolveOnce = ()=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(timeout);
+                resolve();
+            };
             const timeout = setTimeout(()=>{
                 if (this.ws) this.ws.close();
-                reject(new Error("Connection timeout"));
+                rejectOnce(new Error(`WebSocket connection timeout after ${this.options.connectionTimeout}ms (${this.url}).`));
             }, this.options.connectionTimeout);
             try {
                 this.ws = new WebSocket(this.url);
                 this.ws.onopen = ()=>{
-                    clearTimeout(timeout);
                     this.reconnectAttempts = 0;
-                    resolve();
+                    resolveOnce();
                 };
                 this.ws.onmessage = (event)=>{
                     try {
@@ -33,16 +61,20 @@ class WebSocketTransport {
                     }
                 };
                 this.ws.onerror = (error)=>{
-                    clearTimeout(timeout);
-                    reject(error);
+                    rejectOnce(new Error(describeWebSocketError(error, this.url)));
                 };
-                this.ws.onclose = ()=>{
+                this.ws.onclose = (event)=>{
+                    if (!settled) {
+                        const code = event && "number" == typeof event.code ? String(event.code) : "unknown";
+                        const reason = event && "string" == typeof event.reason && event.reason.trim() ? ` (${event.reason.trim()})` : "";
+                        rejectOnce(new Error(`WebSocket closed before connection was established (${this.url}, code=${code})${reason}.`));
+                        return;
+                    }
                     this.ws = null;
                     if (this.options.autoReconnect && this.reconnectAttempts < (this.options.maxReconnectAttempts || 5)) this.scheduleReconnect();
                 };
             } catch (error) {
-                clearTimeout(timeout);
-                reject(error);
+                rejectOnce(new Error(describeWebSocketError(error, this.url)));
             }
         });
     }
@@ -95,4 +127,4 @@ class WebSocketTransport {
         };
     }
 }
-export { WebSocketTransport };
+export { WebSocketTransport, describeWebSocketError };

package/dist/gateway/types.d.ts

@@ -58,6 +58,10 @@ export interface AgentRequestPayload {
     agentId?: string;
     content?: string;
     attachments?: MediaAttachment[];
+    execution?: {
+        workspace?: string;
+        configDir?: string;
+    };
     routing?: RoutingInfo;
     sessionKey?: string;
     queueIfBusy?: boolean;

package/dist/tests/agentInvokerSummarization.test.cjs

@@ -348,42 +348,6 @@ const parseConfig = (input)=>{
         })).toBeUndefined();
     });
 });
-(0, external_vitest_namespaceObject.describe)("evaluateStreamingCompletion", ()=>{
-    (0, external_vitest_namespaceObject.it)("blocks with stream_error when no assistant text and stream error exists", ()=>{
-        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
-            sawAssistantText: false,
-            fallbackText: void 0,
-            streamErrorMessage: "provider timeout"
-        });
-        (0, external_vitest_namespaceObject.expect)(result).toEqual({
-            status: "blocked",
-            reason: "stream_error",
-            message: "Model call failed: provider timeout"
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("blocks with empty_stream_response when no text or fallback is present", ()=>{
-        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
-            sawAssistantText: false,
-            fallbackText: void 0,
-            streamErrorMessage: void 0
-        });
-        (0, external_vitest_namespaceObject.expect)(result).toEqual({
-            status: "blocked",
-            reason: "empty_stream_response",
-            message: "Model completed without a response. Check provider logs for request errors."
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("returns ok when assistant text exists", ()=>{
-        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
-            sawAssistantText: true,
-            fallbackText: void 0,
-            streamErrorMessage: void 0
-        });
-        (0, external_vitest_namespaceObject.expect)(result).toEqual({
-            status: "ok"
-        });
-    });
-});
 (0, external_vitest_namespaceObject.describe)("LangGraph lifecycle termination", ()=>{
     (0, external_vitest_namespaceObject.it)("tracks root LangGraph run id from parentless on_chain_start", ()=>{
         const rootRunId = (0, agentInvoker_cjs_namespaceObject.trackRootLangGraphRunId)(void 0, {
@@ -441,12 +405,67 @@ const parseConfig = (input)=>{
             run_id: "root-run",
             parent_ids: []
         }, "root-run")).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("treats root LangGraph on_chain_end as terminal even without tracked run id", ()=>{
         (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
             event: "on_chain_end",
             name: "LangGraph",
             run_id: "root-run",
             parent_ids: []
-        }, void 0)).toBe(false);
+        }, void 0)).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("treats root LangGraph on_chain_end as terminal when run id is missing", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "LangGraph",
+            parent_ids: []
+        }, "root-run")).toBe(true);
+    });
+});
+(0, external_vitest_namespaceObject.describe)("emitCompletionAndContinuePostProcessing", ()=>{
+    (0, external_vitest_namespaceObject.it)("emits completion before post-processing resolves", ()=>{
+        const callOrder = [];
+        let resolvePostProcess;
+        const postProcess = ()=>new Promise((resolve)=>{
+                callOrder.push("post-process-start");
+                resolvePostProcess = resolve;
+            });
+        (0, agentInvoker_cjs_namespaceObject.emitCompletionAndContinuePostProcessing)({
+            outputManager: {
+                emitAgentComplete: ()=>{
+                    callOrder.push("emit-complete");
+                }
+            },
+            result: {
+                ok: true
+            },
+            postProcess
+        });
+        (0, external_vitest_namespaceObject.expect)(callOrder).toEqual([
+            "emit-complete",
+            "post-process-start"
+        ]);
+        resolvePostProcess?.();
+    });
+    (0, external_vitest_namespaceObject.it)("logs and swallows post-processing failures", async ()=>{
+        const debug = external_vitest_namespaceObject.vi.fn();
+        (0, agentInvoker_cjs_namespaceObject.emitCompletionAndContinuePostProcessing)({
+            outputManager: {
+                emitAgentComplete: external_vitest_namespaceObject.vi.fn()
+            },
+            result: {
+                ok: true
+            },
+            postProcess: async ()=>{
+                throw new Error("materialization failed");
+            },
+            logger: {
+                debug
+            }
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        (0, external_vitest_namespaceObject.expect)(debug).toHaveBeenCalledWith("Failed post-completion processing for streamed agent response", external_vitest_namespaceObject.expect.any(Error));
     });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];