clawconnect-agent 0.1.7 → 0.1.8

package/dist/{relay → openclaw}/relay-manager.js

@@ -1,17 +1,26 @@
 import { WebSocket } from "ws";
 import { OpenClawGatewayClient } from "./gateway-client.js";
-import { handleLocalCommand } from "../commands/local-handlers.js";
-import { handleProviderCommand } from "../commands/provider-handlers.js";
-import { DEFAULT_GATEWAY_SESSION_DEFAULTS, buildContextUsageFingerprint, readContextUsageSnapshot, canonicalizeRelayParams, canonicalizeSessionKey, extractGatewaySessionDefaults, } from "./session-context.js";
-import { appendUniqueSuffix, extractChatRole, extractChatText, normalizeChatEventPayload, normalizeChatState, withMessageText, } from "./chat-payload.js";
-import { extractHistoryOutcome, withTimeout } from "./chat-history.js";
-import { buildMobileAssistantErrorPayload, buildMobileAssistantFinalPayload, } from "./mobile-chat-run-bridge.js";
-import { buildOfficeEventPayload } from "./office-payload.js";
-import { prepareChatSendParams } from "./chat-send-attachments.js";
-import { prepareOpenClawVoiceInputCommand } from "./openclaw-voice-input.js";
-import { voiceInputSetupMessage } from "./voice-input.js";
+import { bindRelayAbortSignal, buildRelayUrl, parseRelayFrame, sendRelayJson, shouldRetryRelayClose, } from "../core/relay/relay-server-connection.js";
+import { handleLocalCommand } from "./handlers/local-handlers.js";
+import { handleProviderCommand } from "./handlers/provider-handlers.js";
+import { DEFAULT_GATEWAY_SESSION_DEFAULTS, buildContextUsageFingerprint, readContextUsageSnapshot, canonicalizeRelayParams, canonicalizeSessionKey, extractGatewaySessionDefaults, } from "./relay/session-context.js";
+import { appendUniqueSuffix, extractChatRole, extractChatText, normalizeChatEventPayload, normalizeChatState, withMessageText, } from "../core/relay/chat-payload.js";
+import { extractHistoryOutcome, readOpenClawTranscriptChatHistory, withTimeout, } from "./relay/chat-history.js";
+import { dedupeOpenClawChatSendUserMirrorTranscript, } from "./relay/transcript-dedupe.js";
+import { buildMobileAssistantErrorPayload, buildMobileAssistantFinalPayload, } from "../core/relay/mobile-chat-run-bridge.js";
+import { buildOfficeEventPayload } from "../core/relay/office-payload.js";
+import { prepareChatSendParams } from "./relay/chat-send-attachments.js";
+import { relayOutgoingMediaInHistoryResponse, relayOutgoingMediaInPayload } from "./relay/outgoing-media-relay.js";
+import { prepareOpenClawVoiceInputCommand } from "./relay/openclaw-voice-input.js";
+import { voiceInputSetupMessage } from "../core/relay/voice-input.js";
 import { gatewayCapabilitiesForType } from "../gateway-profiles.js";
-import { OPENCLAW_SLASH_COMMAND_CATALOG, } from "./slash-command-catalog.js";
+import { OPENCLAW_SLASH_COMMAND_CATALOG } from "./relay/slash-command-catalog.js";
+const CHAT_HISTORY_FETCH_TIMEOUT_MS = 3000;
+const CHAT_HISTORY_FALLBACK_INITIAL_DELAY_MS = 1200;
+const CHAT_HISTORY_FALLBACK_RETRY_DELAY_MS = 1800;
+const CHAT_HISTORY_FALLBACK_MAX_ATTEMPTS = 120;
+const CHAT_HISTORY_FINAL_RETRY_DELAY_MS = 750;
+const CHAT_SEND_MIRROR_DEDUPE_RETRY_DELAYS_MS = [250, 1000, 2500, 5000, 10000, 20000, 30000];
 // ---------------------------------------------------------------------------
 // Main entry point
 // ---------------------------------------------------------------------------
