@magpie-community/opencode-cursor-auth 0.2.20 → 0.2.22

package/README.md

@@ -109,6 +109,13 @@ A step's calls must all arrive within 30 seconds of each other: Cursor sends
 each one once the model has written it, so a step of many long calls can take
 longer than that in all (#155).
 
+A Run Cursor stops answering ends with a 502 that says so, retained or
+stateless: 60 seconds with no message at all, or 4 minutes with only
+Cursor's heartbeats (yetone/magpie#2672, where a Run sent some thinking and
+then nothing, and the reply waited until the agent gave up after 5 minutes).
+Only time spent waiting on Cursor counts: a retained Run waiting for the
+caller's tool results is bounded by the 120 seconds above instead.
+
 Cursor's count of a step's tool calls includes calls the plugin answers itself:
 a tool the request doesn't have is refused to the model, and Cursor's own
 `get_mcp_tools` is answered with the request's tools. The step's calls are the
@@ -146,7 +153,10 @@ as prior usage. Stateless Runs otherwise keep the dashboard accounting above.
 `X-Magpie-Cursor-Continuity` identifies `same-run` or `stateless`, with the fallback
 reason where available. A missing native batch count can retry stateless once
 before any output is exposed or native result submitted; progressive output is
-kept and its later errors are surfaced.
+kept and its later errors are surfaced. A step's declared tool batch waits 30
+seconds from Cursor's latest call, count, text or heartbeat, so one long call
+written under heartbeats is not cut off; the failure says how many of the
+declared calls came.
 
 The existing request builder and model selection remain in use, including the
 legacy `thinking=false` mapping for explicit `none`/`off`. Retention adds no

package/index.mjs

@@ -28,7 +28,7 @@
 //
 // OpenCode speaks chat completions to it (@ai-sdk/openai-compatible); the
 // fetch here answers them.
-import { NATIVE_LIMITS, nativeSessions, NativeSessionError, nativeFields, nativeMcpArgs } from "./native-session.mjs"
+import { NATIVE_LIMITS, nativeSessions, NativeSessionError, nativeFields, nativeMcpArgs, Quiet } from "./native-session.mjs"
 import { isDeepStrictEqual } from "node:util"
 import http2 from "node:http2"
 import { STATUS_CODES } from "node:http"
@@ -2278,7 +2278,8 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
     book.done()
     return { error: failure(o.status, Buffer.concat(chunks).toString("utf8").slice(0, 1 << 20)) }
   }
