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

package/README.md

@@ -95,7 +95,19 @@ 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.
+
+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).
+
+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
@@ -107,7 +119,11 @@ request can rebuild from its supplied history without submitting the result to
 the old native exec again.
 
 A native tool handoff reports zero usage with `magpie_native.accounting=pending`;
-the final native answer reports the turn's totals. An identical completed retry
+the final native answer bills the turn's totals. Its own `prompt_tokens` and
+`completion_tokens` are its last model call's share (the larger of that
+call's prompt estimate and the turn's mean per call), since a client reads
+them as how full its context is; the earlier calls' share is
+`usage.magpie_deferred` (#156). An identical completed retry
 replays the saved response with zero usage. A native final also collects earlier
 stateless debt as `usage.magpie_deferred`, separately from its own prompt total.
 If a started native Run is abandoned after a pending handoff, its dashboard

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
@@ -2547,7 +2592,8 @@ async function answerOf(auth, chat, signal, session = "") {
   const convID = conversationID(chat, session)
   const prepared = nativeSessions.prepare(tok, chat, convID, tools)
   let r
-  if (prepared.owner) r = prepared.owner.resume(prepared, signal)
+  // the continuation's own prompt, which its final step reports (#156)
+  if (prepared.owner) r = prepared.owner.resume({ ...prepared, estimate: conversation(chat, tools).estimate }, signal)
   const model = String(chat.model ?? "")
   if (!r) {
     let raw = []

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
@@ -448,6 +454,10 @@ class NativeSession {
     this.retainedBytes = 0
     this.sequence = 0
     this.segments = 0
+    // the model calls of the turn so far, and what was said before the
+    // latest one began: the last step's own share of the turn (#156)
+    this.steps = 1
+    this.stepSaid = 0
     this.said = 0
     this.wrote = 0
     this.terminal = false
@@ -509,6 +519,7 @@ class NativeSession {
     }
     this.transport = transport
     this.estimate = estimate
+    this.stepEstimate = estimate
     this.blobs = blobs
     this.knownHashes = new Set(blobs.keys())
     this.blobSize = [...blobs.values()].reduce((n, b) => n + b.length, 0)
@@ -530,6 +541,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())
   }
@@ -557,6 +576,8 @@ class NativeSession {
     this.state = "submitting"
     clearTimeout(this.resultTimer)
     clearTimeout(this.batchTimer)
+    this.batchTimer = null
+    this.nextStep(prepared.estimate)
     try {
       for (let i = 0; i < prepared.results.length; i++) {
         const call = batch.calls.find((c) => c.id === prepared.results[i].tool_call_id)
@@ -606,8 +627,20 @@ class NativeSession {
     this.waitForBatch()
     this.sealBatch()
   }
+  // nextStep is Cursor's next model call in the same turn: after the
+  // caller's results, or after a step whose calls were all answered here.
+  nextStep(estimate) {
+    this.steps++
+    this.stepSaid = this.said
+    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).
   waitForBatch() {
-    this.batchTimer ??= later(() => {
+    clearTimeout(this.batchTimer)
+    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" })
     }, this.limits.batchWait)
@@ -615,6 +648,16 @@ 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++
+    if (this.batchTimer) this.waitForBatch()
+    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 +669,19 @@ 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
+      this.nextStep()
+      return
+    }
     clearTimeout(this.batchTimer)
     this.batchTimer = null
     this.state = "awaiting-results"
@@ -729,6 +783,24 @@ class NativeSession {
     const u = usageOf(this.usageFields ?? [])
     if (!measuredInput) u.input = this.estimate
     if (!measuredOutput) u.output = Math.floor((this.said + 3) / 4)
+    // A turn of several model calls: TurnEndedUpdate counts them all, but a
+    // client reads the last response's prompt as how full its context is
+    // (Codex compacted a 61K context at 1.1M, #156). The last call keeps its
+    // own share, the larger of its prompt estimate and the turn's mean per
+    // call; the rest is billed as magpie_deferred.
+    let earlier = null
+    if (this.steps > 1) {
+      const whole = u.input + u.cacheRead + u.cacheWrite
+      const share = (total, own) => total > 0 ? Math.min(1, Math.max(own, total / this.steps) / total) : 0
+      const fi = share(whole, measuredInput ? this.stepEstimate ?? 0 : whole)
+      const fo = share(u.output, Math.floor((this.said - this.stepSaid + 3) / 4))
+      const own = {
+        input: Math.round(u.input * fi), cacheRead: Math.round(u.cacheRead * fi), cacheWrite: Math.round(u.cacheWrite * fi),
+        output: Math.round(u.output * fo), reasoning: Math.round(u.reasoning * fo),
+      }
+      earlier = { input: u.input - own.input, cacheRead: u.cacheRead - own.cacheRead, cacheWrite: u.cacheWrite - own.cacheWrite, output: u.output - own.output }
+      Object.assign(u, own)
+    }
     const prompt = u.input + u.cacheRead + u.cacheWrite
     this.finalUsage = {
       prompt_tokens: prompt, completion_tokens: u.output, total_tokens: prompt + u.output,
@@ -738,8 +810,9 @@ class NativeSession {
     }
     this.state = "finalizing"
     this.closeTransport()
-    const finish = (more) => {
+    const finish = (settled) => {
       if (this.error) return
+      const more = earlier && settled ? Object.fromEntries(Object.keys(earlier).map((k) => [k, earlier[k] + settled[k]])) : earlier ?? settled
       const deferred = more && more.input + more.output + more.cacheRead + more.cacheWrite > 0
       this.segment.finish({ stop: "stop", usage: {
         ...this.finalUsage,
@@ -783,6 +856,7 @@ class NativeSession {
                     this.said += text.length
                     if (u.num === 1) this.wrote += text.length
                     this.segment.emit(u.num === 1 ? { text } : { reasoning: text })
+                    if (this.batchTimer) this.waitForBatch()
                   }
                 } else if (u.num === 14) {
                   if (!this.segment.content && !this.segment.calls.length) invalid("an empty reply (Cursor ended the turn without text or a tool call)", 502)
@@ -793,6 +867,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 +882,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 +891,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.16",
   "description": "Cursor subscriptions (Pro, Pro+, Ultra, Teams) in OpenCode and magpie, through the API cursor-agent talks to",
   "type": "module",
   "main": "./index.mjs",