@@ -35,20 +44,18 @@ export async function runRelayManager(opts) {
             resolve(true);
             return;
         }
-        // If a shutdown signal was provided, close the relay cleanly when fired.
-        if (opts.signal) {
-            if (opts.signal.aborted) {
-                relayWs.close(1001, "shutdown");
-            }
-            else {
-                opts.signal.addEventListener("abort", () => relayWs.close(1001, "shutdown"), { once: true });
-            }
-        }
+        bindRelayAbortSignal(relayWs, opts.signal);
         let gatewayClient = null;
         let sessionDefaults = { ...DEFAULT_GATEWAY_SESSION_DEFAULTS };
         const chatBuffers = new Map();
         const chatFallbacks = new Map();
         const chatRunContexts = new Map();
+        const chatSendDedupeRequests = new Map();
+        const chatSendDedupeRunKeys = new Map();
+        const chatSendDedupeTimers = new Map();
+        const chatSendDedupeAttempts = new Map();
+        const chatSendDedupeRunning = new Map();
+        const outgoingMediaUploadCache = new Map();
         const contextUsageRefreshes = new Map();
         const contextUsageFingerprints = new Map();
         const clearChatFallback = (runId) => {
@@ -58,6 +65,139 @@ export async function runRelayManager(opts) {
                 chatFallbacks.delete(runId);
             }
         };
