@dev-anywhere/relay 0.4.2 → 0.4.3

package/dist/{chunk-ERH2EO6I.js → chunk-OJABHE5C.js}

@@ -536,6 +536,7 @@ var SessionHistoryMessageSchema = z8.object({
   cursor: z8.string().optional()
 });
 var RequestIdShape = { requestId: IdSchema.optional() };
+var RequiredRequestIdShape = { requestId: IdSchema };
 var ControlErrorCodeSchema = z8.enum(Object.values(ControlErrorCode));
 var RequestErrorShape = {
   error: z8.string().optional(),
@@ -618,6 +619,30 @@ var relayControlDefinitions = [
     ...RequestErrorShape,
     capabilities: VoiceCapabilitiesSchema.optional()
   }),
+  // Lightweight latency probes. These measure synthetic round-trip latency for the transport
+  // segments and intentionally stay separate from PTY input echo tracing.
+  control("latency_web_relay_ping", RequiredRequestIdShape),
+  control("latency_web_relay_pong", {
+    ...RequiredRequestIdShape,
+    relayNow: z8.number().optional()
+  }),
+  control("latency_relay_proxy_request", RequiredRequestIdShape),
+  control("latency_relay_proxy_response", {
+    ...RequiredRequestIdShape,
+    success: z8.boolean(),
+    rttMs: z8.number().nonnegative().optional(),
+    error: z8.string().optional()
+  }),
+  control("latency_relay_proxy_ping", {
+    ...RequiredRequestIdShape,
+    relayNow: z8.number().optional()
+  }),
+  control("latency_relay_proxy_pong", {
+    ...RequiredRequestIdShape,
+    proxyNow: z8.number().optional()
+  }),
+  control("latency_web_proxy_ping", RequiredRequestIdShape, "client_to_proxy"),
+  control("latency_web_proxy_pong", { ...RequiredRequestIdShape, proxyNow: z8.number().optional() }, "proxy_to_client"),
   // 客户端注册协议
   control("client_register", {
     clientId: IdSchema
@@ -1244,7 +1269,7 @@ function healthRouter(registry, options = {}) {
 }
 
 // src/handlers/proxy.ts
-import { WebSocket as WebSocket3 } from "ws";
+import { WebSocket as WebSocket4 } from "ws";
 
 // src/router.ts
 import { WebSocket as WebSocket2 } from "ws";
@@ -1331,6 +1356,100 @@ function routeClientMessage(raw, proxyId, clientWs, registry, logger, chaos) {
   else proxyWs.send(raw);
 }
 
+// src/latency-probes.ts
+import { performance } from "perf_hooks";
+import { WebSocket as WebSocket3 } from "ws";
+var DEFAULT_RELAY_PROXY_PROBE_TIMEOUT_MS = 3e3;
+var pendingRelayProxyProbes = /* @__PURE__ */ new Map();
+function keyFor(proxyId, requestId) {
+  return `${proxyId}:${requestId}`;
+}
+function sendClientResponse(clientWs, response, chaos) {
+  if (clientWs.readyState !== WebSocket3.OPEN) return;
+  const raw = serializeControl(response);
+  if (chaos) {
+    chaos.send(clientWs, raw, {
+      direction: "proxy_to_client",
+      type: "latency_relay_proxy_response"
+    });
+    return;
+  }
+  clientWs.send(raw);
+}
+function startRelayProxyLatencyProbe({
+  requestId,
+  proxyId,
+  proxyWs,
+  clientWs,
+  logger,
+  chaos,
+  timeoutMs = DEFAULT_RELAY_PROXY_PROBE_TIMEOUT_MS
+}) {
+  const key = keyFor(proxyId, requestId);
+  const existing = pendingRelayProxyProbes.get(key);
+  if (existing) {
+    clearTimeout(existing.timer);
+    pendingRelayProxyProbes.delete(key);
+  }
+  const startedAt = performance.now();
+  const timer = setTimeout(() => {
+    pendingRelayProxyProbes.delete(key);
+    sendClientResponse(
+      clientWs,
+      {
+        type: "latency_relay_proxy_response",
+        requestId,
+        success: false,
+        error: "Relay \u5230\u5F00\u53D1\u673A\u6D4B\u901F\u8D85\u65F6"
+      },
+      chaos
+    );
+    logger.warn({ proxyId, requestId }, "Relay-proxy latency probe timed out");
+  }, timeoutMs);
+  pendingRelayProxyProbes.set(key, {
+    proxyId,
+    requestId,
+    clientWs,
+    startedAt,
+    timer,
+    chaos
+  });
+  const raw = serializeControl({
+    type: "latency_relay_proxy_ping",
+    requestId,
+    relayNow: Date.now()
+  });
+  if (chaos) {
+    chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: "latency_relay_proxy_ping" });
+    return;
+  }
+  proxyWs.send(raw);
+}
+function completeRelayProxyLatencyProbe({
+  proxyId,
+  requestId,
+  logger
+}) {
+  const key = keyFor(proxyId, requestId);
+  const pending = pendingRelayProxyProbes.get(key);
+  if (!pending) return false;
+  pendingRelayProxyProbes.delete(key);
+  clearTimeout(pending.timer);
+  const rttMs = performance.now() - pending.startedAt;
+  sendClientResponse(
+    pending.clientWs,
+    {
+      type: "latency_relay_proxy_response",
+      requestId,
+      success: true,
+      rttMs
+    },
+    pending.chaos
+  );
+  logger.debug({ proxyId, requestId, rttMs }, "Relay-proxy latency probe completed");
+  return true;
+}
+
 // src/handlers/proxy.ts
 var MAX_BINARY_FRAME_SIZE = 10 * 1024 * 1024;
 var MAX_JSON_MESSAGE_SIZE = 1 * 1024 * 1024;
