@magpie-community/opencode-cursor-auth 0.2.19 → 0.2.21

package/README.md

@@ -109,6 +109,13 @@ 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).
 
+A Run Cursor stops answering ends with a 502 that says so, retained or
+stateless: 60 seconds with no message at all, or 4 minutes with only
+Cursor's heartbeats (yetone/magpie#2672, where a Run sent some thinking and
+then nothing, and the reply waited until the agent gave up after 5 minutes).
+Only time spent waiting on Cursor counts: a retained Run waiting for the
+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

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 } from "./native-session.mjs"
+import { NATIVE_LIMITS, nativeSessions, NativeSessionError, nativeFields, nativeMcpArgs, Quiet } from "./native-session.mjs"
 import { isDeepStrictEqual } from "node:util"
 import http2 from "node:http2"
 import { STATUS_CODES } from "node:http"
@@ -1179,6 +1179,19 @@ function toolsOf(chat) {
     })
 }
 
+// NS is the MCP server the caller's tools are served as, the way Cursor's
+// own client names a user's server by its mcp.json label (providerIdentifier,
+// with "<label>-<tool>" as a call's name). It goes to Cursor in the prompt,
+// each call and each tool definition, so it names nothing of the plugin or
+// the app it runs in. Calls are read back under NAMESPACES: before 0.2.20
+// the server was named "magpie", and a session begun then can still call it.
+const NS = "tools"
+const NAMESPACES = [NS, "magpie"]
+const bareName = (s) => {
+  for (const ns of NAMESPACES) if (s.startsWith(ns + "-")) return s.slice(ns.length + 1)
+  return s
+}
+
 // catalog lists the caller's tools for the model. It sees MCP tools only
 // through Cursor's GetDynamicTools and CallDynamicTool, and Cursor names
 // them in a prompt of its own, which this conversation goes without:
@@ -1188,8 +1201,8 @@ function toolsOf(chat) {
 // those calls went nowhere (#11).
 function catalog(tools) {
   if (!tools.length) return ""
-  let s = `\n\n<dynamic_tool_catalog>\nThe MCP namespace "magpie" has the tools below. They are reached only through \`${CALL}\`, never as tools of their own. Each entry is the exact call to make; its arguments must match the schema given. The schemas are complete, so there is no need to call \`GetDynamicTools\` first.\n`
-  for (const t of tools) s += `<call>${CALL}({"namespace":"magpie","toolName":"${t.name}","arguments":{...}})\n${t.description}\narguments schema: ${t.schemaText}\n</call>\n`
+  let s = `\n\n<dynamic_tool_catalog>\nThe MCP namespace "${NS}" has the tools below. They are reached only through \`${CALL}\`, never as tools of their own. Each entry is the exact call to make; its arguments must match the schema given. The schemas are complete, so there is no need to call \`GetDynamicTools\` first.\n`
+  for (const t of tools) s += `<call>${CALL}({"namespace":"${NS}","toolName":"${t.name}","arguments":{...}})\n${t.description}\narguments schema: ${t.schemaText}\n</call>\n`
   return s + "</dynamic_tool_catalog>"
 }
 
@@ -1263,7 +1276,7 @@ function conversation(chat, tools) {
         if (c?.type && c.type !== "function") continue
         const args = parseArgs(c.function?.arguments)
         size += (c.function?.arguments ?? "").length + (c.function?.name ?? "").length
-        content.push({ type: "tool-call", toolCallId: callID(c.id), toolName: CALL, args: { namespace: "magpie", toolName: c.function?.name, arguments: args } })
+        content.push({ type: "tool-call", toolCallId: callID(c.id), toolName: CALL, args: { namespace: NS, toolName: c.function?.name, arguments: args } })
         pending.push(c.id)
       }
       if (content.length) add({ role: "assistant", content })
@@ -1303,7 +1316,7 @@ function toolDef(t) {
   const d = pb().str(1, t.name)
   if (t.description) d.str(2, t.description)
   d.bytes(3, pbValue(t.schema))
-  return d.str(4, "magpie").str(5, t.name).str(6, t.schemaText).done()
+  return d.str(4, NS).str(5, t.name).str(6, t.schemaText).done()
 }
 
 const env = () => pb().str(1, GOOS).str(2, tmpdir()).str(10, "UTC")
@@ -2265,7 +2278,8 @@ 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)) }
   }
