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

package/README.md

@@ -447,14 +447,30 @@ What is measured, and what is easy to read wrongly:
   rather than +08:00 guessed.
 
 A window that has lapsed reports nothing rather than 0%: nothing is
-exhausted, and the next request opens a fresh one. The China build
-(`copilot.tencent.com`) carries the same window: two Free-plan accounts
+exhausted, and the next request opens a fresh one.
+
+### The China build's windows (measured, shown as estimates)
+
+The China build (`copilot.tencent.com`) carries the same kind of window,
+measured one model at a time. `deepseek-v4.1-flash`: two Free-plan accounts
 refused on 2026-11-02 at 200,389,043 and 200,485,923 tokens, so its cap is
-measured at about 2e8 — and its refusals name the reset in Chinese
-(`将在 … UTC+8 重置`), which reads as an edge the same way. Its card reads
-against 2e8. In 0.2.12 and 0.2.13 it read against a soft cap of 1.9e8, so
-that routing rested the model before the vendor refused it; with the sum set
-aside that headroom only stopped the model early, so it is gone.
+about **2e8** — and its refusals name the reset in Chinese
+(`将在 … UTC+8 重置`), which reads as an edge the same way.
+
+Unlike the AI build's, the China model is **charged in credits** (`x0.11`)
+— the token window and the credits meter are two limits on one model — so
+the card is not a "free model" card. It is named after its model and says
+its cap is an estimate: **`deepseek-v4.1-flash tokens (est.)`**, with
+`~200M` in its text (`151.5M / ~200M`). The estimate is this machine's ledger
+against a cap measured on two accounts; the vendor reports neither, and the
+first refusal of a window pins the card full at the reset the vendor names.
+
+The measured windows live in one table (`CN_ESTIMATED_WINDOWS`), one entry
+per model. Only measured models have a card — a guessed cap would read wrong
+every day. Add an entry when another model's window is measured; remove one
+when the vendor stops applying it. Because the card is set aside (shown, not
+routed on), a stale cap costs a wrong percentage, never a wrongly rested
+model: the refusal is what stops a model, on both builds.
 
 ## When free models work but a credit model does not
 

package/index.mjs

