@magpie-community/opencode-cursor-auth 0.2.33 → 0.2.35

package/README.md

@@ -123,8 +123,11 @@ 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
-rest.
+`get_mcp_tools` is answered with the request's tools. It also includes calls
+Cursor completes by itself, which it writes and completes in the step but never
+starts on the client or sends to it; those count toward it too. Once the count
+has come, a checkpoint whose state waits on exactly the calls the caller was
+given also ends the step (#550). 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
@@ -298,6 +301,30 @@ could still pay for them. On-demand and Total are still shown but never
 keep an account in routing. Use it when on-demand is a shared or paid pool
 you don't want spent. When off, on-demand works as described above.
 
+### Wire trace (optional, for bug reports)
+
+In magpie, open the Cursor provider, turn on **Wire trace** under **Plugin
+options**, and save (or set `"pluginOptions": {"cursor": {"wire_trace":
+true}}` in magpie's settings.json). It is off by default and takes effect
+at the next request.
+
+When on, each Cursor request that fails (not one you cancel) saves a JSON
+file in the `cursor-traces` folder of magpie's folder: `~/.config/magpie/cursor-traces`
+(on Windows `C:\Users\<you>\.config\magpie\cursor-traces`), or the
+portable data folder. The newest 20 are kept. A file holds the Run's
+frames in order, both ways, as each frame's time (ms from the Run's
+start), size, kind (text, thinking, checkpoint, heartbeat, ...), field
+numbers and sizes, and the field numbers and sizes one level inside them,
+plus the error and the model id. A few of Cursor's numbers are kept too: a
+tool count's value, which kind of call (the field number of Cursor's tool
+call) a call update is about, how many calls a checkpoint waits on, and,
+for a Run that went without the native session, why. No prompt, reply or thinking text, tool
+name or argument, blob or checkpoint content, token, header, account or
+conversation id is written; the error's message has anything shaped like
+an email, id or token taken out. Look the file over before you attach it.
+
+Turn it off again when you're done.
+
 Sign in to the Cursor account linked in Grok Bot. A linked SuperGrok
 subscription grants Bot access without a paid Cursor plan; see
 [Grok Bot plans and billing](https://cursor.com/help/grok-bot/plans).

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, Quiet } from "./native-session.mjs"
+import { NATIVE_LIMITS, nativeSessions, NativeSessionError, nativeFields, nativeMcpArgs, pendingCalls, Quiet, setWireTrace, StepCalls } from "./native-session.mjs"
 import { isDeepStrictEqual } from "node:util"
 import http2 from "node:http2"
 import { STATUS_CODES } from "node:http"
@@ -642,6 +642,11 @@ function credits(plan, grants, ids, resets, now = Date.now()) {
 // keeping nothing in routing. Off, on-demand that can still pay keeps it.
 const INCLUDED_ONLY = "included_only"
 
+// WIRE_TRACE is the switch (magpie's plugin options, off by default) that
+// saves a failed Run's frames, scrubbed, as a JSON file in cursor-traces in
+// magpie's folder (plugins#550): see WireTrace for what one holds.
+const WIRE_TRACE = "wire_trace"
+
 // enterpriseUsage is the allowance GetCurrentPeriodUsage leaves out on an
 // Enterprise account. That call answers with only the billing cycle there;
 // the website's usage-summary has individualUsage.overall, in cents, and
@@ -2742,7 +2747,7 @@ async function runNative({ tok, base, id, tools, conv, convID, signal, maxMode,
 
 // runOnce is one Run of the chat on the agent API at base: an async
 // iterator of the answer's pieces, or the error it failed with before any.
-async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, params }) {
+async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, params, why }) {
   // the Run's conversation_id, a new one when nothing names the session:
   // its usage event is found by it
   const cid = convID || randomUUID()
@@ -2772,8 +2777,13 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
   const { session, req } = o
   let closed = false
   let heartbeat
+  // a Run Cursor stops answering ends, as a retained one does (#2672)
+  const quiet = new Quiet(NATIVE_LIMITS, () => close(), { path: "stateless", model: id, why })
   const send = (msg) => {
-    if (!closed && !req.destroyed && req.writable) req.write(frame(msg))
+    if (!closed && !req.destroyed && req.writable) {
+      quiet.trace?.frame("out", msg)
+      req.write(frame(msg))
+    }
   }
   const close = () => {
     if (closed) return
@@ -2804,8 +2814,7 @@ 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)) }
   }
