@magpie-community/opencode-cursor-auth 0.2.6 → 0.2.8

package/README.md

@@ -63,7 +63,11 @@ plugin's `fetch` answers them on Cursor's agent API:
   so subagents under one session are conversations of their own. With
   nothing naming the session, each Run has a new one.
 - Text, thinking (`reasoning_content`) and token usage come back streamed
-  or not. Cursor's `input_tokens` counts the cached prompt too: the cache
+  or not. Replayed assistant `reasoning_content` (or `reasoning`) is kept as
+  AI SDK reasoning parts in the next Run's transcript, including when a
+  caller splits parallel tool calls across assistant messages. It stays
+  separate from reply text; no thinking signature is invented.
+  Cursor's `input_tokens` counts the cached prompt too: the cache
   read and written is taken out of it, and given as `cached_tokens` and
   `cache_write_tokens`, so it is counted once; its reasoning tokens are
   `reasoning_tokens`. A step that calls tools gets no usage in its Run

package/index.mjs

@@ -1081,6 +1081,10 @@ function statusOf(status, code, msg) {
 const textOf = (c) =>
   typeof c === "string" ? c : Array.isArray(c) ? c.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("") : ""
 
+// Chat clients replay thinking beside content. Cursor's transcript blobs
+// use AI SDK reasoning parts; putting it in text would change its role.
+const reasoningOf = (m) => [m.reasoning_content, m.reasoning].find((s) => typeof s === "string" && s.trim()) ?? ""
+
 // joinSplitCalls joins an assistant message onto the assistant message
 // before it when that one made tool calls: Anthropic takes consecutive
 // assistant messages as one turn, and an agent can send a turn's parallel
@@ -1093,7 +1097,8 @@ function joinSplitCalls(msgs) {
     const prev = out.at(-1)
     if (m?.role === "assistant" && prev?.role === "assistant" && prev.tool_calls?.length) {
       const content = [textOf(prev.content), textOf(m.content)].filter(Boolean).join("\n\n")
-      out[out.length - 1] = { ...prev, content, tool_calls: [...prev.tool_calls, ...(m.tool_calls ?? [])] }
+      const reasoning_content = [reasoningOf(prev), reasoningOf(m)].filter(Boolean).join("\n\n")
+      out[out.length - 1] = { ...prev, content, reasoning_content, tool_calls: [...prev.tool_calls, ...(m.tool_calls ?? [])] }
       continue
     }
     out.push(m)
@@ -1198,9 +1203,11 @@ function conversation(chat, tools) {
     if (m.role === "assistant") {
       answer()
       const content = []
+      const reasoning = reasoningOf(m)
+      if (reasoning) content.push({ type: "reasoning", text: reasoning })
       const text = textOf(m.content)
       if (text) content.push({ type: "text", text })
-      size += text.length
+      size += reasoning.length + text.length
       for (const c of m.tool_calls ?? []) {
         if (c?.type && c.type !== "function") continue
         const args = parseArgs(c.function?.arguments)
@@ -1889,6 +1896,12 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
   let said = 0
   // wrote: the reply's text alone; a turn of thinking only says nothing
   let wrote = 0
+  // what the Run sent, for an empty reply to name (#60): the thinking's
+  // length, Cursor's own tools it asked for and was refused, and updates
+  // and messages this doesn't read
+  const seen = { thinking: 0, refused: new Map(), updates: new Map(), messages: new Map() }
+  const count = (m, k) => m.set(k, (m.get(k) ?? 0) + 1)
+  const empty = (how) => ({ error: { status: 502, message: "an empty reply" + emptyWhy(how, seen, ended ? usage : null) } })
   let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 }
   // counted: the step's usage is the dashboard's events, its own counted
   // with it or by a later step (ledger), never guessed
@@ -1934,7 +1947,7 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
       if (f.end) {
         const e = failure(200, f.data)
         if (e.status < 200 || e.status > 299) yield { error: e }
-        else if (wrote === 0 && calls === 0) yield { error: { status: 502, message: "an empty reply" } }
+        else if (wrote === 0 && calls === 0) yield empty(endFrame(f.data))
         else yield await settled()
         return
       }
@@ -1959,6 +1972,7 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
                   const t = pbStr(uf, 1)
                   if (t) {
                     said += t.length
+                    seen.thinking += t.length
                     yield { reasoning: t }
                   }
                   break
@@ -1969,7 +1983,7 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
                   if (calls === 0) {
                     // nothing written and nothing called: an empty reply,
                     // which the client asks again, not a finished turn
-                    yield wrote === 0 ? { error: { status: 502, message: "an empty reply" } } : await settled()
+                    yield wrote === 0 ? empty("Cursor ended the turn") : await settled()
                     return
                   }
                   break
@@ -1980,12 +1994,14 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
                     return
                   }
                   break
+                default:
+                  count(seen.updates, u.num)
               }
             }
             break
           case 2: {
             // exec_server_message: the server asks the client to run something
-            const call = exec(m.data, tools, send, closeExec)
+            const call = exec(m.data, tools, send, closeExec, seen.refused)
             if (call) {
               said += call.args.length
               yield { tool: { index: calls++, ...call } }
@@ -2014,6 +2030,8 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
             }
             break
           }
+          default:
+            count(seen.messages, m.num)
         }
       }
     }
