ocuclaw 1.3.2 → 1.3.4

package/dist/runtime/glasses-backpressure-latch.js

@@ -0,0 +1,93 @@
+const DEFAULT_RECOVERED_HOLD_MS = 3_000;
+const DEFAULT_STALE_MS = 5_000;
+
+export function createGlassesBackpressureLatch(options = {}) {
+  const now = typeof options.now === "function" ? options.now : Date.now;
+  const recoveredHoldMs = Number.isFinite(options.recoveredHoldMs)
+    ? options.recoveredHoldMs
+    : DEFAULT_RECOVERED_HOLD_MS;
+  const staleMs = Number.isFinite(options.staleMs) ? options.staleMs : DEFAULT_STALE_MS;
+  const emitDebug = typeof options.emitDebug === "function" ? options.emitDebug : () => {};
+
+  let latched = false;
+  let latchedAtMs = null;
+  let lastOverAtMs = null;
+  let lastReportAtMs = null;
+  let workerEpoch = null;
+
+  function clearState() {
+    latched = false;
+    latchedAtMs = null;
+    lastOverAtMs = null;
+    lastReportAtMs = null;
+  }
+
+  function emitTransition(nextLatched, reason, atMs) {
+    if (nextLatched === latched) return;
+    if (nextLatched) {
+      latchedAtMs = atMs;
+      emitDebug("glasses_backpressure_latched", "warn", { reason });
+    } else {
+      emitDebug("glasses_backpressure_cleared", "info", {
+        reason,
+        latchedForMs: latchedAtMs === null ? null : Math.max(0, atMs - latchedAtMs),
+      });
+      latchedAtMs = null;
+    }
+    latched = nextLatched;
+  }
+
+  function evaluate(atMs) {
+    if (!latched) return;
+    if (lastReportAtMs !== null && atMs - lastReportAtMs > staleMs) {
+      emitTransition(false, "stale_reports", atMs);
+      return;
+    }
+    if (
+      lastOverAtMs !== null &&
+      atMs - lastOverAtMs >= recoveredHoldMs &&
+      lastReportAtMs !== null &&
+      lastReportAtMs > lastOverAtMs
+    ) {
+
+      emitTransition(false, "recovered", atMs);
+    }
+  }
+
+  function report(params) {
+    const atMs = now();
+    const count =
+      params && Number.isFinite(params.sendBufferHighWaterClients)
+        ? params.sendBufferHighWaterClients
+        : null;
+    if (count === null) return;
+    const epoch = params && Number.isFinite(params.workerEpoch) ? params.workerEpoch : null;
+    if (epoch !== null && workerEpoch !== null && epoch !== workerEpoch) {
+
+      clearState();
+    }
+    if (epoch !== null) workerEpoch = epoch;
+    lastReportAtMs = atMs;
+    if (count >= 1) {
+      lastOverAtMs = atMs;
+      emitTransition(true, "over_high_water", atMs);
+      return;
+    }
+    evaluate(atMs);
+  }
+
+  function isOverHighWater() {
+    evaluate(now());
+    return latched;
+  }
+
+  function reset(reason) {
+    const atMs = now();
+    emitTransition(false, typeof reason === "string" ? reason : "reset", atMs);
+    clearState();
+  }
+
+  return { report, isOverHighWater, reset };
+}
+
+export default { createGlassesBackpressureLatch };

package/dist/runtime/ocuclaw-settings-store.js

@@ -53,6 +53,10 @@ export function normalizeOcuClawDefaultFastMode(value) {
   return value === true;
 }
 
+export function normalizeOcuClawDefaultAgent(value) {
+  return normalizeTrimmedString(value);
+}
+
 function isStoredSnapshotCanonical(value, snapshot) {
   if (!value || typeof value !== "object") {
     return false;
@@ -61,7 +65,8 @@ function isStoredSnapshotCanonical(value, snapshot) {
     normalizeTrimmedString(value.systemPrompt) === snapshot.systemPrompt &&
     normalizeTrimmedString(value.defaultModel) === snapshot.defaultModel &&
     normalizeOcuClawDefaultThinking(value.defaultThinking) === snapshot.defaultThinking &&
-    normalizeOcuClawDefaultFastMode(value.defaultFastMode) === snapshot.defaultFastMode
+    normalizeOcuClawDefaultFastMode(value.defaultFastMode) === snapshot.defaultFastMode &&
+    normalizeOcuClawDefaultAgent(value.defaultAgent) === snapshot.defaultAgent
   );
 }
 
@@ -71,6 +76,7 @@ export function normalizeOcuClawSettingsSnapshot(value = {}) {
     defaultModel: normalizeOcuClawDefaultModel(value.defaultModel),
     defaultThinking: normalizeOcuClawDefaultThinking(value.defaultThinking),
     defaultFastMode: normalizeOcuClawDefaultFastMode(value.defaultFastMode),
+    defaultAgent: normalizeOcuClawDefaultAgent(value.defaultAgent),
   };
 }
 
@@ -266,6 +272,9 @@ export function createOcuClawSettingsStore(opts = {}) {
         defaultFastMode: hasOwn(patch, "defaultFastMode")
           ? normalizeOcuClawDefaultFastMode(patch.defaultFastMode)
           : snapshot.defaultFastMode,
+        defaultAgent: hasOwn(patch, "defaultAgent")
+          ? normalizeOcuClawDefaultAgent(patch.defaultAgent)
+          : snapshot.defaultAgent,
       };
       snapshot = next;
       persistSnapshot(snapshot, "set_settings");

