@magpie-community/opencode-trae-auth 0.2.4 → 0.2.6

package/README.md

@@ -69,6 +69,18 @@ agent's `POST https://trae-api-cn.mchost.guru/api/agent/v3/llm_utils_chat`:
     `solo_work_lite`, SOLO's Work mode; `solo_agent`, the TRAE agent's;
     `solo_agent_lite`). If Trae answers 4001, 4023 or 1005, the plugin tries
     the others once and remembers which one worked.
+  - `session_id` is the conversation's, as the IDE keeps one per conversation:
+    the session magpie (or OpenCode) names the request by, else the chat's
+    first user message, which every later turn repeats, together with the
+    account the request is made as. Trae counts a conversation by it, so a
+    fresh one per request made one user send that takes several steps (a tool
+    result sent back, a retry, another function answering) count as a
+    conversation of its own — several rows in the usage detail, each under no
+    title. One conversation answered by two accounts (magpie failing over, or
+    rotating, inside it) is named twice then, as two conversations, so Trae
+    never reads one account's conversation as another's; that costs the two
+    halves of such a conversation their single row. `request_id` is the
+    request's own, fresh on every one.
 - **Headers:** TRAE SOLO CN 0.1.69's (`x-ide-version`/`x-app-version`
   0.1.69, version code 20260917; Trae offers a model only to clients new
   enough for it): `Authorization: Cloud-IDE-JWT …`, `X-Cloudide-Token`,
@@ -96,6 +108,14 @@ agent's `POST https://trae-api-cn.mchost.guru/api/agent/v3/llm_utils_chat`:
     <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
     name; both are read as the call.
+  - A block is read as models get it wrong too: every quote escaped
+    (`{\"name\":…}`), quotes or backslashes in a string left unescaped, an
+    opener with the name as an attribute (`<tool_call name="bash">` with
+    `<parameter name="k">v</parameter>`), or JSON that is whole when the
+    stream ends without `</tool_call>`. A block that still can't be read,
+    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.
   - 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

package/index.mjs

@@ -9,7 +9,7 @@
 // The account's fetch also sends Trae CN's own pages on api.trae.cn
 // (/trae/api/…) as the account, for magpie's daily check-in (每日签到:
 // /trae/api/v2/ug/checkin_credits/status, then /claim).
-import { generateKeyPairSync, randomBytes, randomUUID, randomInt, sign } from "node:crypto"
+import { createHash, generateKeyPairSync, randomBytes, randomUUID, randomInt, sign } from "node:crypto"
 import { createServer, STATUS_CODES } from "node:http"
 
 const SITES = {
@@ -767,14 +767,72 @@ const nativeTools = (tools) =>
     return { type: "function", function: { name: f.name, description: f.description ?? "", parameters: typeof f.parameters === "string" ? f.parameters : JSON.stringify(f.parameters ?? {}) } }
   })
 