@@ -2031,10 +2049,33 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
   }
 }
 
+// endFrame is how a Run's Connect end frame that said no error reads in
+// an empty reply's words: its JSON, cut short, or that it was empty.
+function endFrame(data) {
+  const t = Buffer.from(data ?? []).toString("utf8").trim()
+  if (!t || t === "{}") return "the Run's stream ended (an empty end frame)"
+  return `the Run's stream ended (end frame: ${t.length > 300 ? t.slice(0, 300) + "…" : t})`
+}
+
+// emptyWhy is what an empty reply says of what came before it (#60): how
+// it ended, the thinking, the turn's own count of output, Cursor's own
+// tools refused, and what Cursor sent that isn't read. Field numbers are
+// agent.v1's, so a report names the message that wasn't understood.
+function emptyWhy(how, seen, usage) {
+  const list = (m) => [...m].map(([k, n]) => (n > 1 ? `#${k} ×${n}` : `#${k}`)).join(", ")
+  const parts = [how]
+  parts.push(seen.thinking ? `after ${seen.thinking} chars of thinking, no text and no tool call` : "with no thinking, no text and no tool call")
+  if (usage) parts.push(`Cursor counted ${usage.output} output tokens`)
+  if (seen.refused.size) parts.push(`Cursor's own tools asked for and refused: ${list(seen.refused)}`)
+  if (seen.updates.size) parts.push(`updates not read: ${list(seen.updates)}`)
+  if (seen.messages.size) parts.push(`messages not read: ${list(seen.messages)}`)
+  return ` (${parts.join("; ")}; try again)`
+}
+
 // exec answers what the server asks the client to run: a call of the
 // caller's tools is returned, the list of them is given, and anything else
 // is refused.
-function exec(msg, tools, send, closeExec) {
+function exec(msg, tools, send, closeExec, refused) {
   const es = fields(msg)
   const id = pbNum(es, 1)
   const execID = pbStr(es, 15)
@@ -2073,6 +2114,8 @@ function exec(msg, tools, send, closeExec) {
     }
   }
   // a shell, a file read or an edit of Cursor's own: never run
+  const kind = es.find((e) => e.num !== 1 && e.num !== 15)?.num ?? 0
+  refused?.set(kind, (refused.get(kind) ?? 0) + 1)
   send(pb().bytes(5, pb().bytes(2, pb().varint(1, id).str(2, "not available"))).done())
   closeExec(id)
   return null

package/package.json

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