triss-coworker 0.24.2 → 0.25.0

package/CHANGELOG.md

@@ -7,6 +7,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.25.0] — 2026-07-27
+
+### Added
+
+- `triss ask` and `triss review` now accept `--provider glm` (also available
+  as the `provider` field on `triss_ask` / `triss_review` MCP tools). They reuse
+  `ZHIPU_API_KEY` for direct OpenAI-compatible chat completions, while the
+  existing `worker` provider remains the default and `deepseek` is an alias.
+  `--model pro` maps to `glm-5.2`, and `--model flash` — Triss's cheap
+  bulk-read tier — maps to `glm-4.7` on the subscription endpoint and
+  `glm-4.5-air` on pay-as-you-go. Explicit `zai-coding-plan/<model>` /
+  `zai/<model>` prefixes select the endpoint, and may carry a preset
+  (`zai/flash`). Usage records retain that endpoint identity: subscription
+  calls remain known `$0` because the plan meters by quota, while PAYG calls
+  are priced from Z.AI's published rates.
+- `triss status` and the `triss_status` MCP tool print a GLM routing block:
+  whether `ZHIPU_API_KEY` is set, the endpoint a `--provider glm` call resolves
+  to, what selected it, and that endpoint's preset models. Worker credential
+  rows are now labelled as such, so a GLM-only setup no longer reads as
+  unconfigured just because it has no worker key.
+- Pay-as-you-go GLM models now ship with Z.AI's published list prices, so
+  `triss usage` reports a real cost for them instead of `unknown`.
+  Provider selection is intentionally scoped to `ask` and `review`;
+  `chat`, `fetch`, `write`, and `commit-msg` keep their existing worker route,
+  while `triss coder` remains the separate agentic path.
+
+### Changed
+
+- Usage JSONL records keep `cost_usd` numeric for compatibility with existing
+  dashboards and add `cost_usd_known: false` when no model price is configured.
+  `triss usage` excludes those zeros from known totals and reports them as
+  unknown. This includes unpriced `opencode/*` OpenCode Zen models; configure
+  `TRISS_PRICE_<MODEL_ID>` to account for one. Existing log entries are not
+  rewritten: older bare GLM model ids and their previously recorded numeric
+  costs remain unchanged.
+
+### Fixed
+
+- A GLM call that nothing pinned to an endpoint is no longer a one-shot guess.
+  A Z.AI key carries no marker of which plan it belongs to, so a pay-as-you-go
+  key used to fail outright against the `zai-coding-plan` default. Such a call
+  is now retried once on the other endpoint; the working one is reported on
+  stderr and reused for the rest of the process, and re-probed if the key
+  changes. The cache stores only the working endpoint, never the API key or a
+  fingerprint derived from it. Endpoints pinned by an explicit prefix or
+  `TRISS_CODER_MODEL` are never second-guessed, and a key that works on neither
+  endpoint still surfaces the original rejection.
+- A preset behind a provider prefix is resolved instead of being sent
+  verbatim: `zai/flash` previously reached the provider as the literal model
+  id `flash`.
+- Long-lived MCP processes now refresh file-backed `TRISS_CODER_MODEL` and
+  `ZHIPU_API_KEY` values between calls, including edits and removals, while
+  preserving the precedence of values supplied by the parent environment.
+- Every model routed through the `zai-coding-plan/` subscription endpoint is
+  treated as known plan-metered usage instead of requiring a hardcoded model
+  allowlist. Explicit `TRISS_PRICE_<MODEL>` overrides still take precedence.
+- A GLM `HTTP 429` now carries the resolved-endpoint hint instead of surfacing
+  Z.AI's bare "Insufficient balance or no resource package" text. That reply is
+  what a subscription key gets on the pay-as-you-go endpoint, so the message now
+  names both the balance and the wrong-plan cause.
+
 ## [0.24.2] — 2026-07-15
 
 ### Changed

package/README.md

@@ -288,6 +288,10 @@ triss ask --paths src/auth.ts src/db.ts \
 triss ask --paths "src/**/*.ts" \
           --question "Find SQL injection risks" \
           --model pro --max-tokens 16384
+
+triss ask --paths "src/**/*.ts" \
+          --question "Find SQL injection risks" \
+          --provider glm --model pro
 ```
 
 Typical output is a focused answer with cited file paths, not a raw file dump.
@@ -335,7 +339,7 @@ triss usage --json                   # raw log records
 triss usage --reset                  # clear the log
 ```
 