+// SESSION carries the conversation magpie (or OpenCode) names a request by,
+// from the chat.headers hook to the loader's fetch. It goes no further.
+const SESSION = "x-magpie-trae-session"
+
+// SALT is what the id is derived with, so it says nothing of the words it was
+// made from. New in each process, as Trae's own session ids are one session's
+// own within a run.
+const SALT = randomBytes(16).toString("hex")
+
+// conversationID is the conversation a chat belongs to, as the UUID the
+// request's session_id wants: the session magpie or OpenCode names (its
+// chat.headers hook), else the chat's first user message, which every later
+// turn of the conversation repeats. "" when neither names one — a body that
+// isn't a chat, or one with no user message in it — and the caller then makes
+// a fresh id per request, as before: a made-up conversation of the request's
+// own is the very splitting this is here to end.
+//
+// who is the account the request is made as (its uid, else its name), and it
+// is part of what the id is made of, so one conversation answered by two
+// accounts (magpie failing over, or rotating, inside it) is two conversations
+// as Trae is concerned — an id a fresh random one never linked, and one that
+// would let Trae read one conversation as another's. The cost is that such a
+// conversation's two halves are counted apart again, which is what it did
+// before this named one at all.
+function conversationID(chat, session, who = "") {
+  const account = String(who ?? "").trim()
+  if (session) return uuidOf("magpie-trae-session|" + account + "|" + session)
+  const first = (Array.isArray(chat?.messages) ? chat.messages : []).find((m) => m?.role === "user")
+  const text = partText(first?.content ?? "")
+  return text.trim() ? uuidOf("magpie-trae-first|" + account + "|" + text) : ""
+}
+
+// uuidOf is a version 4 UUID made of a hash's first 16 bytes: the shape
+// randomUUID() returns, since that is what session_id carried before.
+function uuidOf(s) {
+  const b = Buffer.from(createHash("sha256").update(SALT + "|" + s).digest().subarray(0, 16))
+  b[6] = (b[6] & 0x0f) | 0x40
+  b[8] = (b[8] & 0x3f) | 0x80
+  const h = b.toString("hex")
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`
+}
+
+// sessionOf takes the session a chat.headers hook named off the headers, with
+// the header: it goes no further than here. Its length is capped as magpie's
+// own session ids are, the id being derived from it anyway.
+function sessionOf(headers) {
+  const s = String(headers.get(SESSION) ?? "").trim()
+  headers.delete(SESSION)
+  return s.slice(0, 128)
+}
+
 // chatBody is the request for llm_utils_chat; modelName is the model the
 // function's list names for the config (its __dev one), when it named one,
 // and most the max_tokens it gives that model (0: none given), which a
 // request asking more is held to. A Max model (max: {base, window}) asks
 // the config base by its __max model, max_tokens always set, and gives
 // the prompt the room the window has beside it, as the IDE's Max mode does.
-function chatBody(req, fn, modelName, most = 0, max = null) {
-  const session = randomUUID()
+//
+// session is the conversation's id, made by conversationID, so every request
+// of one conversation carries one: Trae counts a conversation by the session
+// the requests name, and a request naming a new session each time is counted
+// as a conversation of its own — one user send that takes several steps (a
+// tool result sent back, a retry, another function answering) shows up in the
+// usage detail as several, each under no title at all. request_id stays a
+// fresh id per request, being that request's own.
+function chatBody(req, fn, modelName, most = 0, max = null, session = "") {
   const config = max?.base ?? req.model
   const body = {
     messages: traeMessages(req),
@@ -783,8 +841,8 @@ function chatBody(req, fn, modelName, most = 0, max = null) {
     model: config,
     ...(modelName ? { model_name: modelName } : {}),
     stream: true, // Trae answers in SSE either way
-    request_id: session,
-    session_id: session,
+    request_id: randomUUID(),
+    session_id: session || randomUUID(),
   }
   const asked = req.max_completion_tokens ?? req.max_tokens
   if (Number.isFinite(asked) && asked > 0) body.max_tokens = most > 0 ? Math.min(Math.floor(asked), most) : Math.floor(asked)
@@ -889,6 +947,8 @@ class TextTools {
     this.buf = ""
     this.after = false
     this.tools = tools
+    this.sent = "" // the text given out so far, to tell a block in code from a call
+    this.bad = new Set() // where the waiting block's JSON was tried and not read, not tried again
   }
   push(s, end = false) {
     this.buf += s
@@ -907,7 +967,8 @@ class TextTools {
         }
         this.after = false
       }
-      const i = this.buf.indexOf(OPEN)
+      const om = this.buf.match(OPEN_AT)
+      const i = om ? om.index : -1
       const d = this.buf.search(DSML_AT)
       const r = this.buf.search(REASON_AT)
       if (r >= 0 && (i < 0 || r < i) && (d < 0 || r < d)) {
@@ -965,53 +1026,271 @@ class TextTools {
         this.after = true
         continue
       }
-      const o = objectEnd(this.buf, i + OPEN.length)
-      const inner = this.buf.slice(i + OPEN.length).trimStart()
-      if (inner.startsWith("<") || (end && !inner)) {
+      const head = this.buf.slice(0, i)
+      const body = this.buf.slice(i + om[0].length)
+      if (quoted(this.sent + text + head)) {
+        // a <tool_call> in backticks or a code fence is prose about one
+        text += head + om[0]
+        this.buf = body
+        continue
+      }
+      const named = om[1]?.match(/\bname\s*=\s*"([^"]+)"/)?.[1]
+      const inner = body.trimStart()
+      if (!named && (inner.startsWith("<") || (end && !inner))) {
         // no JSON in it: DeepSeek's own invoke, or only the closes of one
         // (magpie#823 again); the opener is dropped and what follows read
         // as it is
-        text += this.buf.slice(0, i)
+        text += head
         this.buf = inner
         this.after = true
         continue
       }
-      const v = o > 0 ? looseJSON(this.buf.slice(i + OPEN.length, o)) : null
-      if (v?.name) {
-        text += this.buf.slice(0, i)
-        calls.push({ name: String(v.name), arguments: callArgs(v) })
-        this.buf = this.buf.slice(o)
-        this.after = true
+      const b = this.block(body, named, end)
+      if (b.wait) break
+      this.bad.clear()
+      if (b.text) {
+        // not a call: the opener is text, and what follows read on
+        text += head + om[0]
+        this.buf = body
         continue
       }
-      let j = this.buf.indexOf(CLOSE, i + OPEN.length)
-      if (j < 0) {
-        // GLM's call, cut short at the end, is still the call
-        if (!end || !glmCall(this.buf.slice(i + OPEN.length), this.tools)) break
-        j = this.buf.length
+      text += head
+      if (b.error) {
+        // a call that can't be read is not the answer (plugins#38): the
+        // turn ends as a failure, so the gateway can try it again
+        this.buf = ""
+        this.sent += text
+        return { text, calls, reasoning, error: b.error }
       }
-      text += this.buf.slice(0, i)
-      const raw = this.buf.slice(i + OPEN.length, j).trim()
-      this.buf = this.buf.slice(j + CLOSE.length)
-      const w = looseJSON(raw) ?? glmCall(raw, this.tools) ?? {}
-      if (w.name) {
-        calls.push({ name: String(w.name), arguments: callArgs(w) })
-        this.after = true
-      } else text += OPEN + raw + CLOSE
+      calls.push(b.call)
+      this.buf = b.rest
+      this.after = true
     }
     if (end) {
       text += this.buf
       this.buf = ""
     } else {
       // keep back an opened block, or what may be the start of one
-      const at = [this.buf.indexOf(OPEN), 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)].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 }
       text += this.buf.slice(0, this.buf.length - keep)
       this.buf = this.buf.slice(this.buf.length - keep)
     }
+    this.sent += text
     return { text, calls, reasoning }
   }
+
+  // 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
+  // even as models get it wrong (plugins#38). named is the name an opener
+  // gave as <tool_call name="…">.
+  block(body, named, end) {
+    if (!end && !body.trim()) return { wait: true }
+    const close = body.indexOf(CLOSE)
+    if (named) {
+      if (close < 0 && !end) return { wait: true }
+      const region = close >= 0 ? body.slice(0, close) : body
+      const rest = close >= 0 ? body.slice(close + CLOSE.length) : ""
+      if (region.trimStart().startsWith("{")) {
+        const v = repairedJSON(region.trim())
+        if (!v) return { error: close >= 0 ? UNREADABLE : CUT_SHORT }
+        return { call: v.name ? { name: String(v.name), arguments: callArgs(v) } : { name: named, arguments: JSON.stringify(v) }, rest }
+      }
+      if (region.includes("<arg_key>")) {
+        const w = glmCall(named + region, this.tools)
+        return w ? { call: { name: w.name, arguments: callArgs(w) }, rest } : { error: close >= 0 ? UNREADABLE : CUT_SHORT }
+      }
+      const p = paramArgs(region, named, this.tools)
+      // cut short at the end: whole only when each parameter was closed
+      if (close < 0 && !p.closed) return { error: CUT_SHORT }
+      return { call: { name: named, arguments: JSON.stringify(p.args) }, rest }
+    }
+    if (body.trimStart().startsWith("{")) {
+      const ph = body.match(PARAM_HEAD)
+      if (ph) {
+        // DeepSeek's half-and-half: the name as JSON, then its parameters
+        // (magpie#917)
+        if (close < 0 && !end) return { wait: true }
+        const region = body.slice(ph[0].length, close >= 0 ? close : body.length)
+        const p = paramArgs(region, ph[1], this.tools)
+        if (close < 0 && !p.closed) return { error: CUT_SHORT }
+        return { call: { name: ph[1], arguments: JSON.stringify(p.args) }, rest: close >= 0 ? body.slice(close + CLOSE.length) : "" }
+      }
+      const o = objectEnd(body, 0)
+      if (o > 0 && !this.bad.has(":" + o)) {
+        const v = callJSON(body.slice(0, o))
+        // a name alone may have its parameters still to come
+        if (v && !end && Object.keys(v).length === 1 && "<parameter".startsWith(body.slice(o).replace(/^\s*>?\s*/, ""))) return { wait: true }
+        if (v) return { call: { name: String(v.name), arguments: callArgs(v) }, rest: body.slice(o) }
+        this.bad.add(":" + o)
+      }
+      // not whole, or not JSON as it stands: read up to a close (a file's
+      // content may hold one), or at the end all of it
+      for (let j = close; j >= 0; j = body.indexOf(CLOSE, j + 1)) {
+        if (this.bad.has("<" + j)) continue
+        const v = callJSON(body.slice(0, j))
+        if (v) return { call: { name: String(v.name), arguments: callArgs(v) }, rest: body.slice(j + CLOSE.length) }
+        this.bad.add("<" + j)
+      }
+      if (!end) return { wait: true }
+      const v = callJSON(body)
+      if (v) return { call: { name: String(v.name), arguments: callArgs(v) }, rest: "" }
+      return { error: close >= 0 ? UNREADABLE : CUT_SHORT }
+    }
+    // GLM's own (a name, then <arg_key>/<arg_value> pairs), or text
+    if (!/^\s*[\w.:-]{1,128}\s*(?:<|$)/.test(body)) return { text: true }
+    if (close < 0 && !end) return { wait: true }
+    const region = close >= 0 ? body.slice(0, close) : body
+    const w = glmCall(region, this.tools)
+    // GLM's call, cut short at the end, is still the call
+    if (w) return { call: { name: w.name, arguments: callArgs(w) }, rest: close >= 0 ? body.slice(close + CLOSE.length) : "" }
+    if (/^\s*[\w.:-]{1,128}\s*<arg_key>/.test(body)) return { error: close >= 0 ? UNREADABLE : CUT_SHORT }
+    return { text: true }
+  }
+}
+
+const CUT_SHORT = "the model's tool call, written as text, was cut short; it is not sent on as the answer"
+const UNREADABLE = "the model's tool call, written as text, can't be read; it is not sent on as the answer"
+
+// an opener: <tool_call>, one with attributes (<tool_call name="bash">),
+// or <tool_call right before its JSON; and one still being written
+const OPEN_AT = /<tool_call(?:(\s[^<>{}]*)?>|(?=\s*\{))/
+const OPEN_HOLD = /<tool_call(?:\s[^<>{}\n]{0,200})?$/
+// DeepSeek's half-and-half call: {"name":"x"} (or its brace or > left
+// out), then <parameter name="k">v</parameter> or Qwen's <parameter=k>
+const PARAM_HEAD = /^\s*\{\s*"name"\s*:\s*"([^"]+)"\s*\}?\s*>?\s*(?=<parameter\b)/
+const PARAM_OPEN = /<parameter(?:\s+name\s*=\s*"([^"]+)"|=([^\s>]+))\s*>/g
+
+// quoted says text ends inside a code fence or inline code: what comes
+// next is shown, not done
+function quoted(text) {
+  if ((text.match(/```/g)?.length ?? 0) % 2) return true
+  const line = text.slice(text.lastIndexOf("\n") + 1).replace(/```/g, "")
+  return (line.match(/`/g)?.length ?? 0) % 2 === 1
+}
+
+// paramArgs reads <parameter name="k">v</parameter> (or <parameter=k>)
+// arguments; a value runs to its close, the next parameter or the end. A
+// value is its text where the tool's schema says string (or it isn't
+// JSON), else its JSON. closed says each one had its close.
+function paramArgs(s, name, tools = []) {
+  const props = (tools.find((t) => (t.function ?? t)?.name === name)?.function ?? {}).parameters?.properties ?? {}
+  const opens = [...s.matchAll(PARAM_OPEN)]
+  const args = {}
+  let closed = opens.length > 0
+  opens.forEach((m, k) => {
+    const from = m.index + m[0].length
+    const to = k + 1 < opens.length ? opens[k + 1].index : s.length
+    let v = s.slice(from, to)
+    const c = v.indexOf("</parameter>")
+    if (c >= 0) v = v.slice(0, c)
+    else closed = false
+    v = v.replace(/^\r?\n|\r?\n$/g, "")
+    const key = m[1] ?? m[2]
+    if (props[key]?.type === "string") {
+      args[key] = v
+      return
+    }
+    try {
+      args[key] = JSON.parse(v.trim())
+    } catch {
+      args[key] = v
+    }
+  })
+  return { args, closed }
+}
+
+// callJSON is a block's call ({name, …}) as a model may get its JSON
+// wrong, null when it isn't one even so
+function callJSON(s) {
+  const v = repairedJSON(s)
+  return v && typeof v.name === "string" && v.name ? v : null
+}
+
+// repairedJSON reads a JSON object as looseJSON does, and else as models
+// get it wrong (plugins#38): every quote escaped ({\"name\":…}), a
+// backslash that escapes nothing JSON knows (\_ \| C:\Users in a file's
+// content), or quotes inside a string left unescaped ("官方" in a write's
+// content)
+function repairedJSON(s) {
+  const v = looseJSON(s)
+  if (v) return v
+  const t = escapeRaw(s)
+  const tries = []
+  if (/^\s*\{\s*\\"/.test(s)) {
+    try {
+      const u = JSON.parse('"' + s.trim().replace(/[\n\r\t]/g, (c) => (c === "\n" ? "\\n" : c === "\r" ? "\\r" : "\\t")) + '"')
+      tries.push(u, escapeRaw(u))
+    } catch {}
+    tries.push(s.replace(/\\"/g, '"'))
+  }
+  tries.push(fixEscapes(t), quoteFix(fixEscapes(t)))
+  for (const x of tries) {
+    try {
+      const v = JSON.parse(x)
+      if (v && typeof v === "object" && !Array.isArray(v)) return v
+    } catch {}
+  }
+  return null
+}
+
+// fixEscapes makes a backslash that escapes nothing JSON knows a backslash
+// of its own (\' is the quote it meant)
+function fixEscapes(s) {
+  return s.replace(/\\(u[0-9a-fA-F]{4}|["\\/bfnrt])|\\'|\\/g, (m, ok) => (ok ? m : m === "\\'" ? "'" : "\\\\"))
+}
+
+// quoteFix escapes the quotes inside strings a model left unescaped: a
+// quote ends a key only before its colon, and a value only before what
+// may follow the last of one (closing braces or brackets, then the end or
+// a comma and the next key or value)
+function quoteFix(s) {
+  let out = ""
+  const stack = []
+  let key = false
+  for (let i = 0; i < s.length; ) {
+    const ch = s[i]
+    if (ch !== '"') {
+      if (ch === "{") {
+        stack.push("{")
+        key = true
+      } else if (ch === "[") stack.push("[")
+      else if (ch === "}" || ch === "]") stack.pop()
+      else if (ch === ",") key = stack.at(-1) === "{"
+      else if (ch === ":") key = false
+      out += ch
+      i++
+      continue
+    }
+    const isKey = key && stack.at(-1) === "{"
+    const inArray = stack.at(-1) === "["
+    out += ch
+    i++
+    for (; i < s.length; i++) {
+      const c = s[i]
+      if (c === "\\") {
+        out += c + (s[i + 1] ?? "")
+        i++
+        continue
+      }
+      if (c !== '"') {
+        out += c
+        continue
+      }
+      const after = s.slice(i + 1)
+      const ends = isKey ? /^\s*:/.test(after) : (inArray ? /^\s*(?:[}\]]\s*)*(?:$|,\s*["{[\d\-tfn])/ : /^\s*(?:[}\]]\s*)*(?:$|,\s*")/).test(after)
+      if (ends) {
+        out += c
+        i++
+        break
+      }
+      out += '\\"'
+    }
+    key = false
+  }
+  return out
 }
 
 // GLM's call template: the tool's name, then each argument as
@@ -1328,6 +1607,10 @@ async function* parts(events, tools = []) {
       if (t) yield { reasoning: t }
       if (r.text) yield { text: r.text }
       for (const c of r.calls) yield call({ ...c, id: callId() })
+      if (r.error) {
+        yield { error: r.error, code: null }
+        return
+      }
     }
     for (const tc of Array.isArray(d.tool_calls) ? d.tool_calls : []) nc.push(tc)
     const u = tokensOf(d.usage)
@@ -1339,6 +1622,10 @@ async function* parts(events, tools = []) {
   if (t) yield { reasoning: t }
   if (r.text) yield { text: r.text }
   for (const c of r.calls) yield call({ ...c, id: callId() })
+  if (r.error) {
+    yield { error: r.error, code: null }
+    return
+  }
   for (const c of nc.take(tools)) yield call(c)
   if (finish) yield { finish }
 }
@@ -1849,6 +2136,14 @@ const makePlugin = (site) => async ({ client }) => {
         models: { ...site.models, ...(was.models ?? {}) },
       }
     },
+    // the conversation's id, which the requests below carry as their
+    // session_id: magpie's (or OpenCode's) session for this request, when it
+    // names one
+    "chat.headers": async (input, output) => {
+      const id = input?.model?.providerID ?? input?.provider?.info?.id
+      if (id !== site.id || !input?.sessionID) return
+      output.headers[SESSION] = String(input.sessionID).slice(0, 128)
+    },
     provider: {
       id: site.id,
       // the account's own list, when Trae answers; else the list above
@@ -1927,11 +2222,16 @@ const makePlugin = (site) => async ({ client }) => {
               if (outer.aborted) ac.abort()
               else outer.addEventListener("abort", () => ac.abort(), { once: true })
             }
+            // the conversation this request belongs to, from the chat.headers
+            // hook (magpie's session) or the chat's own first user message, as
+            // the account answering it, so a failover inside one conversation
+            // is not one Trae reads as another's
+            const session = conversationID(req, sessionOf(new Headers(init.headers ?? r0?.headers ?? {})), who)
             for (const fn of [...new Set(fns)]) {
               const res = await fetch(apiOf(a, site) + "/api/agent/v3/llm_utils_chat", {
                 method: "POST",
                 headers: ideHeaders(a, site, { Accept: "text/event-stream", "X-Request-ID": randomUUID() }),
-                body: JSON.stringify(chatBody(req, fn, named?.fn === fn || max ? named.name : "", named?.fn === fn || max ? named.most : 0, max)),
+                body: JSON.stringify(chatBody(req, fn, named?.fn === fn || max ? named.name : "", named?.fn === fn || max ? named.most : 0, max, session)),
                 signal: ac.signal,
               })
               if (!res.ok) {
@@ -1982,4 +2282,4 @@ const makePlugin = (site) => async ({ client }) => {
 export const TraeCNAuthPlugin = makePlugin(SITES["trae-cn"])
 export const TraeGlobalAuthPlugin = makePlugin(SITES["trae-global"])
 
-export const _internal = { HOSTS: SITES["trae-cn"].hosts, MODELS: SITES["trae-cn"].models, TextTools, NativeCalls, looseJSON, glmCall, toolNamed, traeMessages, chatBody, credits, dollarUsageOf, whenOf, newDevice, proofOf, SITES }
+export const _internal = { HOSTS: SITES["trae-cn"].hosts, MODELS: SITES["trae-cn"].models, TextTools, NativeCalls, looseJSON, glmCall, toolNamed, traeMessages, chatBody, credits, dollarUsageOf, whenOf, newDevice, proofOf, SITES, SESSION, conversationID }

package/package.json

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