@vikrant82/opencode-cache-keepalive 0.1.4 → 0.1.5

package/dist/index.js

@@ -147,7 +147,8 @@ var JITTER_MS = 15e3;
 var CONTROL_POLL_MS = 1e3;
 var STATUS_POLL_MS = 2e3;
 var PING_STATUS_GRACE_MS = 5e3;
-var BUSY_TIMEOUT_MS = 3e5;
+var COLD_AFTER_INTERVALS = 2;
+var MESSAGE_LOOKUP_LIMIT = 50;
 var KeepaliveEngine = class {
   constructor(client, config, store, logger, directory) {
     this.client = client;
@@ -190,9 +191,14 @@ var KeepaliveEngine = class {
     if (this.statusTimer) clearInterval(this.statusTimer);
     this.statusTimer = void 0;
   }
-  /** True while a ping is in flight — used to block tool calls during a ping. */
-  isWarming(sessionID) {
-    return !!this.store.get(sessionID)?.warming;
+  /**
+   * True while a ping turn owns the session, so tool calls must be blocked. Becomes
+   * false as soon as a real user message joins the in-flight ping run: the rest of
+   * that run is real work and needs its tools.
+   */
+  shouldBlockTools(sessionID) {
+    const s = this.store.get(sessionID);
+    return !!s?.warming && !s.ping?.interrupted;
   }
   async onEvent(event) {
     const type = event?.type;
@@ -205,19 +211,31 @@ var KeepaliveEngine = class {
       }
       return;
     }
+    if (type === "message.part.updated") {
+      const part = event.properties?.part;
+      const sessionID = part?.sessionID ?? event.properties?.sessionID;
+      if (!sessionID) return;
+      const session = this.store.get(sessionID);
+      if (session?.warming) this.notePingRunPart(session, part);
+      return;
+    }
     if (type === "message.updated") {
       const info = event.properties?.info;
       const sessionID = info?.sessionID ?? event.properties?.sessionID;
       if (!sessionID) return;
       const session = this.store.get(sessionID);
-      if (session?.warming) return;
+      if (session?.warming) {
+        if (info?.role === "user") this.notePingRunUser(session, info);
+        return;
+      }
       const eventAt = info?.time?.completed ?? info?.time?.created;
       if (session?.lastPingAt && typeof eventAt === "number" && eventAt <= session.lastPingAt)
         return;
       if (info?.role === "user") {
         const s = this.store.ensure(sessionID);
+        if (!isNewUserMessage(s, info)) return;
+        noteUserMessage(s, info);
         s.busy = true;
-        s.busySince = Date.now();
         s.active = false;
         this.store.persist();
         return;
@@ -242,7 +260,6 @@ var KeepaliveEngine = class {
       }
       const s = this.store.ensure(sessionID);
       s.busy = true;
-      s.busySince = Date.now();
       s.active = false;
       this.store.persist();
       return;
@@ -254,6 +271,55 @@ var KeepaliveEngine = class {
       await this.armWindow(sessionID);
     }
   }
+  /**
+   * Track a new user message observed while a ping is in flight. Event order alone
+   * cannot tell the ping's own message from a real prompt racing it, so messages are
+   * held until their text part arrives (see `notePingRunPart`). Any message seen
+   * before the ping is sent, or a second new message, is necessarily a real turn.
+   */
+  notePingRunUser(s, info) {
+    const ping = s.ping;
+    if (!ping || typeof info?.id !== "string") return;
+    const created = info?.time?.created;
+    if (typeof created === "number" && created < ping.startedAt) return;
+    if (info.id === ping.messageID || ping.pending.has(info.id)) return;
+    if (!ping.sent || ping.messageID) {
+      this.interruptPing(s, info);
+      return;
+    }
+    ping.pending.set(info.id, info);
+    if (ping.pending.size > 1) this.interruptPing(s);
+  }
+  /**
+   * Classify a pending user message by its first text part: the ping token marks
+   * the ping's own message; any other text is a real turn joining the ping run.
+   * opencode publishes a user message's parts right after the message itself, before
+   * the run reaches any tool call.
+   */
+  notePingRunPart(s, part) {
+    const ping = s.ping;
+    if (!ping || part?.type !== "text" || part?.synthetic) return;
+    const id = part?.messageID;
+    if (typeof id !== "string" || !ping.pending.has(id)) return;
+    const info = ping.pending.get(id);
+    ping.pending.delete(id);
+    if (!ping.messageID && String(part.text ?? "").trim() === this.config.pingToken) {
+      ping.messageID = id;
+      return;
+    }
+    this.interruptPing(s, info);
+  }
+  /** A real turn joined the in-flight ping: unblock tools and treat the session as busy. */
+  interruptPing(s, info) {
+    const ping = s.ping;
+    if (!ping) return;
+    if (!ping.interrupted) this.logger.dbg(`real turn joined ping ${short(s.sessionID)}`);
+    ping.interrupted = true;
+    if (info) noteUserMessage(s, info);
+    s.busy = true;
+    s.active = false;
+    this.store.persist();
+  }
   async armWindow(sessionID) {
     const s = this.store.ensure(sessionID);
     if (s.active && !s.busy) return;
@@ -261,7 +327,6 @@ var KeepaliveEngine = class {
     s.arming = true;
     try {
       s.busy = false;
-      s.busySince = void 0;
       await this.resolveSession(s);
       if (s.busy || !this.enabled || !s.eligible) {
         s.active = false;
@@ -269,30 +334,37 @@ var KeepaliveEngine = class {
         return;
       }
       const now = Date.now();
-      if (!s.lastResponseAt) s.lastResponseAt = now;
-      s.idleSince = now;
-      s.windowEndsAt = now + this.config.windowMs;
-      s.nextPingAt = now + this.config.intervalMs;
-      s.pingsSent = 0;
-      s.lastPing = void 0;
-      s.active = true;
+      if (!s.lastResponseAt || !this.cacheMayBeWarm(s, now)) {
+        s.active = false;
+        this.store.persist();
+        this.logger.dbg(`not armed ${short(sessionID)} \u2014 no recent real response`);
+        return;
+      }
+      this.openWindow(s, now);
       this.store.persist();
       this.logger.dbg(`armed ${short(sessionID)} model=${s.modelLabel}`);
     } finally {
       s.arming = false;
     }
   }
+  /** Start a warm window anchored on the last real response and the last cache touch. */
+  openWindow(s, now) {
+    s.idleSince = now;
+    s.windowEndsAt = s.lastResponseAt + this.config.windowMs;
+    s.nextPingAt = Math.max(now, lastCacheTouch(s) + this.config.intervalMs);
+    s.pingsSent = 0;
+    s.lastPing = void 0;
+    s.active = true;
+  }
+  /** False once the cache has gone too long without a request to still be trusted warm. */
+  cacheMayBeWarm(s, now) {
+    const touch = lastCacheTouch(s);
+    return touch > 0 && now - touch <= COLD_AFTER_INTERVALS * this.config.intervalMs;
+  }
   async tick() {
     if (!this.enabled) return;
     const now = Date.now();
     for (const s of this.store.all()) {
-      if (s.busy && s.busySince && now - s.busySince > BUSY_TIMEOUT_MS) {
-        this.logger.dbg(`busy timeout ${short(s.sessionID)} \u2014 clearing stuck flag`);
-        s.busy = false;
-        s.busySince = void 0;
-        void this.armWindow(s.sessionID);
-        continue;
-      }
       if (!s.eligible || !s.active || s.busy || s.warming) continue;
       if (now >= s.windowEndsAt) {
         s.active = false;
@@ -302,22 +374,65 @@ var KeepaliveEngine = class {
         );
         continue;
       }
-      if (now >= s.nextPingAt) void this.firePing(s.sessionID);
+      if (now < s.nextPingAt) continue;
+      if (!this.cacheMayBeWarm(s, now)) {
+        s.active = false;
+        this.store.persist();
+        this.logger.dbg(
+          `window closed ${short(s.sessionID)} \u2014 ping overdue, cache presumed cold`
+        );
+        continue;
+      }
+      void this.firePing(s.sessionID);
     }
   }
   async firePing(sessionID) {
     const s = this.store.get(sessionID);
-    if (!s || s.warming || s.busy) return;
+    if (!s || s.warming || s.busy || !s.active) return;
+    const ping = {
+      startedAt: Date.now(),
+      sent: false,
+      pending: /* @__PURE__ */ new Map(),
+      interrupted: false
+    };
     s.warming = true;
-    s.pingsSent += 1;
+    s.ping = ping;
     this.store.persist();
-    const startAt = Date.now();
     try {
+      if (!await this.isIdleOnServer(sessionID)) {
+        s.busy = true;
+        s.active = false;
+        this.logger.dbg(`ping ${short(sessionID)} skipped \u2014 session busy`);
+        return;
+      }
+      const request = s.request ?? await this.lookupRequest(s);
+      if (!request) {
+        s.active = false;
+        this.logger.dbg(`ping ${short(sessionID)} skipped \u2014 last real request unknown`);
+        return;
+      }
+      if (ping.interrupted || s.busy || !s.active || !this.enabled) return;
+      ping.sent = true;
+      s.pingsSent += 1;
+      this.store.persist();
       const res = await this.client.session.prompt({
         path: { id: sessionID },
-        body: { parts: [{ type: "text", text: this.config.pingToken }] }
+        body: {
+          parts: [{ type: "text", text: this.config.pingToken }],
+          ...request.agent ? { agent: request.agent } : {},
+          model: { providerID: request.providerID, modelID: request.modelID },
+          ...request.variant ? { variant: request.variant } : {}
+        }
       });
       const info = res?.data?.info ?? res?.info;
+      if (ping.interrupted) {
+        const completed = info?.time?.completed;
+        if (typeof completed === "number") s.lastResponseAt = completed;
+        this.logger.dbg(
+          `ping ${short(sessionID)} absorbed a real turn \u2014 kept, not reverted`
+        );
+        return;
+      }
       const cache = info?.tokens?.cache ?? {};
       const record = {
         at: Date.now(),
@@ -331,40 +446,94 @@ var KeepaliveEngine = class {
       this.logger.dbg(
         `ping ${short(sessionID)} ${record.hit ? "HIT" : "MISS"} in=${record.input} read=${record.cacheRead} write=${record.cacheWrite} out=${record.output}`
       );
-      if (this.config.revertPing) await this.revertPing(sessionID, startAt);
+      if (this.config.revertPing) await this.revertPing(sessionID, ping);
     } catch (err) {
       this.logger.warn(`ping ${short(sessionID)} failed`, errText(err));
     } finally {
       s.warming = false;
-      s.lastPingAt = Date.now();
-      s.nextPingAt = Math.max(
-        Date.now() + 1e3,
-        s.nextPingAt + jitter(this.config.intervalMs)
-      );
+      s.ping = void 0;
+      const now = Date.now();
+      if (ping.sent) {
+        s.lastPingAt = now;
+        const next = s.nextPingAt + jitter(this.config.intervalMs);
+        s.nextPingAt = next > now ? next : now + jitter(this.config.intervalMs);
+      }
       this.store.persist();
+      if (ping.sent && ping.interrupted) {
+        s.busy = false;
+        s.active = false;
+        void this.armWindow(sessionID);
+      }
     }
   }
-  /** Remove the `~` user + `~` assistant turn so it never enters real context. */
-  async revertPing(sessionID, startAt) {
-    let messages;
+  /** True only when the server positively reports the session idle. */
+  async isIdleOnServer(sessionID) {
     try {
-      const res = await this.client.session.messages({ path: { id: sessionID } });
-      messages = res?.data ?? res ?? [];
+      const res = await this.client.session.status();
+      const statuses = res?.data ?? res ?? {};
+      return (statuses?.[sessionID]?.type ?? "idle") === "idle";
     } catch (err) {
-      this.logger.warn(`ping ${short(sessionID)} revert: list failed`, errText(err));
-      return;
+      this.logger.dbg(`status check ${short(sessionID)} failed`, errText(err));
+      return false;
+    }
+  }
+  /** Recover the last real turn's request settings when no user event was observed. */
+  async lookupRequest(s) {
+    const messages = await this.recentMessages(s.sessionID);
+    if (!messages) return void 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (m?.info?.role !== "user" || this.isPingMessage(m)) continue;
+      const request = requestFrom(m.info);
+      if (request) {
+        s.request = request;
+        return request;
+      }
     }
-    let target;
-    for (const m of messages) {
+    return void 0;
+  }
+  async recentMessages(sessionID) {
+    try {
+      const res = await this.client.session.messages({
+        path: { id: sessionID },
+        query: { limit: MESSAGE_LOOKUP_LIMIT }
+      });
+      const messages = res?.data ?? res;
+      return Array.isArray(messages) ? messages : void 0;
+    } catch (err) {
+      this.logger.warn(`messages ${short(sessionID)} list failed`, errText(err));
+      return void 0;
+    }
+  }
+  isPingMessage(m) {
+    const text = (m?.parts ?? []).filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("").trim();
+    return text === this.config.pingToken;
+  }
+  /**
+   * Remove the `~` user + `~` assistant turn so it never enters real context.
+   * Revert drops the target and everything after it (and rolls back file
+   * snapshots), so it is skipped unless only the ping's own replies follow.
+   */
+  async revertPing(sessionID, ping) {
+    const messages = await this.recentMessages(sessionID);
+    if (!messages) return;
+    let index = -1;
+    for (let i = 0; i < messages.length; i++) {
+      const m = messages[i];
       if (m?.info?.role !== "user") continue;
-      if (Number(m.info?.time?.created ?? 0) < startAt - 2e3) continue;
-      const text = (m.parts ?? []).filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("").trim();
-      if (text === this.config.pingToken) target = m.info.id;
+      if (ping.messageID ? m.info.id === ping.messageID : this.isRecentPing(m, ping))
+        index = i;
     }
-    if (!target) {
+    if (index < 0) {
       this.logger.dbg(`ping ${short(sessionID)} revert: ping message not found`);
       return;
     }
+    const target = messages[index].info.id;
+    const foreign = messages.slice(index + 1).some((m) => m?.info?.role !== "assistant" || m?.info?.parentID !== target);
+    if (foreign) {
+      this.logger.warn(`ping ${short(sessionID)} not reverted \u2014 other messages followed it`);
+      return;
+    }
     try {
       await this.client.session.revert({
         path: { id: sessionID },
@@ -374,6 +543,9 @@ var KeepaliveEngine = class {
       this.logger.warn(`ping ${short(sessionID)} revert failed`, errText(err));
     }
   }
+  isRecentPing(m, ping) {
+    return Number(m?.info?.time?.created ?? 0) >= ping.startedAt - 2e3 && this.isPingMessage(m);
+  }
   async resolveSession(s) {
     try {
       const res = await this.client.session.get({ path: { id: s.sessionID } });
@@ -404,13 +576,8 @@ var KeepaliveEngine = class {
         continue;
       }
       if (!session.eligible || session.busy || session.warming) continue;
-      if (!session.lastResponseAt) continue;
-      session.idleSince = now;
-      session.windowEndsAt = now + this.config.windowMs;
-      session.nextPingAt = now + this.config.intervalMs;
-      session.pingsSent = 0;
-      session.lastPing = void 0;
-      session.active = true;
+      if (!session.lastResponseAt || !this.cacheMayBeWarm(session, now)) continue;
+      this.openWindow(session, now);
     }
     this.store.persist();
     this.logger.info(`runtime ${control.enabled ? "enabled" : "disabled"}`);
@@ -435,6 +602,34 @@ var KeepaliveEngine = class {
     }
   }
 };
+function lastCacheTouch(s) {
+  return Math.max(s.lastResponseAt, s.lastPingAt ?? 0);
+}
+function isNewUserMessage(s, info) {
+  if (typeof info?.id === "string" && info.id === s.lastUserID) return false;
+  const created = info?.time?.created;
+  return typeof created !== "number" || created >= (s.lastUserAt ?? 0);
+}
+function noteUserMessage(s, info) {
+  if (typeof info?.id === "string") s.lastUserID = info.id;
+  const created = info?.time?.created;
+  if (typeof created === "number") s.lastUserAt = created;
+  const request = requestFrom(info);
+  if (request) s.request = request;
+}
+function requestFrom(info) {
+  const model = info?.model;
+  const providerID = model?.providerID;
+  const modelID = model?.modelID ?? model?.id;
+  if (typeof providerID !== "string" || typeof modelID !== "string") return void 0;
+  const variant = model?.variant ?? info?.variant;
+  return {
+    agent: typeof info?.agent === "string" ? info.agent : void 0,
+    providerID,
+    modelID,
+    variant: typeof variant === "string" && variant !== "default" ? variant : void 0
+  };
+}
 function short(sessionID) {
   return sessionID.slice(-6);
 }
@@ -529,7 +724,10 @@ var KeepaliveStore = class {
   all() {
     return [...this.sessions.values()];
   }
-  /** Atomically persist a lean snapshot for the TUI. Never throws to callers. */
+  /**
+   * Atomically persist a lean snapshot for the TUI. Never throws or rejects; the
+   * returned promise resolves once this snapshot and every earlier one are written.
+   */
   persist() {
     const snapshot = {
       version: 1,
@@ -559,6 +757,7 @@ var KeepaliveStore = class {
     };
     const write = () => atomicWrite(stateFilePath(this.directory), JSON.stringify(snapshot));
     this.writeQueue = this.writeQueue.then(write, write);
+    return this.writeQueue;
   }
 };
 async function atomicWrite(path, contents) {
@@ -596,7 +795,7 @@ var server = async (ctx, options) => {
   const store = new KeepaliveStore(config, ctx.directory);
   const engine = new KeepaliveEngine(ctx.client, config, store, logger, ctx.directory);
   engine.start();
-  const version = true ? "0.1.4" : "dev";
+  const version = true ? "0.1.5" : "dev";
   logger.info(`v${version} ready`);
   const instruction = keepaliveInstruction(config.pingToken);
   return {
@@ -614,7 +813,7 @@ var server = async (ctx, options) => {
     // Backstop: if the model ignores the instruction and tries a tool during a
     // ping, block it — the ping turn is going to be reverted anyway.
     "tool.execute.before": async (input) => {
-      if (engine.isWarming(input.sessionID)) {
+      if (engine.shouldBlockTools(input.sessionID)) {
         throw new Error("cache-keepalive: tools are disabled during a keepalive ping");
       }
     },