Your Qoder subscription in OpenCode and magpie. The package serves Qoder's two sites, whose accounts exist only on their own:
| Provider id | Site | Accounts | Plugin export |
|---|---|---|---|
qoder |
qoder.com (international) | Google, GitHub or email | QoderAuthPlugin |
qoder-cn |
qoder.cn (Qoder CN) | Alibaba Cloud or phone number | QoderCNAuthPlugin |
qwenwork |
gateway.qwenwork.cn (QwenWork) | phone number or email | QwenWorkAuthPlugin |
qwenwork-enterprise |
the enterprise's own domain (QwenWork) | email OTP or enterprise SSO | QwenWorkEnterpriseAuthPlugin |
What follows is about qoder. Qoder CN works the same way on its own
hosts; its section says what differs.
Sign in with Qoder is the sign-in Qoder's desktop client uses:
- A PKCE device flow opens qoder.com's account page.
- openapi.qoder.sh is polled every 2 s until you authorize, for at most 15 minutes.
- The device token is traded for a job token, and the account's email and name are read.
The page is asked for no redirect_uri, as Qoder's CLI asks for none, so
the sign-in ends in the browser tab even when Qoder.app is installed
(before 0.2.25 it sent the desktop app's qoder-app://, which handed the
page to Qoder.app).
Sign in with Qoder PAT (and Sign in with Qoder CN PAT) skips the
device flow: a Personal Access Token from <site>/account/integrations is
posted to /api/v1/jobToken/exchange (personal_token), which answers a
job token, its refresh token and its expiry. The PAT is kept on the
credential, so a lapsed job refresh is exchanged again instead of asking
for the sign-in; PATs last up to a year. The job token signs the model list
and chat calls with the same COSY envelope either sign-in's does.
On Qoder CN this is the plugin's own reading of the protocol rather than
the CLI's path: qoder.cn's CLI signs requests with its device token and
never asks for a job token. Verified against a live qoder.cn account — the
exchange answers 200 with a jt- token, the signed model list answers 200
with that account's own models, and a chat completion returns its text.
A PAT account keeps the name its browser sign-in takes (email || uid): magpie
replaces an account on a new sign-in when both the accountId and the uid
match, so a renewed PAT sign-in names the same account rather than adding a
row beside the lapsed one.
A PAT account has no device token, so its usage read, campaigns pages and
daily check-in go out on the job token instead. The check-in works on it: a
live PAT account answered 200 to the campaigns list and CLAIMED to a claim,
so it earns the daily credits the browser sign-in does. That path has no
second token to rotate, so a refused call is the answer rather than a retry.
What is kept: the job token, its refresh token and expiry, the uid, the
device token and a machine id made for this sign-in. OpenCode keeps them in
auth.json; magpie keeps them in plugin-auth.json.
Refreshing:
- Qoder spends a refresh token once, so the plugin never sends one twice.
- magpie renews the job token 10 minutes before it runs out, through the
plugin's
auth.refresh, once for the account and before its requests, models and usage need it; magpie saves the new pair. OpenCode doesn't call that hook: there the job token is refreshed 5 minutes before it runs out, before a request, and the new pair is saved straight away. - Only one refresh runs at a time. A request that reads the sign-in before magpie saved a renewal uses the renewed pair, and a renewal handed a pair a request already spent gives what that request got.
- A job token's end is what Qoder says:
expire_timeorexpires_at(a date, or an epoch in seconds or milliseconds), thenexpires_in(milliseconds), then a day. - A chat Qoder answers 401 or 403 with no other code ("Login expired") is sent again once: with the pair saved since, when another request, magpie or another process renewed it meanwhile, else after one refresh, under the same lock. A token renewed less than 5 minutes ago and refused again isn't renewed again; the refusal is the answer.
- A model Qoder serves that the account's listing has off or leaves out is
asked for the same way: the job token is renewed once (or the pair saved
since is used) and the list read again, before the request is answered
unknown or disabled model. On a job token Qoder no longer honours in full, the listing can have only the free models on (#484). The same 5-minute rule holds, and an id Qoder has never served is said unknown at once, with no renewal. - The device token, which reads usage, has no end on record: it is rotated when Qoder refuses it. On a Qoder CN device-token account it is the chat token too, and is renewed as above.
- When Qoder refuses a refresh (401 or 403), the account needs signing in again. Any other failure is tried again later.
Qoder serves its models on the API its client talks to:
api3.qoder.sh/algo/api/v2/service/pro/sse/agent_chat_generation. The
plugin's fetch takes the chat completion OpenCode sends and does the rest
itself.
Writing the request
- It writes the chat completion as Qoder's request:
- Qoder's own system line comes before yours.
- Messages become text and image blocks.
- Tool calls and results become OpenAI tool turns. Images a tool returned follow in a user turn.
- A result whose id the client lost answers its turn's call in order (since 0.2.22, #277): Qoder refuses a whole request with a result that answers no call before it. A result with no call left to answer goes as text in the user's turn.
- Your tools become Qoder's native function tools.
- A call the client sent without an id gets one made from its turn, its place and its arguments, so it goes out the same on every request.
- It marks the prompt for Qoder's cache as Qoder's own client does (since
0.2.26, #290): the last block of the last user turn carries
cache_control: ephemeral(nothing is marked when the last turn is a tool's result), user turns carry their blocks ascontentstoo, and each request names its conversation insession_id. That id is a hash of the session the agent names (since 0.2.31, #330: DSH'sx-deepseek-harness-session-idand the other agents' own session headers, which magpie hands the plugin'schat.headershook, and OpenCode's session), else of Codex's thread (prompt_cache_key) when magpie sends one, else of the conversation's start, so every turn of one conversation names the same session; the key itself never goes out. Each request has its ownrequest_idandchat_record_id. - Every call that answers one user prompt goes out as one task, as Qoder's
own client sends it (since 0.2.31, #330): one
request_set_id, which is alsobusiness.id, and onebusiness.begin_atfor every call of the tool loop,business.stage"start" until a call is answered and "processing" after. A new user prompt in the session is a new task. The plugin keeps at most 512 tasks, each for 2 hours after its last call. Before 0.2.31 each call was a task of its own.- The model's own configuration from Qoder's list goes with it.
- It picks the reasoning effort from the model's own levels:
- The nearest level to the one asked, the higher one on a tie.
- The model's default when none is asked.
- The lowest level for "none", when the model can't turn thinking off.
- It picks the context window (
context_length) from the model's own windows (Qoder's Context setting: 200K, 400K, 1M): the default while the request fits it, else the smallest that holds it, else the largest. A larger window may cost more, so it is asked for only when needed. - It encodes the body with the client's codec and signs the call with the
client's COSY envelope. The envelope carries:
- the account, AES-encrypted, with the key wrapped by Qoder's RSA key;
- an MD5 signature;
- the machine id and the client's headers.
Cosy-Version: the worker runtime version that Qoder's desktop app ships (1.1.69 in app 0.4.8, since 0.2.23, #281), becauseCosy-ClientTypesays the desktop app.
Reading the reply
- Qoder's SSE comes back as a chat completion, streamed or not, with reasoning and usage.
- Tool calls Qoder writes as XML or JSON in its text become tool calls. Tool calls it sends the OpenAI way keep Qoder's id.
- A call written in the text that can't be read, or that the stream ends inside, is never sent on as the answer (since 0.2.16, #132): the turn ends as an error, a 502 or the stream's error frame with no finish, so the agent or magpie can try again. A call whose JSON is whole when the stream ends without its close is still the call; a tag in code or prose stays text.
- A call written in Anthropic's or Qwen's tags with no
<tool_call>around it (since 0.2.36, #323),<function_calls>around one or more<invoke name="…"><parameter name="k">v</parameter></invoke>, or<function=name><parameter=k>v</parameter></function>, is a call too, but only for a tool the request declared; for any other, or in backticks or a code fence, it stays text. A parameter's value is JSON unless the tool's schema says string, in these and in<tool_call>.
Errors
| What Qoder says | What the request returns |
|---|---|
| A refused sign-in (no code, or code 105) | 401 |
| A quota (codes 110, 112–119, 122) | 429 |
| Busy or queued for the model (code 10605) | Since 0.2.28 the request waits in Qoder's queue as Qoder's client does (below), then is sent again; past the wait, 503 with Retry-After from Qoder's retryAfterSeconds (30s when it gives none). Since 0.2.40, when magpie has another candidate after this request (x-magpie-fallback: 1), the 503 comes at once, saying the queue and how many are ahead, and magpie asks the next. The sign-in is untouched |
| A refusal of the request itself (codes 406, 416, 430, 80411, 80412, 100400–100403) | 400, with Qoder's words |
| "Error in upstream response", the model's own vendor behind Qoder failing, which Qoder sends as a 400 (since 0.2.24) | 502, so magpie asks again or another account; the sign-in is untouched |
| A failure before the answer starts | Qoder's status |
| A failure after the answer has started | The stream ends with an error |
Chat responses report the display name from the same model-list entry used to build the request, in both JSON completions and every SSE chunk (including usage). A blank name or a name equal to the slot key falls back to the requested model ID. This shared behavior applies to Qoder, Qoder CN, QwenWork and QwenWork Enterprise, including tier labels.
Reporting the name does not fetch the model list again. The existing
cache and model-list refresh behavior remain in place: a model missing
from the cache still forces a refresh, and normal list refreshes update
the configuration and name together. Model-list keys, API IDs,
X-Model-Key and model_config are unchanged; slots with the same display
name remain independently selectable. The name describes the catalog
entry used for the request, not an attestation of the backend that
executed it.
The provider.models hook reads the account's own list, as Qoder's client
asks for it (/algo/api/v2/model/list). It keeps the enabled models of the
listing's app scene, the list Qoder's app shows and the one a request
names (session_type: "app"), and adds any model only the chat scene
still lists after the model it follows there, so a model picked before
stays served (since 0.2.13, #97: the app listed Fast, 0.8×, where chat
lists Performance, 1.1×). It leaves out "auto" and "default", which route
inside Qoder. It takes
each model's reasoning levels from its thinking_config, and its context
from its context_config: the largest window it offers (Qoder's docs
give Qwen3.8-Flash 200K, 400K and 1M), not max_input_tokens (180K
there), which is only what a request naming no window gets. A model listed
with no windows keeps max_input_tokens.
The config hook declares the list as it was on 2026-09-30, with the
app's Fast from 2026-10-12:
- Ultimate, Fast, Performance, Efficient
- Sonus, Cantus
- Qwen3.8-Max, Qwen3.8-Flash, Qwen3.7-Max, Qwen3.7-Plus
- Kimi-K3, Kimi-K2.8-Preview
- GLM-5.3, GLM-5.3-Flash
- DeepSeek-V4-Pro, DeepSeek-Flash
- MiniMax-M3
Every model speaks chat completions (@ai-sdk/openai-compatible).
Every model a site ships also says, either way, whether it takes images:
attachment and modalities.input are set on every config entry, image
or no image. A kind left out is not "text only" to magpie but "the vendor
didn't say", and magpie then falls back to models.dev's vote by bare model
ID — where a same-named model of another vendor may take images, so this
one gets sent them. QwenWork's three models and Qoder CN's Lite shipped no
image key; since 0.2.47 they say text alone.
qoder-cn is for accounts on qoder.cn, the China site.
Those accounts sign in with Alibaba Cloud or a phone number and can't sign
in through qoder. Qoder CN speaks the same protocol as qoder.com:
- the same device flow, poll, job token and refresh paths;
- the same COSY envelope and body codec;
- the same model list, chat and usage paths.
Only the hosts and the sign-in's client id differ. The plugin uses the ones
Qoder CN's own CLI builds in for its cn build (@qodercn-ai/qoderclicn
1.1.65):
qoder |
qoder-cn |
|
|---|---|---|
| Sign-in page | qoder.com | qoder.cn |
| Accounts: poll, tokens, user info, usage | openapi.qoder.sh | openapi.qoder.com.cn |
| Models and chat | api3.qoder.sh | gateway.qoder.com.cn |
| Device-flow client id | Qoder's desktop client's | Qoder CN's CLI's (production) |
redirect_uri on the sign-in page |
none, as Qoder's CLI sends (since 0.2.25) | none, as the CLI sends |
Qoder CN's CLI chats with the device token itself and never makes a job token. The plugin asks qoder.cn for a job token first, as it does on qoder.com. If qoder.cn refuses it (a 4xx), the account works the way the CLI does:
- the device token signs the model calls;
- it is renewed with
/api/v1/deviceToken/refresh, the chat and account tokens being one pair; - a refused renewal (401 or 403) means signing in again.
Until you sign in, the config hook declares the tiers Qoder CN's CLI names
(Ultimate, Performance, Efficient, Lite). Once you are signed in, the
account's own list from gateway.qoder.com.cn replaces them.
Neither magpie's built-in Qoder CN nor this plugin has been checked against every kind of qoder.cn account. If a sign-in or a chat fails, please open an issue with the error.
A Qoder CN enterprise on its own VPC instance signs in with Sign in with
Qoder CN Enterprise (VPC) (since 0.2.8). It asks for the instance: its
name (acme) or one of its addresses (acme.vpc.qoder.com.cn,
https://acme.vpc.qoder.com.cn). Only https and hosts under
vpc.qoder.com.cn are taken.
The account then uses the instance's own hosts, as Qoder CN's CLI
(@qodercn-ai/qoderclicn 1.1.64) does once a VPC instance is set. The
paths, client id and protocol are the public ones:
| Public Qoder CN | VPC instance acme |
|
|---|---|---|
| Sign-in page | qoder.cn | acme.vpc.qoder.com.cn |
| Accounts: poll, tokens, user info, usage | openapi.qoder.com.cn | acme-openapi.vpc.qoder.com.cn |
| Models and chat | gateway.qoder.com.cn | acme-gateway.vpc.qoder.com.cn |
- The instance is kept with the account, so its refreshes, models, usage and check-in go to the instance too. An account kept with an instance that isn't one is asked to sign in again; it is never sent to the public hosts.
- The account is named
<email> (<instance>), so it is listed apart from the same person's public account. - An enterprise's usage shows as the Enterprise plan.
- Sign in with Qoder CN is unchanged and still the first way. An account signed in without an instance works as before.
The hosts and reply shapes come from a real VPC account's report (yetone/magpie#312). This plugin has not been tried with a VPC account.
An account signed in with a phone is shown by that phone — masked, 138****8000 — not by
its accountId, which is a uuid. Qoder CN's user info answers the number as security_mobile
(measured 13800138000), so that is what the card takes.
QwenWork's phone accounts answer only the last four digits, as name, beside a synthetic
phone_<uuid>@phone.local email (measured): the card shows ****8000 and never that email.
An email sign-in keeps its email.
accountId stays the account's identity — what magpie keys the user's own name for
it, its proxy, model picks, caps and a gateway key's account list by — so it never
changes: it is what a sign-in and every renewal give back. The card's name is usage's
user, a field magpie shows and never keys by.
A sign-in reads the user info, and a renewal reads it again (outside the token lock), so an account stored by an earlier version shows the phone on the card at its next renewal. A failed read changes nothing and never costs a sign-in.
QwenWork and QwenWork 企业版 serve Alibaba's own QwenWork (qwenwork.cn)
on this same protocol, with the desktop client's client id, an RSA key the
Qoder one's equal, its own qwork scene, and the device token as the chat
token. The public cloud's sign-in is the desktop app's device flow, with
redirect_uri=qwenwork-cn://; usage reads the sign-in's account-context.
A personal account's quota there has total and used null, only
remaining, so the card shows what is left as its balance, with each pool
(daily, monthly, long-term) from /api/v1/adapter/user/wallets, as
QwenWork's own client reads them; no share used is made up. An account
with a total keeps its used / total window, and a biz account (or the
enterprise flagship) never asks for the wallets.
There is no PAT and no daily check-in on it: the pat: false and
checkin: false site fields turn both off, so Qoder's device identity is
never sent there.
The enterprise flagship (企业旗舰版, a VPC / private deployment) serves
web/openapi/api on the enterprise's own single domain, and its device
flow sends no redirect_uri (/device/selectAccounts refuses one).
Its sign-in asks for that domain — the host the admin console lives on,
like your-company.vpc.qwenwork.cn; QWENWORK_ENT_DOMAIN presets it so
the sign-in asks nothing. Every call — chat, models, refresh, usage —
routes to that host, and the account is named <email|uid> (<domain>).
The login page expires in 5 minutes; a member signing in by email OTP
must have their email bound to their account in the admin console, or the
page answers 用户不存在.
The flagship deploys no model-catalog service (/algo/api/v2/model/list
answers 503 there), so its list falls back to the public cloud's qwork
models shipped in this package: flash, pro and qwen3.8-max-preview. A 503
falls back; any other error doesn't.
Qoder gives credits for a daily claim (the Qoder client's campaign
CLAIM_BENEFIT, 100 Credits a day as reported), on both sites. magpie can
claim it for each account when its Qoder check-in switch is on
(Settings), through auth.checkin: an already claimed campaign is done,
a campaign not available is inactive, and a claimable one is claimed
with its benefit amount. It asks these pages through this plugin's own
campaigns path (since 0.2.7),
which sends them as the account, on the device token (Bearer,
Cosy-ClientType: 10) as usage is read; a refused device token is
rotated once and the page asked again.
International campaigns also need Qoder's native device identity:
Cosy-MachineToken and Cosy-MachineType. Without them, the server can
return HTTP 200 but omit the daily claim. The plugin reads them from
Qoder's own runtime-info helper for the signed-in uid, sharing an
in-flight read and caching it in memory for an hour. The same identity
goes on the list, the claim and a device-token retry; it is not saved in
the account's credentials.
- Install Qoder desktop, or sign in to Qoder CLI once, to make its native
runtime available. The plugin finds the desktop's
resources/umid(Qoder.appon macOS,%LOCALAPPDATA%\Programs\Qoderor, since 0.2.26,%ProgramFiles%\Qoderon Windows,/opt/Qoderon Linux) or the runtime the CLI caches in~/.qoder/.bin(runtime-info-<platform>-<arch>-*on macOS and Linux,umid-win32-x64-*\runtime-info.exeon Windows;QODER_CONFIG_DIR,QODER_CLI_HOMEandQODER_CONFIG_DIR_NAMEmove it as they move the CLI's folder). - For another installation location, set
QODER_RUNTIME_INFOto the absolute path of Qoder's installedruntime-infoexecutable (runtime-info.exeon Windows), with its accompanying SDK files. - With no helper anywhere (a machine that never had Qoder desktop or
Qoder CLI), the check-in is
ineligiblefor the day, with a message saying to install one (or setQODER_RUNTIME_INFO); magpie asks again the next day rather than every 30 minutes (#304). The identity comes only from Qoder's own helper: the plugin never makes one up, so such an international account gets no daily claim until Qoder is installed. - A helper that is there but can't be read, or gives an invalid identity,
is
failedand asked again later, rather than a false "no activity" result. - With the identity read and sent, a list with no daily claim is
inactive, with a message (since 0.2.32) saying Qoder offered this device's identity no daily credits campaign, that Qoder decides that per device, and that the credits can be claimed in Qoder desktop when it shows them (#304: a Linux CLI identity was offered none while the same account's desktop identity was). The plugin never sends another device's identity.
Qoder CN (since 0.2.30) sends its own device identity the same way when
Qoder CN is installed: its desktop 0.4.9 and CLI (qoderclicn) both ask
Qoder CN's runtime-info for environment 0 (the international one is
3) and send it on the campaigns pages (yetone/magpie#2911, #304).
-
The plugin finds Qoder CN desktop's
resources/umid(Qoder CN.appon macOS,%LOCALAPPDATA%\Programs\Qoder CNor%ProgramFiles%\Qoder CNon Windows,/opt/Qoder-CNon Linux) or the runtime its CLI caches in~/.qoder-cn/.bin(QODERCN_CONFIG_DIR,QODERCN_CLI_HOMEandQODERCN_CONFIG_DIR_NAMEmove it).QODERCN_RUNTIME_INFOnames another location;QODER_RUNTIME_INFOis only the international one's. -
Without it the requests go out as before, as Qoder CN's desktop does when it can't read the identity, and a claim the list still offers is made. When the list then offers no daily claim, the check-in is
ineligiblefor the day with a message to install Qoder CN desktop (or sign in to its CLI); a helper that is there but can't be read makes itfailed, asked again later. -
Not tried with a real Qoder CN account: whether Qoder CN now hides the daily claim from a request without the identity, as the international site does, is inferred from its clients, not seen.
-
List:
GET <openapi>/sash/api/v1/me/campaigns:campaigns[]withcampaignId,actionType,claimStatus(CLAIMABLE,CLAIMED),startAt,endAt,benefit.amount. -
Claim:
POST <openapi>/sash/api/v1/me/campaigns/{id}/claim, body{}:statusCLAIMED(or underdata). -
<openapi>isopenapi.qoder.sh(Qoder) oropenapi.qoder.com.cn(Qoder CN). Other pages on those hosts are still refused.
When it is asked (0.2.43). The daily 100 credits are a campaign of
their own each day, listed from 10:00 (UTC+8) to 09:59 the next day
(startAt/endAt; the campaign's own text says "Daily reset: 10:00
(UTC+8)", a live list on 2026-10-28). A check-in before 10:00 meets the day
before's campaign: it claims that one if it is still open. Every answer
that knows the window carries until, the next campaign's opening (a day
after this one's start, or its end when it runs longer) plus a minute, and
magpie (with until support) asks again then, so today's credits are
claimed a minute or two after 10:00 (UTC+8), whatever the computer's time
zone, with nothing to set. Between the old campaign's end at 09:59 and
10:00 the check-in is failed with until 10:01. An older magpie ignores
until and asks once a Beijing calendar day, as before.
Taken from wallechfox/qoder-checkin, which a user reports works, and Qoder desktop 0.4.3's campaign requests. International campaign discovery was checked with a real account on 2026-10-08: the native identity exposed the claimable 100 credits, and omitting either header hid them. This verification only queried the activity; a live claim was not performed.
A positive credit balance does not guarantee a queue slot or access to every model. Use the model ids listed for that particular account and region. Do not infer another account's permission from its balance.
Qoder code 10605, including RESOURCE_LIMIT, serviceAvailable or
isQueued details, is a resource/queue answer. Keep its suggested retry
delay; repeatedly signing in does not free that queue. Since 0.2.18
(#185), a 10605 led
by a BOM or wrapped in an outer message is read as busy too; see
#167 for the broader report.
That parser fix does not remove the provider's limit or prove that every
live 401 had the same cause. A timeout likewise does not establish an
empty wallet or an expired login.
Since 0.2.28 a queued request waits its turn as Qoder's own client
(Qoder.app 0.4.3's agent worker) waits it: it asks
/api/v2/service/ask/queue/status with the request's requestSetId, the
model and the plan's queueType, at once and then every
retryAfterSeconds (held to 0.5–30s, 30s when unsaid), and once
isQueued is false it waits that state's retryAfterSeconds and sends the
same request again (up to 10 times). Qoder's client waits up to an hour;
the plugin waits at most 4 minutes from the request's start, since nothing
reaches the agent meanwhile (magpie keeps a stream alive with comments for
5 minutes of silence). Three failed status asks in a row, a 404, or a
cancelled request end the wait early. Qoder's client also reports the end
of its turn to /api/v2/service/ask/finish; the plugin doesn't, and
Qoder releases that lease on its own TTL. queue.test.mjs has the wait.
Since 0.2.40 the wait is only for the last candidate: when magpie says
another account, provider or routing group member follows this request
(its x-magpie-fallback: 1 header, which the plugin host keeps from Qoder),
a queued request is answered at once with the 503 above, e.g. "Qoder queued
the request for dfmodel (this plan's queue: p3, 3 ahead); try again in
30s", and magpie asks the next instead of keeping the agent in Qoder's
queue.
For a bounded offline reproduction, run packages/qoder/busy.test.mjs
from #185 in an isolated temporary HOME. It compares plain queue JSON,
BOM-prefixed JSON and known message wrappers, keeping explicit login and
credit failures distinct. Extracting a JSON body from a translated log
cannot recover the original wire bytes; synthetic wrappers demonstrate
parser behavior, not which wrapper a historical request actually used.
After selecting a local fix with magpie's plugin use, confirm which spec
serves qoder in plugin list; a patched checkout alone does not change
the running provider.
For native check-in, an existing CLAIMED result is not a new credit grant.
The host's recheck/cache behavior is tracked in
magpie#2696. Verify a new
claim against the vendor record; a successful activity query alone is not
proof that credits arrived.
export const protocol = { makePlugin, deviceSignIn, openapi, siteOf } is
the plugin factory and its pieces, for another service on this same
protocol (QwenWork ships here; a future one can too). Its shape is not a
stable API — it changes as the packages on it need.
Qoder serves its free models after the credits are used up: "When Credits
run out, you can continue using free basic models, subject to daily and
monthly limits" (docs.qoder.com/Credits;
the zh page says the same). So the credit windows the usage hook gives
(Qoder and Qoder CN, since 0.2.46) name the account's free models in
notModels: a model listed at 0× (not a discount's 0 for a while), from the
account's own model list. magpie then doesn't count those models as spent
on a used-up account, or on a free account's "0 credits left". A list that
can't be read leaves every model counted. QwenWork reads its usage
elsewhere and is not changed.
- Qoder's usage and quota display.
- Several accounts at once.
- magpie's web-search stand-in.
The protocol (endpoints, COSY envelope, body codec and device flow) comes
from CLIProxyAPI's Qoder support, by
way of magpie. Its MIT license is in LICENSE-CLIProxyAPI.