-  const it = decode(frames(req), {
+  // a Run Cursor stops answering ends, as a retained one does (#2672)
+  const it = decode(new Quiet(NATIVE_LIMITS, close).frames(frames(req)), {
     send,
     blobs,
     tools,
@@ -2479,6 +2493,11 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
     }
     yield { error: { status: 502, message: "the reply broke off: EOF" } }
   } 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 } }
+      return
+    }
     if (calls > 0 && /EOF/.test(e?.message ?? "")) {
       yield await settled()
       return
@@ -2527,13 +2546,13 @@ function exec(msg, tools, send, closeExec, refused, native = false) {
   if (native) for (const e of es) if (e.num === 11) {
     if (e.wire !== 2) throw new NativeSessionError(502, "invalid native MCP argument envelope")
     const { fields: a, args } = nativeMcpArgs(e.data)
-    const name = pbStr(a, 5) || pbStr(a, 1).replace(/^magpie-/, "")
+    const name = pbStr(a, 5) || bareName(pbStr(a, 1))
     const provider = pbStr(a, 4)
     const server = pbStr(a, 9)
-    if (provider && provider !== "magpie" || server && server !== "magpie") nativeUnavailable = true
+    if (provider && !NAMESPACES.includes(provider) || server && !NAMESPACES.includes(server)) nativeUnavailable = true
     if (pbNum(a, 7) || field(a, 6)) nativeUnavailable = true
     if (!tools.some((t) => t.name === name)) nativeUnavailable = true
-    if (!pbStr(a, 5) && pbStr(a, 1) !== "magpie-" + name) nativeUnavailable = true
+    if (!pbStr(a, 5) && !NAMESPACES.some((ns) => pbStr(a, 1) === ns + "-" + name)) nativeUnavailable = true
     const call = { requestID: id, execID, nativeID: pbStr(a, 3), name, args }
     if (nativeCall && !isDeepStrictEqual(nativeCall, call)) throw new NativeSessionError(502, "ambiguous repeated native MCP argument envelopes")
     nativeCall ??= call
@@ -2565,7 +2584,7 @@ function exec(msg, tools, send, closeExec, refused, native = false) {
           const v = field(ef, 2)
           args[pbStr(ef, 1)] = v ? pbAny(v.data) : null
         }
-        const name = pbStr(a, 5) || pbStr(a, 1).replace(/^magpie-/, "")
+        const name = pbStr(a, 5) || bareName(pbStr(a, 1))
         // an OpenAI model's id is its call's and its item's, a line apart,
         // which no caller would take as an id: the line goes as __
         const cid = pbStr(a, 3).replaceAll("\n", "__") || "call_" + randomBytes(12).toString("hex")
@@ -2573,7 +2592,7 @@ function exec(msg, tools, send, closeExec, refused, native = false) {
       }
       case 36: {
         // mcp_state_exec_args: the tools there are
-        const srv = pb().str(1, "magpie").str(2, "magpie").str(7, "connected")
+        const srv = pb().str(1, NS).str(2, NS).str(7, "connected")
         for (const t of tools) srv.bytes(5, toolDef(t))
         answer(36, pb().bytes(1, pb().bytes(1, srv)))
         return null

package/native-session.mjs

@@ -19,6 +19,14 @@ export const NATIVE_LIMITS = {
   // 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,
+  // How long a Run waits on Cursor before it ends as gone quiet
+  // (yetone/magpie#2672): idle, with no message at all, as @cursor/sdk's
+  // stall detector ends one (30 s there; Cursor's client retries, this one
+  // can't once output went out); quiet, with heartbeats and nothing else,
+  // under the 5 minutes magpie keeps a silent reply alive. Only time spent
+  // waiting on Cursor counts, never a Run parked for the caller's results.
+  idle: 60_000,
+  quiet: 240_000,
   perAccount: 8,
   perProcess: 32,
 }
@@ -43,6 +51,113 @@ export class NativeSessionError extends Error {
 const invalid = (message, status = 409) => { throw new NativeSessionError(status, message) }
 const failureOf = (e) => ({ status: e?.status ?? 502, message: e?.message ?? String(e) })
 
+// 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" }
+const MESSAGES = { 2: "tool call", 3: "checkpoint", 4: "blob request" }
+function kindOf(f) {
+  if (f.end) return "stream end"
+  try {
+    const fs = nativeFields(f.data)
+    const updates = fs.filter((m) => m.num === 1).flatMap((m) => nativeFields(m.data))
+    if (fs.length && fs.every((m) => m.num === 1) && updates.length && updates.every((u) => u.num === 13)) return null
+    const u = updates.find((u) => u.num !== 13)
+    if (u) return UPDATES[u.num] ?? `update #${u.num}`
+    return MESSAGES[fs[0]?.num] ?? `message #${fs[0]?.num}`
+  } catch {
+    return "malformed message"
+  }
+}
+
+// Quiet ends a Run Cursor has stopped answering. Cursor can leave a Run's
+// stream open after some thinking with nothing more to come, no text, call,
+// count or TurnEnded, while the plugin's heartbeats keep it alive: the
+// 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.
+export class Quiet {
+  constructor(limits, stop) {
+    this.limits = limits
+    this.stop = stop
+    this.heard = 0 // ms waited since Cursor's last frame that wasn't a heartbeat
+    this.heartbeats = 0
+    this.last = ""
+    this.since = null
+    this.paused = false
+    this.waiting = false
+    this.why = ""
+  }
+  arm() {
+    clearTimeout(this.timer)
+    if (this.paused || !this.waiting || this.why || this.done) return
+    this.since = Date.now()
+    this.timer = later(() => this.fire(), Math.max(0, Math.min(this.limits.idle, this.limits.quiet - this.heard)))
+  }
+  // waited stops the clock: Cursor answered, or the Run paused
+  waited() {
+    clearTimeout(this.timer)
+    if (this.since != null) this.heard += Date.now() - this.since
+    this.since = null
+  }
+  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.gone?.()
+    this.stop({ status: 502, message: this.why })
+  }
+  // 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
+  }
+  resume() {
+    this.paused = false
+    this.heard = 0
+    this.heartbeats = 0
+    this.arm()
+  }
+  // frames passes on a Run's frames; once Cursor has gone quiet, the read
+  // that was waiting ends in its error, whether or not the stream does
+  async *frames(stream) {
+    const it = (stream[Symbol.asyncIterator] ?? stream[Symbol.iterator]).call(stream)
+    try {
+      for (;;) {
+        this.waiting = true
+        this.arm()
+        let r
+        try {
+          const next = Promise.resolve(it.next())
+          next.catch(() => {}) // a read left behind by gone fails unheard
+          // a wake of this read's own: one that lived as long as the stream
+          // would hold every race's result, each frame, until it ended
+          r = await Promise.race([next, new Promise((wake) => { this.gone = wake })])
+        } catch (e) {
+          if (!this.why) throw e
+        } finally {
+          this.gone = null
+          this.waiting = false
+          this.waited()
+        }
+        if (this.why) throw Object.assign(new NativeSessionError(502, this.why), { quiet: true })
+        if (r.done) return
+        const kind = kindOf(r.value)
+        if (kind == null) this.heartbeats++
+        else [this.heard, this.heartbeats, this.last] = [0, 0, kind]
+        yield r.value
+      }
+    } finally {
+      this.done = true
+      clearTimeout(this.timer)
+      // not waited for: a read may still be pending on a stream that didn't
+      // end, and the reader's error handling (a failed protocol check failing
+      // the Run before a sealed batch is read) must not wait behind it
+      Promise.resolve(it.return?.()).catch(() => {})
+    }
+  }
+}
+
 // 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) {
@@ -472,6 +587,7 @@ 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))
   }
   // 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
