@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/debug/terminalProbeAuth.cjs

@@ -0,0 +1,140 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    TERMINAL_PROBE_GATEWAY_TOKEN_ENV: ()=>TERMINAL_PROBE_GATEWAY_TOKEN_ENV,
+    resolveTerminalProbeAuth: ()=>resolveTerminalProbeAuth,
+    formatTerminalProbeHandshakeFailure: ()=>formatTerminalProbeHandshakeFailure,
+    TERMINAL_PROBE_GATEWAY_PASSWORD_ENV: ()=>TERMINAL_PROBE_GATEWAY_PASSWORD_ENV
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const TERMINAL_PROBE_GATEWAY_TOKEN_ENV = "WINGMAN_GATEWAY_TOKEN";
+const TERMINAL_PROBE_GATEWAY_PASSWORD_ENV = "WINGMAN_GATEWAY_PASSWORD";
+function normalizeSecret(raw) {
+    if ("string" != typeof raw) return;
+    const value = raw.trim();
+    return value.length > 0 ? value : void 0;
+}
+function parseGatewayAuthConfig(rawConfig) {
+    if (!rawConfig || "object" != typeof rawConfig || Array.isArray(rawConfig)) return null;
+    const config = rawConfig;
+    const gateway = config.gateway;
+    if (!gateway || "object" != typeof gateway || Array.isArray(gateway)) return null;
+    const auth = gateway.auth;
+    if (!auth || "object" != typeof auth || Array.isArray(auth)) return null;
+    const authConfig = auth;
+    const mode = "string" == typeof authConfig.mode ? authConfig.mode.toLowerCase() : "";
+    const token = normalizeSecret(authConfig.token);
+    const password = normalizeSecret(authConfig.password);
+    if ("token" === mode && token) return {
+        token
+    };
+    if ("password" === mode && password) return {
+        password
+    };
+    if (!mode && (token || password)) return {
+        token,
+        password
+    };
+    return null;
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+function resolveConfigCandidates(options) {
+    if (options.configFileCandidates?.length) return unique(options.configFileCandidates);
+    const cwd = options.cwd ?? process.cwd();
+    const homeDir = options.homeDir ?? (0, external_node_os_namespaceObject.homedir)();
+    return unique([
+        (0, external_node_path_namespaceObject.join)(cwd, ".wingman", "wingman.config.json"),
+        (0, external_node_path_namespaceObject.join)(homeDir, ".wingman", "wingman.config.json")
+    ]);
+}
+function resolveAuthFromConfig(options) {
+    for (const configPath of resolveConfigCandidates(options))if ((0, external_node_fs_namespaceObject.existsSync)(configPath)) try {
+        const raw = (0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const auth = parseGatewayAuthConfig(parsed);
+        if (auth) return {
+            ...auth,
+            configPath
+        };
+    } catch  {}
+    return null;
+}
+function resolveTerminalProbeAuth(options = {}) {
+    const cliToken = normalizeSecret(options.cliToken);
+    const cliPassword = normalizeSecret(options.cliPassword);
+    if (cliToken || cliPassword) return {
+        token: cliToken,
+        password: cliPassword,
+        source: "cli"
+    };
+    const env = options.env ?? process.env;
+    const envToken = normalizeSecret(env[TERMINAL_PROBE_GATEWAY_TOKEN_ENV]);
+    const envPassword = normalizeSecret(env[TERMINAL_PROBE_GATEWAY_PASSWORD_ENV]);
+    if (envToken || envPassword) return {
+        token: envToken,
+        password: envPassword,
+        source: "env"
+    };
+    const fromConfig = resolveAuthFromConfig(options);
+    if (fromConfig?.token || fromConfig?.password) return {
+        token: fromConfig.token,
+        password: fromConfig.password,
+        source: "config",
+        configPath: fromConfig.configPath
+    };
+    return {
+        source: "none"
+    };
+}
+function formatTerminalProbeHandshakeFailure(payload) {
+    if ("string" == typeof payload) {
+        const value = payload.trim();
+        return value.length > 0 ? value : "unknown";
+    }
+    if (null == payload) return "unknown";
+    try {
+        return JSON.stringify(payload);
+    } catch  {
+        return "unknown";
+    }
+}
+exports.TERMINAL_PROBE_GATEWAY_PASSWORD_ENV = __webpack_exports__.TERMINAL_PROBE_GATEWAY_PASSWORD_ENV;
+exports.TERMINAL_PROBE_GATEWAY_TOKEN_ENV = __webpack_exports__.TERMINAL_PROBE_GATEWAY_TOKEN_ENV;
+exports.formatTerminalProbeHandshakeFailure = __webpack_exports__.formatTerminalProbeHandshakeFailure;
+exports.resolveTerminalProbeAuth = __webpack_exports__.resolveTerminalProbeAuth;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TERMINAL_PROBE_GATEWAY_PASSWORD_ENV",
+    "TERMINAL_PROBE_GATEWAY_TOKEN_ENV",
+    "formatTerminalProbeHandshakeFailure",
+    "resolveTerminalProbeAuth"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/debug/terminalProbeAuth.d.ts

@@ -0,0 +1,20 @@
+export declare const TERMINAL_PROBE_GATEWAY_TOKEN_ENV = "WINGMAN_GATEWAY_TOKEN";
+export declare const TERMINAL_PROBE_GATEWAY_PASSWORD_ENV = "WINGMAN_GATEWAY_PASSWORD";
+type TerminalProbeAuthSource = "cli" | "env" | "config" | "none";
+export type TerminalProbeAuth = {
+    token?: string;
+    password?: string;
+    source: TerminalProbeAuthSource;
+    configPath?: string;
+};
+type ResolveTerminalProbeAuthOptions = {
+    cliToken?: string;
+    cliPassword?: string;
+    env?: Record<string, string | undefined>;
+    cwd?: string;
+    homeDir?: string;
+    configFileCandidates?: string[];
+};
+export declare function resolveTerminalProbeAuth(options?: ResolveTerminalProbeAuthOptions): TerminalProbeAuth;
+export declare function formatTerminalProbeHandshakeFailure(payload: unknown): string;
+export {};

package/dist/debug/terminalProbeAuth.js

@@ -0,0 +1,97 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const TERMINAL_PROBE_GATEWAY_TOKEN_ENV = "WINGMAN_GATEWAY_TOKEN";
+const TERMINAL_PROBE_GATEWAY_PASSWORD_ENV = "WINGMAN_GATEWAY_PASSWORD";
+function normalizeSecret(raw) {
+    if ("string" != typeof raw) return;
+    const value = raw.trim();
+    return value.length > 0 ? value : void 0;
+}
+function parseGatewayAuthConfig(rawConfig) {
+    if (!rawConfig || "object" != typeof rawConfig || Array.isArray(rawConfig)) return null;
+    const config = rawConfig;
+    const gateway = config.gateway;
+    if (!gateway || "object" != typeof gateway || Array.isArray(gateway)) return null;
+    const auth = gateway.auth;
+    if (!auth || "object" != typeof auth || Array.isArray(auth)) return null;
+    const authConfig = auth;
+    const mode = "string" == typeof authConfig.mode ? authConfig.mode.toLowerCase() : "";
+    const token = normalizeSecret(authConfig.token);
+    const password = normalizeSecret(authConfig.password);
+    if ("token" === mode && token) return {
+        token
+    };
+    if ("password" === mode && password) return {
+        password
+    };
+    if (!mode && (token || password)) return {
+        token,
+        password
+    };
+    return null;
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+function resolveConfigCandidates(options) {
+    if (options.configFileCandidates?.length) return unique(options.configFileCandidates);
+    const cwd = options.cwd ?? process.cwd();
+    const homeDir = options.homeDir ?? homedir();
+    return unique([
+        join(cwd, ".wingman", "wingman.config.json"),
+        join(homeDir, ".wingman", "wingman.config.json")
+    ]);
+}
+function resolveAuthFromConfig(options) {
+    for (const configPath of resolveConfigCandidates(options))if (existsSync(configPath)) try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const auth = parseGatewayAuthConfig(parsed);
+        if (auth) return {
+            ...auth,
+            configPath
+        };
+    } catch  {}
+    return null;
+}
+function resolveTerminalProbeAuth(options = {}) {
+    const cliToken = normalizeSecret(options.cliToken);
+    const cliPassword = normalizeSecret(options.cliPassword);
+    if (cliToken || cliPassword) return {
+        token: cliToken,
+        password: cliPassword,
+        source: "cli"
+    };
+    const env = options.env ?? process.env;
+    const envToken = normalizeSecret(env[TERMINAL_PROBE_GATEWAY_TOKEN_ENV]);
+    const envPassword = normalizeSecret(env[TERMINAL_PROBE_GATEWAY_PASSWORD_ENV]);
+    if (envToken || envPassword) return {
+        token: envToken,
+        password: envPassword,
+        source: "env"
+    };
+    const fromConfig = resolveAuthFromConfig(options);
+    if (fromConfig?.token || fromConfig?.password) return {
+        token: fromConfig.token,
+        password: fromConfig.password,
+        source: "config",
+        configPath: fromConfig.configPath
+    };
+    return {
+        source: "none"
+    };
+}
+function formatTerminalProbeHandshakeFailure(payload) {
+    if ("string" == typeof payload) {
+        const value = payload.trim();
+        return value.length > 0 ? value : "unknown";
+    }
+    if (null == payload) return "unknown";
+    try {
+        return JSON.stringify(payload);
+    } catch  {
+        return "unknown";
+    }
+}
+export { TERMINAL_PROBE_GATEWAY_PASSWORD_ENV, TERMINAL_PROBE_GATEWAY_TOKEN_ENV, formatTerminalProbeHandshakeFailure, resolveTerminalProbeAuth };

package/dist/gateway/http/fs.cjs

@@ -70,6 +70,25 @@ const handleFsApi = async (ctx, req, url)=>{
             }
         });
     }