@@ -1399,7 +1518,7 @@ function handleProxyConnection(ws, registry, logger, chaos) {
       }
       const clients = registry.getClientsForProxy(proxyWs.proxyId);
       for (const clientWs of clients) {
-        if (clientWs.readyState === WebSocket3.OPEN) {
+        if (clientWs.readyState === WebSocket4.OPEN) {
           clientWs.send(data);
         }
       }
@@ -1453,6 +1572,24 @@ function handleProxyConnection(ws, registry, logger, chaos) {
       logger.info({ proxyId: proxyWs.proxyId, count: sessions.length }, "Session sync received");
       return;
     }
+    if (result.kind === "control" && result.message.type === "latency_relay_proxy_pong") {
+      if (!proxyWs.proxyId) {
+        rejectNotRegistered(proxyWs);
+        return;
+      }
+      const completed = completeRelayProxyLatencyProbe({
+        proxyId: proxyWs.proxyId,
+        requestId: result.message.requestId,
+        logger
+      });
+      if (!completed) {
+        logger.debug(
+          { proxyId: proxyWs.proxyId, requestId: result.message.requestId },
+          "Unmatched relay-proxy latency pong ignored"
+        );
+      }
+      return;
+    }
     if (result.kind === "control") {
       if (isProxyToClientRelayControlType(result.message.type)) {
         if (!proxyWs.proxyId) {
@@ -1461,7 +1598,7 @@ function handleProxyConnection(ws, registry, logger, chaos) {
         }
         const clients = registry.getClientsForProxy(proxyWs.proxyId);
         for (const clientWs of clients) {
-          if (clientWs.readyState === WebSocket3.OPEN) {
+          if (clientWs.readyState === WebSocket4.OPEN) {
             if (chaos) {
               chaos.send(clientWs, raw, {
                 direction: "proxy_to_client",
@@ -1533,13 +1670,13 @@ function handleProxyConnection(ws, registry, logger, chaos) {
 }
 
 // src/handlers/client.ts
-import { WebSocket as WebSocket6 } from "ws";
+import { WebSocket as WebSocket7 } from "ws";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/voice/bailian-asr.ts
 import { EventEmitter } from "events";
 import { nanoid } from "nanoid";
-import { WebSocket as WebSocket4 } from "ws";
+import { WebSocket as WebSocket5 } from "ws";
 
 // src/voice/bailian-endpoints.ts
 var BAILIAN_HOSTS = {
@@ -1558,7 +1695,7 @@ function bailianInferenceUrl(region) {
 var OPEN = 1;
 var END_OF_SPEECH_SILENCE_MS = 1200;
 function defaultSocketFactory(url, options) {
-  return new WebSocket4(url, options);
+  return new WebSocket5(url, options);
 }
 function extractRealtimePreview(payload) {
   if (!payload || typeof payload !== "object") return null;
@@ -1735,10 +1872,10 @@ function createBailianAsrClient(config, options = {}) {
 // src/voice/bailian-tts.ts
 import { EventEmitter as EventEmitter2 } from "events";
 import { nanoid as nanoid2 } from "nanoid";
-import { WebSocket as WebSocket5 } from "ws";
+import { WebSocket as WebSocket6 } from "ws";
 var OPEN2 = 1;
 function defaultSocketFactory2(url, options) {
-  return new WebSocket5(url, options);
+  return new WebSocket6(url, options);
 }
 function errorFromPayload(payload) {
   if (!payload || typeof payload !== "object") return new Error("Bailian TTS error");
@@ -2240,6 +2377,22 @@ function rejectProxySelect(ws, requestId, proxyId) {
     })
   );
 }
+function sendRelayProxyProbeFailure(ws, requestId, error, chaos) {
+  const response = serializeControl({
+    type: "latency_relay_proxy_response",
+    requestId,
+    success: false,
+    error
+  });
+  if (chaos) {
+    chaos.send(ws, response, {
+      direction: "proxy_to_client",
+      type: "latency_relay_proxy_response"
+    });
+    return;
+  }
+  ws.send(response);
+}
 function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, voiceProviders) {
   const clientWs = ws;
   clientWs.isAlive = true;
@@ -2290,6 +2443,48 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
         }
         return;
       }
+      if (msg.type === "latency_web_relay_ping") {
+        const response = serializeControl({
+          type: "latency_web_relay_pong",
+          requestId: msg.requestId,
+          relayNow: Date.now()
+        });
+        if (chaos) {
+          chaos.send(clientWs, response, {
+            direction: "proxy_to_client",
+            type: "latency_web_relay_pong"
+          });
+        } else {
+          clientWs.send(response);
+        }
+        return;
+      }
+      if (msg.type === "latency_relay_proxy_request") {
+        const targetProxyId = clientWs.boundProxyId;
+        if (!targetProxyId) {
+          sendRelayProxyProbeFailure(clientWs, msg.requestId, "\u5F53\u524D\u672A\u8FDE\u63A5\u5F00\u53D1\u673A", chaos);
+          return;
+        }
+        const proxyWs = registry.getProxy(targetProxyId);
+        if (!proxyWs || proxyWs.readyState !== WebSocket7.OPEN) {
+          sendRelayProxyProbeFailure(
+            clientWs,
+            msg.requestId,
+            `\u5F00\u53D1\u673A ${targetProxyId} \u4E0D\u5728\u7EBF`,
+            chaos
+          );
+          return;
+        }
+        startRelayProxyLatencyProbe({
+          requestId: msg.requestId,
+          proxyId: targetProxyId,
+          proxyWs,
+          clientWs,
+          logger,
+          chaos
+        });
+        return;
+      }
       if (voiceConfigStore && handleVoiceConfigControl(msg, clientWs, voiceConfigStore, logger, voiceProviders)) {
         return;
       }
@@ -2300,7 +2495,7 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
           return;
         }
         const proxyWs = registry.getProxy(targetProxyId);
-        if (proxyWs && proxyWs.readyState === WebSocket6.OPEN) {
+        if (proxyWs && proxyWs.readyState === WebSocket7.OPEN) {
           if (chaos) chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: msg.type });
           else proxyWs.send(raw);
         } else {
@@ -2408,7 +2603,7 @@ function setupHeartbeat(wss, interval = 3e4) {
 }
 
 // src/chaos.ts
-import { WebSocket as WebSocket7 } from "ws";
+import { WebSocket as WebSocket8 } from "ws";
 function parseRelayChaosFromEnv(env) {
   const enabled = env.DEV_ANYWHERE_RELAY_CHAOS === "1";
   const types = env.DEV_ANYWHERE_RELAY_CHAOS_TYPES?.split(",").map((type) => type.trim()).filter(Boolean);
@@ -2430,7 +2625,7 @@ function createRelayChaos(options, logger) {
     return true;
   }
   function sendNow(ws, data) {
-    if (ws.readyState === WebSocket7.OPEN) {
+    if (ws.readyState === WebSocket8.OPEN) {
       ws.send(data);
     }
   }
@@ -2547,9 +2742,9 @@ function createVoiceConfigStore(options = {}) {
 }
 
 // src/voice/asr-ws.ts
-import { WebSocket as WebSocket8 } from "ws";
+import { WebSocket as WebSocket9 } from "ws";
 function sendJson(ws, payload) {
-  if (ws.readyState === WebSocket8.OPEN) {
+  if (ws.readyState === WebSocket9.OPEN) {
     ws.send(JSON.stringify(payload));
   }
 }
@@ -2622,9 +2817,9 @@ function handleVoiceAsrConnection(ws, store, logger, providers) {
 }
 
 // src/voice/tts-ws.ts
-import { WebSocket as WebSocket9 } from "ws";
+import { WebSocket as WebSocket10 } from "ws";
 function sendJson2(ws, payload) {
-  if (ws.readyState === WebSocket9.OPEN) {
+  if (ws.readyState === WebSocket10.OPEN) {
     ws.send(JSON.stringify(payload));
   }
 }
@@ -2707,7 +2902,7 @@ function handleVoiceTtsConnection(ws, store, logger, providers) {
         activeStats.audioBytes += chunk.byteLength;
         activeStats.audioChunks += 1;
       }
-      if (ws.readyState === WebSocket9.OPEN) ws.send(chunk);
+      if (ws.readyState === WebSocket10.OPEN) ws.send(chunk);
     });
     provider.on("finished", () => {
       if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS finished");
@@ -3161,4 +3356,4 @@ export {
   parseRelayChaosFromEnv,
   createRelayServer
 };
-//# sourceMappingURL=chunk-ERH2EO6I.js.map
+//# sourceMappingURL=chunk-OJABHE5C.js.map