-Every worker call (CLI **and** MCP) appends one record to
+Every model call (CLI **and** MCP) appends one record to
 `~/.cache/triss/usage.jsonl` with model, tokens, cached tokens, computed
 USD cost, working directory, a label like `triss/ask`, and a per-invocation
 `call_id` (UUIDv4). An optional `parent_call_id` lets a host group several
@@ -343,9 +347,17 @@ Triss calls under a single outer session — set `TRISS_PARENT_CALL_ID` in
 the environment that launches Triss (e.g. in your MCP server's `env`
 block) and every record from that process carries it. External dashboards
 (e.g. tokentelemetry) can group by either field. List-price defaults for
-DeepSeek are baked in; override per-model with
-`TRISS_PRICE_<MODEL_ID>=miss,hit,out` (USD per token). Disable tracking
-entirely with `TRISS_USAGE_LOG=0`.
+DeepSeek are baked in. GLM records retain `zai-coding-plan/` or `zai/` so
+subscription usage stays known `$0` while unpriced PAYG usage is shown as
+`unknown`, never as free. Any other unpriced model, including `opencode/*`
+OpenCode Zen, is also `unknown` unless configured with a matching
+`TRISS_PRICE_<MODEL_ID>` override. The JSONL keeps `cost_usd` numeric for
+dashboard compatibility and marks unpriced records with `cost_usd_known: false`.
+Existing records are not migrated, so older bare GLM model ids remain as
+originally logged. Override per-model with
+`TRISS_PRICE_<MODEL_ID>=miss,hit,out` (USD per token), for example
+`TRISS_PRICE_ZAI_GLM_5_2=...`. Disable tracking entirely with
+`TRISS_USAGE_LOG=0`.
 
 ### Streaming output
 
@@ -391,6 +403,7 @@ triss review                 # current branch vs auto-detected base
 triss review 123             # GitHub PR #123 (requires `gh` CLI)
 triss review --base develop  # explicit base
 triss review --skip-issue    # don't try ticket lookup
