@magpie-community/opencode-trae-auth 0.2.17 → 0.2.19

package/README.md

@@ -122,11 +122,28 @@ agent's `POST https://trae-api-cn.mchost.guru/api/agent/v3/llm_utils_chat`:
   that fails (an `error` event, or Trae's stream breaking off) ends with the
   error and `[DONE]`, with no finish.
 - **Tools:**
-  - Trae's chat has no turn for a tool call or its result, so the tools are
-    named twice:
-    - natively in `tools`, with `parameters` as a JSON string;
-    - in a system prompt that asks for each call as a
-      `<tool_call>{"name", "arguments"}</tool_call>` block.
+  - The tools go natively in `tools`, with `parameters` as a JSON string.
+    A past call goes back as the turn Trae made it: an assistant
+    `tool_calls` message carrying it (each call
+    `{id, type: "function", function_call: {name, arguments}}`) and a
+    `tool` message after it answering it. Trae answers such a history with
+    native calls; asked for its calls in text instead — a system prompt
+    describing a `<tool_call>` block, earlier calls written out as one —
+    models write them as blocks, and a block the stream cuts short is an
+    error (plugins#38). Trae takes no two messages of one role in a row,
+    so an assistant turn's text is folded into the calls turn after it
+    and consecutive calls turns join one `tool_calls` list.
+  - A call with no name is dropped, and the `tool` result answering it
+    with it: Trae requires the name, and an empty `tool_calls` list with a
+    result naming no call is not a turn it takes.
+  - A result with no text goes as `(no output)` (`(the result's image
+    follows)` when it had only an image): Trae refuses the whole request
+    with 4027 when a result's text is empty, reading the calls turn as
+    unanswered (measured on Trae CN in #251). A result answering no call
+    the history sends goes back as text in a `user` turn.
+  - A request that names no tools to Trae (none sent, or `tool_choice:
+    "none"`, such as a summary) sends its past calls and results as text,
+    as before: every live run of the native turns carried the tools.
   - GLM also writes its own template, `<tool_call>name<arg_key>k</arg_key>
     <arg_value>v</arg_value></tool_call>` (a string kept as written, other
     types read as JSON), and sometimes a whole call into a native call's
@@ -148,11 +165,21 @@ agent's `POST https://trae-api-cn.mchost.guru/api/agent/v3/llm_utils_chat`:
     or is cut short, is never sent on as the answer: the reply ends with an
     error (a 502 without a stream), so the gateway can try again
     (plugins#38). A `<tool_call>` in backticks or a code fence is text.
+  - Kimi and MiMo sometimes write a call in the tags they were trained on:
+    Qwen's `<function=name><parameter=k>v</parameter></function>` (bare or
+    inside `<tool_call>`), or Anthropic's `<function_calls>` around one or
+    more `<invoke name="…"><parameter name="k">v</parameter></invoke>`.
+    Each is read as a call, a parameter's value as JSON unless the tool's
+    schema says string, and one cut short is an error as above. These
+    tags are read only for a tool the request declared; for any other, or
+    in backticks or a code fence, they stay text.
   - Calls from either source become OpenAI `tool_calls`. A name matching a
     requested tool but for case or punctuation (`Read`) goes on as the
     request's (`read`); any other goes on as written, so the agent can say
     the tool doesn't exist.
-  - Earlier calls and their results go back in as text.
+  - Trae requires the message answering a call to follow the call: the
+    results of parallel calls go out as consecutive `tool` messages, with
+    nothing between them, or the later ones lose their answer (11148).
   - Images: Trae's lists mark each model `multimodal` true or false (the
     Doubao-Seed models, Kimi K3 and K2.6, Qwen 3.7 Plus and MiniMax M3 take
     images; GLM-5 and DeepSeek V4 don't). A model marked true is listed
@@ -162,6 +189,13 @@ agent's `POST https://trae-api-cn.mchost.guru/api/agent/v3/llm_utils_chat`:
     "[an image, which this model can't see]" in its place. A model whose
     list hasn't been read is sent its images, unless the fallback list
     says it takes none.
+    A tool result's images go in a `user` message after the whole run of
+    results, not in the `tool` turn: measured on the live endpoint, an
+    `image_url` part in a `tool` turn reaches Kimi K2.6 but not
+    Doubao-Seed (it answered "Blue"/"Black" to a red image), while the
+    user-turn placement is read by both. The results of one turn stay
+    consecutive — nothing may go between them (11148) — so the images
+    wait for the last of them.
 
 The model list is the account's own, from
 `/api/ide/v1/batch_get_detail_param`, every function's list in one ask, as
@@ -283,9 +317,11 @@ Trae CN gives credits for a daily check-in (每日签到); Trae Global has no
 such page, so this is CN only. magpie can press it
 once a day for each account (Settings, or the switch on the usage card),
 through `auth.checkin`: `claimed` when Trae grants the credits, `done`
-when the status or Trae's 9095 says this device has already claimed,
-`inactive` when the page is disabled, and `failed` for a turned-away
-sign-in or Trae's 9074 busy answer.
+when the status says today's is in already, `inactive` when the page is
+disabled, `ineligible` when the claim answers 9095 (this device has
+checked in today) or 9074 (to be done in Trae CN's own app; not asked
+again that day), and `failed` for a turned-away sign-in or any other
+answer, which is tried again later that day.
 It asks Trae CN's own pages through
 this plugin's fetch, which sends them as the account, as Trae CN's IDE
 (3.3.104) sends them: its Cloud-IDE-JWT (renewed first when near its
@@ -333,7 +369,9 @@ answered it 9074 even with the client's headers.
   in today, and that holds for the day. No device id is ever changed or
   rotated to get round a 9095 or a 9074, and no account is given another
   account's device or its own client's device unless the client is signed
-  in as that account.
+  in as that account. The credit a claim granted is its `credits` plus
+  its `extra_credits`, either alone; the status answer's is the fallback
+  when the claim says none.
 
 Only `api.trae.cn`'s `/trae/api/` pages are sent this way; any other URL
 that isn't a chat request is still refused (400). Needs 0.1.4 or later.

package/index.mjs

@@ -821,7 +821,16 @@ function clientStoragePaths(platform, home, env) {
   const file = (root, name) => join(root, name, "User", "globalStorage", "storage.json")
   if (platform === "darwin") return [file(join(home, "Library", "Application Support"), "Trae CN")]
   if (platform === "win32") {
-    const roots = [env.APPDATA, join(home, "AppData", "Roaming")].filter((r, i, all) => r && all.indexOf(r) === i)
+    // the two roots are often the same folder: APPDATA and the home's own
+    // AppData\Roaming. They are compared as one system spells them, so a
+    // difference of separator or case alone doesn't read the same file twice
+    const spell = (r) => String(r ?? "").replace(/[\\/]+/g, "\\").replace(/\\+$/, "").toLowerCase()
+    const roots = []
+    for (const r of [env.APPDATA, join(home, "AppData", "Roaming")]) {
+      if (!r) continue
+      if (roots.some((was) => spell(was) === spell(r))) continue
+      roots.push(r)
+    }
     return roots.flatMap((r) => ["Trae CN", "trae-cn"].map((n) => file(r, n)))
   }
   if (platform === "linux") return ["trae-cn", "Trae CN"].map((n) => file(env.XDG_CONFIG_HOME || join(home, ".config"), n))
@@ -914,29 +923,13 @@ const ugPage = (url) => {
   }
 }
 
-// Trae's chat takes text only and has no turn for a tool call or its
-// result. The agent's tools are named to it natively and in a system
-// prompt that asks for each call as a tagged block; earlier calls and
-// their results go in as text. A native call in its answer is taken too.
+// A model that writes a tool call as text still writes it, mostly GLM and
+// DeepSeek: the blocks are read as the calls they mean (the tools also go
+// natively in the body, and a past call is a native turn, so an answer is
+// usually native; the text form is read for when it is not).
 const OPEN = "<tool_call>"
 const CLOSE = "</tool_call>"
 
-function toolPrompt(tools, choice, parallel) {
-  const defs = tools.map((t) => {
-    const f = t.function ?? t
-    return { name: f.name, description: f.description ?? "", parameters: f.parameters ?? {} }
-  })
-  const lines = [
-    "You can call the client's tools, listed below as JSON. They run on the user's machine, not on yours: use no built-in or server tool to reach the user's files.",
-    `To call a tool, write one block per call and nothing after it: ${OPEN}{"name":"tool_name","arguments":{...}}${CLOSE}. Use an exact tool name and fill arguments from its schema. Then stop and wait: the result comes back in the next message.`,
-    "A call is not done until its result comes back; don't say it is, and don't repeat a call whose result you have.",
-  ]
-  if (parallel === false) lines.push("Call at most one tool at a time.")
-  if (choice === "required") lines.push("Call a tool before answering.")
-  else if (choice && typeof choice === "object" && (choice.function?.name || choice.name)) lines.push(`Call the tool ${choice.function?.name || choice.name} before answering.`)
-  lines.push("Tools:", JSON.stringify(defs))
-  return lines.join("\n")
-}
 
 const partText = (content) => {
   if (typeof content === "string") return content
@@ -970,43 +963,137 @@ const partsOf = (content, sees) => {
 // the model takes images: Trae's list says so of each model (multimodal),
 // and a model it says doesn't is sent the placeholder, not the image.
 function traeMessages(req, sees = false) {
-  const tools = Array.isArray(req.tools) && req.tools.length && req.tool_choice !== "none" ? req.tools : []
+  // native is whether the body names the tools to Trae (chatBody's own
+  // test). Past calls go back as Trae's own turns only then: every live
+  // run of that shape carried the tools, and a request without them (a
+  // summary, tool_choice "none") keeps the text form it always had
+  const native = Array.isArray(req.tools) && req.tools.length > 0 && req.tool_choice !== "none"
   const names = new Map()
   const out = []
-  if (tools.length) out.push({ role: "system", text: toolPrompt(tools, req.tool_choice, req.parallel_tool_calls) })
+  // dropped is every call id a turn carried but Trae cannot be sent: an
+  // assistant turn whose calls all lost their name takes its results with it
+  const dropped = new Set()
+  // images of tool results, held until the run of results ends: Trae
+  // takes no message between a call's results, so they cannot go after
+  // each one — one user message once they are all in
+  const pending = []
+  const flushImages = () => {
+    if (pending.length) out.push({ role: "user", images: pending.splice(0) })
+  }
   for (const m of req.messages ?? []) {
     const role = m.role === "developer" ? "system" : m.role
     let { text, images } = partsOf(m.content, sees)
-    if (role === "assistant") {
-      const calls = (m.tool_calls ?? []).map((c) => {
-        names.set(c.id, c.function?.name)
+    if (!native && role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length) {
+      const calls = m.tool_calls.map((c) => {
+        names.set(String(c.id ?? ""), c.function?.name)
         let args = c.function?.arguments ?? "{}"
         try {
           args = JSON.parse(args)
         } catch {}
         return OPEN + JSON.stringify({ name: c.function?.name, arguments: args }) + CLOSE
       })
-      text = [text, ...calls].filter(Boolean).join("\n")
-      out.push({ role: "assistant", text })
+      out.push({ role: "assistant", text: [text, ...calls].filter(Boolean).join("\n") })
+      continue
+    }
+    if (role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length) {
+      // a past call goes back as the turn Trae made it: an assistant
+      // tool_calls message, its result in the tool message after it. Trae
+      // answers such a history with native calls; written out as a
+      // <tool_call> block in the text it answers in blocks too, and a block
+      // the stream cuts short ends the turn as an error (plugins#38).
+      const calls = []
+      for (const c of m.tool_calls) {
+        const name = String(c.function?.name ?? c.name ?? "").trim()
+        // a call Trae cannot be sent is dropped here; its result goes too
+        // (an empty tool_calls list and a result naming no call are not a
+        // turn Trae takes)
+        if (!name) {
+          if (c.id != null) dropped.add(String(c.id))
+          continue
+        }
+        names.set(String(c.id ?? ""), name)
+        let args = c.function?.arguments ?? c.arguments ?? "{}"
+        if (typeof args !== "string") {
+          try {
+            args = JSON.stringify(args)
+          } catch {
+            args = "{}"
+          }
+        }
+        calls.push({ id: String(c.id ?? "call_" + (names.size + 1)), type: "function", function_call: { name, arguments: args } })
+      }
+      if (calls.length) out.push({ role: "assistant", text, images, calls })
+      else if (text || images.length) out.push({ role: "assistant", text, images })
+      continue
+    }
+    if (role === "assistant") {
+      flushImages()
+      out.push({ role: "assistant", text, images })
     } else if (role === "tool") {
-      out.push({ role: "user", text: `Result of ${names.get(m.tool_call_id) || m.name || "the tool"} (call ${m.tool_call_id ?? "?"}):\n${text}`, images })
+      const id = String(m.tool_call_id ?? "")
+      if (dropped.has(id)) continue
+      // a result answering no call this history sends (the text form, or
+      // a call cut away before it) is no turn Trae takes: it goes as text
+      if (!native || !names.has(id)) {
+        flushImages()
+        out.push({ role: "user", text: `Result of ${names.get(id) || m.name || "the tool"} (call ${m.tool_call_id ?? "?"}):\n${text}`, images })
+        continue
+      }
+      // Trae's own result turn: the call it answers, its text as parts
+      // (an empty one for a result with no text). Its images wait: a
+      // tool turn's image_url reaches some models (Kimi) and not others
+      // (Doubao-Seed), so they go in a user message after the whole run
+      // of results, which every multimodal model reads
+      if (images.length) pending.push(...images)
+      // Trae refuses a result with no text (4027: the calls turn reads as
+      // unanswered), so one that printed nothing says so (plugins#251)
+      out.push({ role: "tool", tool_call_id: id, text: text || (images.length ? "(the result's image follows)" : "(no output)") })
     } else {
+      flushImages()
       out.push({ role: role === "system" ? "system" : "user", text, images })
     }
   }
-  // Trae takes no empty message, nor two of one role in a row; a message of
-  // an image alone is not empty
+  flushImages()
+  // Trae takes no two messages of one role in a row, so an assistant turn is
+  // folded into the turn after it: text into the calls turn it introduces
+  // (agents send "let me read" and then the call, and parallel calls split
+  // over two assistant turns), calls joined into one list. A message of an
+  // image alone is not empty; tool results are turns of their own, each
+  // answering its own call.
   const merged = []
   for (const m of out) {
     const images = m.images ?? []
+    if (m.role === "tool") {
+      merged.push(m)
+      continue
+    }
+    if (m.role === "assistant") {
+      const last = merged.at(-1)
+      if (last && last.role === "assistant") {
+        // fold: text and images join, calls append to the same list
+        last.text = [last.text, m.text].filter(Boolean).join("\n\n")
+        last.images = [...(last.images ?? []), ...images]
+        if (m.calls) last.calls = [...(last.calls ?? []), ...m.calls]
+        if (!last.text && !last.images.length && !last.calls) merged.pop()
+        continue
+      }
+      if (!m.text && !images.length && !m.calls) continue
+      merged.push({ role: "assistant", text: m.text, images, ...(m.calls ? { calls: m.calls } : {}) })
+      continue
+    }
     if (!m.text && !images.length) continue
     const last = merged.at(-1)
     if (last && last.role === m.role && m.role !== "system") {
       last.text = [last.text, m.text].filter(Boolean).join("\n\n")
-      last.images = [...last.images, ...images]
+      last.images = [...(last.images ?? []), ...images]
     } else merged.push({ role: m.role, text: m.text, images })
   }
-  return merged.map((m) => ({ role: m.role, content: [...(m.text ? [{ type: "text", text: m.text }] : []), ...m.images] }))
+  return merged.map((m) => {
+    const content = [...(m.text ? [{ type: "text", text: m.text }] : []), ...(m.images ?? [])]
+    if (m.calls) return { role: "assistant", content: content.length ? content : null, tool_calls: m.calls }
+    if (m.role === "tool") return { role: "tool", tool_call_id: m.tool_call_id, content } // results of one turn stay consecutive: nothing may go between them (11148)
+    return { role: m.role, content }
+  })
 }
 
 // nativeTools are the tools as Trae names them: parameters a JSON string
@@ -1245,7 +1332,8 @@ class TextTools {
       const r = this.buf.search(REASON_AT)
       const sm = this.buf.match(STRAY_AT)
       const s = sm ? sm.index : -1
-      if (s >= 0 && [i, d, r].every((x) => x < 0 || s < x)) {
+      const x = this.buf.search(XML_AT)
+      if (s >= 0 && [i, d, r, x].every((y) => y < 0 || s < y)) {
         // a close with no call open, with what GLM left before it
         // (}}</tool_call>, magpie#1945): not the answer, dropped; in code,
         // shown
@@ -1264,7 +1352,7 @@ class TextTools {
         this.after = true
         continue
       }
-      if (r >= 0 && (i < 0 || r < i) && (d < 0 || r < d)) {
+      if (r >= 0 && (i < 0 || r < i) && (d < 0 || r < d) && (x < 0 || r < x)) {
         const o = objectEnd(this.buf, r)
         if (o === -1 && !end) {
           // not whole yet: held, the text before it sent
@@ -1284,7 +1372,39 @@ class TextTools {
         this.buf = this.buf.slice(r + 1)
         continue
       }
-      if (i < 0 && d < 0) break
+      if (i < 0 && d < 0 && x < 0) break
+      if (x >= 0 && (i < 0 || x < i) && (d < 0 || x < d)) {
+        // Anthropic's <function_calls><invoke name="…"> or Qwen's
+        // <function=…>, as Kimi and MiMo write a call (01huadalang on
+        // magpie's Discord, dsh): a call only for a tool the request
+        // declared, and never in a code fence or backticks
+        const head = this.buf.slice(0, x)
+        const at = this.buf.slice(x)
+        const opener = at.match(/^<[^<>]*>?/)[0]
+        if (quoted(this.sent + text + head)) {
+          text += head + opener
+          this.buf = at.slice(opener.length)
+          continue
+        }
+        const b = this.xmlCall(at, end)
+        if (b.wait) break
+        if (b.text) {
+          text += head + opener
+          this.buf = at.slice(opener.length)
+          continue
+        }
+        text += head
+        if (b.error) {
+          this.buf = ""
+          this.sent += text
+          return { text, calls, reasoning, error: b.error }
+        }
+        calls.push(b.call)
+        this.mark = this.sent.length + text.length
+        this.buf = b.rest
+        this.after = true
+        continue
+      }
       if (d >= 0 && (i < 0 || d < i)) {
         text += this.buf.slice(0, d)
         this.buf = this.buf.slice(d)
@@ -1375,7 +1495,7 @@ class TextTools {
       this.buf = ""
     } else {
       // keep back an opened block, or what may be the start of one
-      const at = [this.buf.search(OPEN_AT), this.buf.search(OPEN_HOLD), this.buf.search(DSML_AT), this.buf.search(REASON_AT)].filter((x) => x >= 0)
+      const at = [this.buf.search(OPEN_AT), this.buf.search(OPEN_HOLD), this.buf.search(DSML_AT), this.buf.search(REASON_AT), this.buf.search(XML_AT), this.buf.search(XML_HOLD)].filter((x) => x >= 0)
       let keep = at.length ? this.buf.length - Math.min(...at) : 0
       if (!keep) for (let k = Math.min(MARK_MAX - 1, this.buf.length); k > 0; k--) if (MARKS.some((m) => m.startsWith(this.buf.slice(-k)))) { keep = k; break }
       // and braces, brackets, quotes or a > a close may still come after
@@ -1388,6 +1508,60 @@ class TextTools {
     return { text, calls, reasoning }
   }
 
+  // xmlCall reads a call written in Anthropic's tags (<function_calls>
+  // around one or more <invoke name="…"><parameter name="k">v</parameter>
+  // </invoke>) or Qwen's (<function=…><parameter=k>v</parameter>
+  // </function>), s starting at its first tag: {call, rest}, {wait}
+  // while it may still become one, {text} when it is no call (a tool the
+  // request didn't declare, a tag named in prose), {error} for one cut
+  // short. Each invoke is a call of its own; the tags between them are
+  // dropped as the leftovers of one.
+  xmlCall(s, end) {
+    const w = s.match(/^<(?:antml:)?function_calls>/)
+    if (w) {
+      const rest = s.slice(w[0].length).replace(/^\s+/, "")
+      if (!end && (!rest || XML_STARTS.some((k) => k.startsWith(rest)))) return { wait: true }
+      return this.xmlInvoke(rest, end)
+    }
+    return this.xmlInvoke(s, end)
+  }
+
+  xmlInvoke(s, end) {
+    let m = s.match(/^<(?:antml:)?invoke\s+name\s*=\s*"([^"<>]+)"\s*>/)
+    let closeRe = /<\/(?:antml:)?invoke\s*>/
+    if (!m) {
+      m = s.match(/^<function=([^\s<>]+?)\s*>/)
+      closeRe = /<\/function\s*>/
+    }
+    if (!m) {
+      // an opener still being written
+      if (!end && (XML_STARTS.some((k) => k.startsWith(s)) || /^<(?:antml:)?(?:invoke\s|function=)[^<>]{0,300}$/.test(s))) return { wait: true }
+      return { text: true }
+    }
+    const declared = this.tools.map((t) => (t.function ?? t)?.name).filter(Boolean)
+    const name = toolNamed(m[1].trim(), this.tools)
+    if (!declared.includes(name)) return { text: true }
+    const body = s.slice(m[0].length)
+    const c = body.match(closeRe)
+    const n = body.search(XML_NEXT)
+    let stop = c ? c.index : -1
+    if (n >= 0 && (stop < 0 || n < stop)) stop = n
+    if (stop < 0) {
+      if (!end) return { wait: true }
+      stop = body.length
+    }
+    const whole = !!c && c.index === stop
+    const region = body.slice(0, stop).replace(/<(\/?)antml:parameter\b/g, "<$1parameter")
+    const p = paramArgs(region, name, this.tools)
+    if (!whole && !p.closed) {
+      // no parameter and no close: a tag named in passing; a parameter
+      // left open: the call cut short (plugins#38)
+      if (!/<parameter\b/.test(region)) return { text: true }
+      return { error: CUT_SHORT }
+    }
+    return { call: { name, arguments: JSON.stringify(p.args) }, rest: whole ? body.slice(stop + c[0].length) : body.slice(stop) }
+  }
+
   // block reads what follows a <tool_call> opener: {call, rest} for a
   // call, {wait} while it may still become one, {text} when it is no call
   // at all, {error} for one that can't be read: cut short, or not JSON
@@ -1873,11 +2047,18 @@ const DSML_INVOKE = new RegExp(String.raw`^<\s*[|｜][\s|｜]*DSML[\s|｜]*invok
 const DSML_INVOKE_AT = new RegExp(String.raw`<\s*[|｜][\s|｜]*DSML[\s|｜]*invoke\s+name\s*=`)
 const DSML_CLOSE = new RegExp(String.raw`<\s*\/\s*[|｜][\s|｜]*DSML[\s|｜]*invoke\s*>`)
 const DSML_PARAM = new RegExp(String.raw`<\s*[|｜][\s|｜]*DSML[\s|｜]*parameter\s+name\s*=\s*"([^"]+)"((?:\s+\w+\s*=\s*"[^"]*")*)\s*>([\s\S]*?)` + DSML + String.raw`parameter\s*>`, "g")
+// Anthropic's and Qwen's call tags (xmlCall): where one starts, an
+// opener still being written, the openers a wrapper is followed by, and
+// the next call's opener
+const XML_AT = /<(?:antml:)?(?:function_calls>|invoke\s+name\s*=|function=)/
+const XML_HOLD = /<(?:antml:)?(?:invoke\s[^<>]{0,300}|function=[^<>]{0,300})$/
+const XML_STARTS = ["<invoke ", "<antml:invoke ", "<function="]
+const XML_NEXT = /<(?:antml:)?invoke\s+name\s*=|<function=/
 // what is left after a call: blanks, our close, DeepSeek's tags but the
-// next call's
-const LEFTOVER = new RegExp(String.raw`^(?:\s+|<\/tool_?calls?>|<tool_?calls>|` + DSML + String.raw`(?![\s|｜]*invoke\b)[^<>]*>)+`)
+// next call's, the closes of Anthropic's and Qwen's
+const LEFTOVER = new RegExp(String.raw`^(?:\s+|<\/tool_?calls?>|<tool_?calls>|<\/(?:antml:)?(?:function_calls|invoke|function)>|` + DSML + String.raw`(?![\s|｜]*invoke\b)[^<>]*>)+`)
 // what text may be the start of, so held back
-const MARKS = [OPEN, CLOSE, "<toolcall>", "</toolcall>", "<｜DSML｜", "<|DSML|", "</｜DSML｜", "</|DSML|", '{"reasoning_content"']
+const MARKS = [OPEN, CLOSE, "<toolcall>", "</toolcall>", "<｜DSML｜", "<|DSML|", "</｜DSML｜", "</|DSML|", '{"reasoning_content"', "<function_calls>", "</function_calls>", "<antml:function_calls>", "</antml:function_calls>", "<invoke ", "<antml:invoke ", "</invoke>", "</antml:invoke>", "<function=", "</function>"]
 // reasoning a model wrote into its text as JSON
 const REASON_AT = /\{\s*"reasoning_content"\s*:/
 const MARK_MAX = Math.max(...MARKS.map((m) => m.length))
@@ -2008,7 +2189,13 @@ class NativeCalls {
       this.calls.push({ ...c })
       return
     }
+    // a name comes as the arguments do: a snapshot that grows. A name that
+    // starts with what was read is that snapshot further along, and takes
+    // its place — a wrapper cut short at a tag, then the whole call again.
+    // A name that doesn't start with it is a piece of the name's own, or
+    // one no snapshot explains, and the first is kept as it was
     if (!o.name) o.name = c.name
+    else if (c.name && c.name.startsWith(o.name) && c.name !== o.name) o.name = c.name
     if (c.index !== null && o.index === null) o.index = c.index
     const prev = o.arguments
     const next = c.arguments
@@ -2135,7 +2322,9 @@ async function* parts(events, tools = []) {
     if (data === "[DONE]") break
     if (name === "error" || (name !== "output" && d.code && d.message && !d.response && !d.content)) {
       const e = errorOf(d)
-      yield { error: e.message || "Trae CN returned an error", code: e.code }
+      // the realm answering is named by the caller, which knows it; a bare
+      // word here reads as neither realm's
+      yield { error: e.message || "Trae returned an error", code: e.code }
       return
     }
     if (name === "token_usage") {
@@ -2151,9 +2340,12 @@ async function* parts(events, tools = []) {
     }
     if (!ANSWER.has(name)) continue
     const delta = d.delta && typeof d.delta === "object" ? d.delta : {}
-    const reasoning = d.reasoning_content ?? d.reasoning ?? delta.reasoning_content ?? ""
-    if (typeof reasoning === "string" && reasoning) {
-      const r = th.add(reasoning)
+    // the reasoning's own fields, in the order Trae has put it under: an
+    // empty one is no answer, so the next is asked (an event carrying both
+    // reasoning_content: "" and reasoning: "…" says the thought in the second)
+    const said = [d.reasoning_content, d.reasoning, delta.reasoning_content, delta.reasoning].find((v) => typeof v === "string" && v) ?? ""
+    if (said) {
+      const r = th.add(said)
       if (r) yield { reasoning: r }
     }
     let text = typeof d.response === "string" ? d.response : typeof d.content === "string" ? d.content : typeof delta.content === "string" ? delta.content : typeof d.delta === "string" ? d.delta : ""
@@ -2255,8 +2447,9 @@ async function openai(req, it, abort, site) {
   // a reply that failed (an error event, or Trae's stream breaking off)
   // ends with the error and [DONE], not a finish that says it stopped; the
   // stream is closed whatever happens, and an agent that goes away stops
-  // the reading of Trae's
-  const error = (message, code = null) => enc.encode(`data: ${JSON.stringify({ error: { message: `Trae CN: ${message}`, type: "api_error", code } })}\n\n`)
+  // the reading of Trae's. The realm answering names itself, so a Global
+  // account's failure reads as Trae Global's
+  const error = (message, code = null) => enc.encode(`data: ${JSON.stringify({ error: { message: `${site.realm}: ${message}`, type: "api_error", code } })}\n\n`)
   let gone = false
   const stream = new ReadableStream({
     async start(ctl) {
@@ -2562,8 +2755,12 @@ const makePlugin = (site) => async ({ client }) => {
     if (String(ce.code) === "9074") return { outcome: "ineligible", message: `${ce.message} — check in in the Trae CN app` }
     if (claim.status !== 200 || (ce.code && String(ce.code) !== "0")) return { outcome: "failed", message: ce.message || statusLine(claim.status) }
     if (!answer || typeof answer !== "object" || Array.isArray(answer)) return { outcome: "failed", message: `check-in claim: unreadable reply ${claimText.trim().slice(0, 120) || "(empty)"}` }
-    const credit = Number(answer.credits) + Number(answer.extra_credits || 0)
-    const fallback = Number(body.credits) + Number(body.extra_credits || 0)
+    // a claim may answer extra_credits with no credits beside it, and either
+    // may be absent: Number(undefined) is NaN, and NaN + n is NaN, which
+    // reads as no credit at all
+    const n = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0)
+    const credit = n(answer.credits) + n(answer.extra_credits)
+    const fallback = n(body.credits) + n(body.extra_credits)
     return { outcome: "claimed", ...(credit > 0 ? { credit } : fallback > 0 ? { credit: fallback } : {}) }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-trae-auth",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "OpenCode provider plugins for Trae: Trae CN (trae.cn) and Trae Global (trae.ai), free tier included, with Trae's own browser sign-in",
   "type": "module",
   "main": "./index.mjs",