+    if ("/api/fs/file" === url.pathname && "GET" === req.method) {
+        const rawPath = url.searchParams.get("path");
+        if (!rawPath) return new Response("path required", {
+            status: 400
+        });
+        const resolved = ctx.resolveFsPath(rawPath);
+        const roots = ctx.resolveFsRoots();
+        if (!ctx.isPathWithinRoots(resolved, roots)) return new Response("path not allowed", {
+            status: 403
+        });
+        if (!(0, external_node_fs_namespaceObject.existsSync)(resolved) || !(0, external_node_fs_namespaceObject.statSync)(resolved).isFile()) return new Response("path not found", {
+            status: 404
+        });
+        return new Response(Bun.file(resolved), {
+            headers: {
+                "Cache-Control": "no-store"
+            }
+        });
+    }
     return null;
 };
 exports.handleFsApi = __webpack_exports__.handleFsApi;

package/dist/gateway/http/fs.js

@@ -42,6 +42,25 @@ const handleFsApi = async (ctx, req, url)=>{
             }
         });
     }
+    if ("/api/fs/file" === url.pathname && "GET" === req.method) {
+        const rawPath = url.searchParams.get("path");
+        if (!rawPath) return new Response("path required", {
+            status: 400
+        });
+        const resolved = ctx.resolveFsPath(rawPath);
+        const roots = ctx.resolveFsRoots();
+        if (!ctx.isPathWithinRoots(resolved, roots)) return new Response("path not allowed", {
+            status: 403
+        });
+        if (!existsSync(resolved) || !statSync(resolved).isFile()) return new Response("path not found", {
+            status: 404
+        });
+        return new Response(Bun.file(resolved), {
+            headers: {
+                "Cache-Control": "no-store"
+            }
+        });
+    }
     return null;
 };
 export { handleFsApi };