+triss review --provider glm  # same review flow, one-shot GLM inference
 ```
 
 Defaults to the `pro` preset because review needs reasoning. Output is
@@ -582,6 +595,34 @@ requires an OpenAI-compatible chat-completions endpoint.
 
 You can also pass any model id directly: `--model deepseek-v4-pro`.
 
+`ask` and `review` can route the same one-shot request to GLM without invoking
+the agentic `coder` runtime:
+
+```bash
+triss ask --paths ... --question "..." --provider glm --model flash
+triss review --provider glm --model pro
+triss review --provider glm --model zai/glm-5.2  # pay-as-you-go endpoint
+```
+
+For GLM, `pro` maps to `glm-5.2` on both endpoints, while `flash` — the cheap
+bulk-read tier — maps to `glm-4.7` on the subscription endpoint and to
+`glm-4.5-air` ($0.20/$1.10 per 1M) on pay-as-you-go. The subscription endpoint
+serves a `glm-4.5-air` request as `glm-4.7`, so the preset names what actually
+runs there.
+
+`ZHIPU_API_KEY` is reused. Prefix an explicit model with `zai-coding-plan/`
+or `zai/` to select the subscription or pay-as-you-go endpoint; otherwise
+Triss inherits the prefix from `TRISS_CODER_MODEL` and falls back to the
+coding-plan endpoint. A Z.AI key does not say which plan it belongs to, so
+when nothing pinned the endpoint and the call comes back `401`/`403`/`429`,
+Triss retries once on the other endpoint, prints which one worked, and reuses
+it for the rest of the process. Pin it (`TRISS_CODER_MODEL=zai/glm-5.2`, or run
+`triss coder init`) to skip that probe. `triss status` shows the resolved
+endpoint, where it came from, and the presets it selects.
+
+`triss coder` stays separate because it is an agent runtime with tools,
+sessions, and worktree isolation.
+
 ### Provider recipes
 
 #### DeepSeek (default, recommended)

package/bin/triss.js

@@ -66,16 +66,19 @@ program
 
 program
   .command('ask')
-  .description('Delegate bulk reading (files, URLs, and/or piped stdin) to DeepSeek; returns a structured summary')
+  .description('Delegate bulk reading to the configured worker or GLM; returns a structured summary')
   .option('-p, --paths <paths...>', 'files or globs to read')
   .option('-u, --urls <urls...>', 'http(s) URLs to fetch and convert to markdown')
   .option('--stdin', 'read piped stdin as an additional source (for `cmd | triss ask --stdin ...`)')
   .requiredOption('-q, --question <text>', 'question to answer about the corpus')
+  .option('--provider <name>', 'inference provider: worker (default), deepseek (alias), or glm')
   .option('-m, --model <name>', 'model preset (flash | pro) or full model id')
   .option('--max-tokens <n>', 'token budget for reasoning + answer', (v) => parseInt(v, 10), 8192)
   .option('--system <text>', 'override the system prompt')
   .option('--no-stream', "disable streaming output (default streams when stdout is a TTY)")
-  .action(wrap(runAsk));
+  // Commander also supplies its Command instance to action handlers. Adapt
+  // at the CLI boundary so runAsk receives only its documented options.
+  .action((opts) => wrap(runAsk)(opts));
 
 program
   .command('write')
@@ -128,10 +131,11 @@ program
 
 program
   .command('review [pr]')
-  .description('Code review via DeepSeek. No arg: current branch vs default base. With <pr>: GitHub PR via gh.')
+  .description('Code review via the configured worker or GLM. No arg: current branch vs default base. With <pr>: GitHub PR via gh.')
   .option('-b, --base <branch>', 'compare against this branch (default: auto-detect origin/HEAD or main/master/develop)')
   .option('--skip-issue', "don't try to look up a Jira/Linear ticket from the branch/PR title")
   .option('-q, --question <text>', 'override the default review question')
+  .option('--provider <name>', 'inference provider: worker (default), deepseek (alias), or glm')
   .option('-m, --model <name>', 'model preset (flash | pro) or full model id (default: pro)')
   .option('--max-tokens <n>', 'token budget for the review (default 8192)')
   .option('--no-stream', 'disable streaming output')

package/docs/configuration.md

@@ -218,12 +218,21 @@ env:
 
 You added `.triss.env` to a project after Claude Code was already
 running there. As of v0.9.3, **no restart needed** — `.env` files are
-re-read on every `tools/list` request, so the next time the agent or
-`claude /mcp` lists tools, the new ones appear (or disappear).
+re-read on every `tools/list` request, so newly added integration
+credentials can expose their tools on the next listing. Replacing or removing
+an integration credential that is already loaded still requires restarting
+that MCP process.
 
 The only thing that requires a restart is the *initial* MCP-server
 registration — i.e. running `triss mcp install` for the first time.
-After that, credential changes are live.
+After that, newly added credentials are discovered live.
+
+Separately, GLM calls (`triss_ask` / `triss_review` with `provider: "glm"`)
+re-read file-backed `TRISS_CODER_MODEL` and `ZHIPU_API_KEY` on each call.
+Editing or removing either value in `.triss.env` takes effect on the next GLM
+call without restarting the MCP server. Values supplied by the parent process
+environment still take precedence. This is a GLM per-call guarantee; it does
+not extend the tool-catalogue reload behaviour above to every integration.
 
 ## Environment reference
 
@@ -241,11 +250,11 @@ self-hosted endpoints).
 | `TRISS_WORKER_PRO_MODEL`    | no       | `deepseek-v4-pro`                | Override the `pro` preset             |
 | `TRISS_DEFAULT_MODEL`   | no       | `flash`                          | Which preset is used when no `--model`|
 
-### Coder (GLM coding agent)
+### GLM and coder
 
 | Variable                        | Required | Default            | Notes                                     |
 | -------------------------------- | -------- | ------------------ | ------------------------------------------ |
-| `ZHIPU_API_KEY`                  | yes¹     | —                  | Z.AI API key for GLM models — <https://z.ai/manage-apikey/apikey-list> |
+| `ZHIPU_API_KEY`                  | yes¹     | —                  | Z.AI API key for `ask`/`review --provider glm` and GLM coder models — <https://z.ai/manage-apikey/apikey-list> |
 | `OPENCODE_API_KEY`               | no¹      | —                  | OpenCode Zen key (opencode engine only) — unlocks `opencode/*` models like `opencode/hy3-free` — <https://opencode.ai/docs/zen/> |
 | `TRISS_CODER_MODEL`              | no       | `zai-coding-plan/glm-5.2`       | Resolved model, passed to opencode via `--model` (and written to `opencode.json` by `init`). Use `opencode/hy3-free` for OpenCode Zen |
 | `TRISS_CODER_SMALL_MODEL`        | no       | `zai-coding-plan/glm-5-turbo`   | Small/fast model written to `opencode.json`|
@@ -265,6 +274,30 @@ file) when the existing `model` prefix doesn't match what the key
 verified against — that mismatch is what makes opencode retry a model
 call it can never complete.
 
+`triss ask` and `triss review` can use the same key without spawning a coding
+agent: pass `--provider glm`. `pro` maps to `glm-5.2` on both endpoints;
+`flash` maps to `glm-4.7` on `zai-coding-plan` and `glm-4.5-air` on `zai`,
+because the subscription endpoint answers a `glm-4.5-air` request with
+`glm-4.7` and a preset should name the model that actually runs. A
+provider-prefixed model selects the endpoint explicitly
+(`zai-coding-plan/glm-5.2` for a subscription key, `zai/glm-5.2` for
+pay-as-you-go), and a prefix may carry a preset too — `zai/flash` means "the
+pay-as-you-go flash model". A bare model id inherits the prefix from
+`TRISS_CODER_MODEL`, then falls back to `zai-coding-plan`.
+
+**Endpoint auto-correction.** A Z.AI key carries no marker of which plan it
+belongs to, so an unpinned `zai-coding-plan` route is a guess. When nothing
+pinned the endpoint — no explicit prefix, no `TRISS_CODER_MODEL` — and the
+call is rejected with `401`, `403`, or `429` (Z.AI answers a plan mismatch
+with "Insufficient balance or no resource package"), Triss retries the request
+once on the other endpoint. If that works, it warns on stderr and reuses that
+endpoint for the rest of the process; the discovery is dropped when the key
+changes. An explicitly prefixed or `TRISS_CODER_MODEL`-pinned endpoint is
+never second-guessed. Pin one to skip the probe entirely — and note that a
+pinned endpoint also selects that endpoint's presets. `triss status` and the
+`triss_status` MCP tool print the resolved endpoint, its source, and the
+preset models.
+
 ¹ **Credentials are provider-specific.** A run needs the one key its
 resolved model requires: `zai-coding-plan/*` and `zai/*` (GLM) need
 `ZHIPU_API_KEY`; `opencode/*` OpenCode Zen models (e.g. the free
@@ -337,7 +370,7 @@ are unaffected.
 | `TRISS_USAGE_LOG`              | (on)        | `0` disables the usage tracker (`~/.cache/triss/usage.jsonl`) |
 | `TRISS_USAGE_LOG_CWD`          | (on)        | `0` omits the absolute cwd from each record (then `--by-project` groups under `(unknown)`) |
 | `TRISS_USAGE_LOG_MAX_BYTES`    | `10485760`  | Rotate the active log to `usage.jsonl.old` once it crosses this size (10 MB default) |
-| `TRISS_PRICE_<MODEL_ID>`       | list prices | `miss,hit,out` USD-per-token override per model (e.g. for promo or non-DeepSeek providers) |
+| `TRISS_PRICE_<MODEL_ID>`       | list prices | `miss,hit,out` USD-per-token override per model (e.g. `TRISS_PRICE_ZAI_GLM_5_2` for `zai/glm-5.2`); models without a price, including `opencode/*` Zen models, report `unknown`, not `$0` |
 | `TRISS_FETCH_MAX_BYTES`        | `10485760`  | Max body size for `triss fetch` (default 10 MB)           |
 | `TRISS_RESTRICT_PATHS`         | `1` in MCP, unset in CLI | `0` opts the MCP server out of the project-root file IO sandbox |
 | `TRISS_ALLOW_PRIVATE_NETWORKS` | (off)       | `1` allows `triss fetch` / `triss ask --urls` to hit RFC1918, loopback, link-local, and cloud-metadata IPs. Off blocks SSRF; turn on only for self-hosted internal docs. **Known residual risk:** the guard checks DNS once before fetch; the underlying connection performs another lookup, leaving a narrow DNS-rebinding window. For high-trust environments use network-level egress filtering as the primary control. |
@@ -367,7 +400,18 @@ baked-in DeepSeek list prices (e.g. you point Triss at a different
 provider, or want the discounted rate), set
 `TRISS_PRICE_<MODEL>=<input_cache_miss>,<input_cache_hit>,<output>` in
 USD per token. Example: `TRISS_PRICE_DEEPSEEK_V4_PRO=4.35e-7,3.625e-9,8.7e-7`
-applies the 75% promotional pricing to the pro preset.
+applies the 75% promotional pricing to the pro preset. PAYG GLM calls use the
+canonical `zai/<model>` id and ship with Z.AI's published list prices for the
+models both endpoints advertise (`glm-4.5`, `glm-4.5-air`, `glm-4.6`,
+`glm-4.7`, `glm-5`, `glm-5-turbo`, `glm-5.1`, `glm-5.2`), so a PAYG cost is
+reported, not guessed. Override any of them the same way — `zai/glm-5.2` maps
+to `TRISS_PRICE_ZAI_GLM_5_2`. Subscription (`zai-coding-plan/*`) calls stay
+`$0` because the plan meters by quota rather than tokens. Any model outside
+that catalogue — a newly released GLM id, `opencode/*` OpenCode Zen models —
+is explicitly unknown until you set its matching `TRISS_PRICE_<MODEL_ID>`
+override. Usage JSONL keeps `cost_usd` numeric for
+compatibility and marks these records with `cost_usd_known: false`; existing
+historical records are not relabelled.
 
 **Claude Code integration step in the wizard** — split by mode:
 

package/docs/mcp.md

@@ -187,22 +187,50 @@ or use the other project's credentials.
 `.env` files are re-read on every `tools/list` request, so adding a
 new credential to `.triss.env` mid-session means the next time the
 agent (or `claude /mcp`) lists tools, the new ones show up without
-restarting Claude Code.
+restarting Claude Code. Replacing or removing an integration credential that
+is already loaded still requires restarting that MCP process.
+
+GLM calls have a narrower per-call refresh path: `triss_ask` and
+`triss_review` with `provider: "glm"` re-read file-backed
+`TRISS_CODER_MODEL` and `ZHIPU_API_KEY` before each call. Edits and removals
+take effect without restarting the MCP server, except that values supplied by
+the parent environment continue to win. This does not change the existing
+`tools/list` refresh behaviour for other integrations.
 
 ## What tools are exposed
 
 The set of MCP tools is **filtered by which integrations are configured**.
 Run `triss status` to see readiness.
 
-Always exposed (require only `TRISS_WORKER_API_KEY`):
+Core tools are always listed. Model calls default to the worker and require
+`TRISS_WORKER_API_KEY`:
 
 - `triss_chat` — bare prompt to the worker model
-- `triss_ask` — read files/URLs and answer a question
+- `triss_ask` — read files/URLs and answer a question; accepts an optional
+  `provider` field: `worker` (default), `deepseek` (an alias for `worker`),
+  or `glm`
 - `triss_fetch` — fetch URL(s) as markdown, optional summary
-- `triss_review` — code review on current branch or a GitHub PR
+- `triss_review` — code review on current branch or a GitHub PR; accepts the
+  same optional `provider` field as `triss_ask`
 - `triss_commit_msg` — generate a Conventional Commits message from staged diff
 - `triss_write` — generate boilerplate from a spec; with `target` writes the file (path-sandboxed), without `target` returns the content
-- `triss_status` — current configuration and integration readiness
+- `triss_status` — current configuration and integration readiness, including a
+  GLM block: whether `ZHIPU_API_KEY` is set, the endpoint a `provider: "glm"`
+  call resolves to, what selected it, and the preset models. A GLM-only server
+  has no worker key, so the worker rows say `(missing)` while GLM calls work —
+  the two are labelled separately for that reason.
+
+For `triss_ask` and `triss_review`, `provider: "glm"` requires
+`ZHIPU_API_KEY` rather than `TRISS_WORKER_API_KEY`. `pro` selects `glm-5.2` on
+both endpoints; `flash` selects `glm-4.7` on the subscription endpoint and
+`glm-4.5-air` on pay-as-you-go (the subscription endpoint serves an
+`glm-4.5-air` request as `glm-4.7`). Use `zai-coding-plan/<model>` for the
+subscription endpoint or `zai/<model>` for pay-as-you-go — a prefix may carry
+a preset, so `zai/flash` is valid. When neither the request nor
+`TRISS_CODER_MODEL` pinned an endpoint and the call is rejected with
+`401`/`403`/`429`, the server retries once on the other endpoint and reuses
+whichever one works for the rest of the process (re-probed if the key
+changes). A pinned endpoint is never second-guessed.
 
 Exposed **only when ATLASSIAN_BASE_URL/EMAIL/API_TOKEN are all set**
 (both Jira and Confluence reuse the same Atlassian credentials):
@@ -368,9 +396,10 @@ echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | triss mcp serve
 the `mcpServers` table in `~/.claude.json` is read at startup, so a
 fresh `triss mcp install` requires a session restart to take effect.
 
-**"Triss listed but tools/list is empty"** — `triss status` to check
-the API key. The MCP server connects regardless, but the model-using
-tools (`triss_chat`, `triss_ask`, …) need a working DeepSeek key.
+**"Triss listed but a model call fails"** — `triss status` to check the
+provider's API key. Core tools are always listed: their default `worker`
+route needs `TRISS_WORKER_API_KEY`, while `triss_ask` and `triss_review` with
+`provider: "glm"` need `ZHIPU_API_KEY`.
 
 **"Jira tools missing in this project"** — Triss couldn't find the
 ATLASSIAN_* triple. Either your global `~/.config/triss/.env` has them
@@ -412,6 +441,16 @@ Every MCP tool call gets its own `call_id` (UUIDv4) written to
 fields. Dashboards (e.g. tokentelemetry) can group records per
 invocation.
 
+GLM records keep the endpoint the call actually used (`zai-coding-plan/` or
+`zai/`) — including after an endpoint auto-correction, so a retried call is
+billed to the endpoint that served it. Subscription calls retain the known
+`$0` accounting (the plan meters by quota), and PAYG calls carry Z.AI's
+published list prices for the catalogue models. Anything still unpriced —
+a GLM id outside that catalogue, `opencode/*` OpenCode Zen — keeps numeric
+`cost_usd: 0` for JSONL compatibility, adds `cost_usd_known: false`, and is
+displayed by `triss usage` as `unknown`, not as free. Set the matching
+`TRISS_PRICE_<MODEL_ID>` override to account for one.
+
 To attribute all calls from one MCP server process to a single outer
 session, set `TRISS_PARENT_CALL_ID` in the server's `env` block — every
 record from that process will carry the value as `parent_call_id`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triss-coworker",
-  "version": "0.24.2",
+  "version": "0.25.0",
   "description": "Give your AI coding agent a cheap DeepSeek coworker. Delegate bulk reads, boilerplate, and doc updates to save 60-70% of your token budget.",
   "type": "module",
   "bin": {

package/src/client.js

@@ -1,21 +1,54 @@
 import OpenAI from 'openai';
-import { getConfig, requireApiKey } from './config.js';
+import pc from 'picocolors';
+import { getConfig, requireApiKey, requireGlmApiKey } from './config.js';
 import { logUsage } from './usage.js';
 import { currentCall } from './call-context.js';
+import {
+  ZAI_CODING_PLAN_BASE_URL,
+  normalizeZaiBaseUrl,
+  siblingZaiBaseUrl,
+  zaiPrefixForBaseUrl,
+} from './zai.js';
+
+export function billingModelFor({ provider, baseUrl, model }) {
+  if (provider !== 'glm') return model || '(unknown)';
+
+  const prefix = zaiPrefixForBaseUrl(baseUrl);
+  if (!prefix || !model) return model || '(unknown)';
+
+  // Z.AI responses currently return a bare model id, but avoid duplicating a
+  // prefix if a compatible endpoint starts returning one later.
+  const modelId = String(model).replace(/^zai(?:-coding-plan)?\//, '');
+  return `${prefix}/${modelId}`;
+}
+
+export function glmRouteHint(baseUrl) {
+  const endpoint = normalizeZaiBaseUrl(baseUrl);
+  return (
+    `This request resolved to ${endpoint}. A bare GLM model id uses the resolved endpoint. ` +
+    'Use zai/<model> for pay-as-you-go or zai-coding-plan/<model> for the subscription endpoint.'
+  );
+}
 
 // Recreate the OpenAI client per call so a long-lived MCP server picks
 // up `triss config set TRISS_WORKER_API_KEY` changes mid-session. Constructing
 // the client is microseconds — no observable overhead next to a model RTT.
-export function getClient() {
+export function getClient({ provider = 'worker', baseUrl } = {}) {
+  if (provider === 'glm') {
+    return new OpenAI({
+      apiKey: requireGlmApiKey(),
+      baseURL: baseUrl || ZAI_CODING_PLAN_BASE_URL,
+    });
+  }
   const cfg = requireApiKey(getConfig());
   return new OpenAI({ apiKey: cfg.apiKey, baseURL: cfg.baseUrl });
 }
 
-function recordUsage(resp, label) {
+function recordUsage(resp, label, request = {}) {
   if (!resp?.usage) return;
   const ctx = currentCall();
   logUsage({
-    model: resp.model || '(unknown)',
+    model: billingModelFor({ ...request, model: resp.model || request.model }),
     prompt_tokens: resp.usage.prompt_tokens,
     cached_tokens: resp.usage.prompt_tokens_details?.cached_tokens,
     completion_tokens: resp.usage.completion_tokens,
@@ -25,33 +58,119 @@ function recordUsage(resp, label) {
   });
 }
 
-export async function chat({ model, messages, maxTokens, temperature, label }) {
-  const client = getClient();
+// Statuses Z.AI returns when the key does not match the endpoint the request
+// resolved to. 429 belongs here despite reading as a rate limit: a Coding Plan
+// key sent to the PAYG endpoint answers "Insufficient balance or no resource
+// package. Please recharge." — a billing message for what is really a routing
+// mismatch, so the endpoint hint matters more there than anywhere else.
+const GLM_ROUTE_STATUSES = new Set([401, 403, 429]);
+
+export function providerRequestError(err, { provider, baseUrl, model }) {
+  const status = err?.status || err?.response?.status;
+  const body = err?.error?.message || err?.message || String(err);
+  if (provider === 'glm' && GLM_ROUTE_STATUSES.has(status)) {
+    // A genuine 429 (quota or rate limit on the right endpoint) is also
+    // possible, so name both causes instead of asserting the key is wrong.
+    const advice = status === 429
+      ? 'Either that endpoint has no balance/quota left, or the key belongs to the other plan.'
+      : 'Check that ZHIPU_API_KEY is valid for that endpoint.';
+    return new Error(
+      `GLM request for model "${model}" was rejected (HTTP ${status}). ${glmRouteHint(baseUrl)} ` +
+      `${advice} Original error: ${body}`,
+      { cause: err },
+    );
+  }
+  if (status === 404 || /model.*not.*found|unknown model/i.test(body)) {
+    const hint = provider === 'glm'
+      ? `→ Pass --provider glm --model glm-5.2. ${glmRouteHint(baseUrl)}\n`
+      : '→ Override with --model <name> or set TRISS_WORKER_FLASH_MODEL / TRISS_WORKER_PRO_MODEL in your env.\n' +
+        '→ Current DeepSeek model names: deepseek-v4-flash, deepseek-v4-pro.\n';
+    return new Error(
+      `Model "${model}" not accepted by the provider.\n${hint}Original error: ${body}`,
+      { cause: err },
+    );
+  }
+  return err;
+}
+
+// A Z.AI key authenticates against exactly one of the two endpoints and
+// carries no marker of which, so a call routed by the `zai-coding-plan`
+// default is a guess. When that guess is rejected with a routing status we
+// retry once on the sibling endpoint and remember the winner for the rest of
+// the process — a long-lived MCP server pays for the discovery at most once
+// per process. Only the endpoint is cached: the API key is never retained or
+// fingerprinted. If the key changes and belongs to the other endpoint, the
+// cached route is rejected and this same one-retry path corrects it.
+let glmDiscoveredBaseUrl = null;
+
+// Test seam + escape hatch for a process that swaps keys without restarting.
+export function resetGlmEndpointDiscovery() {
+  glmDiscoveredBaseUrl = null;
+}
+
+function statusOf(err) {
+  return err?.status || err?.response?.status;
+}
+
+export async function withGlmEndpointFallback(request, run, deps = {}) {
+  const warn = deps.warn || ((line) => process.stderr.write(pc.dim(line)));
+  const provisional = request.provider === 'glm' && request.endpointSource === 'default';
+  const baseUrl = provisional && glmDiscoveredBaseUrl
+    ? glmDiscoveredBaseUrl
+    : request.baseUrl;
+
   try {
-    const resp = await client.chat.completions.create({
-      model,
-      messages,
-      max_tokens: maxTokens,
-      temperature: temperature ?? 0.2,
-    });
-    recordUsage(resp, label || 'chat');
-    return resp;
+    return { result: await run(baseUrl), baseUrl };
   } catch (err) {
-    const status = err?.status || err?.response?.status;
-    const body = err?.error?.message || err?.message || String(err);
-    if (status === 404 || /model.*not.*found|unknown model/i.test(body)) {
-      throw new Error(
-        `Model "${model}" not accepted by the provider.\n` +
-          `→ Override with --model <name> or set TRISS_WORKER_FLASH_MODEL / TRISS_WORKER_PRO_MODEL in your env.\n` +
-          `→ Current DeepSeek model names: deepseek-v4-flash, deepseek-v4-pro.\n` +
-          `Original error: ${body}`,
-        { cause: err },
-      );
+    const sibling = provisional && GLM_ROUTE_STATUSES.has(statusOf(err))
+      ? siblingZaiBaseUrl(baseUrl)
+      : null;
+    if (!sibling) throw providerRequestError(err, { ...request, baseUrl });
+
+    let result;
+    try {
+      result = await run(sibling);
+    } catch {
+      // The key works on neither endpoint, so the sibling's rejection says
+      // nothing new — surface the original one, which already carries the
+      // endpoint hint for the route the user actually asked for.
+      throw providerRequestError(err, { ...request, baseUrl });
     }
-    throw err;
+    glmDiscoveredBaseUrl = sibling;
+    warn(
+      `[triss] ZHIPU_API_KEY was rejected by ${normalizeZaiBaseUrl(baseUrl)} (HTTP ${statusOf(err)}) ` +
+        `but works on ${sibling}. Using that endpoint for the rest of this process. ` +
+        `Pin it with TRISS_CODER_MODEL=${zaiPrefixForBaseUrl(sibling)}/<model> ` +
+        'or run `triss coder init` to skip this probe.\n',
+    );
+    return { result, baseUrl: sibling };
   }
 }
 
+export async function chat({
+  provider,
+  baseUrl,
+  model,
+  endpointSource,
+  messages,
+  maxTokens,
+  temperature,
+  label,
+}) {
+  const { result: resp, baseUrl: usedBaseUrl } = await withGlmEndpointFallback(
+    { provider, baseUrl, model, endpointSource },
+    (url) =>
+      getClient({ provider, baseUrl: url }).chat.completions.create({
+        model,
+        messages,
+        max_tokens: maxTokens,
+        temperature: temperature ?? 0.2,
+      }),
+  );
+  recordUsage(resp, label || 'chat', { provider, baseUrl: usedBaseUrl, model });
+  return resp;
+}
+
 export function reportUsage(resp, label = 'worker') {
   const u = resp?.usage;
   if (!u) return '';
@@ -63,31 +182,32 @@ export function reportUsage(resp, label = 'worker') {
 // from the final chunk (requires stream_options.include_usage). Returns
 // the full assembled text and the OpenAI-style response shape so callers
 // can reuse reportUsage().
-export async function chatStream({ model, messages, maxTokens, temperature, label, onChunk }) {
-  const client = getClient();
-  let stream;
-  try {
-    stream = await client.chat.completions.create({
-      model,
-      messages,
-      max_tokens: maxTokens,
-      temperature: temperature ?? 0.2,
-      stream: true,
-      stream_options: { include_usage: true },
-    });
-  } catch (err) {
-    const status = err?.status || err?.response?.status;
-    const body = err?.error?.message || err?.message || String(err);
-    if (status === 404 || /model.*not.*found|unknown model/i.test(body)) {
-      throw new Error(
-        `Model "${model}" not accepted by the provider.\n` +
-          `→ Override with --model <name> or set TRISS_WORKER_FLASH_MODEL / TRISS_WORKER_PRO_MODEL.\n` +
-          `Original error: ${body}`,
-        { cause: err },
-      );
-    }
-    throw err;
-  }
+export async function chatStream({
+  provider,
+  baseUrl,
+  model,
+  endpointSource,
+  messages,
+  maxTokens,
+  temperature,
+  label,
+  onChunk,
+}) {
+  // The endpoint rejects a mismatched key while opening the stream, so the
+  // fallback wraps creation only — nothing has been emitted to the caller yet
+  // at that point, which is what makes retrying on the sibling safe.
+  const { result: stream, baseUrl: usedBaseUrl } = await withGlmEndpointFallback(
+    { provider, baseUrl, model, endpointSource },
+    (url) =>
+      getClient({ provider, baseUrl: url }).chat.completions.create({
+        model,
+        messages,
+        max_tokens: maxTokens,
+        temperature: temperature ?? 0.2,
+        stream: true,
+        stream_options: { include_usage: true },
+      }),
+  );
 
   let text = '';
   let lastChunk = null;
@@ -105,6 +225,6 @@ export async function chatStream({ model, messages, maxTokens, temperature, labe
     choices: [{ message: { content: text }, finish_reason: lastChunk?.choices?.[0]?.finish_reason ?? 'stop' }],
     usage: lastChunk?.usage,
   };
-  recordUsage(fakeResp, label || 'chat-stream');
+  recordUsage(fakeResp, label || 'chat-stream', { provider, baseUrl: usedBaseUrl, model });
   return fakeResp;
 }