package/dist/runtime/openclaw-host-version.js

@@ -0,0 +1,5 @@
+export function readOpenClawHostVersion(env = process.env) {
+  const raw = env ? env.OPENCLAW_SERVICE_VERSION || env.OPENCLAW_VERSION : undefined;
+  const trimmed = typeof raw === "string" ? raw.trim() : "";
+  return trimmed.length > 0 ? trimmed : null;
+}

package/dist/runtime/plugin-version-service.js

@@ -1,9 +1,6 @@
-import { PLUGIN_VERSION, REQUIRES_CLIENT_VERSION } from "../version.js";
+import { PLUGIN_VERSION, REQUIRES_CLIENT_VERSION, BUILD_INPUT_HASH } from "../version.js";
+import { readOpenClawHostVersion } from "./openclaw-host-version.js";
 
-/**
- * Plugin version provider. Exposes the build-time version constants used by the
- * relay handshake. No process execution.
- */
 function createPluginVersionService() {
   function getPluginVersion() {
     return typeof PLUGIN_VERSION === "string" && PLUGIN_VERSION.length > 0
@@ -17,7 +14,17 @@ function createPluginVersionService() {
       : null;
   }
 
-  return { getPluginVersion, getRequiresClientVersion };
+  function getOpenClawHostVersion() {
+    return readOpenClawHostVersion();
+  }
+
+  function getDistHash() {
+    return typeof BUILD_INPUT_HASH === "string" && BUILD_INPUT_HASH.length > 0
+      ? BUILD_INPUT_HASH
+      : null;
+  }
+
+  return { getPluginVersion, getRequiresClientVersion, getOpenClawHostVersion, getDistHash };
 }
 
 export { createPluginVersionService };

package/dist/runtime/provider-usage-select.js

@@ -85,12 +85,6 @@ export function selectProviderUsageSnapshot(summary, opts = {}) {
     (entry) => entry.provider.trim().toLowerCase() === activeProvider,
   );
 
-  // Family fallback: the session model config reports the base provider id
-  // (e.g. "openai") while the usage summary keys the same usage by its
-  // sub-provider source (e.g. "openai-codex"). When there is no exact match
-  // but exactly ONE summary entry belongs to the active provider's family
-  // ("${activeProvider}-…"), resolve it. Restricted to a single family member
-  // to avoid ambiguous attribution when multiple sub-providers exist.
   if (!match) {
     const familyMatches = namedEntries.filter((entry) =>
       entry.provider.trim().toLowerCase().startsWith(`${activeProvider}-`),

package/dist/runtime/register-session-title-distiller.js

@@ -10,10 +10,7 @@ function genRunId() {
 
 export function registerSessionTitleDistiller(api, service) {
   if (!api || typeof api.on !== "function") return () => {};
-  // The budget lives in sessionService (so a logical reset clears it with the
-  // title record + toggle state). Resolve it lazily per call: at registration
-  // the live relay may not exist yet, and a sibling context resolves the shared
-  // relay's budget.
+
   const budget = {
     canRun: (k) => {
       const b = service.getDistillerBudget();
@@ -29,8 +26,7 @@ export function registerSessionTitleDistiller(api, service) {
     },
   };
   const distiller = createSessionTitleDistiller({
-    // Lazy getter: the real state dir only arrives at service.start(), after
-    // this distiller is constructed during registration.
+
     getStateDir: () => (service.getStateDir ? service.getStateDir() : undefined),
     nowMs: () => Date.now(),
     genId: genRunId,
@@ -49,6 +45,12 @@ export function registerSessionTitleDistiller(api, service) {
       typeof service.deleteDistillerSession === "function"
         ? service.deleteDistillerSession(k)
         : Promise.resolve(null),
+
+    llmComplete: (() => {
+      const llm = api && api.runtime && api.runtime.llm;
+      if (!llm || typeof llm.complete !== "function") return undefined;
+      return (params) => llm.complete(params);
+    })(),
     subagentRuntime: (() => {
       const sa = api && api.runtime && api.runtime.subagent;
       if (
@@ -76,24 +78,20 @@ export function registerSessionTitleDistiller(api, service) {
   });
 
   return api.on("agent_end", (event, ctx) => {
-    // 2026.6.x delivers the canonical `agent:<id>:<key>` form; relay state is
-    // keyed by the bare relay key — normalize at the boundary.
+
     const rawSessionKey = ctx && typeof ctx.sessionKey === "string" ? ctx.sessionKey : null;
     const sessionKey = stripAgentSessionPrefix(rawSessionKey);
     if (!sessionKey) return;
-    // Capture the completed run's messages NOW, before the fire-and-forget run
-    // defers: agent_end carries the run's final messages (the authoritative
-    // source for THIS session). Fall back to a synchronous snapshot of the live
-    // conversation state. Either way the messages are pinned here so a later
-    // session switch / clear can't make the distiller title from another
-    // session's transcript.
+
+    const agentId = ctx && typeof ctx.agentId === "string" && ctx.agentId.trim() ? ctx.agentId.trim() : undefined;
+
     const eventMessages = event && Array.isArray(event.messages) ? event.messages : null;
     const messages =
       eventMessages && eventMessages.length
         ? eventMessages
         : service.getRawMessages();
-    // Fire-and-forget; never block run teardown.
-    Promise.resolve(distiller.maybeRun(sessionKey, { messages })).catch(() => {});
+
+    Promise.resolve(distiller.maybeRun(sessionKey, { messages, agentId })).catch(() => {});
   });
 }