@magpie-community/opencode-trae-auth 0.1.9 → 0.1.11

package/index.mjs

@@ -534,25 +534,79 @@ const callId = () => "call_" + randomBytes(12).toString("hex") + (callSeq++).toS
 
 // TextTools splits the model's text into what the agent sees and the tool
 // calls it wrote as blocks, holding back the start of a block until it
-// is whole
+// is whole. A block is ours (<tool_call>{…}</tool_call>), its JSON taken
+// once whole even when DeepSeek closes it with its own tags in place of
+// </tool_call>, or DeepSeek's (<｜DSML｜invoke name="…">, magpie#823); the
+// tags left around a call are dropped.
 class TextTools {
   constructor() {
     this.buf = ""
+    this.after = false
   }
   push(s, end = false) {
     this.buf += s
     let text = ""
     const calls = []
     for (;;) {
+      if (this.after) {
+        const m = this.buf.match(LEFTOVER)
+        if (m) this.buf = this.buf.slice(m[0].length)
+        if (!this.buf || (!end && MARKS.some((k) => k.startsWith(this.buf)))) break
+        this.after = false
+      }
       const i = this.buf.indexOf(OPEN)
-      if (i < 0) break
+      const d = this.buf.search(DSML_AT)
+      if (i < 0 && d < 0) break
+      if (d >= 0 && (i < 0 || d < i)) {
+        text += this.buf.slice(0, d)
+        this.buf = this.buf.slice(d)
+        const tag = this.buf.match(DSML_TAG)
+        if (!tag) {
+          // a tag not closed yet; at the end, or with another tag after it,
+          // a stray one dropped
+          const next = this.buf.indexOf("<", 1)
+          if (next < 0 && !end) break
+          this.buf = next < 0 ? "" : this.buf.slice(next)
+          continue
+        }
+        const inv = tag[0].match(DSML_INVOKE)
+        if (!inv) {
+          // function_calls, a parameter's close, any other tag: dropped,
+          // with the blanks after it
+          this.buf = this.buf.slice(tag[0].length)
+          this.after = true
+          continue
+        }
+        const body = this.buf.slice(tag[0].length)
+        const c = body.match(DSML_CLOSE)
+        const n = body.search(DSML_INVOKE_AT)
+        let stop = c ? c.index : n >= 0 ? n : -1
+        if (n >= 0 && n < stop) stop = n
+        if (stop < 0) {
+          if (!end) break
+          stop = body.length
+        }
+        calls.push({ name: inv[1], arguments: dsmlArgs(body.slice(0, stop)) })
+        this.buf = body.slice(c && c.index === stop ? stop + c[0].length : stop)
+        this.after = true
+        continue
+      }
+      const o = objectEnd(this.buf, i + OPEN.length)
+      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
+        continue
+      }
       const j = this.buf.indexOf(CLOSE, i + OPEN.length)
       if (j < 0) break
       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 v = parseJSON(raw)
-      if (v.name) calls.push({ name: String(v.name), arguments: typeof v.arguments === "string" ? v.arguments : JSON.stringify(v.arguments ?? v.input ?? v.parameters ?? {}) })
+      const w = looseJSON(raw) ?? {}
+      if (w.name) calls.push({ name: String(w.name), arguments: callArgs(w) })
       else text += OPEN + raw + CLOSE
     }
     if (end) {
@@ -560,9 +614,9 @@ class TextTools {
       this.buf = ""
     } else {
       // keep back an opened block, or what may be the start of one
-      const i = this.buf.indexOf(OPEN)
-      let keep = i >= 0 ? this.buf.length - i : 0
-      if (!keep) for (let k = Math.min(OPEN.length - 1, this.buf.length); k > 0; k--) if (OPEN.startsWith(this.buf.slice(-k))) { keep = k; break }
+      const at = [this.buf.indexOf(OPEN), this.buf.search(DSML_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)
     }
@@ -570,14 +624,120 @@ class TextTools {
   }
 }
 
+// DeepSeek's tags, with its full-width bar or a plain one
+const DSML = String.raw`<\s*\/?\s*[|｜][\s|｜]*DSML[\s|｜]*`
+const DSML_AT = new RegExp(DSML)
+const DSML_TAG = new RegExp("^" + DSML + "[^<>]*>")
+const DSML_INVOKE = new RegExp(String.raw`^<\s*[|｜][\s|｜]*DSML[\s|｜]*invoke\s+name\s*=\s*"([^"]+)"\s*>`)
+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")
+// 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)[^<>]*>)+`)
+// what text may be the start of, so held back
+const MARKS = [OPEN, CLOSE, "<｜DSML｜", "<|DSML|", "</｜DSML｜", "</|DSML|"]
+const MARK_MAX = Math.max(...MARKS.map((m) => m.length))
+
+// dsmlArgs is the arguments of a DSML invoke as JSON: a parameter marked
+// string="true" is its text, any other its JSON (its text when not JSON)
+function dsmlArgs(body) {
+  const args = {}
+  for (const p of body.matchAll(DSML_PARAM)) {
+    if (/string\s*=\s*"true"/.test(p[2])) {
+      args[p[1]] = p[3]
+      continue
+    }
+    try {
+      args[p[1]] = JSON.parse(p[3].trim())
+    } catch {
+      args[p[1]] = p[3]
+    }
+  }
+  return JSON.stringify(args)
+}
+
+// objectEnd is where the JSON object starting at from (after blanks) ends:
+// past its closing brace, -1 when it isn't whole yet, -2 when there's none
+function objectEnd(s, from) {
+  let k = from
+  while (k < s.length && /\s/.test(s[k])) k++
+  if (k >= s.length) return -1
+  if (s[k] !== "{") return -2
+  let depth = 0
+  let str = false
+  let esc = false
+  for (; k < s.length; k++) {
+    const ch = s[k]
+    if (str) {
+      if (esc) esc = false
+      else if (ch === "\\") esc = true
+      else if (ch === '"') str = false
+      continue
+    }
+    if (ch === '"') str = true
+    else if (ch === "{") depth++
+    else if (ch === "}" && --depth === 0) return k + 1
+  }
+  return -1
+}
+
+// looseJSON reads a JSON object as a model writes one: a string holding a
+// raw newline or tab (a file's content written out, #799) is read as if
+// they were escaped. null when it isn't one even so.
+function looseJSON(s) {
+  for (const t of [s, escapeRaw(s)]) {
+    try {
+      const v = JSON.parse(t)
+      if (v && typeof v === "object" && !Array.isArray(v)) return v
+    } catch {}
+  }
+  return null
+}
+
+// escapeRaw escapes the control characters inside JSON strings
+function escapeRaw(s) {
+  let out = ""
+  let str = false
+  let esc = false
+  for (const ch of String(s ?? "")) {
+    if (str && !esc && ch < " ") {
+      out += ch === "\n" ? "\\n" : ch === "\r" ? "\\r" : ch === "\t" ? "\\t" : "\\u" + ch.charCodeAt(0).toString(16).padStart(4, "0")
+      continue
+    }
+    if (str && ch === "\\" && !esc) esc = true
+    else {
+      if (ch === '"' && !esc) str = !str
+      esc = false
+    }
+    out += ch
+  }
+  return out
+}
+
+// callArgs is a tagged block's arguments as JSON: under arguments (an
+// object, or a string of one), input or parameters, else the block's other
+// keys, as a model that writes them beside the name means them (#799: a
+// write that went out as {})
+function callArgs(v) {
+  let a = v.arguments ?? v.input ?? v.parameters
+  if (a === undefined) {
+    const { name, type, id, ...rest } = v
+    a = rest
+  }
+  if (typeof a === "string") return a.trim() ? (looseJSON(a) ? JSON.stringify(looseJSON(a)) : a) : "{}"
+  return JSON.stringify(a ?? {})
+}
+
 // nativeCall is a tool call as Trae's events carry one
 function nativeCall(tc) {
   const f = tc?.function ?? tc?.function_call ?? tc
   const name = f?.name ?? tc?.tool_name ?? ""
   const index = Number.isInteger(tc?.index) ? tc.index : null
-  if (!name && index === null && !tc?.id) return null
   const a = f?.arguments ?? f?.args ?? tc?.params ?? tc?.input ?? tc?.parameters ?? ""
-  return { id: tc?.id || tc?.tool_call_id || "", index, name: String(name), arguments: typeof a === "string" ? a : JSON.stringify(a) }
+  const args = typeof a === "string" ? a : JSON.stringify(a)
+  if (!name && index === null && !tc?.id && !args) return null
+  return { id: tc?.id || tc?.tool_call_id || "", index, name: String(name), arguments: args }
 }
 
 // NativeCalls puts together the tool calls Trae streams: a call comes in
@@ -594,6 +754,12 @@ class NativeCalls {
     let o = this.calls.find((x) => (c.id && x.id === c.id) || (!c.id && c.index !== null && x.index === c.index))
     if (!o && !c.id && c.index === null)
       o = this.calls.findLast((x) => x.name === c.name && (x.arguments === c.arguments || (!done(x.arguments) && c.arguments.startsWith(x.arguments))))
+    // a piece with nothing to say whose it is (or an index its call's
+    // first event didn't give) belongs to the call still being written
+    if (!o && !c.name && !c.id) {
+      o = this.calls.findLast((x) => !done(x.arguments))
+      if (o && c.index !== null && o.index !== null && o.index !== c.index) o = null
+    }
     if (!o) {
       if (!c.name) return
       this.calls.push({ ...c })
@@ -608,7 +774,10 @@ class NativeCalls {
     else o.arguments = prev + next // a piece
   }
   take() {
-    return this.calls.filter((c) => c.name).map(({ id, name, arguments: a }) => ({ id: id || callId(), name, arguments: a || "{}" }))
+    return this.calls.filter((c) => c.name).map(({ id, name, arguments: a }) => {
+      const v = a && !done(a) ? looseJSON(a) : null
+      return { id: id || callId(), name, arguments: v ? JSON.stringify(v) : a || "{}" }
+    })
   }
 }
 
@@ -1154,4 +1323,4 @@ export const TraeCNAuthPlugin = async ({ client }) => {
 }
 
 // for tests
-export const _internal = { HOSTS, MODELS, TextTools, traeMessages, chatBody, credits, whenOf, newDevice }
+export const _internal = { HOSTS, MODELS, TextTools, NativeCalls, looseJSON, traeMessages, chatBody, credits, whenOf, newDevice }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-trae-auth",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "OpenCode provider plugin for Trae CN (trae.cn): your Trae CN account's models, free tier included, with Trae's own browser sign-in",
   "type": "module",
   "main": "./index.mjs",