@magpie-community/opencode-cursor-auth 0.2.14 → 0.2.15

package/README.md

@@ -95,7 +95,15 @@ 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. The pool holds at most 8 owners per account and 32 per process, with
-bounded history, blobs, arguments, and pending writes.
+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
+drains them slowly), the Run waits for the link to drain, and fails only if it
+doesn't for 30 seconds.
+
+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
+rest.
 
 These are retention limits. A missing, expired, restarted, busy, incompatible,
 or full owner uses the original history reconstruction and stateless decoder

package/index.mjs

@@ -1939,6 +1939,15 @@ function nativeTransport(req, close, fail, limits = NATIVE_LIMITS) {
   const outbound = { bytes: 0, messages: 0 }
   const queue = []
   let closed = false, flushing = false, rejectWrite
+  // waiters for room (KV replies), woken as writes complete. An eighth of
+  // each bound stays free for heartbeats and exec answers, which never wait.
+  const waiters = new Set()
+  const spare = (n) => Math.floor(n / 8)
+  const fits = (size) => outbound.messages === 0 || (outbound.messages + 1 + spare(limits.outboundMessages) <= limits.outboundMessages
+    && outbound.bytes + size + spare(limits.outboundBytes) <= limits.outboundBytes)
+  const wake = () => {
+    for (const w of waiters) if (closed || fits(w.size)) w.done()
+  }
   const flush = async () => {
     if (closed || flushing) return
     flushing = true
@@ -1975,7 +1984,7 @@ function nativeTransport(req, close, fail, limits = NATIVE_LIMITS) {
             check()
           } catch (e) { finish(e) }
         })
-        if (!closed) { outbound.bytes -= packet.length; outbound.messages-- }
+        if (!closed) { outbound.bytes -= packet.length; outbound.messages--; wake() }
       }
     } catch (e) {
       if (!closed) fail(e)
@@ -1993,12 +2002,35 @@ function nativeTransport(req, close, fail, limits = NATIVE_LIMITS) {
       queue.push(frame(message))
       void flush()
     },
+    // room resolves once a message of size fits the queue with the spare
+    // kept, and fails the Run when the queue doesn't drain for writeWait.
+    room(size) {
+      if (closed || fits(size)) return Promise.resolve()
+      return new Promise((resolve, reject) => {
+        const w = {
+          size,
+          done() {
+            waiters.delete(w)
+            clearTimeout(w.timer)
+            resolve()
+          },
+        }
+        w.timer = setTimeout(() => {
+          waiters.delete(w)
+          const which = outbound.bytes + size + spare(limits.outboundBytes) > limits.outboundBytes ? "bytes" : "messages"
+          reject(new NativeSessionError(503, `native outbound ${which} limit reached: the queue did not drain for ${Math.round(limits.writeWait / 1000)}s`))
+        }, limits.writeWait)
+        w.timer.unref?.()
+        waiters.add(w)
+      })
+    },
     close() {
       if (closed) return
       closed = true
       queue.length = 0
       outbound.bytes = 0
       outbound.messages = 0
+      wake()
       rejectWrite?.(new NativeSessionError(410, "native transport was cancelled"))
       close()
     },
@@ -2232,9 +2264,22 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
 // turn ends, or the model has made its tool calls.
 async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage, owedUsage }) {
   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)
+  let answered = 0
   // ended: Cursor said what the turn used
   let ended = false
   let listed = 0
+  // stepDone is whether every call the step listed has come. A step whose
+  // calls were all answered here goes on on Cursor's side, under a count of
+  // its own.
+  const stepDone = () => {
+    if (!listed || calls + answered < listed) return false
+    if (calls > 0) return true
+    listed = 0
+    answered = 0
+    return false
+  }
   let said = 0
   // wrote: the reply's text alone; a turn of thinking only says nothing
   let wrote = 0
@@ -2342,9 +2387,9 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
                     return
                   }
                   break
-                case 27: // how many tool calls the step makes, sent before them
+                case 27: // how many tool calls the step makes, sent before or after them
                   listed = pbNum(uf, 1)