@@ -508,6 +624,7 @@ class NativeSession {
     clearTimeout(this.resultTimer)
     clearTimeout(this.drainTimer)
     clearTimeout(this.lifetimeTimer)
+    this.quiet.pause()
     this.ac.abort()
     this.transport?.close()
   }
@@ -605,6 +722,7 @@ class NativeSession {
         this.execClose(call.requestID)
       }
       this.state = "running"
+      this.quiet.resume()
     } catch (e) {
       const error = failureOf(e)
       this.fail({ status: error.status, message: `${error.message}; native result submission failed; its outcome is uncertain and cannot be replayed` })
@@ -706,6 +824,8 @@ class NativeSession {
     clearTimeout(this.batchTimer)
     this.batchTimer = null
     this.state = "awaiting-results"
+    // Cursor waits on the caller now: resultWait bounds the wait
+    this.quiet.pause()
     this.batches ??= []
     this.batches.push(segment)
     for (const c of segment.calls) this.pool.handles.set(c.id, { owner: this, batch: segment })
@@ -855,7 +975,7 @@ class NativeSession {
   async pump(stream) {
     const { pb, exec, failure } = this.wire
     try {
-      for await (const f of stream) {
+      for await (const f of this.quiet.frames(stream)) {
         if (this.error || this.state === "complete") return
         if (f.end) {
           const e = failure(200, f.data)

package/package.json

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