ocuclaw 0.1.0 → 1.3.0

package/dist/runtime/session-context-service.js

@@ -0,0 +1,189 @@
+// session-context-service.ts
+//
+// Owns the active-session "context tokens vs context window" snapshot
+// lifecycle. Reads via gateway sessions.describe; reads compaction
+// checkpoint count via sessions.compaction.list; broadcasts on changes.
+//
+// Field mapping (gateway → snapshot):
+//   session.totalTokens   → contextTokens (current cumulative usage)
+//   session.contextTokens → contextWindow (model's configured window)
+// openclaw uses `contextTokens` on the row for window size; `totalTokens`
+// is the running usage. NOTE: the window is NOT resolved on a fresh session —
+// the gateway warms a model's window only after the first turn (sessions.describe
+// returns no window pre-turn). So we cache the observed window per model and
+// reuse it for subsequent cold/new-session reads. The cache is persisted under
+// `stateDir` (keyed by provider/model) so it survives relay restarts.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const MODEL_CONTEXT_WINDOW_CACHE_FILE = "ocuclaw-model-context-windows.json";
+
+function normalizeStateDir(stateDir) {
+  if (typeof stateDir !== "string") return null;
+  const trimmed = stateDir.trim();
+  return trimmed ? trimmed : null;
+}
+
+function resolveModelContextWindowCachePath(stateDir) {
+  const resolved = normalizeStateDir(stateDir);
+  return resolved ? path.join(resolved, MODEL_CONTEXT_WINDOW_CACHE_FILE) : null;
+}
+
+function loadModelContextWindowCache(cachePath) {
+  const cache = new Map();
+  if (!cachePath) return cache;
+  try {
+    if (!fs.existsSync(cachePath)) return cache;
+    const parsed = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+    for (const [key, value] of Object.entries(parsed ?? {})) {
+      if (typeof key === "string" && Number.isFinite(value) && value > 0) {
+        cache.set(key, Math.floor(value));
+      }
+    }
+  } catch {
+    // Missing/corrupt cache file — relearn from the next turn.
+  }
+  return cache;
+}
+
+function persistModelContextWindowCache(cachePath, cache) {
+  if (!cachePath) return;
+  try {
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    const obj = {};
+    for (const [key, value] of cache.entries()) obj[key] = value;
+    fs.writeFileSync(cachePath, JSON.stringify(obj), "utf8");
+  } catch {
+    // Best-effort persistence; the in-memory cache still works this process.
+  }
+}
+
+/**
+ * @typedef SessionContextSnapshot
+ * @property {string} type
+ * @property {string} sessionKey
+ * @property {number} contextTokens
+ * @property {number} contextWindow
+ * @property {number} compactionCount
+ * @property {boolean} runActive
+ * @property {number} snapshotAtMs
+ */
+
+/**
+ * @param {object} opts
+ * @param {{request: (method: string, params: object) => Promise<any>}} opts.gatewayBridge
+ * @param {() => string|null} opts.getActiveSessionKey
+ * @param {() => boolean} opts.getRunActive
+ * @param {() => number} opts.nowMs
+ * @param {(frame: SessionContextSnapshot) => void} opts.broadcast
+ */
+export function createSessionContextService(opts) {
+  const gatewayBridge = opts.gatewayBridge;
+  const getActiveSessionKey = opts.getActiveSessionKey;
+  const getRunActive = opts.getRunActive;
+  const nowMs = opts.nowMs;
+  const broadcast = opts.broadcast;
+  const getActiveModelKey =
+    typeof opts.getActiveModelKey === "function" ? opts.getActiveModelKey : () => null;
+
+  /** @type {SessionContextSnapshot|null} */
+  let lastSnapshot = null;
+
+  // Per-model context-window cache: the gateway only resolves a model's window
+  // after the first turn warms its discovery, so once we observe a real window
+  // we remember it per model and reuse it for later cold/new-session reads.
+  // Persisted under stateDir so it survives relay restarts.
+  const modelContextWindowCachePath = resolveModelContextWindowCachePath(opts.stateDir);
+  /** @type {Map<string, number>} */
+  const modelContextWindowCache = loadModelContextWindowCache(modelContextWindowCachePath);
+
+  async function refreshActiveSessionContext() {
+    const sessionKey = getActiveSessionKey();
+    if (!sessionKey) return null;
+    let describeResp;
+    let compactionResp;
+    try {
+      [describeResp, compactionResp] = await Promise.all([
+        gatewayBridge.request("sessions.describe", { key: sessionKey }),
+        gatewayBridge
+          .request("sessions.compaction.list", { key: sessionKey })
+          .catch(() => null),
+      ]);
+    } catch {
+      return lastSnapshot;
+    }
+    const session =
+      describeResp && typeof describeResp === "object" && describeResp.session && typeof describeResp.session === "object"
+        ? describeResp.session
+        : null;
+    if (!session) return lastSnapshot;
+
+    const contextTokens = Number.isFinite(session.totalTokens)
+      ? Math.floor(session.totalTokens)
+      : 0;
+    const describeWindow = Number.isFinite(session.contextTokens)
+      ? Math.floor(session.contextTokens)
+      : 0;
+    const modelKey = getActiveModelKey();
+    let contextWindow = describeWindow;
+    if (describeWindow > 0) {
+      // Learned naturally (post-turn): remember (and persist) for future cold reads.
+      if (modelKey && modelContextWindowCache.get(modelKey) !== describeWindow) {
+        modelContextWindowCache.set(modelKey, describeWindow);
+        persistModelContextWindowCache(modelContextWindowCachePath, modelContextWindowCache);
+      }
+    } else if (modelKey && modelContextWindowCache.has(modelKey)) {
+      // Cold on a new session: reuse the window learned earlier for this model.
+      contextWindow = modelContextWindowCache.get(modelKey);
+    }
+    const checkpoints =
+      compactionResp && Array.isArray(compactionResp.checkpoints)
+        ? compactionResp.checkpoints
+        : [];
+    const compactionCount = checkpoints.length;
+
+    const snapshot = {
+      type: "ocuclaw.session.context.snapshot",
+      sessionKey,
+      contextTokens,
+      contextWindow,
+      compactionCount,
+      runActive: !!getRunActive(),
+      snapshotAtMs: nowMs(),
+    };
+    lastSnapshot = snapshot;
+    broadcast(snapshot);
+    return snapshot;
+  }
+
+  function broadcastRunActive(runActive) {
+    if (!lastSnapshot) return;
+    const snapshot = { ...lastSnapshot, runActive: !!runActive, snapshotAtMs: nowMs() };
+    lastSnapshot = snapshot;
+    broadcast(snapshot);
+  }
+
+  async function compactActiveSession(sessionKey) {
+    try {
+      await gatewayBridge.request("sessions.compact", { key: sessionKey });
+      return { status: "accepted" };
+    } catch (err) {
+      return {
+        status: "rejected",
+        error: err && err.message ? String(err.message) : "sessions.compact failed",
+      };
+    }
+  }
+
+  function lastSnapshotForResume() {
+    return lastSnapshot;
+  }
+
+  return {
+    refreshActiveSessionContext,
+    broadcastRunActive,
+    compactActiveSession,
+    lastSnapshotForResume,
+  };
+}