-  const it = decode(frames(req), {
+  // a Run Cursor stops answering ends, as a retained one does (#2672)
+  const it = decode(new Quiet(NATIVE_LIMITS, close).frames(frames(req)), {
     send,
     blobs,
     tools,
@@ -2492,6 +2493,11 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
     }
     yield { error: { status: 502, message: "the reply broke off: EOF" } }
   } catch (e) {
+    // gone quiet is no answer, calls or not: the step's count never came
+    if (e?.quiet) {
+      yield { error: { status: e.status, message: e.message } }
+      return
+    }
     if (calls > 0 && /EOF/.test(e?.message ?? "")) {
       yield await settled()
       return

package/native-session.mjs

@@ -19,6 +19,14 @@ export const NATIVE_LIMITS = {
   // How long a KV reply waits for room in the outbound queue (Cursor's own
   // flow control taking the writes before it) before the Run fails.
   writeWait: 30_000,
+  // How long a Run waits on Cursor before it ends as gone quiet
+  // (yetone/magpie#2672): idle, with no message at all, as @cursor/sdk's
+  // stall detector ends one (30 s there; Cursor's client retries, this one
+  // can't once output went out); quiet, with heartbeats and nothing else,
+  // under the 5 minutes magpie keeps a silent reply alive. Only time spent
+  // waiting on Cursor counts, never a Run parked for the caller's results.
+  idle: 60_000,
+  quiet: 240_000,
   perAccount: 8,
   perProcess: 32,
 }
@@ -43,6 +51,113 @@ export class NativeSessionError extends Error {
 const invalid = (message, status = 409) => { throw new NativeSessionError(status, message) }
 const failureOf = (e) => ({ status: e?.status ?? 502, message: e?.message ?? String(e) })
 
+// kindOf is what a frame of AgentServerMessage is, for Quiet: a heartbeat
+// alone, or what an error names as the last thing Cursor sent
+const UPDATES = { 1: "text", 4: "thinking", 14: "turn end", 27: "tool count" }
+const MESSAGES = { 2: "tool call", 3: "checkpoint", 4: "blob request" }
+function kindOf(f) {
+  if (f.end) return "stream end"
+  try {
+    const fs = nativeFields(f.data)
+    const updates = fs.filter((m) => m.num === 1).flatMap((m) => nativeFields(m.data))
+    if (fs.length && fs.every((m) => m.num === 1) && updates.length && updates.every((u) => u.num === 13)) return null
+    const u = updates.find((u) => u.num !== 13)
+    if (u) return UPDATES[u.num] ?? `update #${u.num}`
+    return MESSAGES[fs[0]?.num] ?? `message #${fs[0]?.num}`
+  } catch {
+    return "malformed message"
+  }
+}
+
+// Quiet ends a Run Cursor has stopped answering. Cursor can leave a Run's
+// stream open after some thinking with nothing more to come, no text, call,
+// count or TurnEnded, while the plugin's heartbeats keep it alive: the
+// reply then waited until the agent gave up (305 s, yetone/magpie#2672).
+// Only time spent waiting on Cursor's next frame counts: not this side
+// handling one, not a slow reader of the reply, not a paused Run.
+export class Quiet {
+  constructor(limits, stop) {
+    this.limits = limits
+    this.stop = stop
+    this.heard = 0 // ms waited since Cursor's last frame that wasn't a heartbeat
+    this.heartbeats = 0
+    this.last = ""
+    this.since = null
+    this.paused = false
+    this.waiting = false
+    this.why = ""
+  }
+  arm() {
+    clearTimeout(this.timer)
+    if (this.paused || !this.waiting || this.why || this.done) return
+    this.since = Date.now()
+    this.timer = later(() => this.fire(), Math.max(0, Math.min(this.limits.idle, this.limits.quiet - this.heard)))
+  }
+  // waited stops the clock: Cursor answered, or the Run paused
+  waited() {
+    clearTimeout(this.timer)
+    if (this.since != null) this.heard += Date.now() - this.since
+    this.since = null
+  }
+  fire() {
+    const gap = Date.now() - this.since
+    const what = this.heard + gap >= this.limits.quiet ? `${this.heartbeats} heartbeats and nothing else for ${Math.round((this.heard + gap) / 1000)} s` : `no message for ${Math.round(gap / 1000)} s`
+    this.why = `Cursor went quiet: ${what}${this.last ? ", its last message " + this.last : ""} (try again)`
+    this.gone?.()
+    this.stop({ status: 502, message: this.why })
+  }
+  // pause stops the clock while the Run waits on the caller's tool results;
+  // resume starts it again from nothing, for Cursor's next model call
+  pause() {
+    this.waited()
+    this.paused = true
+  }
+  resume() {
+    this.paused = false
+    this.heard = 0
+    this.heartbeats = 0
+    this.arm()
+  }
+  // frames passes on a Run's frames; once Cursor has gone quiet, the read
+  // that was waiting ends in its error, whether or not the stream does
+  async *frames(stream) {
+    const it = (stream[Symbol.asyncIterator] ?? stream[Symbol.iterator]).call(stream)
+    try {
+      for (;;) {
+        this.waiting = true
+        this.arm()
+        let r
+        try {
+          const next = Promise.resolve(it.next())
+          next.catch(() => {}) // a read left behind by gone fails unheard
+          // a wake of this read's own: one that lived as long as the stream
+          // would hold every race's result, each frame, until it ended
+          r = await Promise.race([next, new Promise((wake) => { this.gone = wake })])
+        } catch (e) {
+          if (!this.why) throw e
+        } finally {
+          this.gone = null
+          this.waiting = false
+          this.waited()
+        }
+        if (this.why) throw Object.assign(new NativeSessionError(502, this.why), { quiet: true })
+        if (r.done) return
+        const kind = kindOf(r.value)
+        if (kind == null) this.heartbeats++
+        else [this.heard, this.heartbeats, this.last] = [0, 0, kind]
+        yield r.value
+      }
+    } finally {
+      this.done = true
+      clearTimeout(this.timer)
+      // not waited for: a read may still be pending on a stream that didn't
+      // end, and the reader's error handling (a failed protocol check failing
+      // the Run before a sealed batch is read) must not wait behind it
+      Promise.resolve(it.return?.()).catch(() => {})
+    }
+  }
+}
+
 // Unlike the compatibility codec, malformed protobuf tails must fail a live
 // continuation. Dropping one could turn a truncated batch into a valid handoff.
 export function nativeFields(input, maxFields = Infinity) {
@@ -472,6 +587,7 @@ class NativeSession {
     this.segment = new Segment(this, prepared.chat)
     this.retain(bytes(prepared.chat))
     this.expireIn(this.limits.lifetime)
+    this.quiet = new Quiet(this.limits, (e) => this.fail(e))
   }
   // expireIn sets the Run's absolute deadline ms from now: from its start,
   // the whole lifetime; a test brings it in after the first answer
@@ -508,6 +624,7 @@ class NativeSession {
     clearTimeout(this.resultTimer)
     clearTimeout(this.drainTimer)
     clearTimeout(this.lifetimeTimer)
+    this.quiet.pause()
     this.ac.abort()
     this.transport?.close()
   }
@@ -605,6 +722,7 @@ class NativeSession {
         this.execClose(call.requestID)
       }
       this.state = "running"
+      this.quiet.resume()
     } catch (e) {
       const error = failureOf(e)
       this.fail({ status: error.status, message: `${error.message}; native result submission failed; its outcome is uncertain and cannot be replayed` })
@@ -650,14 +768,19 @@ class NativeSession {
     if (estimate != null) this.stepEstimate = estimate
   }
   // waitForBatch gives the step batchWait from its latest call, answered
-  // call or count, not from its first. Cursor sends each call once the model
-  // has written its arguments, so a step of many long calls arrives over
-  // longer than batchWait while never pausing that long (#155).
+  // call, count, text or heartbeat, not from its first. Cursor sends each
+  // call once the model has written its arguments, so a step of many long
+  // calls arrives over longer than batchWait while never pausing that long
+  // (#155), and one long call is written with only heartbeats meanwhile
+  // (#377); a heartbeat-only stretch is bounded by quiet. The failure says
+  // how much of the batch came, so a stall reads apart from a slow call.
   waitForBatch() {
     clearTimeout(this.batchTimer)
+    const since = Date.now()
     this.batchTimer = later(() => {
-      if (this.segment.expected == null && this.segment.calls.length && !this.resultSubmitted) this.missingCount()
-      else this.fail({ status: 502, message: "Cursor did not complete its declared native tool batch" })
+      const s = this.segment
+      if (s.expected == null && s.calls.length && !this.resultSubmitted) this.missingCount()
+      else this.fail({ status: 502, message: `Cursor did not complete its declared native tool batch: ${s.calls.length} of ${s.expected ?? "?"} calls came, ${s.answered} answered here, none since ${Date.now() - since} ms` })
     }, this.limits.batchWait)
   }
   missingCount() {
@@ -706,6 +829,8 @@ class NativeSession {
     clearTimeout(this.batchTimer)
     this.batchTimer = null
     this.state = "awaiting-results"
+    // Cursor waits on the caller now: resultWait bounds the wait
+    this.quiet.pause()
     this.batches ??= []
     this.batches.push(segment)
     for (const c of segment.calls) this.pool.handles.set(c.id, { owner: this, batch: segment })
@@ -855,7 +980,7 @@ class NativeSession {
   async pump(stream) {
     const { pb, exec, failure } = this.wire
     try {
-      for await (const f of stream) {
+      for await (const f of this.quiet.frames(stream)) {
         if (this.error || this.state === "complete") return
         if (f.end) {
           const e = failure(200, f.data)
@@ -885,6 +1010,8 @@ class NativeSession {
                 } else if (u.num === 27) {
                   this.listed(num(uf, 1))
                   if (this.error) return
+                } else if (u.num === 13) {
+                  if (this.batchTimer && !this.terminal && this.state !== "awaiting-results") this.waitForBatch()
                 }
               }
               break

package/package.json

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