ocuclaw 1.3.2 → 1.3.4

package/dist/even-ai/even-ai-endpoint.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { constantTimeEqual } from "../domain/constant-time-equal.js";
 import { filterRawEmojiText } from "../domain/message-emoji-filter.js";
 import { composeReadabilitySystemPrompt } from "../domain/readability-system-prompt.js";
 import { normalizeEvenAiSystemPrompt } from "./even-ai-settings-store.js";
@@ -7,6 +8,8 @@ const DEFAULT_RESPONSE_MODEL = "ocuclaw-active-session";
 const DEFAULT_TIMEOUT_MS = 60000;
 const DEFAULT_MAX_BODY_BYTES = 65536;
 const DEFAULT_DEDUP_WINDOW_MS = 500;
+
+const DEFAULT_MAX_INTERCEPT_INFLIGHT = 4;
 export const EVEN_AI_CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
 const REQUEST_HANDLED_MARKER = Symbol.for("ocuclaw.evenai.handled");
 function normalizeLogger(logger) {
@@ -277,6 +280,10 @@ export function createEvenAiEndpoint(opts = {}) {
     typeof opts.seedFastModeForRoute === "function"
       ? opts.seedFastModeForRoute
       : null;
+  const resolveAgentForRoute =
+    typeof opts.resolveAgentForRoute === "function"
+      ? opts.resolveAgentForRoute
+      : null;
   const now =
     typeof opts.now === "function" ? opts.now : () => Date.now();
   const requestTimeoutMs = normalizePositiveInt(
@@ -291,6 +298,10 @@ export function createEvenAiEndpoint(opts = {}) {
     0,
     normalizePositiveInt(opts.dedupWindowMs, DEFAULT_DEDUP_WINDOW_MS),
   );
+  const maxInterceptInflight = normalizePositiveInt(
+    opts.maxInterceptInflight,
+    DEFAULT_MAX_INTERCEPT_INFLIGHT,
+  );
 
   if (!gatewayBridge || typeof gatewayBridge.sendMessage !== "function") {
     throw new Error("Even AI endpoint requires gatewayBridge.sendMessage()");
@@ -310,9 +321,10 @@ export function createEvenAiEndpoint(opts = {}) {
     throw new Error("Even AI endpoint requires runWaiter.waitForRun()");
   }
 
-  /** @type {{requestId: string, fingerprint: string, sessionKey: string|null, startedAtMs: number}|null} */
   let inFlight = null;
-  /** @type {{fingerprint: string, startedAtMs: number}|null} */
+
+  let interceptInflight = 0;
+
   let lastAccepted = null;
 
   async function handleRequest(req, res) {
@@ -346,7 +358,7 @@ export function createEvenAiEndpoint(opts = {}) {
       }),
     );
 
-    if (!token || authToken !== token) {
+    if (!token || !constantTimeEqual(authToken, token)) {
       emitDebug(
         "evenai",
         "request_auth_failed",
@@ -581,6 +593,29 @@ export function createEvenAiEndpoint(opts = {}) {
             userText,
           }),
         ) || "main";
+
+      if (interceptInflight >= maxInterceptInflight) {
+        emitDebug(
+          "evenai",
+          "listen_intercept_capacity_exceeded",
+          "warn",
+          { sessionKey },
+          () => ({
+            requestId,
+            interceptInflight,
+            maxInterceptInflight,
+          }),
+        );
+        writeJson(
+          res,
+          buildListenInterceptCloseoutPayload({
+            id: requestId,
+            createdMs: startedAtMs,
+            model: responseModel,
+          }),
+        );
+        return true;
+      }
       lastAccepted = {
         fingerprint,
         startedAtMs,
@@ -600,6 +635,7 @@ export function createEvenAiEndpoint(opts = {}) {
         }),
       );
 
+      interceptInflight += 1;
       void (async () => {
         try {
           const dispatchResult = await Promise.resolve(
@@ -610,6 +646,12 @@ export function createEvenAiEndpoint(opts = {}) {
               source: "hybrid_voice_endpoint",
             }),
           );
+          const dispatchRunId =
+            dispatchResult &&
+            typeof dispatchResult.runId === "string" &&
+            dispatchResult.runId.trim()
+              ? dispatchResult.runId.trim()
+              : null;
           if (emitListenInterceptBroadcast) {
             try {
               emitListenInterceptBroadcast({ sessionKey });
@@ -625,12 +667,7 @@ export function createEvenAiEndpoint(opts = {}) {
             "info",
             {
               sessionKey,
-              runId:
-                dispatchResult &&
-                typeof dispatchResult.runId === "string" &&
-                dispatchResult.runId.trim()
-                  ? dispatchResult.runId.trim()
-                  : undefined,
+              runId: dispatchRunId || undefined,
             },
             () => ({
               requestId,
@@ -643,6 +680,16 @@ export function createEvenAiEndpoint(opts = {}) {
                   : null,
             }),
           );
+
+          if (dispatchRunId) {
+            try {
+              await runWaiter.waitForRun({
+                runId: dispatchRunId,
+                sessionKey,
+                timeoutMs: requestTimeoutMs,
+              });
+            } catch (_) {}
+          }
         } catch (err) {
           let cleanupEmitted = false;
           let cleanupConnectedAppClients = null;
@@ -687,6 +734,8 @@ export function createEvenAiEndpoint(opts = {}) {
                 cleanupError && cleanupError.message ? cleanupError.message : null,
             }),
           );
+        } finally {
+          interceptInflight -= 1;
         }
       })();
 
@@ -789,12 +838,6 @@ export function createEvenAiEndpoint(opts = {}) {
       startedAtMs,
     };
 
-    // Track the upstream runId so the disconnect handler can cancel the
-    // pending wait without having to wait for the full request timeout.
-    // `clientDisconnected` covers the pre-ack window: if the socket closes
-    // before sendMessage() resolves, activeRunId is still null so cancelRun
-    // is unreachable; we record the flag and short-circuit waitForRun once
-    // the ack arrives.
     let activeRunId = null;
     let clientDisconnected = false;
     const onClientDisconnect = () => {
@@ -818,16 +861,11 @@ export function createEvenAiEndpoint(opts = {}) {
         try {
           runWaiter.cancelRun(activeRunId, "client_disconnect");
         } catch (_err) {
-          // Cancellation is best-effort: the upstream run still completes
-          // server-side because no gateway abort RPC exists.
+
         }
       }
     };
-    // `res` emits 'close' both when the response finishes normally and when
-    // the client disconnects mid-flight. We discriminate via
-    // res.writableEnded inside the handler. (req's own 'close' is not
-    // reliable for premature client aborts in Node 22 — the socket-level
-    // close is what fires.)
+
     res.once("close", onClientDisconnect);
 
     emitDebug(
@@ -867,14 +905,29 @@ export function createEvenAiEndpoint(opts = {}) {
             seedFastModeForRoute({ route, sessionKey, routingMode }),
           );
         } catch (err) {
-          // Seed failure must never block the send — the turn just runs
-          // without fast mode.
+
           emitDebug("evenai", "fast_mode_seed_failed", "warn", { sessionKey }, () => ({
             requestId,
             message: err && err.message ? err.message : String(err),
           }));
         }
       }
+      if (resolveAgentForRoute) {
+        try {
+          const agentId = await Promise.resolve(
+            resolveAgentForRoute({ route, sessionKey, routingMode }),
+          );
+          if (typeof agentId === "string" && agentId.trim()) {
+            sendOptions.agentId = agentId.trim();
+          }
+        } catch (err) {
+
+          emitDebug("evenai", "agent_resolve_failed", "warn", { sessionKey }, () => ({
+            requestId,
+            message: err && err.message ? err.message : String(err),
+          }));
+        }
+      }
       const ack = await promiseWithTimeout(
         gatewayBridge.sendMessage(
           userText,

package/dist/even-ai/even-ai-run-waiter.js

@@ -81,7 +81,6 @@ export function createEvenAiRunWaiter(opts = {}) {
   const clearTimeoutFn =
     typeof opts.clearTimeout === "function" ? opts.clearTimeout : clearTimeout;
 
-  /** @type {Map<string, {resolve: Function, reject: Function, sessionKey: string|null, timer: any, timeoutMs: number|null}>} */
   const pendingRuns = new Map();
 
   function cleanupPending(runId) {

package/dist/even-ai/even-ai-settings-store.js

@@ -83,6 +83,10 @@ export function normalizeEvenAiListenEnabled(value) {
   return value === true;
 }
 
+export function normalizeEvenAiDefaultAgent(value) {
+  return normalizeTrimmedString(value);
+}
+
 function normalizeTrackedThrowawayKeys(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -137,6 +141,9 @@ function isStoredSnapshotCanonical(value, snapshot) {
   if (normalizeEvenAiDefaultFastMode(value.defaultFastMode) !== snapshot.defaultFastMode) {
     return false;
   }
+  if (normalizeEvenAiDefaultAgent(value.defaultAgent) !== snapshot.defaultAgent) {
+    return false;
+  }
   if (!Array.isArray(value.trackedThrowawayKeys)) {
     return snapshot.trackedThrowawayKeys.length === 0;
   }
@@ -155,6 +162,7 @@ export function normalizeEvenAiSettingsSnapshot(value = {}) {
     defaultThinking: normalizeEvenAiDefaultThinking(value.defaultThinking),
     listenEnabled: normalizeEvenAiListenEnabled(value.listenEnabled),
     defaultFastMode: normalizeEvenAiDefaultFastMode(value.defaultFastMode),
+    defaultAgent: normalizeEvenAiDefaultAgent(value.defaultAgent),
     trackedThrowawayKeys: normalizeTrackedThrowawayKeys(value.trackedThrowawayKeys),
   };
 }
@@ -364,6 +372,9 @@ export function createEvenAiSettingsStore(opts = {}) {
         defaultFastMode: hasOwn(patch, "defaultFastMode")
           ? normalizeEvenAiDefaultFastMode(patch.defaultFastMode)
           : snapshot.defaultFastMode,
+        defaultAgent: hasOwn(patch, "defaultAgent")
+          ? normalizeEvenAiDefaultAgent(patch.defaultAgent)
+          : snapshot.defaultAgent,
         trackedThrowawayKeys: [...snapshot.trackedThrowawayKeys],
       };
       snapshot = next;

package/dist/gateway/gateway-bridge.js

@@ -61,6 +61,14 @@ function buildAgentRequestParams(
     params.thinking = thinking;
   }
 
+  const agentId =
+    requestOptions && typeof requestOptions.agentId === "string"
+      ? requestOptions.agentId.trim()
+      : "";
+  if (agentId) {
+    params.agentId = agentId;
+  }
+
   if (
     attachment &&
     typeof attachment === "object" &&
@@ -93,15 +101,6 @@ function buildAgentRequestParams(
   return params;
 }
 
-/**
- * Bridge the relay runtime to OpenClaw structured RPC method calls.
- *
- * This keeps relay-facing bridge semantics unchanged while switching
- * send/approval operations to request-based structured RPC calls.
- *
- * @param {{openclawClient: object, idempotencyKeyFactory?: () => string}} opts
- * @returns {object}
- */
 function createPluginRpcGatewayBridge(opts) {
   const openclawClient = opts && opts.openclawClient;
   const idempotencyKeyFactory =

package/dist/gateway/gateway-timing-ledger.js

@@ -75,6 +75,7 @@ function sanitizeDiagnostic(args) {
     pickBoolean(diagnostic.hasAttachment) ?? attachmentSummary.hasAttachment;
   return {
     messageId: pickId(diagnostic.messageId ?? args.messageId),
+    sessionKey: pickId(diagnostic.sessionKey ?? args.sessionKey),
     source: pickId(diagnostic.source ?? args.source),
     textChars,
     hasAttachment,
@@ -160,10 +161,6 @@ export function createGatewayTimingLedger(opts = {}) {
     clearTimer(ref);
   }
 
-  // Diagnostic timers must never keep the host process alive: a bare
-  // 120s ttlTimer kept `node tests/relay.test.js` idling ~120s after the
-  // suite finished. Injected fake timers (numeric ids) have no unref —
-  // guard for it.
   function armDiagnosticTimer(fn, delayMs) {
     const timer = setTimer(fn, delayMs);
     if (timer && typeof timer.unref === "function") {
@@ -347,7 +344,9 @@ export function createGatewayTimingLedger(opts = {}) {
         method: pickId(args.method) || "unknown",
         expectFinal: args.expectFinal === true,
         sessionKey: pickId(
-          args.sessionKey ?? (isObject(args.params) ? args.params.sessionKey : null),
+          diagnostic.sessionKey ??
+            args.sessionKey ??
+            (isObject(args.params) ? args.params.sessionKey : null),
         ),
         messageId: diagnostic.messageId,
         source: diagnostic.source,
@@ -419,7 +418,10 @@ export function createGatewayTimingLedger(opts = {}) {
         data,
       );
 
-      if (ok && method === "agent" && status === "accepted" && runId) {
+      const acceptedAgentRun =
+        (method === "agent" && status === "accepted") ||
+        (method === "sessions.steer" && (status === "started" || status === "accepted"));
+      if (ok && acceptedAgentRun && runId) {
         const run = {
           runId,
           requestId,