@@ -2212,7 +2212,7 @@ const compact = (n) => (Number.isInteger(n) ? String(n) : n.toFixed(2).replace(/
 
 // The window WorkBuddy rate limits deepseek-v4.1-flash by, which its credit
 // meter does not show: WorkBuddy AI measured at about 1e8 over ten days, the
-// China build at about 2e8 on 2026-11-02 (see FREE_WINDOW_CN).
+// China build at about 2e8 on 2026-11-02 (see CN_ESTIMATED_WINDOWS).
 //
 // A free account's usage() reports only the credits window, so a plan with
 // 160 credits untouched reads 0% while chats to deepseek-v4.1-flash are
@@ -2293,18 +2293,46 @@ const compact = (n) => (Number.isInteger(n) ? String(n) : n.toFixed(2).replace(/
 // ~/.config/magpie otherwise. No endpoint reports the window; a ledger that
 // cannot be read yields no window rather than a made-up one.
 
-// A window: the build's ledger rows it counts (provider), the cap it reports
-// against, and how deep its display rounds. Two builds, two windows, two
-// caps: the same phone number can be signed in to both, and their ledgers
+// A window: the build's ledger rows it counts (provider and model), the cap
+// it reports against, and how its card reads. Two builds, two sets of
+// windows: the same phone number can be signed in to both, and their ledgers
 // stay apart — one build's spending must not fill the other's window.
 //
-// The China cap is the measured one, 2e8 (two accounts refused at 200.39M
-// and 200.49M). It was a soft 1.9e8 in 0.2.12 and 0.2.13, so that routing
-// rested the model before the vendor refused it; since the sum is set aside
-// (freeWindowOf's card), the cap only scales what the card says, and the
-// headroom bought nothing but a model stopped 10M tokens early (plugins#641).
-const FREE_WINDOW_CN = { provider: "workbuddy", cap: 2e8, short: "200M" }
-const FREE_WINDOW_AI = { provider: "workbuddy-ai", cap: 1e8, short: "100M" }
+// The China caps are measured on this machine from the vendor's own
+// refusals, never the vendor's word, and each is an estimate: 2e8 for
+// deepseek-v4.1-flash (two accounts refused at 200.39M and 200.49M on
+// 2026-11-02), with the card saying so (`~` and "(est.)"). The card is
+// shown only — set aside, plugins#641 — so a cap that goes stale costs a
+// wrong percentage, never a wrongly rested model; the first refusal of a
+// window pins the card full at the reset the vendor names.
+//
+// One entry per model, and only models that have been measured: a guessed
+// cap would read wrong every day. Add an entry when another model's window
+// is measured; remove one when the vendor stops applying it.
+const CN_ESTIMATED_WINDOWS = [
+  {
+    provider: "workbuddy",
+    model: "deepseek-v4.1-flash",
+    aliases: ["deepseek-v4.1-flash-sg"],
+    cap: 2e8,
+    name: "deepseek-v4.1-flash tokens (est.)",
+    short: "~200M",
+    // no unit: the name already says tokens, and magpie's narrow account
+    // cards cut a unit short ("tok…") beside the nine-digit numbers
+    unit: "",
+  },
+]
+// WorkBuddy AI's window keeps the name it shipped with: there the model is
+// served at x0.00, so "Free model tokens" is what it is.
+const FREE_WINDOW_AI = {
+  provider: "workbuddy-ai",
+  model: "deepseek-v4.1-flash",
+  aliases: ["deepseek-v4.1-flash-sg"],
+  cap: 1e8,
+  name: "Free model tokens",
+  short: "100M",
+  unit: "tokens",
+}
 const FREE_WINDOW_SPAN = 24 * 3600 * 1000
 // The lead: how far back of an edge the read goes on. A chain read from a row
 // that opens a window needs the window the span makes of the rows above it,
@@ -2317,10 +2345,9 @@ const FREE_WINDOW_LEAD = 86400 * 1000
 // earlier row began at most 24h before it, and so ended 24h after it at the
 // latest. This is one of the two edges the ledger itself spells out.
 const FREE_WINDOW_GAP = FREE_WINDOW_SPAN
-// the model the window is counted for; -sg shares it
-const FREE_WINDOW_MODEL = "deepseek-v4.1-flash"
-// both ids, so magpie's exact match finds the -sg one too
-const FREE_WINDOW_MODELS = ["deepseek-v4.1-flash", "deepseek-v4.1-flash-sg"]
+// the model a window is counted for is its spec's `model`; `aliases` are the
+// ids that share the window (-sg is the same model under its paid id), and
+// both are named in the card's models so magpie's exact match finds them
 
 // windowOffset is the UTC offset a refusal spells out, in minutes, from
 // "UTC+8", "UTC+08:00", "UTC-5" or "GMT+8". null when it spells out none,
@@ -2367,7 +2394,7 @@ function freeWindowOf(rows, account, now = Date.now(), win = FREE_WINDOW_AI) {
       r?.provider === win.provider &&
       r.providerAccount === account &&
       typeof r.model === "string" &&
-      r.model.startsWith(FREE_WINDOW_MODEL) &&
+      r.model.startsWith(win.model) &&
       r.t,
   )
   if (!mine.length) return null
@@ -2440,15 +2467,17 @@ function freeWindowOf(rows, account, now = Date.now(), win = FREE_WINDOW_AI) {
   if (now >= end) return null // lapsed: nothing is exhausted, a new window opens on the next request
 
   const card = (amount, resetsAt, refused) => ({
-    name: "Free model tokens",
+    name: win.name,
     used: Math.min(100, (100 * amount) / win.cap),
     amount,
     limit: win.cap,
-    unit: "tokens",
+    unit: win.unit,
     display: `${tokensShort(amount)} / ${win.short}`,
     resetsAt: new Date(resetsAt).toISOString(),
     span: FREE_WINDOW_SPAN / 1000,
-    models: FREE_WINDOW_MODELS.slice(),
+    // the window's own model and the ids that share it, so magpie's exact
+    // match finds every id it limits
+    models: [win.model, ...win.aliases],
     // the ledger's sum is an estimate, shown and set aside; the vendor's
     // refusal is the one that stops the model (see the window above)
     ...(refused ? { refused: true } : { aside: true }),
@@ -2550,10 +2579,11 @@ function freeWindowRows(account, now = Date.now(), cwd = process.cwd(), env = pr
   // way this ledger is written; one rewritten in place (a rotation or a
   // compaction) moves mtime even when its size lands the same.
   const file = path + "|" + st.mtimeMs + ":" + st.size
-  // the key carries the account and the build: one account's rows are its
-  // own, and the two builds' chains over one ledger must not answer for
-  // each other (the same phone number can be signed in to both)
-  const key = file + "|" + win.provider + "|" + account
+  // the key carries the account, the build and the model: one account's
+  // rows are its own, the two builds' chains over one ledger must not
+  // answer for each other (the same phone number can be signed in to both),
+  // and two windows of one build count different models
+  const key = file + "|" + win.provider + "|" + win.model + "|" + account
   if (ledgerParsed?.key === key) return ledgerParsed.rows
   let got
   try {
@@ -2617,15 +2647,15 @@ function rowAccount(line) {
 }
 
 // ofAccount is whether a row belongs to the chain read for account: this
-// account's own row of the build's free model, either id. A refusal of
-// another account's, of the other build, or of a paid model says nothing
-// about where this chain opens.
+// account's own row of the window's model, either id. A refusal of another
+// account's, of the other build, or of another model says nothing about
+// where this chain opens.
 function ofAccount(row, account, win = FREE_WINDOW_AI) {
   return (
     row?.provider === win.provider &&
     row.providerAccount === account &&
     typeof row.model === "string" &&
-    row.model.startsWith(FREE_WINDOW_MODEL)
+    row.model.startsWith(win.model)
   )
 }
 
@@ -3883,17 +3913,21 @@ function makePlugin(site) {
             } catch {}
           }
           await spareFree(site, a, out.windows)
-          // the free model's own window, which the credit meter above does
-          // not show: what actually refuses a chat long before 160 credits
-          // are spent. Both builds: WorkBuddy AI at 1e8 (ten days of
-          // refusals), the China build's at about 2e8 (2026-11-02). Set
-          // aside until the vendor refuses (see the window definitions above)
+          // each measured model's own window, which the credit meter above
+          // does not show: what actually refuses a chat long before the
+          // credits are spent. WorkBuddy AI has one (deepseek, 1e8, ten days
+          // of refusals); the China build's are measured one model at a time
+          // (deepseek at about 2e8, 2026-11-02), each its own card. Shown
+          // only, set aside: the vendor's refusal is what stops a model
+          // (see the window definitions above)
           {
             const account = a.accountId || a.user || a.uid || ""
-            const win = site.ai ? FREE_WINDOW_AI : FREE_WINDOW_CN
-            const rows = freeWindowRows(account, Date.now(), process.cwd(), process.env, homedir(), win)
-            const w = rows && freeWindowOf(rows, account, Date.now(), win)
-            if (w) out.windows.push(w)
+            const wins = site.ai ? [FREE_WINDOW_AI] : CN_ESTIMATED_WINDOWS
+            for (const win of wins) {
+              const rows = freeWindowRows(account, Date.now(), process.cwd(), process.env, homedir(), win)
+              const w = rows && freeWindowOf(rows, account, Date.now(), win)
+              if (w) out.windows.push(w)
+            }
           }
           return { ...out, signIn: said }
         } catch (e) {
@@ -4037,4 +4071,4 @@ export const WorkBuddyAuthPlugin = makePlugin(SITES.workbuddy)
 export const WorkBuddyAIAuthPlugin = makePlugin(SITES["workbuddy-ai"])
 
 // for tests
-export const _internal = { planCodes, listedExtra, idFor, OFF_TAKEN, replyAfterToolsOn, withDefaultEffort, SMALL_BUDGET, defaultEffortOf, gzipped, FREE_ONLY, PRICE_TTL, keyAccount, remoteConfig, cycleOf, typeUnions, systemAsUser, systemKey, DEFAULT_SYSTEM, EDGE_READS, fitShape, replyAfterTools, AFTER_TOOLS_REFUSED, enterpriseUsageOf, accountName, notDesktop, textOnly, runsOutOf, packagesOf, endOf, enterpriseHeaders, enterpriseOf, liveModels, browserSignIn, withSystem, asReasoning, normalizeToolChoice, fitTools, fitted, renamed, unsaid, FILTER_SAYS, unflagged, usageOf, desktopHeld, explained, REFUSED_HINT, RESTRICTED_HINT, EXHAUSTED_HINT, REFUSED_DOC, commaPaused, commaPausedOn, opened, freeCredits, creditsOf, priceOf, fresh, SITES, renewing, renewed, SESSION, attend, scopeOf, turnKey, conversationKey, signatureOf, isMessages, withoutUnsigned, withoutSignedThinking, prepared, answeredBefore, nativeOf, modelOf, configModels, freeWindowOf, tokensShort, freeWindowRows, freeWindowLedger, readLedgerTail, pinned, pinning, rowTime, rowAccount, ofAccount, windowOffset, windowReset, FREE_WINDOW_MODELS, FREE_WINDOW_CN, FREE_WINDOW_AI, FREE_WINDOW_SPAN, FREE_WINDOW_GAP, FREE_WINDOW_LEAD, checkinOf, API_MESSAGES: NPM_MESSAGES, API_CHAT: NPM }
+export const _internal = { planCodes, listedExtra, idFor, OFF_TAKEN, replyAfterToolsOn, withDefaultEffort, SMALL_BUDGET, defaultEffortOf, gzipped, FREE_ONLY, PRICE_TTL, keyAccount, remoteConfig, cycleOf, typeUnions, systemAsUser, systemKey, DEFAULT_SYSTEM, EDGE_READS, fitShape, replyAfterTools, AFTER_TOOLS_REFUSED, enterpriseUsageOf, accountName, notDesktop, textOnly, runsOutOf, packagesOf, endOf, enterpriseHeaders, enterpriseOf, liveModels, browserSignIn, withSystem, asReasoning, normalizeToolChoice, fitTools, fitted, renamed, unsaid, FILTER_SAYS, unflagged, usageOf, desktopHeld, explained, REFUSED_HINT, RESTRICTED_HINT, EXHAUSTED_HINT, REFUSED_DOC, commaPaused, commaPausedOn, opened, freeCredits, creditsOf, priceOf, fresh, SITES, renewing, renewed, SESSION, attend, scopeOf, turnKey, conversationKey, signatureOf, isMessages, withoutUnsigned, withoutSignedThinking, prepared, answeredBefore, nativeOf, modelOf, configModels, freeWindowOf, tokensShort, freeWindowRows, freeWindowLedger, readLedgerTail, pinned, pinning, rowTime, rowAccount, ofAccount, windowOffset, windowReset, CN_ESTIMATED_WINDOWS, FREE_WINDOW_AI, FREE_WINDOW_SPAN, FREE_WINDOW_GAP, FREE_WINDOW_LEAD, checkinOf, API_MESSAGES: NPM_MESSAGES, API_CHAT: NPM }

package/opencode.mjs

@@ -0,0 +1,5 @@
+// The package's OpenCode 1.x plugins, as OpenCode 1.x and magpie's host
+// load them: its plugin functions and nothing else (1.x refuses a
+// package whose exports include anything but plugins). OpenCode 2.x
+// loads opencode2.mjs, which runs these.
+export { WorkBuddyAIAuthPlugin, WorkBuddyAuthPlugin } from "./index.mjs"

package/opencode2.mjs

@@ -0,0 +1,594 @@
+// The OpenCode 2.x face of a package whose plugins are written for
+// OpenCode 1.x (and magpie's plugin host).
+//
+// OpenCode 2.x loads a package's `exports["."]` and wants its default to be
+// {id, setup(ctx)}; it has no fallback for a 1.x plugin's named functions
+// (plugins#657). This file is that default. It runs each 1.x plugin the
+// package's opencode.mjs exports and hands 2.x what the plugin's hooks say:
+//
+//   auth.methods     → the integration's sign-in methods
+//   config()         → the provider, its package, base URL and models
+//   provider.models  → the signed-in account's own model list
+//   auth.loader      → each request's base URL, key, headers and fetch
+//
+// What 2.x has no place for is left out: chat.headers and chat.params
+// (2.x's sdk hook doesn't carry the session), magpie's usage and checkin,
+// tools and events.
+//
+// scripts/opencode2.mjs is the one copy that is edited. Every package that
+// has it carries the same bytes as packages/<name>/opencode2.mjs, and
+// scripts/check.mjs fails when a copy differs.
+
+import { readFileSync } from "node:fs"
+import * as v1 from "./opencode.mjs"
+
+const pkg = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8"))
+
+// The key the SDK is made with: the account's own goes on each request in
+// its place (see wrapFetch), so a key read when the SDK was made can't go
+// out after the account changed.
+const PLACEHOLDER = "opencode2-v1-key"
+
+// The SDK package a 1.x npm name runs as on 2.x. A version keeps 2.x from
+// swapping @ai-sdk/* for its native providers, which never call the sdk
+// hook below; openai-compatible's is the one 2.x ships, the others are AI
+// SDK v6's dist-tag, the line 2.x's bridge runs.
+export function packageOf(npm) {
+  const name = npm || "@ai-sdk/openai-compatible"
+  if (name === "@ai-sdk/openai-compatible") return "aisdk:@ai-sdk/openai-compatible@2.0.41"
+  if (/^@ai-sdk\/[^/@]+$/.test(name)) return `aisdk:${name}@ai-v6`
+  return `aisdk:${name}`
+}
+
+// The plugins a 1.x module exports, as magpie's host and OpenCode 1.x read
+// them: a default {server} is the one plugin, else every function export
+// and every {server} object.
+export function pluginsOf(mod) {
+  const d = mod?.default
+  if (d && typeof d === "object" && ("server" in d || "id" in d || "tui" in d))
+    return typeof d.server === "function" ? [d.server] : []
+  const out = []
+  for (const value of Object.values(mod ?? {})) {
+    const fn = typeof value === "function" ? value : value && typeof value === "object" && typeof value.server === "function" ? value.server : null
+    if (fn && !out.includes(fn)) out.push(fn)
+  }
+  return out
+}
+
+const int = (n, fallback = 0) => {
+  const v = Math.trunc(Number(n))
+  return Number.isFinite(v) && v >= 0 ? v : fallback
+}
+const money = (n) => (Number.isFinite(Number(n)) && Number(n) >= 0 ? Number(n) : 0)
+const record = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {})
+const json = (v) => {
+  try {
+    return JSON.parse(JSON.stringify(v ?? null))
+  } catch {
+    return null
+  }
+}
+const strings = (v) => Object.fromEntries(Object.entries(record(v)).filter(([, s]) => typeof s === "string"))
+const nonEmpty = (o) => (Object.keys(o).length ? o : undefined)
+
+// connKey names a connection the way 2.x does.
+const connKey = (c) => (!c ? "" : c.type === "credential" ? `credential:${c.id}` : `env:${c.name}`)
+
+// ---- sign-in ------------------------------------------------------------
+
+// fields is a 1.x method's prompts as a 2.x form.
+export function fieldsOf(prompts) {
+  const out = []
+  for (const p of prompts ?? []) {
+    if (!p?.key) continue
+    const f = { key: String(p.key), type: "string", title: String(p.message ?? p.key) }
+    if (p.placeholder) f.placeholder = String(p.placeholder)
+    if (p.type === "select" && Array.isArray(p.options))
+      f.options = p.options.map((o) => ({ value: String(o.value), label: String(o.label ?? o.value), ...(o.hint ? { description: String(o.hint) } : {}) }))
+    // a prompt shown only when another answer says so can't be required
+    if (!p.condition) f.required = true
+    out.push(f)
+  }
+  return out.length ? out : undefined
+}
+
+// v1Saved is what a 1.x sign-in's success is saved as, the way 1.x writes
+// auth.json: the result without its type and provider.
+function v1Saved(r) {
+  const { type: _t, provider: _p, ...rest } = r
+  if ("key" in r) return { type: "api", ...rest }
+  return { type: "oauth", ...rest }
+}
+
+// credentialOf is a 1.x sign-in's success as a 2.x credential: OAuth for
+// both kinds, the 1.x auth kept whole in its metadata. No refresh is
+// registered, so 2.x hands the credential over as it is and the plugin's
+// own loader renews it, as it does on 1.x.
+export function credentialOf(methodID, r) {
+  if (!r || r.type !== "success") throw new Error(r?.error || r?.message || "the sign-in failed")
+  const saved = json(v1Saved(r))
+  if (saved.type === "api")
+    return { type: "oauth", methodID, access: String(saved.key ?? ""), refresh: "", expires: 0, metadata: { v1: saved } }
+  return {
+    type: "oauth",
+    methodID,
+    access: String(saved.access ?? ""),
+    refresh: String(saved.refresh ?? ""),
+    expires: int(saved.expires),
+    metadata: { v1: saved },
+  }
+}
+
+// authOfValue is the 1.x auth a 2.x credential stands for.
+export function authOfValue(value) {
+  if (!value) return null
+  if (value.type === "oauth") {
+    const v1 = record(value.metadata).v1
+    if (v1 && typeof v1 === "object") return v1
+    return { type: "oauth", access: value.access, refresh: value.refresh, expires: value.expires }
+  }
+  if (value.type === "key") {
+    const meta = value.metadata && Object.keys(value.metadata).length ? { metadata: value.metadata } : {}
+    return { type: "api", key: value.key, ...meta }
+  }
+  return null
+}
+
+const fingerprint = (a) => JSON.stringify([a?.type, a?.access ?? a?.key ?? "", a?.refresh ?? ""])
+
+// ---- models -------------------------------------------------------------
+
+const MODALITIES = ["text", "audio", "image", "video", "pdf"]
+
+// internalOf is a config model as 1.x hands it to provider.models: what
+// fromModelsDevModel makes of it, with the config's own variants.
+export function internalOf(providerID, conf, key, m) {
+  const mods = record(m.modalities)
+  const has = (list, k) => Array.isArray(list) && list.includes(k)
+  const cost = record(m.cost)
+  return {
+    ...m,
+    id: key,
+    providerID,
+    name: m.name ?? key,
+    api: { id: m.id ?? key, url: m.provider?.api ?? conf.api ?? conf.options?.baseURL ?? "", npm: m.provider?.npm ?? conf.npm ?? "@ai-sdk/openai-compatible" },
+    status: m.status ?? "active",
+    headers: m.headers ?? {},
+    options: m.options ?? {},
+    cost: { input: money(cost.input), output: money(cost.output), cache: { read: money(cost.cache_read), write: money(cost.cache_write) } },
+    limit: { context: int(m.limit?.context), input: m.limit?.input, output: int(m.limit?.output) },
+    capabilities: {
+      temperature: m.temperature ?? false,
+      reasoning: m.reasoning ?? false,
+      attachment: m.attachment ?? false,
+      toolcall: m.tool_call ?? true,
+      input: Object.fromEntries(MODALITIES.map((k) => [k, mods.input ? has(mods.input, k) : k === "text"])),
+      output: Object.fromEntries(MODALITIES.map((k) => [k, mods.output ? has(mods.output, k) : k === "text"])),
+      interleaved: m.interleaved ?? false,
+    },
+    release_date: m.release_date ?? "",
+    variants: record(m.variants),
+  }
+}
+
+// modelOf is a 1.x model, in config or internal form, as a 2.x Model.Info.
+export function modelOf(providerID, provider, key, m) {
+  const caps = record(m.capabilities)
+  const listFrom = (obj, list) => {
+    if (obj && typeof obj === "object") return MODALITIES.filter((k) => obj[k])
+    if (Array.isArray(list)) return list.map(String)
+    return ["text"]
+  }
+  const input = listFrom(caps.input, m.modalities?.input)
+  const output = listFrom(caps.output, m.modalities?.output)
+  const c = record(m.cost)
+  const cache = record(c.cache)
+  const npm = m.api?.npm ?? m.provider?.npm
+  const url = m.api?.url ?? m.provider?.api
+  const settings = { ...record(json(m.options)) }
+  if (url && url !== provider.baseURL) settings.baseURL = url
+  const variants = Object.entries(record(m.variants))
+    .filter(([, v]) => !record(v).disabled)
+    .map(([id, v]) => {
+      const { disabled: _d, ...rest } = record(json(v))
+      return nonEmpty(rest) ? { id, settings: rest } : { id }
+    })
+  const status = ["alpha", "beta", "deprecated", "active"].includes(m.status) ? m.status : "active"
+  const out = {
+    id: key,
+    modelID: String(m.api?.id ?? m.id ?? key),
+    providerID,
+    name: String(m.name ?? key),
+    capabilities: {
+      tools: caps.toolcall ?? m.tool_call ?? true,
+      input: input.length ? input : ["text"],
+      output: output.length ? output : ["text"],
+      ...(typeof (caps.temperature ?? m.temperature) === "boolean" ? { temperature: caps.temperature ?? m.temperature } : {}),
+    },
+    variants,
+    time: { released: Date.parse(m.release_date ?? "") || 0 },
+    cost: [{ input: money(c.input), output: money(c.output), cache: { read: money(cache.read ?? c.cache_read), write: money(cache.write ?? c.cache_write) } }],
+    status,
+    enabled: true,
+    limit: { context: int(m.limit?.context, 128000) || 128000, output: int(m.limit?.output, 8192) || 8192 },
+  }
+  if (m.limit?.input) out.limit.input = int(m.limit.input)
+  if (npm && npm !== provider.npm) out.package = packageOf(npm)
+  if (nonEmpty(settings)) out.settings = settings
+  const headers = strings(m.headers)
+  if (nonEmpty(headers)) out.headers = headers
+  return out
+}
+
+// ---- requests -----------------------------------------------------------
+
+const urlOf = (input) => (typeof input === "string" ? input : input instanceof URL ? input.href : input?.url ?? String(input))
+
+// wrapFetch sends a request the SDK made from the provider's settings the
+// way 1.x would have sent it with the loader's options: the loader's base
+// URL in place of the configured one, the account's key in place of the
+// placeholder, the loader's headers added, through the loader's fetch.
+export function wrapFetch(next, base, options) {
+  return async (input, init = {}) => {
+    const o = await options()
+    let url = urlOf(input)
+    const from = String(base ?? "").replace(/\/+$/, "")
+    const to = o.baseURL ? String(o.baseURL).replace(/\/+$/, "") : ""
+    if (from && to && from !== to && url.startsWith(from)) url = to + url.slice(from.length)
+    const req = input instanceof Request ? input : null
+    const headers = new Headers(init.headers ?? req?.headers ?? undefined)
+    for (const [k, v] of [...headers.entries()]) {
+      if (!v.includes(PLACEHOLDER)) continue
+      if (o.key) headers.set(k, v.replaceAll(PLACEHOLDER, o.key))
+      else headers.delete(k)
+    }
+    for (const [k, v] of Object.entries(strings(o.headers))) headers.set(k, v)
+    const send = typeof o.fetch === "function" ? o.fetch : next ?? fetch
+    if (req && init.body === undefined) {
+      const body = req.method === "GET" || req.method === "HEAD" ? undefined : await req.text()
+      return send(url, { method: req.method, headers, body, signal: init.signal ?? req.signal })
+    }
+    return send(url, { ...init, headers })
+  }
+}
+
+// ---- one plugin ---------------------------------------------------------
+
+async function setupPlugin(ctx, fn, live) {
+  const directory = ctx?.location?.directory ?? process.cwd()
+  // the active account each provider was last read for, and the renewed
+  // auth a plugin saved for it (2.x has no way for a plugin to write a
+  // credential back, so it is kept in the plugin's storage, under the
+  // credential it renews and the token it was renewed from)
+  const current = new Map()
+  const saved = new Map()
+  const signingIn = new Map()
+  const storeKey = (id, key) => `v1auth/${id}/${key}`
+
+  const client = {
+    auth: {
+      async set(arg) {
+        const id = arg?.path?.id
+        const body = json(arg?.body)
+        const cur = id && current.get(id)
+        // a sign-in's own saves belong to the credential it is about to
+        // make, not the one that was active when it started
+        if (!cur || !body || signingIn.get(id) > 0) return { data: true }
+        const entry = { fp: cur.fp, auth: body }
+        saved.set(storeKey(id, cur.key), entry)
+        await Promise.resolve()
+          .then(() => ctx.storage?.set?.(storeKey(id, cur.key), entry))
+          .catch(() => {})
+        return { data: true }
+      },
+      async get() {
+        return { data: undefined }
+      },
+    },
+    app: { log: async () => ({ data: true }) },
+  }
+
+  const hooks = (await fn({ client, directory, worktree: directory, project: {}, serverUrl: undefined, $: undefined }, {})) ?? {}
+  const cfg = { provider: {} }
+  try {
+    await hooks.config?.(cfg)
+  } catch {}
+  const auth = hooks.auth
+  const authID = auth?.provider ? String(auth.provider) : undefined
+  const providers = record(cfg.provider)
+
+  // getAuth reads the active account: the credential 2.x holds, or what the
+  // plugin last saved renewing it.
+  const getAuth = async (id) => {
+    const connection = await ctx.integration.connection.active(id).catch(() => undefined)
+    if (!connection) {
+      current.delete(id)
+      return undefined
+    }
+    const value = await ctx.integration.connection.resolve(connection).catch(() => undefined)
+    const base = authOfValue(value)
+    if (!base) {
+      current.delete(id)
+      return undefined
+    }
+    const key = connKey(connection)
+    const fp = fingerprint(base)
+    // ours: a credential one of this plugin's own sign-ins made
+    const ours = value?.type === "oauth" && !!record(value.metadata).v1
+    current.set(id, { key, fp, ours })
+    const sk = storeKey(id, key)
+    let entry = saved.get(sk)
+    if (!entry) {
+      entry = await Promise.resolve()
+        .then(() => ctx.storage?.get?.(sk))
+        .catch(() => undefined)
+      if (entry) saved.set(sk, entry)
+    }
+    return entry && entry.fp === fp && entry.auth ? entry.auth : base
+  }
+
+  // the sign-in methods
+  if (authID && Array.isArray(auth.methods) && auth.methods.length) {
+    const label = (c) => {
+      const a = authOfValue(c)
+      const name = a?.name ?? a?.email ?? a?.metadata?.name ?? a?.metadata?.email ?? a?.account
+      return typeof name === "string" && name ? name : undefined
+    }
+    const begin = () => signingIn.set(authID, (signingIn.get(authID) ?? 0) + 1)
+    const end = () => signingIn.set(authID, Math.max(0, (signingIn.get(authID) ?? 1) - 1))
+    const title = record(providers[authID]).name
+    // 2.x runs a transform again on every reload, from nothing
+    await ctx.integration.transform((editor) => {
+      let keyed = false
+      // the integration 2.x makes for an id it doesn't know is named by the
+      // id; the provider's own name reads better in the sign-in list
+      if (typeof title === "string" && title)
+        try {
+          editor.update?.(authID, (i) => {
+            if (i && (!i.name || i.name === authID)) i.name = title
+          })
+        } catch {}
+      auth.methods.forEach((m, i) => {
+        if (!m) return
+        const methodID = `v1-${i}`
+        const form = fieldsOf(m.prompts)
+        if (m.type === "api" && typeof m.authorize !== "function") {
+          if (keyed) return
+          keyed = true
+          editor.method.update({ integrationID: authID, method: { type: "key", label: String(m.label ?? "API key"), ...(form ? { form } : {}) } })
+          return
+        }
+        if (typeof m.authorize !== "function") return
+        editor.method.update({
+          integrationID: authID,
+          method: { id: methodID, type: "oauth", label: String(m.label ?? authID), ...(form ? { form } : {}) },
+          async authorize(answer) {
+            begin()
+            let ended = false
+            const done = () => {
+              if (!ended) end()
+              ended = true
+            }
+            try {
+              const inputs = Object.fromEntries(Object.entries(record(answer)).map(([k, v]) => [k, String(v)]))
+              const r = await m.authorize(inputs)
+              if (m.type === "api") {
+                done()
+                return { url: "", instructions: "", mode: "auto", callback: Promise.resolve().then(() => credentialOf(methodID, r)) }
+              }
+              if (r?.method === "code")
+                return {
+                  url: String(r.url ?? ""),
+                  instructions: String(r.instructions ?? ""),
+                  mode: "code",
+                  callback: async (code) => {
+                    try {
+                      return credentialOf(methodID, await r.callback(code))
+                    } finally {
+                      done()
+                    }
+                  },
+                }
+              const callback = Promise.resolve()
+                .then(() => r.callback())
+                .then((res) => credentialOf(methodID, res))
+                .finally(done)
+              callback.catch(() => {})
+              return { url: String(r?.url ?? ""), instructions: String(r?.instructions ?? ""), mode: "auto", callback }
+            } catch (e) {
+              done()
+              throw e
+            }
+          },
+          label,
+        })
+      })
+    })
+  }
+
+  // the loader's options for the account signed in now, read again when
+  // the account changes
+  let loaded = null
+  const loaderOptions = async (id) => {
+    if (id !== authID || typeof auth?.loader !== "function") {
+      const a = authID === id ? await getAuth(id) : undefined
+      return { key: a?.type === "api" ? a.key : undefined }
+    }
+    const a = await getAuth(id)
+    if (!a) return {}
+    const fp = current.get(id)?.key + "\0" + fingerprint(a)
+    if (loaded?.fp !== fp) {
+      const p = Promise.resolve()
+        .then(() => auth.loader(() => getAuth(id), providerOf(id)))
+        .then((o) => record(o))
+      loaded = { fp, p }
+      p.catch(() => {
+        if (loaded?.fp === fp) loaded = null
+      })
+    }
+    const o = await loaded.p
+    const key = typeof o.apiKey === "string" && o.apiKey ? o.apiKey : a.type === "api" ? a.key : undefined
+    return { baseURL: o.baseURL, key, headers: o.headers, fetch: o.fetch }
+  }
+
+  // the providers, with the list the account's own read last gave each
+  const source = new Map()
+  // providerOf is a provider as 1.x hands it to provider.models and
+  // auth.loader
+  const providerOf = (id) => {
+    const conf = record(providers[id])
+    const models = Object.fromEntries(Object.entries(record(conf.models)).map(([k, m]) => [k, internalOf(id, conf, k, record(m))]))
+    return { id, name: conf.name ?? id, source: "config", env: [], options: record(conf.options), models }
+  }
+  const listed = new Set()
+  for (const [id, conf0] of Object.entries(providers)) {
+    const conf = record(conf0)
+    // a provider entry that only names the sign-in (no package, no models)
+    // is not a provider of models
+    if (!conf.npm && !Object.keys(record(conf.models)).length) continue
+    const options = record(conf.options)
+    const { apiKey: _k, baseURL: _b, fetch: _f, headers: optHeaders, ...rest } = options
+    // with no base URL the config leaves it to the loader: a name that
+    // can't resolve stands in for it, and each request swaps in the
+    // loader's (wrapFetch)
+    const baseURL = options.baseURL ?? conf.api ?? `https://${id.replace(/[^a-z0-9-]/gi, "-")}.opencode2-v1.invalid`
+    const npm = conf.npm ?? "@ai-sdk/openai-compatible"
+    const info = {
+      id,
+      ...(id === authID ? { integrationID: id } : {}),
+      name: String(conf.name ?? id),
+      activation: "auto",
+      package: packageOf(npm),
+      settings: { ...record(json(rest)), ...(baseURL ? { baseURL: String(baseURL) } : {}) },
+    }
+    const headers = { ...strings(conf.headers), ...strings(optHeaders) }
+    if (nonEmpty(headers)) info.headers = headers
+    const prov = { baseURL, npm }
+    const fromConfig = () =>
+      Object.entries(record(conf.models)).map(([key, m]) => modelOf(id, prov, key, internalOf(id, conf, key, record(m))))
+    listed.add(id)
+    await ctx.provider.transform((editor) => {
+      const s = source.get(id)
+      editor.add({ info, models: s?.models ?? fromConfig(), sourceConnection: s?.connection })
+    })
+    source.set(id, { conf, prov, models: null, connection: undefined })
+  }
+
+  // each request: the placeholder key, and the fetch that swaps in the
+  // account's. A provider the package doesn't list (one 2.x has built in
+  // that the plugin only signs in to) is left to 2.x unless the plugin's
+  // loader serves it and one of the plugin's own sign-ins is active.
+  const own = authID && !listed.has(authID) && typeof auth?.loader === "function" ? [authID] : []
+  for (const id of new Set([...listed, ...own])) {
+    const base = source.get(id)?.prov.baseURL
+    await ctx.aisdk.hook(
+      "sdk",
+      async (evt) => {
+        const opts = evt.options
+        if (!opts || opts.__opencode2) return
+        if (!listed.has(id)) {
+          await getAuth(id)
+          if (!current.get(id)?.ours) return
+        }
+        opts.__opencode2 = true
+        opts.apiKey = PLACEHOLDER
+        opts.fetch = wrapFetch(opts.fetch, opts.baseURL ?? base, () => loaderOptions(id))
+      },
+      { providerID: id },
+    )
+  }
+
+  // refresh reads the account's own list after a sign-in or a switch
+  const listID = hooks.provider?.id ? String(hooks.provider.id) : undefined
+  let refreshing = null
+  let again = false
+  // the account the list was last read for: a credential.updated that
+  // leaves it as it was reads nothing again
+  let readFor = null
+  const stateOf = async () => {
+    const c = await ctx.integration.connection.active(authID).catch(() => undefined)
+    const a = c ? await getAuth(authID) : undefined
+    return connKey(c) + "\0" + (a ? fingerprint(a) : "")
+  }
+  const refresh = () => {
+    if (refreshing) {
+      again = true
+      return refreshing
+    }
+    refreshing = (async () => {
+      try {
+        if (!authID || !source.has(authID)) return
+        const s = source.get(authID)
+        const connection = await ctx.integration.connection.active(authID).catch(() => undefined)
+        const a = connection ? await getAuth(authID) : undefined
+        readFor = connKey(connection) + "\0" + (a ? fingerprint(a) : "")
+        if (!a || listID !== authID || typeof hooks.provider?.models !== "function") {
+          if (s.connection || s.models) {
+            s.connection = undefined
+            s.models = null
+            await ctx.provider.reload()
+          }
+          return
+        }
+        const provider = providerOf(authID)
+        let got
+        try {
+          got = await hooks.provider.models(provider, { auth: a })
+        } catch {
+          got = null
+        }
+        if (connKey(await ctx.integration.connection.active(authID).catch(() => undefined)) !== connKey(connection)) {
+          again = true
+          return
+        }
+        s.connection = connection
+        s.models = got && typeof got === "object" ? Object.entries(got).map(([k, m]) => modelOf(authID, s.prov, k, record(m))) : null
+        await ctx.provider.reload()
+        await ctx.model?.reload?.()
+      } finally {
+        refreshing = null
+        if (again && live.on) {
+          again = false
+          void refresh()
+        }
+      }
+    })()
+    return refreshing
+  }
+
+  if (authID && ctx.event?.subscribe)
+    void (async () => {
+      try {
+        // a switch names the integration; an update (a sign-in, a removal)
+        // names nothing, so it reads again only when this account changed
+        const types = ["credential.switched", "credential.updated"]
+        for await (const event of ctx.event.subscribe({ types })) {
+          if (!live.on) return
+          if (event?.type === "credential.switched" && event?.data?.integrationID === authID) {
+            loaded = null
+            await refresh()
+          } else if (event?.type === "credential.updated" && (await stateOf()) !== readFor) {
+            await refresh()
+          }
+        }
+      } catch {}
+    })()
+  void refresh()
+}
+
+export async function setup(ctx, mod = v1) {
+  const live = { on: true }
+  for (const fn of pluginsOf(mod)) {
+    try {
+      await setupPlugin(ctx, fn, live)
+    } catch (e) {
+      // one plugin failing to start leaves the package's others working
+      console.error(`${pkg.name}: ${e?.message ?? e}`)
+    }
+  }
+  return () => {
+    live.on = false
+  }
+}
+
+export default { id: pkg.name, setup: (ctx) => setup(ctx) }

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@magpie-community/opencode-workbuddy-auth",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "OpenCode provider plugins for WorkBuddy's plans: WorkBuddy (CodeBuddy, copilot.tencent.com) and WorkBuddy AI (www.workbuddy.ai)",
   "type": "module",
-  "main": "./index.mjs",
-  "exports": "./index.mjs",
+  "main": "./opencode.mjs",
+  "exports": { ".": "./opencode2.mjs" },
   "files": [
     "index.mjs",
+    "opencode.mjs",
+    "opencode2.mjs",
     "README.md"
   ],
   "keywords": [