+        const clearChatSendDedupe = (clientRunId) => {
+            const timer = chatSendDedupeTimers.get(clientRunId);
+            if (timer) {
+                clearTimeout(timer);
+                chatSendDedupeTimers.delete(clientRunId);
+            }
+            chatSendDedupeRequests.delete(clientRunId);
+            chatSendDedupeAttempts.delete(clientRunId);
+            for (const [runId, mappedClientRunId] of chatSendDedupeRunKeys.entries()) {
+                if (mappedClientRunId === clientRunId) {
+                    chatSendDedupeRunKeys.delete(runId);
+                }
+            }
+        };
+        const registerChatSendDedupe = (request, runId) => {
+            chatSendDedupeRequests.set(request.clientRunId, request);
+            if (runId) {
+                chatSendDedupeRunKeys.set(runId, request.clientRunId);
+            }
+            scheduleChatSendDedupe(request.clientRunId);
+        };
+        function scheduleChatSendDedupe(clientRunId, delayOverrideMs) {
+            if (!chatSendDedupeRequests.has(clientRunId)) {
+                return;
+            }
+            const existing = chatSendDedupeTimers.get(clientRunId);
+            if (existing) {
+                clearTimeout(existing);
+            }
+            const attempt = chatSendDedupeAttempts.get(clientRunId) ?? 0;
+            const delayMs = delayOverrideMs ?? CHAT_SEND_MIRROR_DEDUPE_RETRY_DELAYS_MS[Math.min(attempt, CHAT_SEND_MIRROR_DEDUPE_RETRY_DELAYS_MS.length - 1)];
+            const timer = setTimeout(() => {
+                chatSendDedupeTimers.delete(clientRunId);
+                void runChatSendDedupeAttempt(clientRunId).then((changed) => {
+                    if (changed || !chatSendDedupeRequests.has(clientRunId)) {
+                        return;
+                    }
+                    const nextAttempt = attempt + 1;
+                    if (nextAttempt >= CHAT_SEND_MIRROR_DEDUPE_RETRY_DELAYS_MS.length) {
+                        clearChatSendDedupe(clientRunId);
+                        return;
+                    }
+                    chatSendDedupeAttempts.set(clientRunId, nextAttempt);
+                    scheduleChatSendDedupe(clientRunId);
+                });
+            }, delayMs);
+            timer.unref?.();
+            chatSendDedupeTimers.set(clientRunId, timer);
+        }
+        function scheduleChatSendDedupeForRun(runId, delayMs = 100) {
+            const clientRunId = chatSendDedupeRunKeys.get(runId);
+            if (!clientRunId) {
+                return;
+            }
+            scheduleChatSendDedupe(clientRunId, delayMs);
+        }
+        async function runChatSendDedupeAttempt(clientRunId) {
+            const running = chatSendDedupeRunning.get(clientRunId);
+            if (running) {
+                return running;
+            }
+            const promise = (async () => {
+                const request = chatSendDedupeRequests.get(clientRunId);
+                if (!request) {
+                    return false;
+                }
+                try {
+                    const result = await dedupeOpenClawChatSendUserMirrorTranscript(request, sessionDefaults, { maxRetries: 2 });
+                    if (result.changed) {
+                        console.log(`[relay] removed ${result.removedCount} duplicate OpenClaw prompt mirror(s) from ${result.transcriptPath ?? "transcript"}`);
+                        clearChatSendDedupe(clientRunId);
+                        return true;
+                    }
+                }
+                catch (error) {
+                    console.warn(`[relay] chat.send transcript dedupe failed runId=${clientRunId}: ${String(error)}`);
+                }
+                return false;
+            })().finally(() => {
+                chatSendDedupeRunning.delete(clientRunId);
+            });
+            chatSendDedupeRunning.set(clientRunId, promise);
+            return promise;
+        }
+        async function dedupePendingChatSendMirrorsForSession(rawParams) {
+            const sessionKey = resolveRawParamsSessionKey(rawParams);
+            const pending = Array.from(chatSendDedupeRequests.entries()).filter(([, request]) => {
+                const requestSessionKey = canonicalizeSessionKey(request.sessionKey ?? sessionDefaults.mainSessionKey, sessionDefaults);
+                return requestSessionKey === sessionKey;
+            });
+            for (const [clientRunId] of pending) {
+                await runChatSendDedupeAttempt(clientRunId);
+            }
+        }
+        function buildChatSendDedupeRequest(paramsRecord) {
+            if (!paramsRecord) {
+                return undefined;
+            }
+            const message = typeof paramsRecord.message === "string" && paramsRecord.message.trim().length > 0
+                ? paramsRecord.message.trim()
+                : "";
+            const idempotencyKey = typeof paramsRecord.idempotencyKey === "string" && paramsRecord.idempotencyKey.trim().length > 0
+                ? paramsRecord.idempotencyKey.trim()
+                : "";
+            if (!message || !idempotencyKey) {
+                return undefined;
+            }
+            const clientRunId = idempotencyKey.endsWith(":user")
+                ? idempotencyKey.slice(0, -":user".length)
+                : idempotencyKey;
+            if (!clientRunId) {
+                return undefined;
+            }
+            return {
+                clientRunId,
+                message,
+                sessionKey: resolveRawParamsSessionKey(paramsRecord),
+                senderId: "openclaw-macos",
+                senderName: "ClawConnect Agent",
+            };
+        }
+        function resolveRawParamsSessionKey(rawParams) {
+            const record = rawParams && typeof rawParams === "object" && !Array.isArray(rawParams)
+                ? rawParams
+                : {};
+            const rawSessionKey = typeof record.sessionKey === "string" && record.sessionKey.trim().length > 0
+                ? record.sessionKey.trim()
+                : sessionDefaults.mainSessionKey;
+            const normalized = canonicalizeSessionKey(rawSessionKey, sessionDefaults);
+            return typeof normalized === "string" && normalized.trim().length > 0
+                ? normalized.trim()
+                : sessionDefaults.mainSessionKey;
+        }
         const publishContextUsageSnapshot = async (sessionKey, force = false) => {
             const normalizedSessionKey = canonicalizeSessionKey(sessionKey, sessionDefaults);
             if (typeof normalizedSessionKey !== "string" || normalizedSessionKey.trim().length === 0) {
@@ -118,11 +258,11 @@ export async function runRelayManager(opts) {
                     chatFallbacks.delete(runId);
                     return;
                 }
-                const fetchHistory = () => gatewayClient.request("chat.history", { sessionKey: context.sessionKey, limit: 10 });
-                withTimeout(fetchHistory(), 800, "chat.history fallback")
+                const fetchHistory = () => requestChatHistoryFromClawConnect({ sessionKey: context.sessionKey, limit: 10 });
+                withTimeout(fetchHistory(), CHAT_HISTORY_FETCH_TIMEOUT_MS, "chat.history fallback")
                     .then(async (history) => {
                     const outcome = extractHistoryOutcome(history, context);
-                    if (!outcome && attempt < 4) {
+                    if (!outcome && attempt < CHAT_HISTORY_FALLBACK_MAX_ATTEMPTS) {
                         scheduleChatHistoryFallback(runId, context, attempt + 1);
                         return;
                     }
@@ -134,27 +274,22 @@ export async function runRelayManager(opts) {
                     clearChatFallback(runId);
                     chatRunContexts.delete(runId);
                     if (outcome.kind === "final") {
-                        send({
-                            type: "event",
-                            event: "chat",
-                            payload: buildMobileAssistantFinalPayload({
-                                run: { runId, sessionKey: context.sessionKey },
-                                text: outcome.text,
-                            }),
+                        const basePayload = buildMobileAssistantFinalPayload({
+                            run: { runId, sessionKey: context.sessionKey },
+                            text: outcome.text,
+                            includeTimelineEvents: true,
                         });
+                        await publishAndSendGatewayEvent("chat", buildFinalPayloadFromHistoryOutcome(basePayload, outcome), true);
                         return;
                     }
-                    send({
-                        type: "event",
-                        event: "chat",
-                        payload: buildMobileAssistantErrorPayload({
-                            run: { runId, sessionKey: context.sessionKey },
-                            errorMessage: outcome.errorMessage,
-                        }),
-                    });
+                    await publishAndSendGatewayEvent("chat", buildMobileAssistantErrorPayload({
+                        run: { runId, sessionKey: context.sessionKey },
+                        errorMessage: outcome.errorMessage,
+                        includeTimelineEvents: true,
+                    }), true);
                 })
                     .catch((err) => {
-                    if (attempt < 4) {
+                    if (attempt < CHAT_HISTORY_FALLBACK_MAX_ATTEMPTS) {
                         scheduleChatHistoryFallback(runId, context, attempt + 1);
                         return;
                     }
@@ -162,7 +297,7 @@ export async function runRelayManager(opts) {
                     chatFallbacks.delete(runId);
                     chatRunContexts.delete(runId);
                 });
-            }, attempt === 0 ? 1500 : 2000);
+            }, attempt === 0 ? CHAT_HISTORY_FALLBACK_INITIAL_DELAY_MS : CHAT_HISTORY_FALLBACK_RETRY_DELAY_MS);
             timer.unref?.();
             chatFallbacks.set(runId, timer);
         };
@@ -183,9 +318,7 @@ export async function runRelayManager(opts) {
             }
         };
         function send(msg) {
-            if (relayWs.readyState === WebSocket.OPEN) {
-                relayWs.send(JSON.stringify(msg));
-            }
+            sendRelayJson(relayWs, msg);
         }
         function publishOfficeSnapshot(eventName, payload) {
             const officePayload = buildOfficeEventPayload(eventName, payload, () => new Date().toISOString());
@@ -194,6 +327,149 @@ export async function runRelayManager(opts) {
             }
             send({ type: "event", event: "office", payload: officePayload });
         }
+        async function publishAndSendGatewayEvent(eventName, payload, publishOffice) {
+            const outgoingPayload = eventName === "chat"
+                ? await relayOutgoingMediaInPayload(payload, {
+                    relayServerUrl: opts.relayServerUrl,
+                    relaySecret: opts.relaySecret,
+                    gatewayId: opts.gatewayId,
+                    senderDisplayName: "OpenClaw",
+                    cache: outgoingMediaUploadCache,
+                })
+                : payload;
+            if (publishOffice) {
+                publishOfficeSnapshot(eventName, outgoingPayload);
+            }
+            send({ type: "event", event: eventName, payload: outgoingPayload });
+        }
+        async function relayOutgoingMediaForResponse(method, payload) {
+            if (method !== "chat.history") {
+                return payload;
+            }
+            return relayOutgoingMediaInHistoryResponse(payload, {
+                relayServerUrl: opts.relayServerUrl,
+                relaySecret: opts.relaySecret,
+                gatewayId: opts.gatewayId,
+                senderDisplayName: "OpenClaw",
+                cache: outgoingMediaUploadCache,
+            });
+        }
+        async function requestChatHistoryFromClawConnect(params) {
+            try {
+                await dedupePendingChatSendMirrorsForSession(params);
+                const transcriptHistory = await readOpenClawTranscriptChatHistory(params, sessionDefaults);
+                if (transcriptHistory) {
+                    return transcriptHistory;
+                }
+            }
+            catch (err) {
+                console.warn(`[relay] transcript chat.history unavailable: ${String(err)}`);
+            }
+            if (hasHistoryCursor(params)) {
+                return buildEmptyHistoryPage(params);
+            }
+            if (!shouldUseLegacyOpenClawHistoryFallback(params)) {
+                return buildEmptyHistoryPage(params);
+            }
+            if (!gatewayClient) {
+                throw new Error("gateway not connected");
+            }
+            return gatewayClient.request("chat.history", buildLegacyOpenClawHistoryParams(params));
+        }
+        function shouldUseLegacyOpenClawHistoryFallback(params) {
+            const record = params && typeof params === "object" && !Array.isArray(params)
+                ? params
+                : {};
+            const rawSessionKey = typeof record.sessionKey === "string" && record.sessionKey.trim().length > 0
+                ? record.sessionKey.trim()
+                : sessionDefaults.mainSessionKey;
+            const normalized = canonicalizeSessionKey(rawSessionKey, sessionDefaults);
+            return typeof normalized === "string" && normalized === sessionDefaults.mainSessionKey;
+        }
+        function buildLegacyOpenClawHistoryParams(params) {
+            const record = params && typeof params === "object" && !Array.isArray(params)
+                ? params
+                : {};
+            const rawSessionKey = typeof record.sessionKey === "string" && record.sessionKey.trim().length > 0
+                ? record.sessionKey.trim()
+                : sessionDefaults.mainSessionKey;
+            const sessionKey = canonicalizeSessionKey(rawSessionKey, sessionDefaults);
+            const legacyParams = {
+                sessionKey: typeof sessionKey === "string" && sessionKey.trim().length > 0
+                    ? sessionKey.trim()
+                    : sessionDefaults.mainSessionKey,
+            };
+            const limit = normalizePositiveInteger(record.limit);
+            if (limit !== undefined) {
+                legacyParams.limit = limit;
+            }
+            const maxChars = normalizePositiveInteger(record.maxChars);
+            if (maxChars !== undefined) {
+                legacyParams.maxChars = maxChars;
+            }
+            return legacyParams;
+        }
+        function buildEmptyHistoryPage(params) {
+            const record = params && typeof params === "object" && !Array.isArray(params)
+                ? params
+                : {};
+            const rawSessionKey = typeof record.sessionKey === "string" && record.sessionKey.trim().length > 0
+                ? record.sessionKey.trim()
+                : sessionDefaults.mainSessionKey;
+            const sessionKey = canonicalizeSessionKey(rawSessionKey, sessionDefaults);
+            return {
+                sessionKey: typeof sessionKey === "string" && sessionKey.trim().length > 0
+                    ? sessionKey.trim()
+                    : sessionDefaults.mainSessionKey,
+                messages: [],
+                hasMore: false,
+            };
+        }
+        function hasHistoryCursor(params) {
+            if (!params || typeof params !== "object" || Array.isArray(params)) {
+                return false;
+            }
+            const cursor = params.cursor;
+            return typeof cursor === "string" && cursor.trim().length > 0;
+        }
+        function normalizePositiveInteger(value) {
+            const parsed = typeof value === "number" && Number.isFinite(value)
+                ? Math.round(value)
+                : typeof value === "string" && value.trim().length > 0
+                    ? Number.parseInt(value.trim(), 10)
+                    : Number.NaN;
+            return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+        }
+        function buildFinalPayloadFromHistoryOutcome(basePayload, outcome) {
+            const payload = outcome.text.trim()
+                ? withMessageText(basePayload, outcome.text)
+                : basePayload && typeof basePayload === "object" && !Array.isArray(basePayload)
+                    ? { ...basePayload }
+                    : {};
+            const historyMessage = outcome.message;
+            const content = Array.isArray(historyMessage.content) ? historyMessage.content : [];
+            if (content.length === 0) {
+                return payload;
+            }
+            const payloadRecord = payload && typeof payload === "object" && !Array.isArray(payload)
+                ? payload
+                : {};
+            const existingMessage = payloadRecord.message && typeof payloadRecord.message === "object" && !Array.isArray(payloadRecord.message)
+                ? payloadRecord.message
+                : {};
+            return {
+                ...payloadRecord,
+                message: {
+                    ...existingMessage,
+                    ...stripUndefinedHistoryMessageFields(historyMessage),
+                    role: "assistant",
+                    content,
+                },
+            };
+        }
+        function stripUndefinedHistoryMessageFields(message) {
+            return Object.fromEntries(Object.entries(message).filter(([, value]) => value !== undefined));
+        }
         relayWs.on("open", () => {
             console.log(`Connected to relay server (gatewayId=${opts.gatewayId})`);
             opts.onConnected?.();
@@ -235,13 +511,21 @@ export async function runRelayManager(opts) {
                         const resolvedSessionKey = sessionKey ?? runContext?.sessionKey;
                         const currentText = extractChatText(normalizedPayload);
                         const role = extractChatRole(normalizedPayload);
+                        let realtimePayload = normalizedPayload;
                         if (runId) {
+                            if (state === "final" || state === "error" || state === "failed" || state === "fail" || state === "aborted") {
+                                scheduleChatSendDedupeForRun(runId, 100);
+                            }
                             if (role === "assistant" && (state === "delta" || state === "final" || state === "error" || state === "failed" || state === "fail")) {
                                 clearChatFallback(runId);
                             }
                             if (state === "delta" || state === "streaming" || state === "in_progress") {
                                 const previousText = chatBuffers.get(runId) ?? "";
-                                chatBuffers.set(runId, appendUniqueSuffix(previousText, currentText));
+                                const bufferedText = appendUniqueSuffix(previousText, currentText);
+                                chatBuffers.set(runId, bufferedText);
+                                if (role === "assistant" && bufferedText.trim()) {
+                                    realtimePayload = withMessageText(normalizedPayload, bufferedText);
+                                }
                             }
                             else if (state === "error" || state === "failed" || state === "fail" || state === "aborted") {
                                 chatBuffers.delete(runId);
@@ -259,31 +543,25 @@ export async function runRelayManager(opts) {
                                     chatRunContexts.delete(runId);
                                 }
                                 const outgoingPayload = withMessageText(normalizedPayload, resolvedText);
-                                if (shouldPublishOffice) {
-                                    publishOfficeSnapshot(event, outgoingPayload);
-                                }
-                                send({ type: "event", event, payload: outgoingPayload });
+                                void publishAndSendGatewayEvent(event, outgoingPayload, shouldPublishOffice);
                                 return;
                             }
-                            const fetchHistory = () => gatewayClient.request("chat.history", { sessionKey: resolvedSessionKey, limit: 10 });
-                            withTimeout(fetchHistory(), 500, "chat.history")
+                            const fetchHistory = () => requestChatHistoryFromClawConnect({ sessionKey: resolvedSessionKey, limit: 10 });
+                            withTimeout(fetchHistory(), CHAT_HISTORY_FETCH_TIMEOUT_MS, "chat.history")
                                 .then(async (history) => {
                                 let outcome = runContext ? extractHistoryOutcome(history, runContext) : null;
-                                // Retry once after a short delay if OpenClaw hasn't committed the message yet.
+                                // Retry once if OpenClaw has emitted final before the transcript is committed.
                                 if (!outcome) {
-                                    await new Promise((resolve) => setTimeout(resolve, 150));
-                                    const retryHistory = await withTimeout(fetchHistory(), 500, "chat.history retry");
+                                    await new Promise((resolve) => setTimeout(resolve, CHAT_HISTORY_FINAL_RETRY_DELAY_MS));
+                                    const retryHistory = await withTimeout(fetchHistory(), CHAT_HISTORY_FETCH_TIMEOUT_MS, "chat.history retry");
                                     outcome = runContext ? extractHistoryOutcome(retryHistory, runContext) : null;
                                 }
-                                if (runId) {
+                                if (runId && outcome) {
                                     chatRunContexts.delete(runId);
                                 }
                                 if (outcome?.kind === "final") {
-                                    const outgoingPayload = withMessageText(normalizedPayload, outcome.text);
-                                    if (shouldPublishOffice) {
-                                        publishOfficeSnapshot(event, outgoingPayload);
-                                    }
-                                    send({ type: "event", event, payload: outgoingPayload });
+                                    const outgoingPayload = buildFinalPayloadFromHistoryOutcome(normalizedPayload, outcome);
+                                    await publishAndSendGatewayEvent(event, outgoingPayload, shouldPublishOffice);
                                     return;
                                 }
                                 if (outcome?.kind === "error") {
@@ -292,30 +570,22 @@ export async function runRelayManager(opts) {
                                         state: "error",
                                         errorMessage: outcome.errorMessage,
                                     };
-                                    if (shouldPublishOffice) {
-                                        publishOfficeSnapshot(event, outgoingPayload);
-                                    }
-                                    send({
-                                        type: "event",
-                                        event,
-                                        payload: outgoingPayload,
-                                    });
+                                    await publishAndSendGatewayEvent(event, outgoingPayload, shouldPublishOffice);
                                     return;
                                 }
-                                if (shouldPublishOffice) {
-                                    publishOfficeSnapshot(event, normalizedPayload);
+                                if (runId && runContext) {
+                                    scheduleChatHistoryFallback(runId, runContext, 0);
+                                    return;
                                 }
-                                send({ type: "event", event, payload: normalizedPayload });
+                                await publishAndSendGatewayEvent(event, normalizedPayload, shouldPublishOffice);
                             })
                                 .catch((err) => {
                                 console.error(`[relay] chat.history fetch failed: ${err}`);
-                                if (runId) {
-                                    chatRunContexts.delete(runId);
-                                }
-                                if (shouldPublishOffice) {
-                                    publishOfficeSnapshot(event, normalizedPayload);
+                                if (runId && runContext) {
+                                    scheduleChatHistoryFallback(runId, runContext, 0);
+                                    return;
                                 }
-                                send({ type: "event", event, payload: normalizedPayload });
+                                void publishAndSendGatewayEvent(event, normalizedPayload, shouldPublishOffice);
                             });
                             return;
                         }
@@ -323,12 +593,10 @@ export async function runRelayManager(opts) {
                             chatRunContexts.delete(runId);
                             scheduleContextUsageRefresh(p?.sessionKey, 450);
                         }
-                        if (shouldPublishOffice) {
-                            publishOfficeSnapshot(event, normalizedPayload);
-                        }
-                        send({ type: "event", event, payload: normalizedPayload });
+                        void publishAndSendGatewayEvent(event, realtimePayload, shouldPublishOffice);
                         return;
                     }
+                    void publishAndSendGatewayEvent(event, normalizedPayload, shouldPublishOffice);
                 },
             });
             gatewayClient.start();
@@ -338,11 +606,8 @@ export async function runRelayManager(opts) {
             let methodForLog;
             let voiceInputRun;
             try {
-                let msg;
-                try {
-                    msg = JSON.parse(raw.toString());
-                }
-                catch {
+                const msg = parseRelayFrame(raw);
+                if (!msg) {
                     return;
                 }
                 if (msg.type === "heartbeat") {
@@ -405,12 +670,17 @@ export async function runRelayManager(opts) {
                 const paramsRecord = params && typeof params === "object" && !Array.isArray(params)
                     ? params
                     : undefined;
-                if (!gatewayClient) {
+                const chatSendDedupeRequest = msg.method === "chat.send"
+                    ? buildChatSendDedupeRequest(paramsRecord)
+                    : undefined;
+                if (!gatewayClient && msg.method !== "chat.history") {
                     throw new Error("gateway not connected");
                 }
-                gatewayClient
-                    .request(msg.method, params)
-                    .then((result) => {
+                const commandPromise = msg.method === "chat.history"
+                    ? requestChatHistoryFromClawConnect(params)
+                    : gatewayClient.request(msg.method, params);
+                commandPromise
+                    .then(async (result) => {
                     let resolvedRunId;
                     if ((msg.method === "chat.send" || msg.method === "agent") && params && typeof params === "object" && !Array.isArray(params)) {
                         const paramsRecord = params;
@@ -435,12 +705,16 @@ export async function runRelayManager(opts) {
                             };
                             scheduleChatHistoryFallback(runId, runContext);
                         }
+                        if (msg.method === "chat.send" && chatSendDedupeRequest) {
+                            registerChatSendDedupe(chatSendDedupeRequest, runId);
+                        }
                         // Let a model switch settle before publishing context usage again.
                         // Forced refreshes can replay a stale model snapshot and overwrite the new selection.
                         scheduleContextUsageRefresh(sessionKey, 1200);
                     }
                     if (requestId) {
-                        send({ type: "res", id: requestId, ok: true, payload: result });
+                        const responsePayload = await relayOutgoingMediaForResponse(msg.method, result);
+                        send({ type: "res", id: requestId, ok: true, payload: responsePayload });
                     }
                 })
                     .catch((err) => {
@@ -461,6 +735,7 @@ export async function runRelayManager(opts) {
                         payload: buildMobileAssistantErrorPayload({
                             run: voiceInputRun,
                             errorMessage: setupMessage,
+                            includeTimelineEvents: true,
                         }),
                     });
                     if (requestId) {
@@ -481,15 +756,18 @@ export async function runRelayManager(opts) {
                 clearTimeout(timer);
             }
             chatFallbacks.clear();
+            for (const timer of chatSendDedupeTimers.values()) {
+                clearTimeout(timer);
+            }
+            chatSendDedupeTimers.clear();
+            chatSendDedupeRequests.clear();
+            chatSendDedupeRunKeys.clear();
+            chatSendDedupeAttempts.clear();
             for (const timer of contextUsageRefreshes.values()) {
                 clearTimeout(timer);
             }
             contextUsageRefreshes.clear();
-            // Code 4000 = server kicked us because another relay client took over.
-            // Stop retrying so the two instances don't bounce each other forever.
-            // Also stop retrying when the shutdown signal was received.
-            const intentional = opts.signal?.aborted || code === 4000;
-            resolve(!intentional);
+            resolve(shouldRetryRelayClose(code, opts.signal));
         });
         relayWs.on("error", (err) => {
             console.error("Relay WebSocket error:", err.message);
@@ -506,8 +784,4 @@ export function buildRelayHelloMessage(opts) {
         slashCommands: OPENCLAW_SLASH_COMMAND_CATALOG,
     };
 }
-function buildRelayUrl(serverUrl, gatewayId, relaySecret) {
-    const base = serverUrl.replace(/\/+$/, "").replace(/^http/, "ws");
-    return `${base}/relay/${gatewayId}?secret=${encodeURIComponent(relaySecret)}`;
-}
 //# sourceMappingURL=relay-manager.js.map