-                  if (listed > 0 && calls >= listed) {
+                  if (stepDone()) {
                     yield await settled()
                     return
                   }
@@ -2360,8 +2405,8 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
             if (call) {
               said += call.args.length
               yield { tool: { index: calls++, ...call } }
-            }
-            if (listed > 0 && calls >= listed) {
+            } else if (!fields(m.data).some((e) => e.num === 10)) answered++
+            if (stepDone()) {
               // every call made: the caller runs them
               yield await settled()
               return

package/native-session.mjs

@@ -16,6 +16,9 @@ export const NATIVE_LIMITS = {
   argumentDepth: 64,
   outboundBytes: 16 << 20,
   outboundMessages: 256,
+  // 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,
   perAccount: 8,
   perProcess: 32,
 }
@@ -270,6 +273,9 @@ class Segment {
     this.prefixDigest = historyDigest(chat.messages)
     this.events = []
     this.calls = []
+    // answered: the step's execs the bridge answered itself (a refusal, or
+    // the MCP tool list). Cursor's tool_requests_listed counts them too.
+    this.answered = 0
     this.content = ""
     this.reasoning = ""
     this.expected = null
@@ -530,6 +536,14 @@ class NativeSession {
     if (this.error || this.transportClosed) invalid("native transport is no longer writable", 410)
     this.transport.send(message)
   }
+  // reply answers one of Cursor's KV requests once the outbound queue has
+  // room. Cursor asks for every history blob at once, hundreds for a long
+  // conversation, faster than a slow link takes the replies: the decoder
+  // waits for the queue rather than failing the Run (#142).
+  async reply(message) {
+    await this.transport.room?.(message.length + 5)
+    this.send(message)
+  }
   execClose(id) {
     this.send(this.wire.pb().bytes(5, this.wire.pb().bytes(1, this.wire.pb().varint(1, id))).done())
   }
@@ -615,6 +629,15 @@ class NativeSession {
   missingCount() {
     this.fail({ status: 502, message: "Cursor did not declare its native tool batch", retentionIneligible: !this.resultSubmitted })
   }
+  // A call of the model's step the bridge answered itself: a refused tool (a
+  // name it doesn't serve, Cursor's own tools) or get_mcp_tools. Cursor's
+  // count is of every call the step made, so it counts toward the batch;
+  // never handed to the caller (#142).
+  answeredCall() {
+    if (this.terminal || this.state === "awaiting-results") return
+    this.segment.answered++
+    this.sealBatch()
+  }
   listed(count) {
     if (!Number.isSafeInteger(count) || count < 1) invalid("invalid native tool count", 502)
     if (this.segment.expected != null && this.segment.expected !== count) invalid("inconsistent native tool count", 502)
@@ -626,8 +649,18 @@ class NativeSession {
   sealBatch() {
     const segment = this.segment
     if (segment.expected == null) return
-    if (segment.calls.length > segment.expected) invalid("native tool batch exceeded its declared count", 502)
-    if (segment.calls.length !== segment.expected || segment.closed) return
+    const made = segment.calls.length + segment.answered
+    if (made > segment.expected) invalid("native tool batch exceeded its declared count", 502)
+    if (made !== segment.expected || segment.closed) return
+    if (!segment.calls.length) {
+      // Every call of the step was answered here: Cursor goes on with the
+      // turn by itself, and its next step lists a count of its own.
+      segment.expected = null
+      segment.answered = 0
+      clearTimeout(this.batchTimer)
+      this.batchTimer = null
+      return
+    }
     clearTimeout(this.batchTimer)
     this.batchTimer = null
     this.state = "awaiting-results"
@@ -793,6 +826,8 @@ class NativeSession {
             case 2: {
               const c = exec(m.data, this.chatTools, (b) => this.send(b), (id) => this.execClose(id), null, true)
               if (c) this.acceptCall(c)
+              // request_context is Cursor asking for the environment, not a call
+              else if (!nativeFields(m.data).some((e) => e.num === 10)) this.answeredCall()
               break
             }
             case 3:
@@ -806,7 +841,7 @@ class NativeSession {
                   const want = field(nativeFields(k.data), 1)?.data.toString("hex") ?? ""
                   const b = this.blobs.get(want)
                   const res = b ? pb().bytes(1, b) : pb().bytes(2, pb().str(1, "blob not found"))
-                  this.send(pb().bytes(3, pb().varint(1, id).bytes(2, res)).done())
+                  await this.reply(pb().bytes(3, pb().varint(1, id).bytes(2, res)).done())
                 } else if (k.num === 3) {
                   try {
                     const set = nativeFields(k.data)
@@ -815,7 +850,7 @@ class NativeSession {
                     this.send(pb().bytes(3, pb().varint(1, id).bytes(3, pb().bytes(1, pb().str(1, "native blob could not be retained")))).done())
                     throw e
                   }
-                  this.send(pb().bytes(3, pb().varint(1, id).bytes(3, Buffer.alloc(0))).done())
+                  await this.reply(pb().bytes(3, pb().varint(1, id).bytes(3, Buffer.alloc(0))).done())
                 }
               }
               break

package/package.json

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