-  // a Run Cursor stops answering ends, as a retained one does (#2672)
-  const it = decode(new Quiet(NATIVE_LIMITS, close).frames(frames(req)), {
+  const it = decode(quiet.frames(frames(req)), {
     send,
     blobs,
     tools,
@@ -2813,10 +2822,14 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
     close,
     stepUsage: book.own,
     owedUsage: book.owed,
+    note: (name) => quiet.trace?.event(name),
   })
   const wrapped = (async function* () {
     try {
-      yield* it
+      for await (const v of it) {
+        if (v?.error) quiet.failed(v.error)
+        yield v
+      }
     } finally {
       close()
       book.done()
@@ -2840,7 +2853,7 @@ async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, pa
 
 // decode follows the server's messages into the answer's pieces until the
 // turn ends, or the model has made its tool calls.
-async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage, owedUsage }) {
+async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage, owedUsage, note }) {
   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)
@@ -2848,14 +2861,18 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
   // ended: Cursor said what the turn used
   let ended = false
   let listed = 0
+  // what Cursor said of the step's calls: those it completed by itself
+  // count toward listed too, and never come as an exec (plugins#550)
+  const step = new StepCalls(fields)
   // 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 (!listed || calls + answered + step.completed < listed) return false
     if (calls > 0) return true
     listed = 0
     answered = 0
+    step.nextStep()
     return false
   }
   let said = 0
@@ -2972,6 +2989,16 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
                     return
                   }
                   break
+                case 2: // a call started on the client
+                case 3: // a call completed: by Cursor itself when it never started here
+                case 7: // a call the model is writing
+                  // still named in an empty reply's list: only their ids are read
+                  count(seen.updates, u.num)
+                  if (step.update(u.num, uf) && (note?.("completed by Cursor"), stepDone())) {
+                    yield await settled()
+                    return
+                  }
+                  break
                 default:
                   count(seen.updates, u.num)
               }
@@ -2979,6 +3006,7 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
             break
           case 2: {
             // exec_server_message: the server asks the client to run something
+            step.exec(m.data)
             const call = exec(m.data, tools, send, closeExec, seen.refused)
             if (call) {
               said += call.args.length
@@ -2991,6 +3019,18 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
             }
             break
           }
+          case 3:
+            // conversation_checkpoint_update: Cursor's state. Once the step
+            // has its count, a state waiting on just the calls handed to the
+            // caller is a step Cursor has finished: what more the count
+            // says will not come (plugins#550)
+            if (listed && calls > 0 && pendingCalls(m.data, fields) === calls) {
+              note?.("waited on")
+              yield await settled()
+              return
+            }
+            count(seen.messages, m.num)
+            break
           case 4: {
             // kv_server_message: a blob wanted, or one to keep
             const kv = fields(m.data)
@@ -3021,7 +3061,10 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
   } 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 } }
