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

package/README.md

@@ -94,12 +94,19 @@ 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. The pool holds at most 8 owners per account and 32 per process, with
+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.
+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
 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
@@ -115,7 +122,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

@@ -2592,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

@@ -381,6 +381,14 @@ export class NativeSessionPool {
           return { owner, batch, replay: true, segment: batch.next }
         }
         if (owner.state !== "awaiting-results" || owner.segment !== batch || !batch.clean) return fallback("owner busy")
+        // 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)
+        if (owner.expiresAt - Date.now() <= reserve) {
+          owner.fail({ status: 410, message: "native Run retired before lifetime deadline" }, "expired")
+          return fallback("owner near lifetime deadline")
+        }
         return { owner, batch, results, encoded, digest, chat }
       } catch (e) {
         if (!(e instanceof NativeSessionError)) throw e
@@ -454,12 +462,23 @@ 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
     this.segment = new Segment(this, prepared.chat)
     this.retain(bytes(prepared.chat))
-    this.lifetimeTimer = later(() => this.fail({ status: 410, message: "native Run lifetime expired" }, "expired"), this.limits.lifetime)
+    this.expireIn(this.limits.lifetime)
+  }
+  // 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
+  expireIn(ms) {
+    clearTimeout(this.lifetimeTimer)
+    this.expiresAt = Date.now() + ms
+    this.lifetimeTimer = later(() => this.fail({ status: 410, message: "native Run lifetime expired" }, "expired"), ms)
   }
   retain(n) {
     if (this.retainedBytes + n > this.limits.outputBytes) invalid("native output/history retention limit reached", 503)
@@ -515,6 +534,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)
@@ -571,6 +591,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)
@@ -620,8 +642,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)
@@ -636,6 +670,7 @@ class NativeSession {
   answeredCall() {
     if (this.terminal || this.state === "awaiting-results") return
     this.segment.answered++
+    if (this.batchTimer) this.waitForBatch()
     this.sealBatch()
   }
   listed(count) {
@@ -659,6 +694,7 @@ class NativeSession {
       segment.answered = 0
       clearTimeout(this.batchTimer)
       this.batchTimer = null
+      this.nextStep()
       return
     }
     clearTimeout(this.batchTimer)
@@ -762,6 +798,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,
@@ -771,8 +825,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,
@@ -816,6 +871,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)

package/package.json

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