package/dist/gateway/http/sessions.cjs

@@ -28,17 +28,37 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_crypto_namespaceObject = require("node:crypto");
 const external_node_fs_namespaceObject = require("node:fs");
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const getSessionAgents = (ctx, explicitAgentId)=>{
+    if (explicitAgentId) return [
+        explicitAgentId
+    ];
+    const config = ctx.getWingmanConfig();
+    const configuredAgents = config.agents?.list?.map((agent)=>agent.id?.trim()).filter((id)=>Boolean(id)) ?? [];
+    let discoveredAgents = [];
+    try {
+        const loader = new agentLoader_cjs_namespaceObject.AgentLoader(ctx.configDir, ctx.workspace, config);
+        discoveredAgents = loader.loadAllAgentConfigs().map((agent)=>agent.name?.trim()).filter((id)=>Boolean(id));
+    } catch (error) {
+        if ("function" == typeof ctx.logger?.warn) ctx.logger.warn("Failed to load discovered agents while listing sessions", error);
+    }
+    const agents = [
+        ...new Set([
+            ...configuredAgents,
+            ...discoveredAgents
+        ])
+    ];
+    return agents.length > 0 ? agents : [
+        "main"
+    ];
+};
 const handleSessionsApi = async (ctx, req, url)=>{
     if ("/api/sessions" === url.pathname) {
         if ("GET" === req.method) {
             const limit = Number(url.searchParams.get("limit") || "100");
             const status = url.searchParams.get("status") || "active";
             const agentId = url.searchParams.get("agentId") || void 0;
-            const agents = agentId ? [
-                agentId
-            ] : ctx.getWingmanConfig().agents?.list?.map((agent)=>agent.id) || [
-                "main"
-            ];
+            const agents = getSessionAgents(ctx, agentId);
             const sessions = [];
             for (const agent of agents){
                 const manager = await ctx.getSessionManager(agent);

package/dist/gateway/http/sessions.js

@@ -1,16 +1,36 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+const getSessionAgents = (ctx, explicitAgentId)=>{
+    if (explicitAgentId) return [
+        explicitAgentId
+    ];
+    const config = ctx.getWingmanConfig();
+    const configuredAgents = config.agents?.list?.map((agent)=>agent.id?.trim()).filter((id)=>Boolean(id)) ?? [];
+    let discoveredAgents = [];
+    try {
+        const loader = new AgentLoader(ctx.configDir, ctx.workspace, config);
+        discoveredAgents = loader.loadAllAgentConfigs().map((agent)=>agent.name?.trim()).filter((id)=>Boolean(id));
+    } catch (error) {
+        if ("function" == typeof ctx.logger?.warn) ctx.logger.warn("Failed to load discovered agents while listing sessions", error);
+    }
+    const agents = [
+        ...new Set([
+            ...configuredAgents,
+            ...discoveredAgents
+        ])
+    ];
+    return agents.length > 0 ? agents : [
+        "main"
+    ];
+};
 const handleSessionsApi = async (ctx, req, url)=>{
     if ("/api/sessions" === url.pathname) {
         if ("GET" === req.method) {
             const limit = Number(url.searchParams.get("limit") || "100");
             const status = url.searchParams.get("status") || "active";
             const agentId = url.searchParams.get("agentId") || void 0;
-            const agents = agentId ? [
-                agentId
-            ] : ctx.getWingmanConfig().agents?.list?.map((agent)=>agent.id) || [
-                "main"
-            ];
+            const agents = getSessionAgents(ctx, agentId);
             const sessions = [];
             for (const agent of agents){
                 const manager = await ctx.getSessionManager(agent);

package/dist/gateway/server.cjs

@@ -367,12 +367,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",
@@ -475,9 +492,15 @@ class GatewayServer {
         this.activeSessionRequests.set(sessionQueueKey, msg.id);
         const outputManager = new outputManager_cjs_namespaceObject.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,
@@ -508,17 +531,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,
@@ -594,6 +643,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, {
@@ -768,11 +823,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,
@@ -784,6 +853,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",
@@ -798,11 +886,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) {
@@ -831,12 +919,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;
@@ -1410,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;

package/dist/gateway/server.d.ts

@@ -129,10 +129,12 @@ export declare class GatewayServer {
      * Send a message to a WebSocket
      */
     private sendMessage;
+    private sendMessageWithRetry;
     /**
      * Send an error message
      */
     private sendError;
+    private sendAgentComplete;
     private sendAgentError;
     private cancelSocketAgentRequests;
     private attachSessionContext;