+      // with what came of the step's calls, as the native path's batch
+      // error says it (plugins#550)
+      const batch = calls || listed ? `; the step's tool count ${listed || "not sent"}: ${calls} calls came, ${answered} answered here, ${step.completed} completed by Cursor` : ""
+      yield { error: { status: e.status, message: batch ? e.message.replace(/( \(try again\))?$/, batch + "$1") : e.message } }
       return
     }
     if (calls > 0 && /EOF/.test(e?.message ?? "")) {
@@ -3195,10 +3238,11 @@ async function answerOf(auth, chat, signal, session = "") {
       // uses the original history builder/decoder without cancelling a live parent.
       const native = prepared.fallback ? null : nativeSessions.create(prepared, { id, maxMode, params }, { pb, exec, usageOf, failure })
       const args = { tok, base, id, tools, conv, convID, signal, maxMode, params }
-      let response = native ? await runNative({ ...args, native }) : await runOnce(args)
+      let response = native ? await runNative({ ...args, native }) : await runOnce({ ...args, why: prepared.fallback || "retention capacity or reservation unavailable" })
       const rebuild = async () => {
-        const fallback = await runOnce(args)
-        fallback.diagnostic = "stateless; bootstrap=imported-history; reason=" + (response.error?.continuityReason || "missing-batch-count")
+        const why = response.error?.continuityReason || "missing-batch-count"
+        const fallback = await runOnce({ ...args, why })
+        fallback.diagnostic = "stateless; bootstrap=imported-history; reason=" + why
         return fallback
       }
       // A missing or conflicting native batch count may be retried once,
@@ -3328,6 +3372,16 @@ export async function CursorAuthPlugin(input) {
       return false
     }
   }
+  // the folder a failed Run's trace goes to, read at each Run's start;
+  // "" with Wire trace off, and outside magpie, which has no such option
+  // (OpenCode's directory is the project's, never written to)
+  setWireTrace(() => {
+    try {
+      return input?.magpie?.option?.(ID, WIRE_TRACE) === true && input.directory ? join(input.directory, "cursor-traces") : ""
+    } catch {
+      return ""
+    }
+  })
   return {
     auth: {
       provider: ID,
@@ -3369,6 +3423,12 @@ export async function CursorAuthPlugin(input) {
           description:
             "Keeps an account in routing only while its included usage lasts: once an included pool (Cursor Models, Other Models, a newer plan's Weekly) is used up, magpie moves its models to the next account until it resets, even if on-demand or free credit could pay.",
         },
+        {
+          key: WIRE_TRACE,
+          label: "Wire trace",
+          description:
+            "For a bug report: when a Cursor request fails, saves the shape of what Cursor sent and what was sent back (each frame's kind, field numbers, size and time) to the cursor-traces folder in magpie's folder. No prompt or reply text, tool names or arguments, tokens, headers or account ids are written. The newest 20 are kept.",
+        },
       ],
       // magpie's: how much of the plan's included usage is gone (the plan
       // is the one the sign-in read). The built-in's read, clean or not,

package/native-session.mjs

@@ -1,4 +1,6 @@
 import { createHash, randomBytes } from "node:crypto"
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
 
 // Retention is process-local and optional. A lost owner rebuilds Chat history
 // on a fresh Run; it never resubmits a result to an uncertain native exec.
@@ -53,7 +55,13 @@ const failureOf = (e) => ({ status: e?.status ?? 502, message: e?.message ?? Str
 
 // 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" }
+// (names after cursor-agent's agent.v1 InteractionUpdate, 2026.10.01)
+const UPDATES = {
+  1: "text", 2: "tool call started", 3: "tool call completed", 4: "thinking", 5: "thinking done",
+  6: "user message", 7: "partial tool call", 8: "token count", 9: "summary", 10: "summary started",
+  11: "summary done", 12: "shell output", 14: "turn end", 15: "tool call delta", 16: "step started",
+  17: "step done", 27: "tool count",
+}
 const MESSAGES = { 2: "tool call", 3: "checkpoint", 4: "blob request" }
 function kindOf(f) {
   if (f.end) return "stream end"
@@ -75,8 +83,10 @@ function kindOf(f) {
 // 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.
+// meta names the Run for a wire trace (path, model); with the trace off it
+// is unused.
 export class Quiet {
-  constructor(limits, stop) {
+  constructor(limits, stop, meta = {}) {
     this.limits = limits
     this.stop = stop
     this.heard = 0 // ms waited since Cursor's last frame that wasn't a heartbeat
@@ -86,6 +96,14 @@ export class Quiet {
     this.paused = false
     this.waiting = false
     this.why = ""
+    // what the error says of a checkpoint (plugins#550): its number in the
+    // Run, which of its step's it was (step is 0 where the path doesn't
+    // count steps), and the kinds of the frames before it, run-length
+    this.checkpoints = 0
+    this.step = 0
+    this.stepCheckpoints = 0
+    this.trail = []
+    this.trace = WireTrace.open(meta)
   }
   arm() {
     clearTimeout(this.timer)
@@ -102,20 +120,47 @@ export class Quiet {
   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.why = `Cursor went quiet: ${what}${this.last ? ", its last message " + this.lastSaid() : ""} (try again)`
+    this.trace?.event("quiet", { heard: this.heard + gap, heartbeats: this.heartbeats })
     this.gone?.()
     this.stop({ status: 502, message: this.why })
+    this.failed({ status: 502, message: this.why })
+  }
+  // lastSaid is the last frame's kind as the error names it; a checkpoint
+  // with its number, its place in the step and what came before it
+  lastSaid() {
+    if (this.last !== "checkpoint") return this.last
+    const row = this.trail.at(-1)?.[1] ?? 1
+    const before = this.trail.slice(0, -1).map(([k, n]) => n > 1 ? `${k} ×${n}` : k).join(", ")
+    const nth = this.stepCheckpoints === 1 ? "the first" : `number ${this.stepCheckpoints}`
+    return `checkpoint #${this.checkpoints} of the Run`
+      + (this.step ? `, ${nth} of step ${this.step}` : "")
+      + (row > 1 ? `, ${row} in a row` : "")
+      + `, after ${before || "nothing else"}`
+  }
+  // nextStep is the Run's next model call (NativeSession counts them)
+  nextStep(n) {
+    this.step = n
+    this.stepCheckpoints = 0
+    this.trace?.event("step", { n })
+  }
+  // failed is how the Run ended, when it failed: a wire trace, if on, is
+  // written then (once)
+  failed(error) {
+    this.trace?.write(error, this)
   }
   // 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
+    this.trace?.event("pause")
   }
   resume() {
     this.paused = false
     this.heard = 0
     this.heartbeats = 0
+    this.trace?.event("resume")
     this.arm()
   }
   // frames passes on a Run's frames; once Cursor has gone quiet, the read
@@ -141,10 +186,25 @@ export class Quiet {
           this.waited()
         }
         if (this.why) throw Object.assign(new NativeSessionError(502, this.why), { quiet: true })
-        if (r.done) return
+        if (r.done) {
+          this.trace?.event("eof")
+          return
+        }
         const kind = kindOf(r.value)
+        this.trace?.frame("in", r.value, kind)
         if (kind == null) this.heartbeats++
-        else [this.heard, this.heartbeats, this.last] = [0, 0, kind]
+        else {
+          [this.heard, this.heartbeats, this.last] = [0, 0, kind]
+          if (kind === "checkpoint") {
+            this.checkpoints++
+            this.stepCheckpoints++
+          }
+          if (this.trail.at(-1)?.[0] === kind) this.trail.at(-1)[1]++
+          else {
+            this.trail.push([kind, 1])
+            if (this.trail.length > 4) this.trail.shift()
+          }
+        }
         yield r.value
       }
     } finally {
@@ -158,6 +218,141 @@ export class Quiet {
   }
 }
 
+// The wire trace (plugins#550, off by default; the plugin's Wire trace
+// option): a failed Run's frames, in and out, written to a JSON file for a
+// bug report. A frame is kept as its kind, size, top-level field numbers
+// with their wire types and sizes, and those fields' own field numbers and
+// sizes one level down: the shape of the protocol, never its bytes. No
+// text, thinking, tool name or argument, blob or blob id, checkpoint
+// content, token, header, account or conversation id is read into it; the
+// error's message is scrubbed of anything shaped like an email, id or
+// token. traceDir is the folder, or "" while off, asked at each Run's start.
+let traceDir = () => ""
+export function setWireTrace(dir) {
+  traceDir = typeof dir === "function" ? dir : () => dir || ""
+}
+const TRACE_HEAD = 2000 // the Run's first frames, kept
+const TRACE_TAIL = 3000 // and its last, the ones in between counted only
+const TRACE_FILES = 20 // the newest traces kept in the folder
+// shape is a message's fields as [number, wire, size] (a varint's size 0),
+// with children: the fields' own fields, for a field that is a message
+function shape(data, children) {
+  return nativeFields(data).map((f) => {
+    const own = [f.num, f.wire, f.wire === 0 ? 0 : f.data.length]
+    if (!children || f.wire !== 2) return own
+    try {
+      return [...own, nativeFields(f.data).map((c) => [c.num, c.wire, c.wire === 0 ? 0 : c.data.length])]
+    } catch {
+      return own
+    }
+  })
+}
+export function scrub(s) {
+  return String(s ?? "")
+    .replace(/[\w.+-]+@[\w-]+(\.[\w-]+)+/g, "<email>")
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<id>")
+    .replace(/(auth0|user|google-oauth2|github)\|[\w-]+/gi, "<account>")
+    .replace(/[A-Za-z0-9_\-+/=.]{24,}/g, "<redacted>")
+    .slice(0, 2000)
+}
+// detail is what a trace keeps of an inbound frame past its shape, all of
+// it numbers of Cursor's protocol, never content (plugins#550): a tool
+// count's number, the kind of call (ToolCall's field) a call update is
+// of, and how many calls a checkpoint's state waits on
+function detail(data) {
+  const out = {}
+  for (const m of nativeFields(data)) {
+    if (m.num === 1) {
+      for (const u of nativeFields(m.data)) {
+        if (u.num === 27) out.count = num(nativeFields(u.data), 1)
+        else if (u.num === 2 || u.num === 3 || u.num === 7) {
+          const tc = field(nativeFields(u.data), 2)
+          const kind = tc && nativeFields(tc.data)[0]
+          if (kind) out.tool = kind.wire === 2 ? [kind.num, nativeFields(kind.data)[0]?.num ?? 0] : [kind.num]
+        }
+      }
+    } else if (m.num === 3) out.pending = pendingCalls(m.data)
+  }
+  return out
+}
+export class WireTrace {
+  static open(meta) {
+    let dir = ""
+    try { dir = traceDir() } catch {}
+    return dir ? new WireTrace(dir, meta) : null
+  }
+  constructor(dir, meta = {}) {
+    this.dir = dir
+    this.meta = { path: String(meta.path ?? ""), model: String(meta.model ?? "") }
+    // why a Run went stateless: the retention fallback's reason
+    if (meta.why) this.meta.why = String(meta.why)
+    this.started = Date.now()
+    this.head = []
+    this.tail = []
+    this.dropped = 0
+  }
+  push(entry) {
+    if (this.written) return
+    if (this.head.length < TRACE_HEAD) return void this.head.push(entry)
+    this.tail.push(entry)
+    if (this.tail.length > TRACE_TAIL) {
+      this.tail.shift()
+      this.dropped++
+    }
+  }
+  // frame is one frame of the Run: "in" from Cursor ({data} or {end, data}),
+  // "out" a message this side sent
+  frame(dir, f, kind) {
+    const t = Date.now() - this.started
+    const data = dir === "in" ? f.data : f
+    const entry = { t, dir, size: data?.length ?? 0 }
+    if (dir === "in") entry.kind = kind ?? "heartbeat"
+    if (dir === "in" && f.end) entry.end = true
+    else try { entry.fields = shape(data, true) } catch { entry.malformed = true }
+    if (dir === "in" && !f.end) try { Object.assign(entry, detail(data)) } catch {}
+    this.push(entry)
+  }
+  event(name, extra = {}) {
+    this.push({ t: Date.now() - this.started, event: name, ...extra })
+  }
+  // write saves the trace once, when the Run failed; a write that fails
+  // leaves the Run's error as it was
+  write(error, quiet) {
+    if (this.written) return
+    this.written = true
+    try {
+      const at = new Date(this.started).toISOString().replace(/[:.]/g, "-")
+      const body = {
+        trace: 1,
+        plugin: "@magpie-community/opencode-cursor-auth",
+        version: version(),
+        ...this.meta,
+        started: new Date(this.started).toISOString(),
+        ms: Date.now() - this.started,
+        error: { status: error?.status ?? 0, message: scrub(error?.message) },
+        quiet: quiet ? { last: quiet.last, checkpoints: quiet.checkpoints, step: quiet.step, stepCheckpoints: quiet.stepCheckpoints, heartbeats: quiet.heartbeats, heard: quiet.heard, trail: quiet.trail } : undefined,
+        frames: [...this.head, ...(this.dropped ? [{ dropped: this.dropped }] : []), ...this.tail],
+      }
+      mkdirSync(this.dir, { recursive: true })
+      const file = join(this.dir, `${at}-${randomBytes(3).toString("hex")}.json`)
+      writeFileSync(file + ".tmp", JSON.stringify(body) + "\n", { mode: 0o600 })
+      renameSync(file + ".tmp", file)
+      this.file = file
+      const old = readdirSync(this.dir).filter((n) => n.endsWith(".json")).sort()
+      for (const n of old.slice(0, Math.max(0, old.length - TRACE_FILES))) rmSync(join(this.dir, n), { force: true })
+    } catch {}
+    this.head = this.tail = []
+  }
+}
+// version is the package's, for a trace to say
+function version() {
+  try {
+    return JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8")).version ?? ""
+  } catch {
+    return ""
+  }
+}
+
 // 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) {
@@ -272,6 +467,67 @@ const field = (fs, n) => fs.find((f) => f.num === n)
 const str = (fs, n) => field(fs, n)?.data.toString("utf8") ?? ""
 const num = (fs, n) => field(fs, n)?.n ?? 0
 
+// StepCalls is what Cursor says of a step's calls besides its execs
+// (plugins#550). InteractionUpdate 2 (tool_call_started), 3
+// (tool_call_completed) and 7 (partial_tool_call) each carry the call's
+// call_id (field 1). A call Cursor completed by itself, never started on
+// the client and never sent as an exec, is in tool_requests_listed's count
+// all the same, and no exec of it will come: 0.2.34 waited for it while
+// Cursor waited for the one call it had sent, 240 s, heartbeats only.
+// parse is the path's field reader.
+export class StepCalls {
+  constructor(parse) {
+    this.parse = parse
+    this.started = new Set()
+    this.execs = new Set() // the short strings of each exec's args: its tool_call_id among them
+    this.partial = new Set() // calls the model is writing in this step
+    this.byCursor = new Set()
+  }
+  // update takes an InteractionUpdate's own field (num) and its fields; it
+  // says whether a call was completed by Cursor: one this step wrote (7)
+  // and completed (3) with no start on the client (2) and no exec. A
+  // completion of an earlier step's call is never counted again.
+  update(n, uf) {
+    if (n !== 2 && n !== 3 && n !== 7) return false
+    const id = str(uf, 1)
+    if (!id) return false
+    if (n === 2) this.started.add(id)
+    if (n === 7) this.partial.add(id)
+    if (n !== 3) return false
+    if (!this.partial.has(id) || this.started.has(id) || this.execs.has(id) || this.byCursor.has(id)) return false
+    this.byCursor.add(id)
+    return true
+  }
+  // exec notes an exec's args, whatever its kind: each kind keeps its
+  // tool_call_id at a field of its own (ShellArgs 4, ReadArgs 2, McpArgs 3)
+  exec(data) {
+    try {
+      for (const e of this.parse(data)) {
+        if (e.wire !== 2 || e.num === 15 || e.num === 19) continue
+        for (const a of this.parse(e.data)) if (a.wire === 2 && a.data.length && a.data.length <= 512) this.execs.add(a.data.toString("utf8"))
+      }
+    } catch {}
+  }
+  get completed() {
+    return this.byCursor.size
+  }
+  // nextStep starts the next step's count
+  nextStep() {
+    this.partial.clear()
+    this.byCursor.clear()
+  }
+}
+// pendingCalls is how many calls a checkpoint (ConversationStateStructure)
+// says Cursor waits on: its pending_tool_calls, field 4; null when it
+// can't be read
+export function pendingCalls(data, parse = nativeFields) {
+  try {
+    return parse(data).filter((f) => f.num === 4).length
+  } catch {
+    return null
+  }
+}
+
 function argsOf(s) {
   try {
     const v = typeof s === "string" ? JSON.parse(s) : s
@@ -571,6 +827,8 @@ class NativeSession {
     this.ac = new AbortController()
     this.execs = new Map()
     this.nativeCalls = new Map()
+    // what Cursor said of the step's calls besides its execs (plugins#550)
+    this.stepCalls = new StepCalls(nativeFields)
     this.blobs = new Map()
     this.knownHashes = new Set()
     this.blobSize = 0
@@ -587,7 +845,8 @@ 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))
+    this.quiet = new Quiet(this.limits, (e) => this.fail(e), { path: "native", model: resolution?.id })
+    this.quiet.nextStep(this.steps)
   }
   // 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
@@ -632,6 +891,8 @@ class NativeSession {
     if (this.error || this.state === "complete") return
     this.error = error
     this.state = state
+    // a cancelled Run is the caller's doing, not a failure to trace
+    if (state !== "cancelled") this.quiet.failed(error)
     this.segment.fail(error)
     for (const segment of this.batches ?? []) segment.detach?.()
     this.segment.detach?.()
@@ -671,6 +932,7 @@ class NativeSession {
   }
   send(message) {
     if (this.error || this.transportClosed) invalid("native transport is no longer writable", 410)
+    this.quiet.trace?.frame("out", message)
     this.transport.send(message)
   }
   // reply answers one of Cursor's KV requests once the outbound queue has
@@ -764,6 +1026,8 @@ class NativeSession {
   // caller's results, or after a step whose calls were all answered here.
   nextStep(estimate) {
     this.steps++
+    this.stepCalls.nextStep()
+    this.quiet.nextStep(this.steps)
     this.stepSaid = this.said
     if (estimate != null) this.stepEstimate = estimate
   }
@@ -780,7 +1044,7 @@ class NativeSession {
     this.batchTimer = later(() => {
       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` })
+      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${this.stepCalls.completed ? `, ${this.stepCalls.completed} completed by Cursor` : ""}, none since ${Date.now() - since} ms` })
     }, this.limits.batchWait)
   }
   missingCount() {
@@ -796,6 +1060,23 @@ class NativeSession {
     if (this.batchTimer) this.waitForBatch()
     this.sealBatch()
   }
+  // A call of the step Cursor completed by itself (plugins#550): in its
+  // count, and never sent as an exec.
+  completedByCursor() {
+    if (this.terminal || this.state === "awaiting-results") return
+    if (this.batchTimer) this.waitForBatch()
+    this.sealBatch()
+  }
+  // A checkpoint whose state waits on just the calls handed to the caller,
+  // after the step's count, is a step Cursor has finished: what more the
+  // count says will not come (plugins#550).
+  waitedOn(data) {
+    const s = this.segment
+    if (this.terminal || this.state === "awaiting-results" || s.closed || s.expected == null || !s.calls.length) return
+    if (pendingCalls(data) !== s.calls.length) return
+    s.waitedOn = true
+    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) {
@@ -815,7 +1096,8 @@ class NativeSession {
     if (segment.expected == null) 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
+    // the calls Cursor completed by itself make up the rest (plugins#550)
+    if ((made + this.stepCalls.completed < segment.expected && !segment.waitedOn) || 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.
@@ -1012,10 +1294,14 @@ class NativeSession {
                   if (this.error) return
                 } else if (u.num === 13) {
                   if (this.batchTimer && !this.terminal && this.state !== "awaiting-results") this.waitForBatch()
+                } else if ((u.num === 2 || u.num === 3 || u.num === 7) && this.stepCalls.update(u.num, uf)) {
+                  this.completedByCursor()
+                  if (this.error) return
                 }
               }
               break
             case 2: {
+              this.stepCalls.exec(m.data)
               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
@@ -1024,6 +1310,7 @@ class NativeSession {
             }
             case 3:
               this.checkpointReceived(m.data)
+              this.waitedOn(m.data)
               break
             case 4: {
               const kv = nativeFields(m.data)

package/package.json

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