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

package/README.md

@@ -100,6 +100,10 @@ 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 +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

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

@@ -454,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
@@ -515,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)
@@ -571,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)
@@ -620,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)
@@ -636,6 +655,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 +679,7 @@ class NativeSession {
       segment.answered = 0
       clearTimeout(this.batchTimer)
       this.batchTimer = null
+      this.nextStep()
       return
     }
     clearTimeout(this.batchTimer)
@@ -762,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,
@@ -771,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,
@@ -816,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-cursor-auth",
-  "version": "0.2.15",
+  "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",