@magpie-community/opencode-cursor-auth 0.2.35 → 0.2.37

package/README.md

@@ -101,9 +101,12 @@ Tool results can continue a retained Run in the same plugin process. The owner
 uses the same session/cache key and first user message as `conversation_id`, so
 Task subagents sharing their parent's session can run independently. Retention
 waits at most 120 seconds for a result batch and 15 minutes for a Run's total
-lifetime. A continuation arriving in the last minute of that lifetime rebuilds
-from supplied history before submitting results to the old Run. The absolute
-deadline still applies to an active segment; it is never extended by activity.
+lifetime. A continuation arriving with less than 10 minutes of that lifetime
+left rebuilds from supplied history on a fresh Run before submitting results
+to the old one, since one step can be a long answer. The absolute deadline
+still applies to an active segment; it is never extended by activity. A Run
+cut by it mid-answer ends with `native Run lifetime expired: the Run timed
+out; retry your request`, words agents ask again on.
 The pool holds at most 8 owners per account and 32 per process, with
 bounded history, blobs, arguments, and pending writes. When pending writes
 reach their bound (a long history asks for its blobs at once, and a slow link

package/index.mjs

@@ -2853,7 +2853,7 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
 
 // decode follows the server's messages into the answer's pieces until the
 // turn ends, or the model has made its tool calls.
-async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage, owedUsage, note }) {
+async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage, owedUsage, note, countWait = NATIVE_LIMITS.countWait }) {
   let calls = 0
   // answered: the step's calls answered here (a refusal, the MCP tool
   // list), which Cursor's count of the step's calls takes in too (#142)
@@ -2937,8 +2937,48 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
     return finish(owedUsage ? await owedUsage(calls === 0).catch(() => null) : null)
   }
   const closeExec = (id) => send(pb().bytes(5, pb().bytes(1, pb().varint(1, id))).done())
+  // A step whose calls came and whose count never does: Cursor sent the
+  // calls and then only heartbeats (plugins#550, the fifth trace: two
+  // calls, no count, 240 s of heartbeats until quiet). Once countWait has
+  // passed since Cursor's last frame that wasn't a heartbeat, with no call
+  // still being written, the calls that came are the step's. Heartbeats
+  // never move the deadline: they are all such a Run sends.
+  const it = (stream[Symbol.asyncIterator] ?? stream[Symbol.iterator]).call(stream)
+  let heardAt = Date.now()
+  const read = async () => {
+    const next = Promise.resolve(it.next())
+    if (!calls || listed || step.writing) return next
+    next.catch(() => {}) // a read left behind by the cut fails unheard
+    let timer
+    const cut = new Promise((r) => {
+      timer = setTimeout(() => r({ cut: true }), Math.max(0, heardAt + countWait - Date.now()))
+      timer.unref?.()
+    })
+    try {
+      return await Promise.race([next, cut])
+    } finally {
+      clearTimeout(timer)
+    }
+  }
+  const beat = (data) => {
+    try {
+      const ms = fields(data)
+      return ms.length > 0 && ms.every((m) => m.num === 1 && fields(m.data).every((u) => u.num === 13))
+    } catch {
+      return false
+    }
+  }
   try {
-    for await (const f of stream) {
+    for (;;) {
+      const r = await read()
+      if (r.cut) {
+        note?.("no count")
+        yield await settled()
+        return
+      }
+      if (r.done) break
+      const f = r.value
+      if (f.end || !beat(f.data)) heardAt = Date.now()
       if (f.end) {
         const e = failure(200, f.data)
         if (e.status < 200 || e.status > 299) yield { error: e }
@@ -3072,6 +3112,9 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
       return
     }
     yield { error: { status: 502, message: "the reply broke off: " + (e?.message ?? e) } }
+  } finally {
+    // not waited for: after a cut, the read left behind ends with the Run
+    Promise.resolve(it.return?.()).catch(() => {})
   }
 }
 

package/native-session.mjs

@@ -8,7 +8,20 @@ import { join } from "node:path"
 export const NATIVE_LIMITS = {
   resultWait: 120_000,
   lifetime: 15 * 60_000,
+  // How much of the lifetime a retained Run must have left to take a tool
+  // batch's results and go on; with less, the step starts on a fresh Run
+  // from the supplied history. One step can be a long answer: a Pi turn on
+  // grok-4.7 went on with 494 s left and was still answering at the
+  // deadline (plugins#616, yetone/magpie#4419). At most two thirds of the
+  // lifetime, so a short one set in a test still has room to continue.
+  continueReserve: 10 * 60_000,
   batchWait: 30_000,
+  // How long a stateless step whose calls came waits for Cursor's count of
+  // them (update 27) with nothing but heartbeats before it hands the calls
+  // that came to the caller (plugins#550). A count comes within ms of the
+  // step's last call; a Run that sent calls and then only heartbeats has
+  // stopped, and the caller's next request goes on from the calls' results.
+  countWait: 60_000,
   drain: 6000,
   replayWait: 120_000,
   blobBytes: 64 << 20,
@@ -511,6 +524,14 @@ export class StepCalls {
   get completed() {
     return this.byCursor.size
   }
+  // writing is how many calls the step wrote (7) that are neither started
+  // on the client, sent as an exec, nor completed by Cursor: a call of
+  // Cursor's own still running, or one still to be sent
+  get writing() {
+    let n = 0
+    for (const id of this.partial) if (!this.started.has(id) && !this.execs.has(id) && !this.byCursor.has(id)) n++
+    return n
+  }
   // nextStep starts the next step's count
   nextStep() {
     this.partial.clear()
@@ -714,6 +735,13 @@ class Segment {
   }
 }
 
+// What a Run cut at its absolute deadline says. It most often lands
+// mid-answer, the 200 long sent, so the agent reads only these words; the
+// conversation is not lost (asked again, the history goes on a fresh Run),
+// and they say so in words agents retry on: "timed out" (Pi, magpie's
+// passingSaid) and "retry your request" (plugins#616, yetone/magpie#4419).
+export const LIFETIME_EXPIRED = "native Run lifetime expired: the Run timed out; retry your request"
+
 export class NativeSessionPool {
   constructor(limits = NATIVE_LIMITS) {
     this.limits = limits
@@ -755,7 +783,7 @@ export class NativeSessionPool {
         // A retained Run's absolute timer spans all tool roundtrips. Rebuild
         // near its deadline before writing this batch: otherwise a new Chat
         // segment can lose its transport after already exposing output.
-        const reserve = Math.min(60_000, owner.limits.lifetime / 10)
+        const reserve = Math.min(owner.limits.continueReserve, owner.limits.lifetime * 2 / 3)
         if (owner.expiresAt - Date.now() <= reserve) {
           owner.fail({ status: 410, message: "native Run retired before lifetime deadline" }, "expired")
           return fallback("owner near lifetime deadline")
@@ -853,7 +881,7 @@ class NativeSession {
   expireIn(ms) {
     clearTimeout(this.lifetimeTimer)
     this.expiresAt = Date.now() + ms
-    this.lifetimeTimer = later(() => this.fail({ status: 410, message: "native Run lifetime expired" }, "expired"), ms)
+    this.lifetimeTimer = later(() => this.fail({ status: 410, message: LIFETIME_EXPIRED }, "expired"), ms)
   }
   retain(n) {
     if (this.retainedBytes + n > this.limits.outputBytes) invalid("native output/history retention limit reached", 503)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-cursor-auth",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "description": "Cursor subscriptions (Pro, Pro+, Ultra, Teams) in OpenCode and magpie, through the API cursor-agent talks to",
   "type": "module",
   "main": "./index.mjs",