@magpie-community/opencode-workbuddy-auth 0.1.42 → 0.1.44

package/README.md

@@ -235,7 +235,16 @@ is used.
 - Kimi-K3, Kimi-K2.6
 - MiniMax-M3
 
-A model's reasoning levels are its variants (`reasoningEffort`).
+A model's reasoning levels are its variants (`reasoningEffort`). A chat
+that names no level goes at the model's own default from the config
+(`reasoning.defaultEffort`, "high" for DeepSeek-V4.1-Flash), as WorkBuddy's
+client sends it: WorkBuddy doesn't think when a chat names none, so
+OpenCode's default variant got answers without thinking. An effort the
+client names, `none` too, goes as it came.
+
+A chat goes gzipped (`Content-Encoding: gzip`), as WorkBuddy's own client
+sends its model requests (`RequestBodyGzip` in both builds' product.json).
+Claude's Messages route goes as it came.
 
 A model's price is its `credits` ("x0.29") and the config's
 `modelPromotions`. A discount for whole days (Step-5-Preview's 独家限免) is

package/index.mjs

@@ -13,6 +13,7 @@ import { createHash, randomBytes } from "node:crypto"
 import { readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { join } from "node:path"
+import { gzipSync } from "node:zlib"
 
 const APP_VERSION = "2.0.0" // the version WorkBuddy's sign-in page is opened with
 const POLL_MS = 1000
@@ -458,8 +459,28 @@ const SALT = randomBytes(16).toString("hex")
 
 // idFor is the 32 hex digits WorkBuddy's own ids are made of, made of a
 // name of the thing the id is for (a turn, a conversation) and what names it.
+// key is a string, or the pieces it is made of: the digest is the same
+// either way, and a key made of a 45 MiB message is never joined into one
+// string to be hashed (plugins#461). Each piece goes to the hash whole:
+// Bun reads a one-byte string's bytes in place, where a piece cut into
+// slices was measured costing a copy of each slice.
 function idFor(kind, key) {
-  return createHash("sha256").update(`${SALT}|${kind}|${key}`).digest("hex").slice(0, 32)
+  const h = createHash("sha256").update(`${SALT}|${kind}|`)
+  // a surrogate pair's first half ending one piece waits for the next, as
+  // the joined key would hold the pair together
+  let held = ""
+  for (let piece of typeof key === "string" ? [key] : key) {
+    if (held) piece = held + piece
+    held = ""
+    const c = piece.charCodeAt(piece.length - 1)
+    if (c >= 0xd800 && c <= 0xdbff) {
+      held = piece.slice(-1)
+      piece = piece.slice(0, -1)
+    }
+    h.update(piece)
+  }
+  if (held) h.update(held)
+  return h.digest("hex").slice(0, 32)
 }
 
 // signatureOf is a message content's signature: its text, and a digest of
@@ -468,14 +489,20 @@ function idFor(kind, key) {
 // clients of Anthropic's shape — is left out: it is not what the user said,
 // and it changes with every step of the send.
 function signatureOf(content) {
-  if (typeof content === "string") return content
-  if (!Array.isArray(content)) return ""
-  let out = ""
+  return signatureParts(content).join("")
+}
+
+// signatureParts is signatureOf in the pieces it is joined from, none empty
+function signatureParts(content) {
+  if (typeof content === "string") return content ? [content] : []
+  if (!Array.isArray(content)) return []
+  const out = []
   for (const part of content) {
     const type = part?.type ?? ""
-    if (type === "" || type === "text") out += typeof part?.text === "string" ? part.text : ""
-    else if (type !== "tool_result" && type !== "tool-result") {
-      out += `[${type}:${createHash("sha256").update(JSON.stringify(part)).digest("hex").slice(0, 8)}]`
+    if (type === "" || type === "text") {
+      if (typeof part?.text === "string" && part.text) out.push(part.text)
+    } else if (type !== "tool_result" && type !== "tool-result") {
+      out.push(`[${type}:${createHash("sha256").update(JSON.stringify(part)).digest("hex").slice(0, 8)}]`)
     }
   }
   return out
@@ -521,13 +548,18 @@ function hasBlock(m, type) {
 // has none at all: the caller then makes a fresh id for that request, as
 // before these were derived at all.
 function turnKey(chat) {
+  return turnParts(chat).join("")
+}
+
+// turnParts is turnKey in pieces (idFor takes them): [] for ""
+function turnParts(chat) {
   const msgs = Array.isArray(chat?.messages) ? chat.messages : []
   for (let i = msgs.length - 1; i >= 0; i--) {
     if (msgs[i]?.role !== "user" || answeredBefore(msgs, i)) continue
-    const sig = signatureOf(msgs[i].content)
-    return sig ? `u${i}:${sig}` : ""
+    const sig = signatureParts(msgs[i].content)
+    return sig.length ? [`u${i}:`, ...sig] : []
   }
-  return ""
+  return []
 }
 
 // conversationKey names the conversation a chat belongs to: the session
@@ -537,14 +569,19 @@ function turnKey(chat) {
 // conversation id is sent then: a made-up one would be a conversation of the
 // request's own, which is what fragments the usage detail in the first place.
 function conversationKey(chat, session) {
-  if (session) return `session:${session}`
+  return conversationParts(chat, session).join("")
+}
+
+// conversationParts is conversationKey in pieces (idFor takes them): [] for ""
+function conversationParts(chat, session) {
+  if (session) return [`session:${session}`]
   const msgs = Array.isArray(chat?.messages) ? chat.messages : []
   for (const m of msgs) {
     if (m?.role !== "user") continue
-    const sig = signatureOf(m.content)
-    if (sig) return `first:${sig}`
+    const sig = signatureParts(m.content)
+    if (sig.length) return ["first:", ...sig]
   }
-  return ""
+  return []
 }
 
 // isMessages says whether a request is an Anthropic Messages one, which
@@ -683,17 +720,17 @@ function attend(headers, body, session) {
 }
 
 function attendChat(headers, chat, session) {
-  const conv = conversationKey(chat, session)
+  const conv = conversationParts(chat, session)
   const msg = hex()
   headers.set("X-Conversation-Message-ID", msg)
   headers.set("X-Request-ID", msg)
   if (!headers.has("X-Conversation-Request-ID")) {
-    const turn = turnKey(chat)
+    const turn = turnParts(chat)
     // a turn is a conversation's own: two conversations whose user message
     // reads the same are still two sends, not one
-    headers.set("X-Conversation-Request-ID", turn ? idFor("turn", `${conv}|${turn}`) : hex())
+    headers.set("X-Conversation-Request-ID", turn.length ? idFor("turn", [...conv, "|", ...turn]) : hex())
   }
-  if (conv && !headers.has("X-Conversation-ID")) headers.set("X-Conversation-ID", idFor("conversation", conv))
+  if (conv.length && !headers.has("X-Conversation-ID")) headers.set("X-Conversation-ID", idFor("conversation", conv))
 }
 
 // FLAGGED are the words WorkBuddy refuses a chat for, "Illegal API
@@ -1289,6 +1326,24 @@ function fitted(body) {
   }
 }
 
+// gzipped is a chat's body compressed, as WorkBuddy's own client sends its
+// model requests: its CLI's GzipRequestProcessor (WorkBuddy 5.9.3, CLI
+// 2.165.0; WorkBuddy AI 5.8.4 the same) gzips each POST's body and sets
+// Content-Encoding: gzip when the product's RequestBodyGzip feature is on,
+// which both builds' product.json turn on and /v3/config (merged over it)
+// doesn't turn off. Sent as plain JSON, a long agent conversation went up
+// whole on every step: runmiNeverstop on X saw 2.89 GB up to
+// copilot.tencent.com against 258 MB down. Measured 2026-10-28 on
+// www.workbuddy.ai: a gzipped chat answers as the plain one does. A
+// Messages request (Claude on the China build) goes as it came: that route
+// wasn't tried gzipped. null when the body isn't sent gzipped.
+function gzipped(native, b) {
+  if (native) return null
+  if (typeof b === "string") return gzipSync(Buffer.from(b))
+  if (b instanceof ArrayBuffer || ArrayBuffer.isView(b)) return gzipSync(b)
+  return null
+}
+
 // prepared is a request's body read once for every change the loader makes
 // to it and everything it reads off it (plugins#461): a long chat, 45 MiB
 // of history, was parsed six times on its way, once by each step, and
@@ -2119,6 +2174,37 @@ function effortsOf(d, site, id) {
   return EFFORT_ORDER.filter((e) => set.has(e))
 }
 
+// defaultEffortOf is the level WorkBuddy's own client asks a model for when
+// the user picked none: its CLI's configureThinkingSettings (WorkBuddy
+// 5.9.3, CLI 2.165.0) takes the session's effort, else the settings', else
+// the config's reasoning.defaultEffort, else reasoning.effort, and sends it
+// as reasoning_effort unless thinking was turned off. A request with no
+// reasoning_effort is not thinking on WorkBuddy's side: measured 2026-10-28
+// on www.workbuddy.ai, deepseek-v4.1-flash (defaultEffort "high") answered
+// with 0 reasoning tokens without one, and thought at low and high
+// (troilus1011 on X, OpenCode's default variant). A default the model's
+// levels don't hold is left out, as the CLI clamps it to one they do.
+function defaultEffortOf(d, efforts) {
+  const own = d.reasoning?.defaultEffort ?? d.reasoning?.effort
+  return typeof own === "string" && efforts.includes(own) ? own : undefined
+}
+
+// withDefaultEffort gives a chat that names no effort the model's default
+// (defaultEffortOf), as WorkBuddy's client sends it; true when it did. An
+// effort the client named, "none" too, goes as it came.
+function withDefaultEffort(chat, list) {
+  if (!chat || typeof chat !== "object" || namesEffort(chat)) return false
+  const m = list?.find((x) => x.id === chat.model)
+  if (!m?.effort) return false
+  chat.reasoning_effort = m.effort
+  return true
+}
+
+// namesEffort is whether a chat names its effort itself, in either spelling
+function namesEffort(chat) {
+  return chat.reasoning_effort !== undefined || (!!chat.reasoning && typeof chat.reasoning === "object" && chat.reasoning.effort !== undefined)
+}
+
 async function liveModels(site, a) {
   const headers = new Headers()
   sign(site, a, headers)
@@ -2145,6 +2231,8 @@ async function liveModels(site, a) {
         if (es.length) {
           const canOff = d.reasoning?.canDisableThinking
           m.efforts = [...(!d.onlyReasoning && (canOff == null || canOff) ? ["none"] : []), ...es]
+          const def = defaultEffortOf(d, es)
+          if (def) m.effort = def
         }
       }
       out.push(m)
@@ -2185,13 +2273,19 @@ const AFTER_TOOLS_REFUSED = /must end with a user message|["']code["']\s*:\s*["'
 // ending with the assistant's message is a prefill, refused as it is.
 function replyAfterTools(body) {
   const b = chatOf(body)
+  return replyAfterToolsOn(b) ? JSON.stringify(b) : null
+}
+
+// replyAfterToolsOn makes replyAfterTools's change on a chat's object; false
+// for a chat it doesn't take
+function replyAfterToolsOn(b) {
   const msgs = b?.messages
-  if (!Array.isArray(msgs)) return null
+  if (!Array.isArray(msgs)) return false
   let i = msgs.length - 1
   while (i >= 0 && msgs[i]?.role === "user") i--
-  if (i === msgs.length - 1 || i < 0 || msgs[i]?.role !== "tool") return null
+  if (i === msgs.length - 1 || i < 0 || msgs[i]?.role !== "tool") return false
   msgs.splice(i + 1, 0, { role: "assistant", content: "" })
-  return JSON.stringify(b)
+  return true
 }
 
 // FREE_ONLY is the switch that keeps an account off credits (#430): its
@@ -2238,6 +2332,24 @@ function makePlugin(site) {
     if (lists.size > 64) lists.delete(lists.keys().next().value)
     return list
   }
+  // effortList is the list a chat's default effort is read from
+  // (withDefaultEffort): listed's, or null when there is none to read — a
+  // key WorkBuddy's CLI reads no config with (as models does), or a read
+  // that failed within PRICE_TTL, so a config that can't be read costs a
+  // chat one try a minute, not one each
+  const unlisted = new Map()
+  const effortList = async (a) => {
+    if (a.source === "key" && !remoteConfig(a.key)) return null
+    const k = listKey(a)
+    if (Date.now() - (unlisted.get(k) ?? 0) < PRICE_TTL) return null
+    try {
+      return await listed(a)
+    } catch {
+      unlisted.set(k, Date.now())
+      if (unlisted.size > 64) unlisted.delete(unlisted.keys().next().value)
+      return null
+    }
+  }
   const freeOnly = () => magpie?.option?.(site.id, FREE_ONLY) === true
   // onlyFree is a list with the switch on: its free models, or a failure
   // when there are none to tell (magpie then keeps the list it had)
@@ -2341,18 +2453,6 @@ function makePlugin(site) {
             sign(site, a, headers)
             let body = init?.body
             if (body === undefined && req) body = await req.clone().text()
-            // the switch is checked before anything is sent: a model not
-            // free, or one whose price can't be read, never reaches WorkBuddy
-            if (freeOnly()) {
-              const model = chatOf(typeof body === "string" ? body : bodyString(body))?.model
-              let list
-              try {
-                list = await listed(a)
-              } catch (e) {
-                return notFree(site, model, e?.message ?? String(e))
-              }
-              if (!list.some((m) => m.id === model && m.free)) return notFree(site, model)
-            }
             // An Anthropic request goes as the agent sent it: WorkBuddy
             // serves these models on Messages itself, and the rewrites
             // below (a default system message, the chat endpoint's
@@ -2363,16 +2463,40 @@ function makePlugin(site) {
             // Codex's and DeepSeek Harness's openings all answer on
             // /v1/messages, where a chat is refused 11128.
             const native = isMessages(req ? req.url : String(input), body)
-            let names = {}
-            const p = prepared(body, native)
-            let chat = p.chat
-            let changed = p.changed
-            body = p.body
-            if (!native) names = p.names
+            // read once (prepared): nothing below parses the body again on
+            // its way out, and nothing keeps the parsed chat once it is
+            // written (plugins#461)
+            let chat, changed, names
+            ;({ body, chat, changed, names } = prepared(body, native))
+            if (native) names = {}
+            // the switch is checked before anything is sent: a model not
+            // free, or one whose price can't be read, never reaches
+            // WorkBuddy. The model is read off the chat parsed above; a body
+            // prepared leaves unread (bytes on Messages) is read for it.
+            if (freeOnly()) {
+              const model = (chat ?? chatOf(typeof body === "string" ? body : bodyString(body)))?.model
+              let list
+              try {
+                list = await listed(a)
+              } catch (e) {
+                return notFree(site, model, e?.message ?? String(e))
+              }
+              if (!list.some((m) => m.id === model && m.free)) return notFree(site, model)
+            }
+            // a chat that names no effort is asked at the model's default,
+            // as WorkBuddy's client asks it (withDefaultEffort); with no
+            // list to read (effortList) the chat goes as it came
+            if (!native && chat && !namesEffort(chat) && withDefaultEffort(chat, await effortList(a))) changed = true
             chatHeaders(site, headers)
             attendChat(headers, chat, session)
-            const post = (b) =>
-              fetch(req ? req.url : input, { ...init, method: init?.method ?? req?.method, headers, body: b }).catch((e) => unanswered(site, a, b, e, init?.signal))
+            const post = (b) => {
+              // a chat goes gzipped, as WorkBuddy's client sends it
+              // (gzipped); its size on the wire is what unanswered weighs
+              const z = gzipped(native, b)
+              if (z) headers.set("Content-Encoding", "gzip")
+              else headers.delete("Content-Encoding")
+              return fetch(req ? req.url : input, { ...init, method: init?.method ?? req?.method, headers, body: z ?? b }).catch((e) => unanswered(site, a, z ?? b, e, init?.signal))
+            }
             // a 401 is answered once, on whichever try meets it: by a
             // sign-in with another access token (reissued), the request
             // sent once more with it, never again after that; else, or
@@ -2422,10 +2546,16 @@ function makePlugin(site) {
             // words at once (see systemAsUser)
             const sysKey = native ? "" : systemKeyOf(chat)
             if (sysKey && refusedSystems.has(sysKey) && systemAsUserOn(chat)) changed = true
+            // shaped is a body as such a model takes it. The first try's
+            // is made on the chat already parsed, after the move above,
+            // as shaped would make it of the body written; a resend with
+            // the system prompt moved (below) is shaped again, and a body
+            // that has the reply already is left as it is.
+            const shaped = (b) => (!native && endsAfterTools.has(model) ? replyAfterTools(b) ?? b : b)
+            if (!native && endsAfterTools.has(model) && replyAfterToolsOn(chat)) changed = true
             if (changed) body = JSON.stringify(chat)
             chat = null
-            const shaped = (b) => (!native && endsAfterTools.has(model) ? replyAfterTools(b) ?? b : b)
-            let res = await send(shaped(body))
+            let res = await send(body)
             // a signature WorkBuddy's own signing didn't make — a session
             // moved here from another provider keeps its thinking blocks,
             // and a truncated or altered one reads the same way — is 11159
@@ -2653,4 +2783,4 @@ export const WorkBuddyAuthPlugin = makePlugin(SITES.workbuddy)
 export const WorkBuddyAIAuthPlugin = makePlugin(SITES["workbuddy-ai"])
 
 // for tests
-export const _internal = { FREE_ONLY, PRICE_TTL, keyAccount, remoteConfig, cycleOf, typeUnions, systemAsUser, systemKey, DEFAULT_SYSTEM, EDGE_READS, fitShape, replyAfterTools, AFTER_TOOLS_REFUSED, enterpriseUsageOf, notDesktop, textOnly, runsOutOf, packagesOf, endOf, enterpriseHeaders, enterpriseOf, liveModels, browserSignIn, withSystem, asReasoning, normalizeToolChoice, fitTools, fitted, renamed, unflagged, usageOf, desktopHeld, explained, REFUSED_HINT, RESTRICTED_HINT, EXHAUSTED_HINT, freeCredits, creditsOf, priceOf, fresh, SITES, renewing, renewed, SESSION, attend, turnKey, conversationKey, signatureOf, isMessages, withoutUnsigned, withoutSignedThinking, prepared, answeredBefore, nativeOf, modelOf, configModels, API_MESSAGES: NPM_MESSAGES, API_CHAT: NPM }
+export const _internal = { idFor, replyAfterToolsOn, withDefaultEffort, defaultEffortOf, gzipped, FREE_ONLY, PRICE_TTL, keyAccount, remoteConfig, cycleOf, typeUnions, systemAsUser, systemKey, DEFAULT_SYSTEM, EDGE_READS, fitShape, replyAfterTools, AFTER_TOOLS_REFUSED, enterpriseUsageOf, notDesktop, textOnly, runsOutOf, packagesOf, endOf, enterpriseHeaders, enterpriseOf, liveModels, browserSignIn, withSystem, asReasoning, normalizeToolChoice, fitTools, fitted, renamed, unflagged, usageOf, desktopHeld, explained, REFUSED_HINT, RESTRICTED_HINT, EXHAUSTED_HINT, freeCredits, creditsOf, priceOf, fresh, SITES, renewing, renewed, SESSION, attend, turnKey, conversationKey, signatureOf, isMessages, withoutUnsigned, withoutSignedThinking, prepared, answeredBefore, nativeOf, modelOf, configModels, API_MESSAGES: NPM_MESSAGES, API_CHAT: NPM }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-workbuddy-auth",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "OpenCode provider plugins for WorkBuddy's plans: WorkBuddy (CodeBuddy, copilot.tencent.com) and WorkBuddy AI (www.workbuddy.ai)",
   "type": "module",
   "main": "./index.mjs",