+
@@ -101,7 +101,7 @@
+
@@ -461,7 +461,7 @@ All **19** strategies — mix & match per combo step: -
+
📊 Full methodology & per-feature detail vs 9router, OpenRouter, CLIProxyAPI & LiteLLM → [`docs/comparison/OMNIROUTE_VS_ALTERNATIVES.md`](docs/comparison/OMNIROUTE_VS_ALTERNATIVES.md)
@@ -559,7 +559,7 @@ the current catalog at **[radar.omniroute.online/planos](https://radar.omniroute
- **🖼️ New endpoints** — `/v1/ocr` (Mistral OCR) and `/v1/audio/translations` (Whisper-style) round out the media surface. → [API Reference](docs/reference/API_REFERENCE.md)
- **🎨 Image / video / audio generation** — one API for media: xAI Grok Imagine & Novita AI video, ComfyUI, Freepik, Adobe Firefly, Microsoft Designer, Segmind, EdgeTTS. → [API Reference](docs/reference/API_REFERENCE.md)
- **🌍 Deployment & ops** — reverse-proxy `basePath`, browser-language auto-detect, per-key device tracking, root-less MITM trust, zh-TW localization. → [Environment](docs/reference/ENVIRONMENT.md)
-- **🤝 More providers & agents** — Cursor Cloud Agent, Grok Build (xAI) with browser + OAuth login, Ollama first-class card, Claude Opus 5 & Sonnet 5, Kimi official partnership (Code/Web/Moonshot), Zed, Requesty, SenseNova, Yuanbao, Agnes AI… and a refreshed **348-provider catalog**. → [Providers](docs/reference/PROVIDER_REFERENCE.md)
+- **🤝 More providers & agents** — Cursor Cloud Agent, Grok Build (xAI) with browser + OAuth login, Ollama first-class card, Claude Opus 5 & Sonnet 5, Kimi official partnership (Code/Web/Moonshot), Zed, Requesty, SenseNova, Yuanbao, Agnes AI… and a refreshed **349-provider catalog**. → [Providers](docs/reference/PROVIDER_REFERENCE.md)
- **📡 Routing transparency** — every response carries an `X-OmniRoute-Decision` header naming the strategy/provider/latency that served it, a new `cache-optimized` combo strategy + Auto-Combo `cacheAffinity` factor route repeat requests back to the connection holding the cached prefix, and a read-only `/v1/auto-combo/{channel}/candidates` endpoint exposes an `auto/*` channel's live candidate pool. → [Auto-Combo](docs/routing/AUTO-COMBO.md)
- **⚡ Local performance & infra** — one-click local Redis, Cloudflare Workers / Deno Deploy relay deployers, Bifrost & Mux as supervised embedded services. → [Embedded Services](docs/frameworks/EMBEDDED-SERVICES.md)
@@ -642,11 +642,11 @@ of your shell history. → [CLI Integrations](docs/guides/CLI-INTEGRATIONS.md)
-## 🌐 348 AI Providers — 90+ Free
+## 🌐 349 AI Providers — 90+ Free
-> The most complete catalog of any open-source router: **348 providers**, **90+ with a free tier**, **57 free forever**.
+> The most complete catalog of any open-source router: **349 providers**, **90+ with a free tier**, **56 free forever**.
@@ -990,11 +990,11 @@ docker run -d --name omniroute --restart unless-stopped --stop-timeout 40 \
`:latest` follows the highest **published** stable SemVer. It does not track git `main`. Pin `:X.Y.Z` for GitOps. See [Docker Release Channels](docs/guides/DOCKER_GUIDE.md#release-channels).The image pins **`OMNIROUTE_MEMORY_MB=1024`**. That is enough for the dashboard and a light chat. **Coding agents** (`POST /v1/responses` from Claude Code, Codex, Grok, …) need a much larger V8 heap or the process `FATAL ERROR`s at ~12 GiB under two overlapping long contexts. Size the container above the heap (native buffers sit outside V8):
-| Workload | Heap (`-e OMNIROUTE_MEMORY_MB`) | Container (`--memory`) |
-| --- | --- | --- |
-| Dashboard / light chat | `1024` (image default) | ≥2 g |
-| One coding agent | `8192` | ≥10 g |
-| Two concurrent long `/v1/responses` | `10240`–`12288` | ≥12–16 g |
+| Workload | Heap (`-e OMNIROUTE_MEMORY_MB`) | Container (`--memory`) |
+| ----------------------------------- | ------------------------------- | ---------------------- |
+| Dashboard / light chat | `1024` (image default) | ≥2 g |
+| One coding agent | `8192` | ≥10 g |
+| Two concurrent long `/v1/responses` | `10240`–`12288` | ≥12–16 g |
```bash
docker run -d --name omniroute --restart unless-stopped --stop-timeout 40 \
@@ -1003,6 +1003,7 @@ docker run -d --name omniroute --restart unless-stopped --stop-timeout 40 \
```
Full table: [Docker Guide — runtime RAM](docs/guides/DOCKER_GUIDE.md#runtime-ram-for-coding-agents).
+
> **Pre-release Docker channel:** `diegosouzapw/omniroute:next` and
> `diegosouzapw/omniroute:next-web` follow the current default `release/v*`
> branch. These mutable tags are intended only for testing unreleased fixes and
@@ -1200,7 +1201,7 @@ Métricas de validação: 1002 vídeos rastreados · 7,069,190 visualizações c
Runtime Node.js 22.x / 24.x LTS — Language TypeScript 6.0 — 100% TypeScript across Framework Next.js 16 + React 19 + Tailwind CSS 4 Database better-sqlite3 (SQLite, WAL journaling) + LowDB (JSON legacy) — 120 domain modules, 157 migrations Database better-sqlite3 (SQLite, WAL journaling) + LowDB (JSON legacy) — 120 domain modules, 159 migrations Memory SQLite FTS5 full-text + int8-quantized vector embeddings, typed decay Schemas Zod 4 — MCP tool I/O validation + API contracts Protocols MCP (stdio / HTTP / SSE) + A2A v0.3 (JSON-RPC 2.0 + SSE) and/or repeat --model ."
+ );
+ return 1;
+ }
try {
return await withRuntime(async ({ kind, api, db }) => {
diff --git a/bin/cli/commands/oauth.mjs b/bin/cli/commands/oauth.mjs
index 8bf547b2c00f..c9f8386d2b9d 100644
--- a/bin/cli/commands/oauth.mjs
+++ b/bin/cli/commands/oauth.mjs
@@ -228,20 +228,38 @@ async function runSocialFlow(def, opts) {
async function runDeviceFlow(def, opts) {
const providerKey = resolveBackendKey(def.id);
- const startRes = await apiFetch(`/api/providers/${providerKey}/auth/start`, {
- ...targetApiOptions(opts),
- method: "POST",
- });
+ let startRes = await apiFetch(`/api/oauth/${providerKey}/device-code`, targetApiOptions(opts));
+ if (!startRes.ok) {
+ startRes = await apiFetch(`/api/providers/${providerKey}/auth/start`, {
+ ...targetApiOptions(opts),
+ method: "POST",
+ });
+ }
if (!startRes.ok) {
process.stderr.write(`Failed to start device flow: ${startRes.status}\n`);
process.exit(1);
}
const start = await startRes.json();
- process.stdout.write(
- `\nDevice code: ${start.userCode ?? start.user_code ?? ""}\nVisit: ${start.verificationUri ?? start.verification_uri}\n\n`
- );
- if (opts.browser !== false)
- await openBrowser(start.verificationUri ?? start.verification_uri ?? "");
+ const userCode = start.userCode ?? start.user_code ?? "";
+ const verificationUri =
+ start.verificationUriComplete ??
+ start.verification_uri_complete ??
+ start.verificationUri ??
+ start.verification_uri ??
+ start.authUrl ??
+ start.url ??
+ "";
+
+ if (userCode) {
+ process.stdout.write(`\nDevice code: ${userCode}\nVisit: ${verificationUri}\n\n`);
+ } else if (verificationUri) {
+ process.stdout.write(`\nVisit: ${verificationUri}\n\n`);
+ } else {
+ process.stdout.write(`\nAuthorization URL not available\n\n`);
+ }
+
+ if (opts.browser !== false && verificationUri)
+ await openBrowser(verificationUri);
process.stderr.write("Waiting for device authorization...\n");
const deadline = Date.now() + (opts.timeout ?? 300000);
const intervalMs = (start.intervalMs ?? start.interval ?? 5) * 1000;
diff --git a/changelog.d/features/10987-logfare-free-provider.md b/changelog.d/features/10987-logfare-free-provider.md
new file mode 100644
index 000000000000..507a528411fd
--- /dev/null
+++ b/changelog.d/features/10987-logfare-free-provider.md
@@ -0,0 +1 @@
+- **feat(providers):** add Logfare as a free OpenAI-compatible provider — dashboard card with a Free badge and request-logging disclosure (every prompt/completion is logged for research; opt out at logfare.ai/consent), live model discovery from `https://logfare.ai/v1/models` (20 models, 11 chat-capable: kimi-k3, deepseek-v4-pro, glm-5.2, gpt-5.6-luna, minimax-m3…), full chat/streaming through the existing OpenAI-compatible path, the real Logfare logo on the card, and a listing in the free-tiers guide. ([#10987](https://github.com/diegosouzapw/OmniRoute/pull/10987))
diff --git a/changelog.d/features/11104-operator-error-rules.md b/changelog.d/features/11104-operator-error-rules.md
new file mode 100644
index 000000000000..f31e78c01f3e
--- /dev/null
+++ b/changelog.d/features/11104-operator-error-rules.md
@@ -0,0 +1 @@
+- **feat(providers):** let operators declare per-provider error rules through `settings.providerErrorRules` instead of patching the catalog — an operator-supplied rule for a provider is consulted before the built-in `providerRuleRegistry`, receives the raw error text, and has its declared scope/cooldown/reason actually honored end to end, for any provider (declaring the rule is the opt-in — no extra allowlist entry needed). Matches are plain case-insensitive substrings (never RegExp) and bounded to 50 rules to keep the hot path safe ([#11104](https://github.com/diegosouzapw/OmniRoute/pull/11104))
diff --git a/changelog.d/features/11190-usage-command-json.md b/changelog.d/features/11190-usage-command-json.md
new file mode 100644
index 000000000000..d7655f04c51b
--- /dev/null
+++ b/changelog.d/features/11190-usage-command-json.md
@@ -0,0 +1 @@
+- **feat(api):** `/api/usage/om-usage` gains a structured form — `?format=json` returns the key's own usage as `ApiKeyUsageLimitStatus` + `UsageSnapshot` instead of `text/plain`. This is the surface a UI (the OmniCopilot panel) consumes to show a key holder their daily/weekly spend and quota reset. The route is self-service (the caller's own key, gated by `allowUsageCommand`), not the management surface; refusals come back as a discriminated `{ "allowed": false, "error": … }` so a UI can tell "not allowed" apart from "allowed but nothing cached yet". The endpoint was previously undocumented in `API_REFERENCE.md`; it now has a section ([#11190](https://github.com/diegosouzapw/OmniRoute/pull/11190))
diff --git a/changelog.d/features/11192-usage-command-providers-array.md b/changelog.d/features/11192-usage-command-providers-array.md
new file mode 100644
index 000000000000..b7ef42110913
--- /dev/null
+++ b/changelog.d/features/11192-usage-command-providers-array.md
@@ -0,0 +1 @@
+- **feat(api):** `/api/usage/om-usage?format=json` now returns `providers[]` — every connection's quota snapshot, not just the single selected one — so a panel can render Codex / Claude / OpenCode side by side. The collector already gathered all of them; the single-pick `provider` field (kept) is a terminal presentation choice. Closes the per-connection gap from OmniCopilot #8 ([#11192](https://github.com/diegosouzapw/OmniRoute/pull/11192))
diff --git a/changelog.d/fixes/10550-responses-reasoning-transport.md b/changelog.d/fixes/10550-responses-reasoning-transport.md
index d34c433debd8..e2b40cdb8c97 100644
--- a/changelog.d/fixes/10550-responses-reasoning-transport.md
+++ b/changelog.d/fixes/10550-responses-reasoning-transport.md
@@ -1 +1 @@
-- Preserve portable plaintext reasoning by default across streaming and non-streaming Chat Completions and Responses routes while keeping provider-bound opaque state target-compatible. Combos now drop incompatible continuation reasoning by default and can explicitly skip incompatible targets, while known providers no longer show redundant encrypted-reasoning controls. (#10550)
+- Preserve portable plaintext reasoning by default across streaming and non-streaming Chat Completions and Responses routes while keeping provider-bound opaque state target-compatible. Direct requests drop incompatible continuation reasoning by default; combos can explicitly skip incompatible targets without mutating the request. Known providers no longer show redundant encrypted-reasoning controls. (#10550, #10959)
diff --git a/changelog.d/fixes/10949-mixed-reasoning-plaintext.md b/changelog.d/fixes/10949-mixed-reasoning-plaintext.md
new file mode 100644
index 000000000000..05a055ec5384
--- /dev/null
+++ b/changelog.d/fixes/10949-mixed-reasoning-plaintext.md
@@ -0,0 +1 @@
+- Preserve explicit plaintext reasoning when a Responses reasoning item also carries opaque provider state (rare OpenCode Go `deepseek-v4-flash` responses). Mixed plaintext + opaque input is projected onto the target transport: plaintext targets keep portable text, opaque targets keep provider state. Opaque-only reasoning is dropped when the selected target cannot replay it, allowing cross-model conversations to continue. (#10949, #10959)
diff --git a/changelog.d/fixes/11015-shutdown-track-sse.md b/changelog.d/fixes/11015-shutdown-track-sse.md
new file mode 100644
index 000000000000..1ed99b3669d8
--- /dev/null
+++ b/changelog.d/fixes/11015-shutdown-track-sse.md
@@ -0,0 +1 @@
+- **fix(resilience):** count heavyweight `/v1` admission leases in the SIGTERM drain and send `Retry-After` on shutdown 503s so Recreate no longer looks like an empty 502 ([#11015](https://github.com/diegosouzapw/OmniRoute/issues/11015)) — thanks @RaviTharuma
diff --git a/changelog.d/fixes/11060-perplexity-filter.md b/changelog.d/fixes/11060-perplexity-filter.md
new file mode 100644
index 000000000000..c221d3ccaba1
--- /dev/null
+++ b/changelog.d/fixes/11060-perplexity-filter.md
@@ -0,0 +1 @@
+- fix(providers): filter Perplexity model import to the Sonar family so Agent-API catalog ids stop surfacing as routable chat models (#11060)
diff --git a/changelog.d/fixes/11085-claude-code-tool-name-casing.md b/changelog.d/fixes/11085-claude-code-tool-name-casing.md
new file mode 100644
index 000000000000..5ad424c14182
--- /dev/null
+++ b/changelog.d/fixes/11085-claude-code-tool-name-casing.md
@@ -0,0 +1 @@
+- **fix(claude):** restore canonical tool names (`bash` → `Bash`, `croncreate` → `CronCreate`) on non-streaming OpenAI→Claude conversion and through identity-echo alias maps, so Claude Code stops rejecting tool calls with "No such tool available" ([#11085](https://github.com/diegosouzapw/OmniRoute/pull/11085)) — thanks @linhdmn
diff --git a/changelog.d/fixes/11095-termux-onnx.md b/changelog.d/fixes/11095-termux-onnx.md
new file mode 100644
index 000000000000..8c268037104c
--- /dev/null
+++ b/changelog.d/fixes/11095-termux-onnx.md
@@ -0,0 +1 @@
+- fix(install): make the ONNX dependency chain optional so Termux/Android installs succeed again (#11095)
diff --git a/changelog.d/fixes/11101-reject-silent-validation.md b/changelog.d/fixes/11101-reject-silent-validation.md
new file mode 100644
index 000000000000..04b2a67d5a07
--- /dev/null
+++ b/changelog.d/fixes/11101-reject-silent-validation.md
@@ -0,0 +1 @@
+- **fix(providers):** Reject silent validation degradation on provider connection patch — unknown `rateLimitOverrides` keys (e.g. a typo'd `tpm`) and empty/non-numeric values now return `400` with the rejected key list instead of being silently dropped ([#11101](https://github.com/diegosouzapw/OmniRoute/pull/11101))
diff --git a/changelog.d/fixes/11102-combo-suggestion-count.md b/changelog.d/fixes/11102-combo-suggestion-count.md
new file mode 100644
index 000000000000..3cbf6f11d3de
--- /dev/null
+++ b/changelog.d/fixes/11102-combo-suggestion-count.md
@@ -0,0 +1 @@
+- **Autopilot suggestion counter:** the combo health autopilot summary now reports `suggestionCount` (the real number of suggested actions across all issues) instead of conflating it with link counts, while keeping `actionableCount` as a deprecated alias for backward compatibility. The `run_combo_test` action now links to the dashboard with the combo id (`/dashboard/combos?test=`) rather than the read-only API route, so operators can actually trigger a test from the UI ([#11102](https://github.com/diegosouzapw/OmniRoute/pull/11102)).
diff --git a/changelog.d/fixes/11103-persist-config-audit-log.md b/changelog.d/fixes/11103-persist-config-audit-log.md
new file mode 100644
index 000000000000..aeb53b178145
--- /dev/null
+++ b/changelog.d/fixes/11103-persist-config-audit-log.md
@@ -0,0 +1 @@
+- **Config audit persistence:** persist the configuration audit trail to SQLite (`config_audit_log`) instead of an in-memory buffer capped at 1000 volatile entries, and bound its growth with `cleanupConfigAudit()` driven by the `retention.configAudit` setting (default 30 days), wired into `runAutoCleanup` ([#11103](https://github.com/diegosouzapw/OmniRoute/pull/11103)).
diff --git a/changelog.d/fixes/11109-stream-recovery-toolcall.md b/changelog.d/fixes/11109-stream-recovery-toolcall.md
new file mode 100644
index 000000000000..04a43382e427
--- /dev/null
+++ b/changelog.d/fixes/11109-stream-recovery-toolcall.md
@@ -0,0 +1 @@
+- fix(sse): resume mid-stream recovery after a _completed_ tool call — `finish_reason: "tool_calls"` is now tracked per-call instead of as a general terminal marker, so truncation of trailing prose after a fully-delivered tool call is recoverable while in-flight calls stay blocked ([#11109](https://github.com/diegosouzapw/OmniRoute/pull/11109))
diff --git a/changelog.d/fixes/11116-reasoning-effort-capability-discovery.md b/changelog.d/fixes/11116-reasoning-effort-capability-discovery.md
new file mode 100644
index 000000000000..fbc4dfe694e3
--- /dev/null
+++ b/changelog.d/fixes/11116-reasoning-effort-capability-discovery.md
@@ -0,0 +1 @@
+- **fix(providers):** `reasoning_effort` now learns the accepted values from a provider's own 400/422 response and clamps to the highest one instead of forwarding an unsupported `xhigh`/`max` (or a hardcoded `"high"` fallback) — fixes custom OpenAI-compatible connections and registered providers with no reasoning metadata ([#11116](https://github.com/diegosouzapw/OmniRoute/pull/11116)) — thanks @maxmad64bis
diff --git a/changelog.d/fixes/11144-responses-parallel-tool-calls-index.md b/changelog.d/fixes/11144-responses-parallel-tool-calls-index.md
new file mode 100644
index 000000000000..35ba19b27960
--- /dev/null
+++ b/changelog.d/fixes/11144-responses-parallel-tool-calls-index.md
@@ -0,0 +1 @@
+- **fix(sse):** parallel `function_call` items in a Responses API stream (e.g. several tool calls dispatched in the same turn) now each get a stable, distinct `index`/`id` when translated to Chat Completions streaming deltas, instead of colliding on index 0 and tripping strict stream parsers with `Expected 'id' to be a string.` ([#11144](https://github.com/diegosouzapw/OmniRoute/pull/11144))
diff --git a/changelog.d/fixes/11154-provider-registry-node-net-bundle.md b/changelog.d/fixes/11154-provider-registry-node-net-bundle.md
new file mode 100644
index 000000000000..b30d9e139265
--- /dev/null
+++ b/changelog.d/fixes/11154-provider-registry-node-net-bundle.md
@@ -0,0 +1 @@
+- fix(dashboard): keep `open-sse/config/providerRegistry.ts` free of `node:net` so the provider detail client bundle builds again — the host classification moved to a platform-free `src/shared/network/privateHost.ts` with a pure-JS `isIP` equivalent, leaving the #11122 routing behaviour unchanged (#11154)
diff --git a/changelog.d/fixes/11162-combo-create-requires-model.md b/changelog.d/fixes/11162-combo-create-requires-model.md
new file mode 100644
index 000000000000..228e6a9b20f8
--- /dev/null
+++ b/changelog.d/fixes/11162-combo-create-requires-model.md
@@ -0,0 +1 @@
+- **Combo create:** creating a routing combo without any model is now refused (`400`) — the CLI requires `--models`/`--model` on `combo create`, matching the dashboard which already rejected empty combos.
diff --git a/changelog.d/fixes/11165-shared-registry-passthrough-model-lockout.md b/changelog.d/fixes/11165-shared-registry-passthrough-model-lockout.md
new file mode 100644
index 000000000000..eabe67cb09cb
--- /dev/null
+++ b/changelog.d/fixes/11165-shared-registry-passthrough-model-lockout.md
@@ -0,0 +1 @@
+- **fix(resilience):** a missing-model `404` on a provider that declares `passthroughModels: true` in the shared registry (novita, uncloseai, orcarouter and 37 others) now locks out only that model instead of cooling the entire connection — `hasPerModelQuota()` previously read only the open-sse registry and the local/self-hosted families ([#11165](https://github.com/diegosouzapw/OmniRoute/pull/11165)) — thanks @yourspraveen
diff --git a/changelog.d/fixes/pending-opencode-empty-rejection-rotation.md b/changelog.d/fixes/pending-opencode-empty-rejection-rotation.md
new file mode 100644
index 000000000000..82a88c5905a7
--- /dev/null
+++ b/changelog.d/fixes/pending-opencode-empty-rejection-rotation.md
@@ -0,0 +1 @@
+- **fix(executors):** OpencodeExecutor rotates (or retries once on a single-account direct path) on upstream 400 empty-body rejections — malformed completion envelopes with no error field were propagated as success and killed client sessions. Bounded +1 attempt per request; body reads are conditioned on status 400 so successful/streaming responses are never buffered. 400s carrying an error field keep propagating immediately.
diff --git a/changelog.d/fixes/release-v3850-basereds-tests-i18n.md b/changelog.d/fixes/release-v3850-basereds-tests-i18n.md
new file mode 100644
index 000000000000..3a6dee61b9cd
--- /dev/null
+++ b/changelog.d/fixes/release-v3850-basereds-tests-i18n.md
@@ -0,0 +1 @@
+- fix(i18n): complete Vietnamese translations for recently added UI strings (#9985)
diff --git a/changelog.d/maintenance/11053-stryker-oauth-autoimport-registration.md b/changelog.d/maintenance/11053-stryker-oauth-autoimport-registration.md
new file mode 100644
index 000000000000..b2e214190099
--- /dev/null
+++ b/changelog.d/maintenance/11053-stryker-oauth-autoimport-registration.md
@@ -0,0 +1 @@
+- fix(quality): register `tests/unit/authz/oauth-autoimport-local-only.test.ts` in stryker `tap.testFiles` (residual of #11053)
diff --git a/changelog.d/maintenance/11160-drain-v3850-basereds-docs-counts-orphan-test.md b/changelog.d/maintenance/11160-drain-v3850-basereds-docs-counts-orphan-test.md
new file mode 100644
index 000000000000..e695a2b8fc0b
--- /dev/null
+++ b/changelog.d/maintenance/11160-drain-v3850-basereds-docs-counts-orphan-test.md
@@ -0,0 +1 @@
+- chore(quality): drain two `release/v3.8.50` base-reds — refresh the drifted doc counts (159 migrations, 56 free-forever providers, 40 free-tier pools, incl. the 42 `llm.txt` locale mirrors) and move `uncloseai-noauth.test.ts` to a collected path so the UncloseAI no-auth regression guard actually runs (#11160)
diff --git a/changelog.d/maintenance/vi-harimport-parity.md b/changelog.d/maintenance/vi-harimport-parity.md
new file mode 100644
index 000000000000..b08b8dc92f7d
--- /dev/null
+++ b/changelog.d/maintenance/vi-harimport-parity.md
@@ -0,0 +1 @@
+- fix(i18n): translate the 14 `providers.harImport*` keys into Vietnamese (parity gap left by #11069)
diff --git a/config/quality/file-size-baseline.json b/config/quality/file-size-baseline.json
index 536318240a40..2eb468e16c6d 100644
--- a/config/quality/file-size-baseline.json
+++ b/config/quality/file-size-baseline.json
@@ -1,5 +1,6 @@
{
"_rebaseline_2026_08_20_10531_freebuff_provider": "PR #10531 (adrianaryaputra, feat/freebuff-provider-support, closes #6793) own growth: src/shared/constants/providers/apikey/gateways.ts 1283->1298 (+15, the freebuff APIKEY_PROVIDERS_GATEWAYS catalog entry, additive data at the existing registry chokepoint, same god-file no-split rationale as prior gateways.ts rebaselines) and src/app/(dashboard)/dashboard/providers/[id]/components/modals/AddApiKeyModal.tsx 1062->1067 (+5, freebuff credential placeholder/hint at the existing per-provider switch chokepoint). Covered by tests/unit/freebuff-provider.test.ts (9/9 passing).",
+ "_rebaseline_2026_08_21_10987_logfare_provider": "PR #10987 (jonlwheat2-gif, feat/10644-logfare-provider, closes #10644) own growth: src/shared/constants/providers/apikey/gateways.ts 1298->1321 (+23, the logfare APIKEY_PROVIDERS_GATEWAYS catalog entry with Free badge/freeNote/apiHint documenting the request-logging policy, additive data at the existing registry chokepoint, same god-file no-split rationale as the prior gateways.ts rebaselines: #10531 freebuff, merge-storm 2026-08-11). Covered by tests/unit/logfare-registry.test.ts (1/1 passing).",
"_rebaseline_2026_08_20_10574_reasoning_transport_fallback": "PR #10574 (jackjinke, fix/responses-reasoning-transport, fixes #10550) own growth: src/sse/handlers/chatHelpers.ts 1017->1019 (+2 = the new reasoningTransportFallback option threaded through executeChatWithBreaker's options destructure and its downstream handleSingleModel call, at the existing per-attempt options-passthrough chokepoint; not extractable without splitting the option-forwarding call itself). Covered by the PR's own reasoning-policy test suite (tests/unit/chatcore-translation-paths.test.ts, tests/unit/combo-attempt-body-isolation-7847.test.ts, tests/unit/reasoning-cache.test.ts, tests/unit/strip-reasoning-blobs-agentic-context-1599.test.ts among others), 446/446 focused tests passing.",
"_rebaseline_2026_08_18_10517_zed_hosted_oauth_callback_port": "PR #10517 (phatchau036, fix/zed-hosted-oauth-callback-port) own growth: src/shared/components/OAuthModal.tsx 1131->1148 (wc -l; check-file-size.mjs counts via split(\"\\n\").length so the gate sees 1134->1149, +15/+18, crosses the frozen 1134 cap). Wires the zed-hosted native-app callback auto-complete: forceManual gating on isTrueLocalhost for zed-hosted, the loopback-redirect-URI comment block, and the exchangeToken full-URL-as-code branch, all at the existing provider-switch chokepoints this modal already carries growth for (seventh bump: 969->989->993->998->1030->1056->1100->1149; structural shrink tracked in #3501). The actual port-derivation logic lives in src/lib/oauth/providers/zed-hosted.ts (not frozen here) and was hardened during pre-merge review to use the server's own getRuntimePorts() instead of a browser-guessed scheme/port, covered by the new tests/unit/zed-hosted-loopback-port-derivation.test.ts (8/8 passing).",
"_rebaseline_2026_08_13_10243_codex_fingerprint_merge": "PR #10243 (xz-dev, Codex OAuth fingerprint convergence) merge into release/v3.8.50: src/app/(dashboard)/dashboard/providers/[id]/providerPageHelpers.ts crossed the 1000-line new-file cap for the first time (974 on base, 997 on the PR's own branch, 1013 after merging + prettier reflow) purely from combining two independent, already-legitimate feature additions that landed on the same shared UI-helper file — this PR's own Codex fingerprint-mode select/toggle wiring (CODEX_FINGERPRINT_MODE_VALUES, getCodexFingerprintModeLabel, CodexFingerprintModeValue) plus #8949's unrelated Codex account-service-tier helpers merged concurrently on release/v3.8.50. Neither addition alone crosses the cap; git's line-level auto-merge does not detect a threshold crossing. Not modularized as part of this conflict-resolution merge commit (out of scope — this is a merge, not a feature change). Covered by the PR's own tests/unit/codex-fingerprint-convergence.test.ts, tests/unit/executor-codex.test.ts, tests/unit/provider-specific-data-schema.test.ts (all passing post-merge).",
@@ -388,6 +389,10 @@
"open-sse/services/claudeCodeCompatible.ts": 1563,
"open-sse/services/combo.ts": 4742,
"open-sse/services/compression/strategySelector.ts": 1379,
+ "open-sse/services/compression/engines/ccr/index.ts": 1024,
+ "_rebaseline_2026_08_22_11084_ccr_caller_gate": "PR #11084 (HouMinXi) own growth: open-sse/services/compression/engines/ccr/index.ts 1000->1024 (first listing — the engine was unlisted and drifted just over the 1000 cap; +24 are the callerSupportsCcrRetrieve gate that skips replacement entirely for callers without the retrieve tool, closing the stranded-prompt incident measured in production). Covered by tests/unit/compression/ccr-non-mcp-full-prompt-loss-7746.test.ts. Owner pre-authorized baseline bumps 2026-08-22.",
+ "open-sse/services/contextManager.ts": 1001,
+ "_rebaseline_2026_08_22_11113_purify_system_first": "PR #11113 (ggdayup) own growth: open-sse/services/contextManager.ts 1000->1001 (+1, purifyHistory merges the compression notice into the leading system message instead of splicing a second one mid-array — live-confirmed TokenRouter 400s; the +1 is the merge-into-leading branch, not extractable). Covered by tests/unit/context-manager-purify-system-first.test.ts. Owner pre-authorized baseline bumps 2026-08-22.",
"open-sse/services/rateLimitManager.ts": 1517,
"open-sse/translator/response/openai-responses.ts": 1652,
"open-sse/utils/cursorAgentProtobuf.ts": 1956,
@@ -443,10 +448,11 @@
"src/shared/components/ModelSelectModal.tsx": 1138,
"src/shared/constants/providers/apikey/gateways.ts": 1250
},
- "src/app/(dashboard)/dashboard/providers/[id]/components/modals/AddApiKeyModal.tsx": 1080,
+ "src/app/(dashboard)/dashboard/providers/[id]/components/modals/AddApiKeyModal.tsx": 1082,
+ "_rebaseline_2026_08_22_11156_enter_check_disabled": "PR #11156 (rqzbeh) own growth: AddApiKeyModal.tsx 1080->1082 (+2, Enter keydown handler now mirrors the isCheckDisabled condition — owner-requested post-merge polish from #11056; the rest of the diff is Prettier reflow). Covered by tests/unit/ui/add-api-key-modal-enter-key.test.tsx (jsdom render test, Enter dispatch assertions).",
"src/app/(dashboard)/dashboard/providers/[id]/hooks/useProviderConnections.ts": 1051,
"src/shared/components/ModelSelectModal.tsx": 1138,
- "src/shared/constants/providers/apikey/gateways.ts": 1298,
+ "src/shared/constants/providers/apikey/gateways.ts": 1321,
"open-sse/vendor/codex-chatgpt-web/bridge.ts": 1387,
"_rebaseline_2026_08_11_v3850_merge_storm_provider_registry": "DRIFT do merge-storm 2026-08-11 (99 PRs mergeados no release/v3.8.50). AddApiKeyModal.tsx (PR #8949 ChatGPT Web provider) e useProviderConnections.ts/ModelSelectModal.tsx (PRs #9011 combo test-all, #9499 image combos) = UI nova legitima acima do cap; gateways.ts = god-file de catalogo de providers que cresceu com PRs #9009/#9421/#9468/#9594 (qualquer split arriscaria corromper o merge de novo — o proprio PR #9421 quebrou o arquivo); bridge.ts (PR #8949) = ponte Chromium vendored; proxyFetch.ts 1207->1220 = drift herdado de merges. Owner autorizou rebaseline com anotacao (2026-08-11).",
"src/lib/modelCapabilities.ts": 1072,
@@ -454,7 +460,8 @@
"src/app/(dashboard)/dashboard/providers/[id]/providerPageHelpers.ts": 1014,
"open-sse/config/imageRegistry.ts": 1034,
"src/sse/handlers/chatHelpers.ts": 1019,
- "src/shared/middleware/chatBodyAdmission.ts": 1005,
+ "src/shared/middleware/chatBodyAdmission.ts": 1009,
+ "_rebaseline_2026_08_22_11020_sigterm_drain": "PR #11020 (RaviTharuma) own growth: chatBodyAdmission.ts 1005->1009 (+4, heavyweight admission leases now increment the SIGTERM drain counter and releaseChatAdmissionWhenDone holds it for the SSE lifetime — closes #11015; +4 are the lease/drain wiring lines at the existing admission chokepoint). Covered by tests/unit/chat-body-admission.test.ts heavyweight-lease cases. Owner pre-authorized baseline bumps 2026-08-22.",
"_rebaseline_2026_08_20_10668_tabitoken_gateway": "#10668 (yawar-aquil) own catalog growth: src/shared/constants/providers/apikey/gateways.ts 1268->1283 (+15, entirely this PR diff -- one new tabitoken gateway entry, data lines only; base moved from 1255 to 1268 via other merges since the PR forked). Not combination drift: reproducible on the PR branch alone, so the WS5.5 release-captain rule does not apply. Extraction is not available -- the file is pure data (own header: \"Pure data; merged by apikey/index.ts via spread\") and already split into 6 family files under apikey/. Same precedent as _rebaseline_2026_08_14_imagetotext_servicekinds (#10275/#10291, gateways.ts 1250->1255, data lines only) and _rebaseline_2026_08_11_v3850_merge_storm_provider_registry (owner-authorized for this same file).",
"open-sse/executors/commandCode.ts": 1059,
"_rebaseline_2026_08_21_10859_vision_bridge_catalog": "#10859 own growth (Vision Bridge fixes #10808/#10809): src/lib/modelCapabilities.ts 1006->1016 (+10, cmd/gpt-5.3-codex* text-only capability resolution) and open-sse/executors/commandCode.ts 988->1023 (+35, Command Code wire-model normalization for bare ids + reasoning field fallback for opencode-routed gateways). Cohesive bug fixes at the existing capability-resolution / executor chokepoints; not extractable mid-fix. Covered by tests/unit/model-capabilities-command-code-codex-textonly-10703.test.ts, tests/unit/command-code-vision.test.ts, tests/unit/opencode-mimo-reasoning-details-nonstream.test.ts. Pushed directly to release (own-session miss: the original rebaseline was made in a throwaway validation worktree and never landed on the PR branch or the release before merge).",
diff --git a/config/quality/quality-baseline.json b/config/quality/quality-baseline.json
index 95e35a5adec2..604a5a8e19da 100644
--- a/config/quality/quality-baseline.json
+++ b/config/quality/quality-baseline.json
@@ -197,10 +197,11 @@
"_rebaseline_2026_08_09_v3850_release_close": "7666 -> 8045 (+379 gzip bytes, +4.9%). Release v3.8.50 close reconciliation measured twice with the real size-limit + @size-limit/file path on tip e0ce95c592. Per-entry measurements remain below their absolute budgets: omniroute.mjs 4380/15000, mcp-server.mjs 1195/5000, nodeRuntimeSupport.mjs 887/8000, reset-password.mjs 1583/6000. The growth accumulated through legitimate CLI/runtime work in this cycle, including global-install ESM alias resolution, Termux cache preparation, and MCP stdio startup hardening; no entrypoint is near its absolute ceiling. The direction:down ratchet stays blocking from this exact measured tip."
},
"openapiBreaking": {
- "value": 0,
+ "value": 4,
"direction": "down",
"dedicatedGate": true,
- "_note": "oasdiff breaking-change gate (Fase 9 Onda 0). Blocks any breaking change vs base spec."
+ "_note": "oasdiff breaking-change gate (Fase 9 Onda 0). Blocks any breaking change vs base spec.",
+ "_rebaseline_2026_08_22_combo_create_min1": "0 -> 4, split 3 own + 1 inherited. Docs-only alignment of components.schemas.ComboCreate with the request contract already enforced by the API since 638fc5fbd (combo create refuses an empty model list) and d5034ea52: `model`/`nodes` were phantom properties the server never accepted, and `models` (array, minItems 1) is the real required field. OWN findings (3, caused by this commit): removed `model`, removed `nodes`, added required `models` on POST /api/combos — spec-vs-server drift, not client-facing breakage, no working client could have relied on the removed shapes. INHERITED finding (1, NOT caused by this PR's code changes — pre-existing drift already present at parent d5034ea52): PATCH /api/combos/{id} request-body-added-required; that route's patch operation declares its own inline requestBody (required: true, bare object schema, docs/openapi.yaml ~2107-2118) and does not reference ComboCreate, so this finding exists independently of the ComboCreate alignment (same own-growth vs inherited-drift convention as _rebaseline_2026_07_20_aliasresolver_hook_split_7808). No code change in this PR; follow-up tracking = this change's PR description."
},
"mutationScore.src/sse/services/auth.ts": {
"value": 52.57,
diff --git a/docs/architecture/RESILIENCE_GUIDE.md b/docs/architecture/RESILIENCE_GUIDE.md
index 030f65dd4141..0048761e6093 100644
--- a/docs/architecture/RESILIENCE_GUIDE.md
+++ b/docs/architecture/RESILIENCE_GUIDE.md
@@ -448,14 +448,14 @@ classification rules pick the fallback `reason` and lock `scope`
Classification rules only see full error **text** (needed to match body
markers like `额度不足`) for providers listed in the `FULL_TEXT_RULE_PROVIDERS`
allowlist in `providerErrorRules.ts` — currently only `"agentrouter"`. For
-every other provider, `checkFallbackError` hands `getProviderErrorRuleMatch`
-only the structured error (`{code, type}`), which is enough for
-header/status/code-based rules but blind to body-text markers. The helper
-`resolveRuleMatchBody()` performs this selection: full error text for
-allowlisted providers, the structured error otherwise. Adding a provider to
-`FULL_TEXT_RULE_PROVIDERS` is an explicit per-provider opt-in — it exists so
-that the default path for every provider not on the list stays
-byte-for-byte unchanged.
+every other **built-in catalog** provider, `checkFallbackError` hands
+`getProviderErrorRuleMatch` only the structured error (`{code, type}`), which
+is enough for header/status/code-based rules but blind to body-text markers.
+The helper `resolveRuleMatchBody()` performs this selection: full error text
+for allowlisted providers, the structured error otherwise. Adding a
+**built-in** provider to `FULL_TEXT_RULE_PROVIDERS` is an explicit per-provider
+opt-in — it exists so that the default path for every provider not on the
+list stays byte-for-byte unchanged.
A rule's `scope` (`model` / `provider` / `connection`) is a separate opt-in
from `FULL_TEXT_RULE_PROVIDERS`: `checkFallbackError` only surfaces it as
@@ -466,6 +466,31 @@ honorsRuleLockScope()` — today only `"agentrouter"`). See "Restated quota
errors" above for what a `scope: "connection"` match actually does once a
provider is on that allowlist.
+**#11104 — operator-declared rules bypass both allowlists.** An operator can
+declare a per-provider rule at runtime via `settings.providerErrorRules`
+(`open-sse/config/providerErrorRules.ts::setOperatorProviderErrorRules`)
+without editing this file. Gating an operator rule behind
+`FULL_TEXT_RULE_PROVIDERS`/`HONORS_RULE_LOCK_SCOPE_PROVIDERS` — allowlists
+meant to protect the **default** behavior of built-in catalog rules — would
+make the settings mechanism inert for every provider except the ones already
+listed there, since declaring the rule is already the operator's explicit
+opt-in. `resolveRuleMatchBody()` and `honorsRuleLockScope()` both check
+`hasOperatorRuleForProvider()` first: a provider with an operator rule gets
+the raw error text and has its declared `scope` honored, regardless of
+whether it also appears in either allowlist.
+
+**Known gap — `providerRuleRegistry` is never consulted for HTTP 400.**
+`checkFallbackError`'s `BAD_REQUEST` branch classifies status 400 entirely
+through its own pattern arrays (`MODEL_ACCESS_DENIED_PATTERNS`,
+`CONTEXT_OVERFLOW_PATTERNS`, etc. in `accountFallback.ts`) and returns before
+the `configuredRule`/`getProviderErrorRuleMatch` branch above it is reached.
+A built-in catalog rule (or an operator rule) with `status: 400` is
+syntactically valid but will never fire. No existing rule targets 400 today,
+so nothing in production is affected — but a future 400 rule needs this
+branch touched first, which is a larger change than adding a rule (it
+reclassifies 400 for every provider already relying on the pattern-array
+behavior) and is out of scope for a single-provider rule addition.
+
### Adding a new quota-misstating gateway
1. Register one rule array in `statusRestatementRegistry`
diff --git a/docs/changelog/fragments/10962.md b/docs/changelog/fragments/10962.md
new file mode 100644
index 000000000000..5170a415e3f1
--- /dev/null
+++ b/docs/changelog/fragments/10962.md
@@ -0,0 +1 @@
+fix(catalog): expose only provider-routable GLM reasoning-effort tiers and remove unroutable ZCode aliases
diff --git a/docs/diagrams/cli-terminal.svg b/docs/diagrams/cli-terminal.svg
index e2ad57c8b13f..6ec68793d0c0 100644
--- a/docs/diagrams/cli-terminal.svg
+++ b/docs/diagrams/cli-terminal.svg
@@ -1,4 +1,4 @@
-
>=22.22.2 <23 || >=24.0.0 <27src/ and open-sse/ (zero any in core since v2.0)
- setFormData({ ...formData, apiKey: e.target.value })}
- onKeyDown={(e) => {
- if (e.key === "Enter" && !validating && !saving) {
- e.preventDefault();
- handleValidate();
- }
- }}
- className="flex-1"
- placeholder={apiCredentialPlaceholder}
- hint={apiCredentialHint}
- autoComplete="off"
- spellCheck={false}
- autoCapitalize="off"
- />
-
-
+ {!isNoAuthWebSessionCredential && (() => {
+ const isCheckDisabled =
+ (!isCompatible && !apiKeyOptional && !formData.apiKey) ||
+ (isGooglePse && !formData.cx.trim()) ||
+ validating ||
+ saving;
+ return (
+
- )}
+ );
+ })()}
{isChatGptWebCodex && (
+ setFormData({ ...formData, apiKey: e.target.value })}
+ onKeyDown={(e) => {
+ if (e.key === "Enter" && !isCheckDisabled) {
+ e.preventDefault();
+ handleValidate();
+ }
+ }}
+ className="flex-1"
+ placeholder={apiCredentialPlaceholder}
+ hint={apiCredentialHint}
+ autoComplete="off"
+ spellCheck={false}
+ autoCapitalize="off"
+ />
+
-
+
+
diff --git a/src/app/(dashboard)/home/page.tsx b/src/app/(dashboard)/home/page.tsx
index beccde22610e..bc10df88f424 100644
--- a/src/app/(dashboard)/home/page.tsx
+++ b/src/app/(dashboard)/home/page.tsx
@@ -4,6 +4,7 @@ import { getSettings } from "@/lib/localDb";
import HomePageClient from "../dashboard/HomePageClient";
import BootstrapBanner from "../dashboard/BootstrapBanner";
import KimiSponsorBanner from "../dashboard/KimiSponsorBanner";
+import CheaperInferenceSponsorBanner from "../dashboard/CheaperInferenceSponsorBanner";
import VscodeCopilotBanner from "../dashboard/VscodeCopilotBanner";
import NewsBanner from "../dashboard/NewsBanner";
@@ -20,6 +21,7 @@ export default async function HomePage() {
<>
{isBootstrapped && {
});
}
+function parseRedisUrl(url?: string): { host: string; port: number } | null {
+ if (!url) return null;
+ try {
+ const u = new URL(url);
+ return { host: u.hostname || "127.0.0.1", port: Number(u.port) || 6379 };
+ } catch {
+ return null;
+ }
+}
+
export async function GET() {
const guard = isLocalRequestAllowed();
if (!guard.allowed) {
- return NextResponse.json({ error: guard.reason }, { status: 403 });
+ const reason = (guard as { reason?: string }).reason ?? "Forbidden: not a loopback request";
+ return NextResponse.json({ error: reason }, { status: 403 });
}
+ // Docker/Podman container state (the 1-click launcher path).
const runtime = await detectRuntime();
- if (!runtime) {
- return NextResponse.json(
- { exists: false, running: false, reachable: false, error: "No container runtime (podman or docker) found on PATH" },
- { status: 503 }
- );
+ let container = { exists: false, running: false, reachable: false };
+ if (runtime) {
+ const { exists, running } = await containerState(runtime);
+ const reachable = running ? await pingRedis(HOST_PORT) : false;
+ container = { exists, running, reachable };
}
- const { exists, running } = await containerState(runtime);
- const reachable = running ? await pingRedis(HOST_PORT) : false;
- return NextResponse.json({ runtime, name: CONTAINER_NAME, port: HOST_PORT, exists, running, reachable });
+ // Native Redis via REDIS_URL (the production path this instance uses). OmniRoute
+ // is "connected" whenever REDIS_URL is configured AND the server answers — even
+ // when no Docker container is present.
+ const redisUrl = process.env.REDIS_URL?.trim() || "";
+ const parsed = parseRedisUrl(redisUrl);
+ const redisUrlReachable = parsed ? await pingRedis(String(parsed.port)) : false;
+
+ const running = container.running || redisUrlReachable;
+ const reachable = container.reachable || redisUrlReachable;
+ const exists = container.exists || redisUrlReachable;
+
+ return NextResponse.json({
+ runtime: runtime ?? null,
+ name: CONTAINER_NAME,
+ port: HOST_PORT,
+ exists,
+ running,
+ reachable,
+ redisUrlConfigured: Boolean(redisUrl),
+ redisUrlReachable,
+ });
}
\ No newline at end of file
diff --git a/src/app/api/providers/[id]/models/discovery/providerModelsConfig.ts b/src/app/api/providers/[id]/models/discovery/providerModelsConfig.ts
index 62988798d77e..0939b59b554d 100644
--- a/src/app/api/providers/[id]/models/discovery/providerModelsConfig.ts
+++ b/src/app/api/providers/[id]/models/discovery/providerModelsConfig.ts
@@ -87,6 +87,22 @@ export function parseAlibabaModelStudioModelsForConnection(
export function parseQwenCloudTextModels(data: any): any[] {
return parseCuratedDashscopeModels(data, QWEN_CLOUD_TEXT_MODELS, QWEN_CLOUD_TEXT_MODEL_IDS);
}
+
+// Perplexity's /v1/models lists the Agent API catalog (vendor-prefixed ids like
+// "anthropic/claude-fable-5"), but chat requests always go to the classic
+// /chat/completions endpoint, which only accepts the Sonar family. Filter
+// discovery to Sonar-family ids so agent-style ids never surface as routable
+// chat models (#11060). Bounded pattern — no ReDoS-prone quantifiers.
+export function parsePerplexitySonarModels(data: any): any[] {
+ const models = Array.isArray(data?.data)
+ ? data.data
+ : Array.isArray(data?.models)
+ ? data.models
+ : [];
+ return models.filter(
+ (model: any) => typeof model?.id === "string" && /^sonar(-|$)/.test(model.id)
+ );
+}
type ProviderModelsHeaderContext = {
authType?: string;
providerSpecificData?: unknown;
@@ -659,6 +675,17 @@ export const PROVIDER_MODELS_CONFIG: Record =
headers: { Accept: "application/json" },
parseResponse: parseClinepassRecommendedModels,
},
+ // Perplexity's /v1/models lists the Agent API catalog (vendor-prefixed agent
+ // ids), but chat only accepts the Sonar family on /chat/completions. Import
+ // must keep Sonar-family ids only (#11060).
+ perplexity: {
+ url: "https://api.perplexity.ai/v1/models",
+ method: "GET",
+ headers: { "Content-Type": "application/json" },
+ authHeader: "Authorization",
+ authPrefix: "Bearer ",
+ parseResponse: parsePerplexitySonarModels,
+ },
cohere: {
url: "https://api.cohere.com/v2/models",
method: "GET",
diff --git a/src/app/api/providers/[id]/models/discovery/providerSets.ts b/src/app/api/providers/[id]/models/discovery/providerSets.ts
index 823868147904..2b35e54b01e3 100644
--- a/src/app/api/providers/[id]/models/discovery/providerSets.ts
+++ b/src/app/api/providers/[id]/models/discovery/providerSets.ts
@@ -95,6 +95,11 @@ export const NAMED_OPENAI_STYLE_PROVIDERS = new Set([
"internlm",
"ant-ling",
"nanogpt",
+ // Logfare (https://logfare.ai) — free OpenAI-compatible gateway live-verified
+ // 2026-08-21: GET https://logfare.ai/v1/models returns a real 20-model catalog
+ // (11 chat-capable). Live fetch keeps it fresh; the registry seed stays as the
+ // offline fallback.
+ "logfare",
]);
export function isNamedOpenAIStyleProvider(provider: string): boolean {
diff --git a/src/app/api/providers/[id]/route.ts b/src/app/api/providers/[id]/route.ts
index 562dad074448..4f588571b87c 100644
--- a/src/app/api/providers/[id]/route.ts
+++ b/src/app/api/providers/[id]/route.ts
@@ -121,7 +121,17 @@ export async function PUT(request: Request, { params }: { params: Promise<{ id:
const { id } = await params;
const validation = validateBody(updateProviderConnectionSchema, rawBody);
if (isValidationFailure(validation)) {
- return NextResponse.json({ error: validation.error }, { status: 400 });
+ // never drop an operator's intent silently. Surface the rejected
+ // keys (field paths and unrecognized-key names) alongside the existing
+ // error envelope so clients and the UI can tell exactly what was refused.
+ const rejected = [
+ ...validation.error.details.map((d) => d.field).filter(Boolean),
+ ...validation.error.details.flatMap((d) => d.keys ?? []),
+ ];
+ return NextResponse.json(
+ { error: { ...validation.error, rejected } },
+ { status: 400 }
+ );
}
const body = validation.data;
const {
diff --git a/src/app/api/usage/call-logs/route.ts b/src/app/api/usage/call-logs/route.ts
index c340514c235a..c91a0561a5b5 100644
--- a/src/app/api/usage/call-logs/route.ts
+++ b/src/app/api/usage/call-logs/route.ts
@@ -3,7 +3,7 @@ export const dynamic = "force-dynamic";
import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
import { getCallLogs } from "@/lib/usageDb";
import { getCompletedDetails, getPendingById } from "@/lib/usage/usageHistory";
-import { getProviderConnections } from "@/lib/localDb";
+import { getProviderConnections } from "@/lib/db/providers";
import { getProviderNodes } from "@/models";
import { matchesSearch } from "@/shared/utils/turkishText";
@@ -27,6 +27,66 @@ function rowPriority(row: any): number {
return 2;
}
+/**
+ * Applies the active filter predicates to a single merged call-log row.
+ *
+ * `getCallLogs()` already filters the persisted DB rows server-side, but the
+ * in-memory entries (active/pending + recently-completed) are merged in by
+ * `buildCallLogListRows()` and would otherwise bypass every filter except
+ * `correlationId`. Running the same predicates over the merged rows closes that
+ * gap. It is idempotent for DB rows (they already satisfy the predicate) while
+ * correctly excluding in-memory rows that do not match.
+ */
+export function rowMatchesFilter(row: any, filter: Record): boolean {
+ if (!filter) return true;
+
+ if (filter.status === "error") {
+ if (!(Number(row?.status) >= 400 || Boolean(row?.error))) return false;
+ } else if (filter.status === "ok") {
+ if (!(Number(row?.status) >= 200 && Number(row?.status) < 300)) return false;
+ } else if (typeof filter.status === "number" || (typeof filter.status === "string" && !isNaN(Number(filter.status)))) {
+ if (Number(row?.status) !== Number(filter.status)) return false;
+ }
+
+ if (filter.model && !matchesSearch(row?.model || "", String(filter.model))) {
+ return false;
+ }
+ if (filter.provider && !matchesSearch(row?.provider || "", String(filter.provider))) {
+ return false;
+ }
+ if (filter.account && !matchesSearch(row?.account || "", String(filter.account))) {
+ return false;
+ }
+ if (filter.apiKey && !matchesSearch(row?.apiKeyName || "", String(filter.apiKey))) {
+ return false;
+ }
+ if (filter.combo && !matchesSearch(row?.comboName || "", String(filter.combo))) {
+ return false;
+ }
+ if (filter.correlationId && !matchesSearch(row?.correlationId || "", String(filter.correlationId))) {
+ return false;
+ }
+ if (filter.search) {
+ const term = String(filter.search);
+ const haystack = [
+ row?.model,
+ row?.provider,
+ row?.providerDisplay,
+ row?.account,
+ row?.apiKeyName,
+ row?.comboName,
+ row?.correlationId,
+ row?.error,
+ row?.path,
+ ]
+ .filter(Boolean)
+ .join(" ");
+ if (!matchesSearch(haystack, term)) return false;
+ }
+
+ return true;
+}
+
export function buildCallLogListRows({
logs,
connections,
@@ -174,15 +234,8 @@ export async function GET(request: Request) {
completedDetails: getCompletedDetails().values(),
});
- // When correlationId filter is set, also filter in-memory entries
- // (active + completed) that don't match — getCallLogs already filters
- // the DB rows but activeEntries/completedEntries bypass it.
- if (filter.correlationId) {
- const cid = filter.correlationId;
- return NextResponse.json(rows.filter((r: any) => matchesSearch(r.correlationId || "", cid)));
- }
-
- return NextResponse.json(rows);
+ const filtered = rows.filter((r: any) => rowMatchesFilter(r, filter));
+ return NextResponse.json(filtered);
} catch (error) {
console.error("[API ERROR] /api/usage/call-logs failed:", error);
return NextResponse.json({ error: "Failed to fetch call logs" }, { status: 500 });
diff --git a/src/app/api/v1/rerank/route.ts b/src/app/api/v1/rerank/route.ts
index bf9da386eb4a..04fb1632dc6c 100644
--- a/src/app/api/v1/rerank/route.ts
+++ b/src/app/api/v1/rerank/route.ts
@@ -10,11 +10,15 @@ import { HTTP_STATUS } from "@omniroute/open-sse/config/constants.ts";
import { enforceApiKeyPolicy } from "@/shared/utils/apiKeyPolicy";
import { v1RerankSchema } from "@/shared/validation/schemas";
import { isValidationFailure, validateBody } from "@/shared/validation/helpers";
-import { getCachedProviderNodes } from "@/lib/localDb";
+import { getCachedProviderNodes } from "@/lib/db/readCache";
import {
isAllRateLimitedCredentials,
rateLimitedProviderResponse,
} from "@/app/api/v1/_shared/rateLimit";
+import { saveCallLog } from "@/lib/usageDb";
+import { attachOmniRouteMetaHeaders } from "@/domain/omnirouteResponseMeta";
+import { generateRequestId } from "@/shared/utils/requestId";
+import { CORS_HEADERS } from "@omniroute/open-sse/utils/cors.ts";
/**
* Handle CORS preflight
@@ -121,6 +125,8 @@ async function postHandler(request, context) {
return_documents: body.return_documents,
credentials,
connectionId: (credentials as { connectionId?: string } | null)?.connectionId || null,
+ apiKeyId: policy.apiKeyInfo?.id || null,
+ apiKeyName: policy.apiKeyInfo?.name || null,
});
if (response?.ok) {
await clearRecoveredProviderState(credentials);
@@ -148,8 +154,9 @@ async function postHandler(request, context) {
}
const token = credentials?.apiKey || credentials?.accessToken;
+ const startTime = Date.now();
try {
- const res = await fetch(localProvider.baseUrl, {
+ let res = await fetch(localProvider.baseUrl, {
method: "POST",
headers: {
"Content-Type": "application/json",
@@ -164,19 +171,110 @@ async function postHandler(request, context) {
}),
});
+ // Some local providers (e.g. Infinity, TEI) mount at /rerank rather than /v1/rerank
+ if (res.status === 404 && localProvider.baseUrl.endsWith("/v1/rerank")) {
+ const fallbackUrl = localProvider.baseUrl.replace(/\/v1\/rerank$/, "/rerank");
+ try {
+ const fallbackRes = await fetch(fallbackUrl, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ Authorization: `Bearer ${token}`,
+ },
+ body: JSON.stringify({
+ model: localModel,
+ query: body.query,
+ documents: body.documents,
+ top_n: body.top_n || body.documents.length,
+ return_documents: body.return_documents !== false,
+ }),
+ });
+ if (fallbackRes.ok || fallbackRes.status !== 404) {
+ res = fallbackRes;
+ }
+ } catch {
+ // retain original 404 response if fallback fetch fails
+ }
+ }
+
if (!res.ok) {
const errData = await res.json().catch(() => ({}));
- return errorResponse(
- res.status,
- errData.message || errData.detail || `Provider returned HTTP ${res.status}`
- );
+ const errorMessage =
+ errData.message || errData.detail || `Provider returned HTTP ${res.status}`;
+ saveCallLog({
+ method: "POST",
+ path: "/v1/rerank",
+ status: res.status,
+ model: body.model,
+ provider: prefix,
+ connectionId:
+ (credentials as { connectionId?: string } | null)?.connectionId || undefined,
+ duration: Date.now() - startTime,
+ requestBody: {
+ model: body.model,
+ query: body.query,
+ documents: body.documents,
+ top_n: body.top_n,
+ return_documents: body.return_documents,
+ },
+ responseBody: errData,
+ error: errorMessage,
+ apiKeyId: policy.apiKeyInfo?.id || undefined,
+ apiKeyName: policy.apiKeyInfo?.name || undefined,
+ }).catch(() => {});
+ return errorResponse(res.status, errorMessage);
}
const data = await res.json();
- return Response.json(data, {
- headers: {},
+ const latencyMs = Date.now() - startTime;
+ saveCallLog({
+ method: "POST",
+ path: "/v1/rerank",
+ status: 200,
+ model: body.model,
+ provider: prefix,
+ connectionId:
+ (credentials as { connectionId?: string } | null)?.connectionId || undefined,
+ duration: latencyMs,
+ tokens: { prompt_tokens: 0, completion_tokens: 0 },
+ requestBody: {
+ model: body.model,
+ query: body.query,
+ documents: body.documents,
+ top_n: body.top_n,
+ return_documents: body.return_documents,
+ },
+ responseBody: data,
+ apiKeyId: policy.apiKeyInfo?.id || undefined,
+ apiKeyName: policy.apiKeyInfo?.name || undefined,
+ }).catch(() => {});
+
+ const headers = new Headers({ ...CORS_HEADERS, "Content-Type": "application/json" });
+ attachOmniRouteMetaHeaders(headers, {
+ provider: prefix,
+ model: localModel,
+ costUsd: 0,
+ latencyMs,
+ requestId: generateRequestId(),
+ });
+ return new Response(JSON.stringify(data), {
+ status: 200,
+ headers,
});
} catch (err: any) {
+ saveCallLog({
+ method: "POST",
+ path: "/v1/rerank",
+ status: 500,
+ model: body.model,
+ provider: prefix,
+ connectionId:
+ (credentials as { connectionId?: string } | null)?.connectionId || undefined,
+ duration: Date.now() - startTime,
+ error: err.message,
+ apiKeyId: policy.apiKeyInfo?.id || undefined,
+ apiKeyName: policy.apiKeyInfo?.name || undefined,
+ }).catch(() => {});
return errorResponse(500, `Rerank request failed: ${err.message}`);
}
}
diff --git a/src/app/api/v1/search/route.ts b/src/app/api/v1/search/route.ts
index adb888dff778..313b72dece0c 100644
--- a/src/app/api/v1/search/route.ts
+++ b/src/app/api/v1/search/route.ts
@@ -58,9 +58,7 @@ export async function OPTIONS() {
export async function GET() {
const settings = await getSettings().catch(() => ({} as any));
const blockedProviders = settings?.blockedProviders || [];
- const providers = getAllSearchProviders().filter(
- (p) => !isProviderBlockedByIdOrAlias(p.id, blockedProviders)
- );
+ const providers = getAllSearchProviders(blockedProviders);
const timestamp = Math.floor(Date.now() / 1000);
const data = providers.map((p) => ({
diff --git a/src/domain/configAudit.ts b/src/domain/configAudit.ts
index c2701b2a21f7..873d3b046a5f 100644
--- a/src/domain/configAudit.ts
+++ b/src/domain/configAudit.ts
@@ -13,6 +13,8 @@
* - Optional human notes
*/
+import { getDbInstance } from "../lib/db/core";
+
/** Types of configuration entities that can be audited */
export type AuditTarget = "provider" | "combo" | "policy" | "connection" | "settings";
@@ -72,10 +74,8 @@ export interface ConfigSnapshot {
data: Record;
}
-// ── In-memory store ──────────────────────────────────────────────────────────
-// In production, persist to SQLite alongside other domain state.
+// ── SQLite-backed store ───────────────────────────────────────────────────────
-let auditLog: ConfigAuditEntry[] = [];
let idCounter = 0;
function generateId(): string {
@@ -85,6 +85,40 @@ function generateId(): string {
return `audit-${ts}-${seq}`;
}
+function db() {
+ return getDbInstance();
+}
+
+interface ConfigAuditRow {
+ id: string;
+ timestamp: string;
+ action: string;
+ target: string;
+ target_id: string;
+ target_name: string;
+ before_json: string | null;
+ after_json: string | null;
+ diff_json: string;
+ source: string;
+ note: string | null;
+}
+
+function rowToEntry(row: ConfigAuditRow): ConfigAuditEntry {
+ return {
+ id: row.id,
+ timestamp: row.timestamp,
+ action: row.action as AuditAction,
+ target: row.target as AuditTarget,
+ targetId: row.target_id,
+ targetName: row.target_name,
+ before: row.before_json === null ? null : (JSON.parse(row.before_json) as Record | null),
+ after: row.after_json === null ? null : (JSON.parse(row.after_json) as Record | null),
+ source: row.source as AuditSource,
+ diff: JSON.parse(row.diff_json) as ConfigDiff,
+ note: row.note,
+ };
+}
+
/**
* Compute a structured diff between two configuration states.
*/
@@ -159,12 +193,24 @@ export function recordChange(
note: note ?? null,
};
- auditLog.push(entry);
-
- // Keep log bounded (max 1000 entries in memory)
- if (auditLog.length > 1000) {
- auditLog = auditLog.slice(-1000);
- }
+ db().prepare(
+ `INSERT INTO config_audit_log
+ (id, timestamp, action, target, target_id, target_name, before_json, after_json, diff_json, source, note)
+ VALUES
+ (@id, @timestamp, @action, @target, @targetId, @targetName, @beforeJson, @afterJson, @diffJson, @source, @note)`
+ ).run({
+ id: entry.id,
+ timestamp: entry.timestamp,
+ action: entry.action,
+ target: entry.target,
+ targetId: entry.targetId,
+ targetName: entry.targetName,
+ beforeJson: before === null ? null : JSON.stringify(before),
+ afterJson: after === null ? null : JSON.stringify(after),
+ diffJson: JSON.stringify(entry.diff),
+ source: entry.source,
+ note: entry.note,
+ });
return entry;
}
@@ -181,42 +227,57 @@ export function getAuditLog(options?: {
limit?: number;
offset?: number;
}): { entries: ConfigAuditEntry[]; total: number } {
- let filtered = auditLog;
+ const where: string[] = [];
+ const params: Record = {};
if (options?.target) {
- filtered = filtered.filter((e) => e.target === options.target);
+ where.push("target = @target");
+ params.target = options.target;
}
if (options?.targetId) {
- filtered = filtered.filter((e) => e.targetId === options.targetId);
+ where.push("target_id = @targetId");
+ params.targetId = options.targetId;
}
if (options?.action) {
- filtered = filtered.filter((e) => e.action === options.action);
+ where.push("action = @action");
+ params.action = options.action;
}
if (options?.source) {
- filtered = filtered.filter((e) => e.source === options.source);
+ where.push("source = @source");
+ params.source = options.source;
}
if (options?.since) {
- filtered = filtered.filter((e) => e.timestamp >= options.since!);
+ where.push("timestamp >= @since");
+ params.since = options.since;
}
- const total = filtered.length;
+ const whereSql = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
- // Sort newest first
- filtered = [...filtered].sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+ const totalRow = db()
+ .prepare(`SELECT COUNT(*) AS c FROM config_audit_log ${whereSql}`)
+ .get(params) as { c: number };
+ const total = totalRow.c;
- // Paginate
const offset = options?.offset ?? 0;
const limit = options?.limit ?? 50;
- filtered = filtered.slice(offset, offset + limit);
- return { entries: filtered, total };
+ const rows = db()
+ .prepare(
+ `SELECT * FROM config_audit_log ${whereSql} ORDER BY datetime(timestamp) DESC, id DESC LIMIT @limit OFFSET @offset`
+ )
+ .all({ ...params, limit, offset }) as ConfigAuditRow[];
+
+ return { entries: rows.map(rowToEntry), total };
}
/**
* Get a specific audit entry by ID.
*/
export function getAuditEntry(id: string): ConfigAuditEntry | null {
- return auditLog.find((e) => e.id === id) ?? null;
+ const row = db()
+ .prepare("SELECT * FROM config_audit_log WHERE id = @id")
+ .get({ id }) as ConfigAuditRow | undefined;
+ return row ? rowToEntry(row) : null;
}
/**
@@ -260,19 +321,23 @@ export function getAuditSummary(): {
const byAction: Record = {};
const bySource: Record = {};
- for (const entry of auditLog) {
- byTarget[entry.target] = (byTarget[entry.target] || 0) + 1;
- byAction[entry.action] = (byAction[entry.action] || 0) + 1;
- bySource[entry.source] = (bySource[entry.source] || 0) + 1;
+ const rows = db()
+ .prepare("SELECT * FROM config_audit_log ORDER BY datetime(timestamp) DESC, id DESC")
+ .all() as ConfigAuditRow[];
+
+ for (const row of rows) {
+ byTarget[row.target] = (byTarget[row.target] || 0) + 1;
+ byAction[row.action] = (byAction[row.action] || 0) + 1;
+ bySource[row.source] = (bySource[row.source] || 0) + 1;
}
return {
- totalEntries: auditLog.length,
+ totalEntries: rows.length,
byTarget,
byAction,
bySource,
- oldestEntry: auditLog.length > 0 ? auditLog[0].timestamp : null,
- newestEntry: auditLog.length > 0 ? auditLog[auditLog.length - 1].timestamp : null,
+ oldestEntry: rows.length > 0 ? rows[rows.length - 1].timestamp : null,
+ newestEntry: rows.length > 0 ? rows[0].timestamp : null,
};
}
@@ -280,6 +345,6 @@ export function getAuditSummary(): {
* Reset the audit log. Useful for testing.
*/
export function resetAuditLog(): void {
- auditLog = [];
+ db().prepare("DELETE FROM config_audit_log").run();
idCounter = 0;
}
diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json
index ec091011e9d9..930f5b595875 100644
--- a/src/i18n/messages/en.json
+++ b/src/i18n/messages/en.json
@@ -5692,8 +5692,8 @@
"aggregatorsGateways": "Aggregators Gateways",
"enterpriseCloud": "Enterprise & Cloud",
"apiFormatLabel": "Api Format Label",
- "apiKeyOptionalHint": "Api Key Optional Hint",
- "apiKeyOptionalLabel": "Api Key Optional Label",
+ "apiKeyOptionalHint": "Leave empty if your local setup or provider does not require authentication.",
+ "apiKeyOptionalLabel": "API Key (optional)",
"apiRegionChina": "Api Region China",
"apiRegionHint": "Api Region Hint",
"apiRegionInternational": "Api Region International",
@@ -13869,5 +13869,12 @@
"toolsMismatch": "Provider does not support tool calling",
"structuredOutputMismatch": "Provider does not support structured output",
"contextWindowMismatch": "Request exceeds provider context window"
+ },
+ "cheaperInferenceSponsorBanner": {
+ "title": "Cheaper Inference is an OmniRoute Open Source Friend",
+ "description": "A cost-ranked gateway reselling dozens of frontier models behind one OpenAI-compatible endpoint — routing each request to the cheapest eligible provider, never above list price.",
+ "cta": "Get an API Key",
+ "partnerLinkNote": "Partner link",
+ "dismissAriaLabel": "Dismiss"
}
}
diff --git a/src/i18n/messages/pt.json b/src/i18n/messages/pt.json
index 11a3606a54cd..1921f3fba7fb 100644
--- a/src/i18n/messages/pt.json
+++ b/src/i18n/messages/pt.json
@@ -13845,5 +13845,12 @@
"toolsMismatch": "Provider does not support tool calling",
"structuredOutputMismatch": "Provider does not support structured output",
"contextWindowMismatch": "Request exceeds provider context window"
+ },
+ "cheaperInferenceSponsorBanner": {
+ "title": "A Cheaper Inference é uma Amiga do Código Aberto do OmniRoute",
+ "description": "Um gateway com custo ordenado que revende dezenas de modelos de fronteira num único endpoint compatível com OpenAI — roteando cada requisição ao provedor elegível mais barato, nunca acima do preço de tabela.",
+ "cta": "Obter uma Chave de API",
+ "partnerLinkNote": "Link de parceiro",
+ "dismissAriaLabel": "Dispensar"
}
}
diff --git a/src/i18n/messages/vi.json b/src/i18n/messages/vi.json
index a17c1fc52c41..e04b20666139 100644
--- a/src/i18n/messages/vi.json
+++ b/src/i18n/messages/vi.json
@@ -6269,6 +6269,20 @@
"webSessionGuideStep3": "Sao chép thông tin xác thực được yêu cầu từ tên miền riêng của nhà cung cấp. Đối với cookie, chỉ sao chép giá trị tiêu đề Cookie và bỏ qua Cookie:.",
"webSessionGuideStep3Manual": "Cách thủ công: mở công cụ dành cho nhà phát triển của trình duyệt (F12 → Network), tải lại trang, mở một yêu cầu đã xác thực và sao chép giá trị tiêu đề Cookie trong Request Headers — bỏ tiền tố Cookie:.",
"webSessionGuideStep4": "Dán vào đây và kiểm tra kết nối. Nếu nó ngừng hoạt động, hãy đăng nhập lại và thay thế bằng một giá trị mới.",
+ "harImportButtonLabel": "Nhập tệp .har",
+ "harImportButtonBusy": "Đang nhập…",
+ "harImportButtonHint": "Xuất từ thẻ Network của DevTools sau khi gửi ít nhất một tin nhắn chat.",
+ "harImportStatusValid": "Đã nhập — hợp lệ trong ~{minutes} phút.",
+ "harImportStatusExpiringSoon": "Đã nhập — chỉ còn hợp lệ ~{minutes} phút nữa.",
+ "harImportStatusExpired": "Đã nhập, nhưng token này đã hết hạn ({minutes} phút trước) — hãy xuất một HAR mới.",
+ "harImportStatusUnknownExpiry": "Đã nhập. Không đọc được thời hạn.",
+ "harImportErrorNotJson": "Tệp đó không phải JSON hợp lệ — có đúng là bản xuất .har không?",
+ "harImportErrorNoEntries": "HAR này không có mục network nào được ghi lại.",
+ "harImportErrorNoChathubUrl": "Không tìm thấy kết nối Copilot chat trong HAR này. Hãy gửi ít nhất một tin nhắn chat trong m365.cloud.microsoft trước khi xuất.",
+ "harImportErrorUnparsableUrl": "Tìm thấy kết nối chat, nhưng không đọc được URL của nó.",
+ "harImportErrorMissingFields": "Tìm thấy kết nối chat, nhưng token bị thiếu trong đó.",
+ "harImportErrorReadFailed": "Không đọc được tệp đó.",
+ "harImportErrorUnknown": "Không trích xuất được thông tin xác thực từ tệp HAR đó.",
"webSessionSecurityHint": "Hãy coi đây như mật khẩu: nó có thể truy cập vào tài khoản web đã đăng nhập của bạn cho đến khi hết hạn hoặc bị thu hồi.",
"webNoAuthGuideTitle": "Không yêu cầu thông tin xác thực",
"webNoAuthGuideBody": "{provider} không cần khóa API hoặc cookie. Lưu kết nối để sử dụng endpoint web miễn phí của nó.",
@@ -12207,7 +12221,7 @@
},
"omni-webhooks": {
"name": "Webhook",
- "description": "__MISSING__:Register, list, test, and remove webhook endpoints. Configure event subscriptions (request.completed, request.failed, quota.exceeded, etc.) and manage delivery retries."
+ "description": "Đăng ký, liệt kê, kiểm thử và xoá các endpoint webhook. Cấu hình đăng ký sự kiện (request.completed, request.failed, quota.exceeded, v.v.) và quản lý thử lại giao hàng."
},
"omni-mcp": {
"name": "Máy chủ MCP",
diff --git a/src/lib/cli-helper/config-generator/opencode.ts b/src/lib/cli-helper/config-generator/opencode.ts
index a2329968abc3..e65206dc5574 100644
--- a/src/lib/cli-helper/config-generator/opencode.ts
+++ b/src/lib/cli-helper/config-generator/opencode.ts
@@ -280,10 +280,9 @@ function buildModelEntry(
}
// Resolve the context window. Honor an explicit user override, then fall
- // back to the catalog. We do NOT synthesize a default — if the catalog
- // is unaware of a model's window, the opencode.json will simply omit
- // `limit.context` for that model and OpenCode's own heuristics apply.
- // (OpenCode v1 defaults to 128K when `limit.context` is missing.)
+ // back to the catalog. If the catalog is unaware of a model's window, we
+ // fall back to a safe default (128K) so OpenCode's v1 provider schema
+ // validator never rejects the config with a missing key error (#11035).
const userLimit = existing?.limit?.context;
const catalogLimit = catalog ? resolveContextLength(catalog) : undefined;
const context = typeof userLimit === "number" && userLimit > 0 ? userLimit : catalogLimit;
@@ -292,9 +291,6 @@ function buildModelEntry(
// Use the catalog's max_output_tokens when available; otherwise fall
// back to the user's existing `limit.output` and finally to a small
// default (8K) so OpenCode never errors on a totally missing output cap.
- // We do NOT default context — context is a property of the model and
- // we have no business guessing. Output is a per-request setting and a
- // small default is harmless when truly unknown.
const userOutput = existing?.limit?.output;
const catalogOutput =
catalog && typeof catalog.max_output_tokens === "number" && catalog.max_output_tokens > 0
@@ -411,7 +407,7 @@ export interface GenerateOpencodeOptions {
/**
* If `true` (default), the generator fetches the live `/v1/models` catalog
* so every model entry has an explicit `limit.context`. The catalog is the
- * single source of truth for context windows; we never invent defaults.
+ * primary source of truth for context windows, falling back to 128K when unknown.
*
* When the catalog request fails, the generator throws — opencode.json must
* not be emitted with stale or fabricated values. The CLI can catch the
@@ -426,7 +422,7 @@ export interface GenerateOpencodeOptions {
/**
* Generate a full `opencode.json` document for OmniRoute. The catalog is the
- * single source of truth for context windows — we never hardcode values.
+ * primary source of truth for context windows, with a 128K fallback when unknown.
*
* Behavior:
* - Preserves the user's existing provider name, npm, options, and
@@ -436,8 +432,8 @@ export interface GenerateOpencodeOptions {
* - For each catalog model id the user did NOT have, a new entry is
* added with `limit.context` populated when the catalog has it.
* - If the catalog has no context for a model AND the user has no
- * override, the model is emitted WITHOUT a `limit.context` field.
- * OpenCode's own heuristic (typically 128K) applies.
+ * override, a safe default (128K) is emitted so OpenCode's schema validator
+ * does not reject the model.
* - Throws if the catalog fetch fails — the user must fix the upstream
* before we can generate a reliable opencode.json.
*/
diff --git a/src/lib/config/runtimeSettings.ts b/src/lib/config/runtimeSettings.ts
index dc5e9d720dc8..bf615749bae6 100644
--- a/src/lib/config/runtimeSettings.ts
+++ b/src/lib/config/runtimeSettings.ts
@@ -1,5 +1,9 @@
import { clearHealthCheckLogCache } from "@/lib/tokenHealthCheck";
import { setCustomBannedSignals } from "@omniroute/open-sse/services/accountFallback.ts";
+import {
+ setOperatorProviderErrorRules,
+ type OperatorProviderErrorRule,
+} from "@omniroute/open-sse/config/providerErrorRules.ts";
import { isAutomatedTestProcess } from "@/shared/utils/testProcess";
type JsonRecord = Record;
@@ -46,6 +50,7 @@ interface RuntimeSettingsSnapshot {
systemTransforms: unknown;
authzBypass: AuthzBypassSnapshot;
customBannedSignals: string[];
+ providerErrorRules: Record | null;
}
// Default bypass policy: kill-switch on, `/api/mcp/` bypassable. Mirrors the
@@ -72,6 +77,7 @@ const DEFAULT_RUNTIME_SETTINGS_SNAPSHOT: RuntimeSettingsSnapshot = {
systemTransforms: null,
authzBypass: DEFAULT_AUTHZ_BYPASS_SNAPSHOT,
customBannedSignals: [],
+ providerErrorRules: null,
};
let lastAppliedSnapshot: RuntimeSettingsSnapshot | null = null;
@@ -138,6 +144,34 @@ function normalizeStringArray(value: unknown): string[] {
);
}
+/**
+ * Defensive shape-check of operator-declared error rules pulled from settings.
+ * The settings schema already validates this on write; this guard prevents a
+ * malformed stored value (or an unexpected shape) from crashing the
+ * error-classification hot path. Returns null when the value is missing or not
+ * a record of non-empty rule arrays.
+ */
+function normalizeOperatorProviderErrorRules(
+ value: unknown
+): Record | null {
+ if (value === null || typeof value !== "object") return null;
+ const record = value as Record;
+ const result: Record = {};
+ for (const [provider, list] of Object.entries(record)) {
+ if (!Array.isArray(list) || list.length === 0) continue;
+ const rules = list.filter(
+ (entry): entry is OperatorProviderErrorRule =>
+ !!entry &&
+ typeof entry === "object" &&
+ typeof (entry as OperatorProviderErrorRule).status === "number" &&
+ typeof (entry as OperatorProviderErrorRule).match === "string" &&
+ typeof (entry as OperatorProviderErrorRule).scope === "string"
+ );
+ if (rules.length > 0) result[provider.toLowerCase()] = rules;
+ }
+ return Object.keys(result).length > 0 ? result : null;
+}
+
function normalizeStringRecord(value: unknown): Record {
const record = toRecord(parseStoredJson(value, "modelAliases"));
const entries = Object.entries(record)
@@ -244,6 +278,7 @@ export function buildRuntimeSettingsSnapshot(
systemTransforms: parseStoredJson(settings.systemTransforms, "systemTransforms"),
authzBypass: normalizeAuthzBypass(settings),
customBannedSignals: normalizeStringArray(settings.customBannedSignals),
+ providerErrorRules: normalizeOperatorProviderErrorRules(settings.providerErrorRules),
};
}
@@ -540,6 +575,13 @@ export async function applyRuntimeSettings(
markChanged("bannedSignals");
}
+ if (
+ force ||
+ hasChanged(currentSnapshot.providerErrorRules, previousSnapshot.providerErrorRules)
+ ) {
+ setOperatorProviderErrorRules(currentSnapshot.providerErrorRules ?? undefined);
+ }
+
lastAppliedSnapshot = currentSnapshot;
return changes;
}
diff --git a/src/lib/db/adapters/driverFactory.ts b/src/lib/db/adapters/driverFactory.ts
index 64c06153dbe6..304b334bd8eb 100644
--- a/src/lib/db/adapters/driverFactory.ts
+++ b/src/lib/db/adapters/driverFactory.ts
@@ -224,7 +224,10 @@ export function createSyncDriverFactory(load: DriverLoader, betterSqliteProbe?:
const bunOptions: Record = {};
if (options?.readonly === true) bunOptions.readonly = true;
if (options?.create === false && filePath !== ":memory:") bunOptions.create = false;
- const db = new Database(filePath, bunOptions);
+ const db =
+ Object.keys(bunOptions).length > 0
+ ? new Database(filePath, bunOptions)
+ : new Database(filePath);
return createBunSqliteAdapter(db, filePath);
} catch (err) {
logSwallowedDriverError("bun:sqlite", err);
diff --git a/src/lib/db/cleanup.ts b/src/lib/db/cleanup.ts
index 617bf4c22642..60e288bf4b47 100644
--- a/src/lib/db/cleanup.ts
+++ b/src/lib/db/cleanup.ts
@@ -193,6 +193,31 @@ export async function cleanupMcpAudit(): Promise {
return result;
}
+/**
+ * Clean up old config_audit_log based on retention settings.
+ */
+export async function cleanupConfigAudit(retentionDays = getRetentionSettings().configAudit): Promise {
+ const db = getDbInstance();
+ const result: CleanupResult = { deleted: 0, errors: 0 };
+
+ try {
+ const stmt = db.prepare(
+ "DELETE FROM config_audit_log WHERE datetime(timestamp) < datetime('now', '-' || ? || ' days')"
+ );
+ const runResult = stmt.run(String(retentionDays));
+ result.deleted = runResult.changes;
+
+ console.log(
+ `[Cleanup] Deleted ${result.deleted} config_audit_log older than ${retentionDays} days`
+ );
+ } catch (err: unknown) {
+ console.error("[Cleanup] Error cleaning config_audit_log:", err);
+ result.errors++;
+ }
+
+ return result;
+}
+
/**
* Clean up old a2a_task_events based on retention settings.
*/
@@ -420,6 +445,7 @@ export async function runAutoCleanup(): Promise<{
usageHistory: await cleanupUsageHistory(),
compressionAnalytics: await cleanupCompressionAnalytics(),
mcpAudit: await cleanupMcpAudit(),
+ configAudit: await cleanupConfigAudit(),
a2aEvents: await cleanupA2aEvents(),
memoryEntries: await cleanupMemoryEntries(),
domainCostHistory: await cleanupDomainCostHistory(),
diff --git a/src/lib/db/databaseSettings.ts b/src/lib/db/databaseSettings.ts
index e18f2a66bd9a..0a12729242cd 100644
--- a/src/lib/db/databaseSettings.ts
+++ b/src/lib/db/databaseSettings.ts
@@ -46,6 +46,7 @@ const LEGACY_FLAT_KEYS: {
quotaSnapshots: ["quotaSnapshots"],
compressionAnalytics: ["compressionAnalytics"],
mcpAudit: ["mcpAudit"],
+ configAudit: ["configAudit"],
a2aEvents: ["a2aEvents"],
callLogs: ["callLogs"],
usageHistory: ["usageHistory"],
diff --git a/src/lib/db/migrations/046_database_settings.sql b/src/lib/db/migrations/046_database_settings.sql
index 57fd15c903be..6fb9864390a5 100644
--- a/src/lib/db/migrations/046_database_settings.sql
+++ b/src/lib/db/migrations/046_database_settings.sql
@@ -25,6 +25,7 @@ INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSetting
INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'quotaSnapshots', '90');
INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'compressionAnalytics', '30');
INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'mcpAudit', '30');
+INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'configAudit', '30');
INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'a2aEvents', '30');
INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'callLogs', '90');
INSERT OR IGNORE INTO key_value (namespace, key, value) VALUES ('databaseSettings', 'usageHistory', '365');
diff --git a/src/lib/db/migrations/161_config_audit_log.sql b/src/lib/db/migrations/161_config_audit_log.sql
new file mode 100644
index 000000000000..0aad91ace28e
--- /dev/null
+++ b/src/lib/db/migrations/161_config_audit_log.sql
@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS config_audit_log (
+ id TEXT PRIMARY KEY,
+ timestamp TEXT NOT NULL,
+ action TEXT NOT NULL,
+ target TEXT NOT NULL,
+ target_id TEXT NOT NULL,
+ target_name TEXT NOT NULL,
+ before_json TEXT,
+ after_json TEXT,
+ diff_json TEXT NOT NULL,
+ source TEXT NOT NULL,
+ note TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_config_audit_log_target_created ON config_audit_log(target, timestamp);
+CREATE INDEX IF NOT EXISTS idx_config_audit_log_created ON config_audit_log(timestamp);
diff --git a/src/lib/db/migrations/162_remove_hackclub_provider.sql b/src/lib/db/migrations/162_remove_hackclub_provider.sql
new file mode 100644
index 000000000000..4dd20904e96e
--- /dev/null
+++ b/src/lib/db/migrations/162_remove_hackclub_provider.sql
@@ -0,0 +1,21 @@
+-- 162_remove_hackclub_provider.sql
+-- Hack Club AI provider was removed from OmniRoute at the request of Hack Club's
+-- maintainers (#11118). Clean up any locally stored configuration for it.
+-- Historical request and usage records are intentionally preserved under the
+-- provider identity that existed when they were written.
+
+DELETE FROM provider_connections
+WHERE provider = 'hackclub';
+
+DELETE FROM registered_keys
+WHERE provider = 'hackclub';
+
+DELETE FROM provider_key_limits
+WHERE provider = 'hackclub';
+
+DELETE FROM discovery_results
+WHERE provider_id = 'hackclub';
+
+DELETE FROM key_value
+WHERE namespace = 'customModels'
+ AND key = 'hackclub';
diff --git a/src/lib/db/providers.ts b/src/lib/db/providers.ts
index 3b02933e1135..fbab6817fd69 100644
--- a/src/lib/db/providers.ts
+++ b/src/lib/db/providers.ts
@@ -627,15 +627,26 @@ export async function createProviderConnection(data: JsonRecord) {
// to no-overrides) keeps the field present on the returned object so the
// UI can tell "field was read, no overrides" apart from "field absent."
if ("quotaWindowThresholds" in connection) {
- connection.quotaWindowThresholds = sanitizeQuotaWindowThresholds(
- connection.quotaWindowThresholds
- );
+ const result = sanitizeQuotaWindowThresholds(connection.quotaWindowThresholds);
+ if (result.rejected.length > 0) {
+ throw new Error(
+ `Refusing to persist quotaWindowThresholds with rejected keys: ${result.rejected.join(", ")}`
+ );
+ }
+ connection.quotaWindowThresholds = result.sanitized;
}
// Same sanitization for rateLimitOverrides — keep in-memory representation
- // in sync with what gets persisted.
+ // in sync with what gets persisted. Reject (don't silently drop) invalid
+ // keys/values so a direct DB writer can't lose operator intent.
if ("rateLimitOverrides" in connection) {
- connection.rateLimitOverrides = sanitizeRateLimitOverrides(connection.rateLimitOverrides);
+ const result = sanitizeRateLimitOverrides(connection.rateLimitOverrides);
+ if (result.rejected.length > 0) {
+ throw new Error(
+ `Refusing to persist rateLimitOverrides with rejected keys: ${result.rejected.join(", ")}`
+ );
+ }
+ connection.rateLimitOverrides = result.sanitized;
}
_insertConnectionRow(db, encryptConnectionFields({ ...connection }));
@@ -849,13 +860,24 @@ export async function updateProviderConnection(id: string, data: JsonRecord) {
// Mirror the sanitization the create path applies — keep the returned
// object in lockstep with what we persist.
if ("quotaWindowThresholds" in merged) {
- const sanitized = sanitizeQuotaWindowThresholds(merged.quotaWindowThresholds);
+ const result = sanitizeQuotaWindowThresholds(merged.quotaWindowThresholds);
+ if (result.rejected.length > 0) {
+ throw new Error(
+ `Refusing to persist quotaWindowThresholds with rejected keys: ${result.rejected.join(", ")}`
+ );
+ }
// For updates we always carry the key forward (even as null) so the read
- // path surfaces the cleared state to callers that just patched it.
- merged.quotaWindowThresholds = sanitized;
+ // path surfaces the cleared state to callers that merged it.
+ merged.quotaWindowThresholds = result.sanitized;
}
if ("rateLimitOverrides" in merged) {
- merged.rateLimitOverrides = sanitizeRateLimitOverrides(merged.rateLimitOverrides);
+ const result = sanitizeRateLimitOverrides(merged.rateLimitOverrides);
+ if (result.rejected.length > 0) {
+ throw new Error(
+ `Refusing to persist rateLimitOverrides with rejected keys: ${result.rejected.join(", ")}`
+ );
+ }
+ merged.rateLimitOverrides = result.sanitized;
}
const existingRecord = toRecord(existing);
diff --git a/src/lib/db/providers/columns.ts b/src/lib/db/providers/columns.ts
index b32f653f7c6c..f06f948cd212 100644
--- a/src/lib/db/providers/columns.ts
+++ b/src/lib/db/providers/columns.ts
@@ -64,20 +64,37 @@ export function normalizeBooleanColumn(value: unknown, fallback: boolean): boole
return fallback;
}
+// Result of sanitizing a per-connection overrides/threshold map. `sanitized`
+// is the cleaned value (or null when it collapses to nothing); `rejected`
+// lists every key that was refused so callers can fail loudly
+// instead of silently dropping the operator's input.
+export type SanitizeResult = {
+ sanitized: Record | null;
+ rejected: string[];
+};
+
// Sanitize the per-connection rate limit overrides map: keep only known
-// fields with valid numeric values. Called once at each write-path boundary.
-export function sanitizeRateLimitOverrides(value: unknown): Record | null {
- if (value === null || value === undefined) return null;
- if (typeof value !== "object" || Array.isArray(value)) return null;
+// fields with valid non-negative integer values. Called once at each
+// write-path boundary. Unknown keys and invalid values go into `rejected`
+// rather than being dropped in silence.
+export function sanitizeRateLimitOverrides(value: unknown): SanitizeResult {
+ if (value === null || value === undefined) return { sanitized: null, rejected: [] };
+ if (typeof value !== "object" || Array.isArray(value)) return { sanitized: null, rejected: [] };
const allowedKeys = new Set(["rpm", "tpm", "tpd", "minTime", "maxConcurrent"]);
+ const rejected: string[] = [];
const map: Record = {};
for (const [key, v] of Object.entries(value as Record)) {
- if (!allowedKeys.has(key)) continue;
+ if (!allowedKeys.has(key)) {
+ rejected.push(key);
+ continue;
+ }
if (typeof v === "number" && Number.isInteger(v) && v >= 0) {
map[key] = v;
+ } else {
+ rejected.push(key);
}
}
- return Object.keys(map).length === 0 ? null : map;
+ return { sanitized: Object.keys(map).length === 0 ? null : map, rejected };
}
// Serialize an already-sanitized map for SQLite TEXT storage.
@@ -91,20 +108,29 @@ export function toRecord(value: unknown): JsonRecord {
return value && typeof value === "object" ? (value as JsonRecord) : {};
}
-// Sanitize the per-window threshold map: keep only 0-100 integer values.
-// Called once at each write-path boundary (createProviderConnection +
-// updateProviderConnection) so both the in-memory return and the persisted
-// row share the same shape. Serialization below trusts this output.
-export function sanitizeQuotaWindowThresholds(value: unknown): Record | null {
- if (value === null || value === undefined) return null;
- if (typeof value !== "object" || Array.isArray(value)) return null;
+// Sanitize the per-window threshold map: keep only 0-100 integer values with
+// keys no longer than 64 chars. Called once at each write-path boundary
+// (createProviderConnection + updateProviderConnection) so both the in-memory
+// return and the persisted row share the same shape. Serialization below
+// trusts this output. Invalid keys/values go into `rejected` rather than being
+// dropped in silence.
+export function sanitizeQuotaWindowThresholds(value: unknown): SanitizeResult {
+ if (value === null || value === undefined) return { sanitized: null, rejected: [] };
+ if (typeof value !== "object" || Array.isArray(value)) return { sanitized: null, rejected: [] };
+ const rejected: string[] = [];
const map: Record = {};
for (const [key, v] of Object.entries(value as Record)) {
+ if (key.length > 64) {
+ rejected.push(key);
+ continue;
+ }
if (typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 100) {
map[key] = v;
+ } else {
+ rejected.push(key);
}
}
- return Object.keys(map).length === 0 ? null : map;
+ return { sanitized: Object.keys(map).length === 0 ? null : map, rejected };
}
export function toStringOrNull(value: unknown): string | null {
diff --git a/src/lib/memory/injection.ts b/src/lib/memory/injection.ts
index 9fdd2bbbf108..d4d8ead7f7c6 100644
--- a/src/lib/memory/injection.ts
+++ b/src/lib/memory/injection.ts
@@ -65,7 +65,11 @@ export function providerSupportsSystemMessage(provider: string | null | undefine
*
* Populated with the Xiaomi MiMo endpoint (provider id `xiaomi-mimo`, registry
* alias `mimo`, serving mimo-v2.5) confirmed live to 400 on a non-first system
- * message. Add other providers here only when they are documented as strict.
+ * message, and the TokenRouter gateway (provider id `tokenrouter`), confirmed
+ * live on 2026-08-22 to reject mid-array system messages — including the
+ * compression notice spliced by purifyHistory() before that splice was fixed to
+ * merge into the leading system message. Add other providers here only when
+ * they are documented as strict.
*
* Self-hosted deployments can extend this list without a source change via
* OMNIROUTE_STRICT_SYSTEM_PROVIDERS (comma-separated provider ids,
@@ -73,7 +77,7 @@ export function providerSupportsSystemMessage(provider: string | null | undefine
* self-hosted Qwen3.5+/3.6 model, whose chat template enforces the same
* single-leading-system-message constraint as xiaomi-mimo.
*/
-const BUILTIN_PROVIDERS_SYSTEM_MUST_BE_FIRST = new Set(["xiaomi-mimo", "mimo"]);
+const BUILTIN_PROVIDERS_SYSTEM_MUST_BE_FIRST = new Set(["xiaomi-mimo", "mimo", "tokenrouter"]);
/**
* Parses OMNIROUTE_STRICT_SYSTEM_PROVIDERS into a normalized id list.
diff --git a/src/lib/modelMetadataRegistry.ts b/src/lib/modelMetadataRegistry.ts
index 3828047b90b9..b7aa2aa21643 100644
--- a/src/lib/modelMetadataRegistry.ts
+++ b/src/lib/modelMetadataRegistry.ts
@@ -130,6 +130,11 @@ function uniqueStrings(values: Array) {
];
}
+export function isGlmFamilyModel(modelId: string, displayName = ""): boolean {
+ const glmFamilyPattern = /(?:^|[/@:_. -])glm(?=$|[-._ /@:](?:z)?\d|\d)/i;
+ return glmFamilyPattern.test(modelId) || glmFamilyPattern.test(displayName);
+}
+
function toQualifiedId(
providerAlias: string | null,
provider: string | null,
@@ -477,11 +482,16 @@ export function enrichCatalogModelEntry(
? declaredEffortTiers
: sourceDeclaresThinking
? undefined
- : extendCodexGpt56EffortValues(
- metadata.provider,
- metadata.model,
- CANONICAL_EFFORT_VALUES
- );
+ : // #10963: GLM-family models never inherit generic OpenAI tiers — an
+ // explicit empty list is authoritative unless a provider-declared
+ // contract exists (handled by declaredEffortTiers above).
+ isGlmFamilyModel(metadata.model, metadata.displayName)
+ ? []
+ : extendCodexGpt56EffortValues(
+ metadata.provider,
+ metadata.model,
+ CANONICAL_EFFORT_VALUES
+ );
const capabilityFields = {
...(typeof metadata.capabilities.vision === "boolean"
? { vision: metadata.capabilities.vision }
@@ -502,7 +512,9 @@ export function enrichCatalogModelEntry(
// #6241: surface thinking support + the canonical effort tiers so the frontend can
// render the effort/thinking toggles. `thinking` is kept for back-compat; `supportsThinking`
// is the explicit flag and `effort_tiers` lists the selectable reasoning levels
- // (only when the model actually supports thinking).
+ // (only when the model actually supports thinking). An explicit empty registry list
+ // is authoritative; GLM models also require a provider-declared contract instead of
+ // inheriting generic OpenAI effort tiers.
...(typeof metadata.capabilities.supportsThinking === "boolean"
? {
thinking: metadata.capabilities.supportsThinking,
diff --git a/src/lib/monitoring/comboHealthAutopilot.ts b/src/lib/monitoring/comboHealthAutopilot.ts
index 71a104948375..24eba32a634c 100644
--- a/src/lib/monitoring/comboHealthAutopilot.ts
+++ b/src/lib/monitoring/comboHealthAutopilot.ts
@@ -16,6 +16,7 @@ import type {
ComboForecastMetrics,
ComboForecastResponse,
ComboForecastRiskLevel,
+ ProviderAutopilotReport,
ComboHealthMetrics,
ComboHealthResponse,
ComboRecord,
@@ -34,6 +35,7 @@ export interface ComboHealthAutopilotOptions {
combos?: ComboRecord[];
healthResponse?: ComboHealthResponse;
forecastResponse?: ComboForecastResponse;
+ providerHealthResponse?: ProviderAutopilotReport;
}
type ProviderIssueView = {
@@ -103,7 +105,12 @@ function actionSet(
case "open_combo_editor":
return action(type, "Open combo editor", target, "/dashboard/combos");
case "run_combo_test":
- return action(type, "Run combo test", target, "/dashboard/combos");
+ return action(
+ type,
+ "Run combo test",
+ target,
+ `/dashboard/combos?test=${encodeURIComponent(target.comboId)}`
+ );
case "open_provider_health_autopilot":
return action(type, "Open provider autopilot", target, "/dashboard/health");
case "review_quota_limits":
@@ -447,7 +454,8 @@ export async function buildComboHealthAutopilotReport(
now: options.now,
combos: combosSnapshot,
}),
- buildProviderHealthAutopilotReport({ includeHealthy: false, includeActions: false }),
+ options.providerHealthResponse ??
+ buildProviderHealthAutopilotReport({ includeHealthy: false, includeActions: false }),
]);
const forecastsByComboId = new Map(forecast.combos.map((entry) => [entry.comboId, entry]));
@@ -470,7 +478,7 @@ export async function buildComboHealthAutopilotReport(
const degradedCount = allCombos.filter((combo) => combo.state === "degraded").length;
const healthyCount = allCombos.filter((combo) => combo.state === "healthy").length;
const issueCount = allCombos.reduce((sum, combo) => sum + combo.issues.length, 0);
- const actionableCount = allCombos.reduce(
+ const suggestionCount = allCombos.reduce(
(sum, combo) =>
sum + combo.issues.reduce((issueSum, issue) => issueSum + issue.actions.length, 0),
0
@@ -487,7 +495,8 @@ export async function buildComboHealthAutopilotReport(
degradedCount,
downCount,
issueCount,
- actionableCount,
+ suggestionCount,
+ actionableCount: suggestionCount,
},
combos,
};
diff --git a/src/lib/providers/validation/webProvidersA.ts b/src/lib/providers/validation/webProvidersA.ts
index a1b20f1df9bd..52e9aa4c0ef1 100644
--- a/src/lib/providers/validation/webProvidersA.ts
+++ b/src/lib/providers/validation/webProvidersA.ts
@@ -13,11 +13,14 @@ import {
normalizeSessionCookieHeader,
} from "@/lib/providers/webCookieAuth";
-// kimi-web uses the international `www.kimi.com` Connect-RPC API. The legacy
-// `kimi.moonshot.cn` domain now 307-redirects every non-CN visitor, and even
-// if you bypass the redirect the old `/api/chat` REST endpoint is gone. The
-// SPA exposes a profile probe at `GET /api/user` that returns the user object
-// at the top level when the `Authorization: Bearer ` header is valid.
+// kimi-web uses the international (west-facing) `www.kimi.ai` Connect-RPC API by
+// default. `www.kimi.com` is the China-region endpoint — it serves China users but
+// the China region is not reliably reachable from outside CN, so it is not the
+// default. The legacy `kimi.moonshot.cn` domain now 307-redirects every non-CN
+// visitor, and even if you bypass the redirect the old `/api/chat` REST endpoint is
+// gone. The SPA exposes a profile probe at `GET /api/user` that returns the user
+// object at the top level when the `Authorization: Bearer ` header is
+// valid. Override the endpoint with KIMI_WEB_BASE_URL (opt-in).
export async function validateKimiWebProvider({ apiKey }: any) {
const rawCred = String(apiKey ?? "").trim();
if (!rawCred) {
diff --git a/src/lib/quota/redisQuotaStore.ts b/src/lib/quota/redisQuotaStore.ts
index 7c0e99ceb7ad..d9d17309eda7 100644
--- a/src/lib/quota/redisQuotaStore.ts
+++ b/src/lib/quota/redisQuotaStore.ts
@@ -72,7 +72,7 @@ export function resetRedisClient(): void {
// Key helpers
// ---------------------------------------------------------------------------
-const KEY_PREFIX = "omniroute:quota";
+const KEY_PREFIX = `${process.env.REDIS_KEY_PREFIX?.trim() || "omniroute:"}quota`;
function bucketKey(apiKeyId: string, dimensionKey: string, bucketIndex: number): string {
return `${KEY_PREFIX}:${apiKeyId}:${dimensionKey}:${bucketIndex}`;
diff --git a/src/lib/usage/internalUsageCommand.ts b/src/lib/usage/internalUsageCommand.ts
index 257b8f9c1580..37f5f009d1c2 100644
--- a/src/lib/usage/internalUsageCommand.ts
+++ b/src/lib/usage/internalUsageCommand.ts
@@ -13,7 +13,7 @@ const TEXT_PLAIN_HEADERS = { "Content-Type": "text/plain; charset=utf-8" } as co
type JsonRecord = Record;
-interface UsageCommandApiKeyMetadata {
+export interface UsageCommandApiKeyMetadata {
id: string;
name?: string;
allowedConnections?: string[] | null;
@@ -31,7 +31,7 @@ interface ProviderConnectionLike {
quotaWindowThresholds?: Record | null;
}
-interface UsageSnapshot {
+export interface UsageSnapshot {
connectionId: string;
provider: string;
plan: unknown;
@@ -39,7 +39,7 @@ interface UsageSnapshot {
quotaWindowThresholds?: Record | null;
}
-interface UsageCommandSelection {
+export interface UsageCommandSelection {
preferredProvider?: string | null;
preferredConnectionId?: string | null;
}
@@ -258,7 +258,7 @@ function snapshotFromConnection(
};
}
-async function collectUsageSnapshots(
+export async function collectUsageSnapshots(
metadata: UsageCommandApiKeyMetadata,
deps: RequiredDeps
): Promise {
@@ -525,6 +525,55 @@ function appendQuotaBlock(
lines.push(`⏱ reset in ${formatResetIn(getResetAt(match?.quota ?? null), now)}`);
}
+/**
+ * Structured form of the usage command — what {@link buildUsageCommandText}
+ * renders as text, exposed as data for API consumers (the OmniCopilot panel
+ * asks for it via `?format=json`). Text and JSON share the exact same
+ * collectors, so the two can never disagree about a number.
+ *
+ * The key design constraint is the 403 case: a key without `allowUsageCommand`
+ * must reach the client as a *structured* reason, not a bare text error — a
+ * caller rendering a usage panel has to be able to tell "the server does not
+ * know your limits yet" apart from "this key may not ask".
+ */
+/** Discriminated so the caller never reads a data field off a refusal:
+ * `allowed:false` carries only `error`; `allowed:true` carries the data. */
+export type UsageCommandJson =
+ | { allowed: false; error: { message: string } }
+ | {
+ allowed: true;
+ /** Present only when the key opted into per-key usage limits. */
+ personal: unknown | null;
+ /** The selected provider snapshot, or null when nothing is cached. */
+ provider: UsageSnapshot | null;
+ /** Every connection's snapshot, so a panel can render Codex / Claude /
+ * OpenCode side by side instead of only the selected one (#11191). The
+ * single-pick in `provider` is a presentation choice for a terminal; the
+ * collector already gathered all of them. */
+ providers: UsageSnapshot[];
+ };
+
+export async function buildUsageCommandJson(
+ metadata: UsageCommandApiKeyMetadata,
+ deps: InternalUsageCommandDeps = {},
+ selection: UsageCommandSelection = {}
+): Promise {
+ const resolvedDeps = await normalizeDeps(deps);
+ const personal =
+ metadata.usageLimitEnabled === true
+ ? await resolvedDeps.getApiKeyUsageLimitStatus(
+ {
+ ...metadata,
+ preferredProvider: selection.preferredProvider ?? metadata.preferredProvider ?? null,
+ },
+ { now: resolvedDeps.now }
+ )
+ : null;
+ const snapshots = await collectUsageSnapshots(metadata, resolvedDeps);
+ const provider = selectUsageSnapshot(snapshots, selection);
+ return { allowed: true, personal, provider, providers: snapshots };
+}
+
export async function buildUsageCommandText(
metadata: UsageCommandApiKeyMetadata,
deps: InternalUsageCommandDeps = {},
@@ -588,6 +637,17 @@ function inferHttpUsageCommandSelection(request: Request): UsageCommandSelection
}
}
+/** `?format=json` (or `?format=JSON`) — anything else falls back to the text
+ * form, which is the historical contract of this endpoint. */
+function wantsUsageCommandJson(request: Request): boolean {
+ try {
+ const format = new URL(request.url, "http://localhost").searchParams.get("format");
+ return format !== null && format.trim().toLowerCase() === "json";
+ } catch {
+ return false;
+ }
+}
+
function createPlainUsageCommandResponse(text: string, status = 200): Response {
return new Response(text, { status, headers: TEXT_PLAIN_HEADERS });
}
@@ -764,22 +824,45 @@ export async function handleInternalUsageCommandHttpRequest(
): Promise {
try {
const resolvedDeps = await normalizeDeps(deps);
+ const json = wantsUsageCommandJson(request);
const apiKey = extractUsageCommandApiKey(request);
if (!apiKey || !(await resolvedDeps.isValidApiKey(apiKey))) {
+ if (json) {
+ return Response.json(
+ { allowed: false, error: { message: USAGE_COMMAND_AUTH_REQUIRED_MESSAGE } } satisfies UsageCommandJson,
+ { status: 401 }
+ );
+ }
return createPlainUsageCommandResponse(USAGE_COMMAND_AUTH_REQUIRED_MESSAGE, 401);
}
const metadata = await resolvedDeps.getApiKeyMetadata(apiKey);
if (!metadata?.id) {
+ if (json) {
+ return Response.json(
+ { allowed: false, error: { message: USAGE_COMMAND_AUTH_REQUIRED_MESSAGE } } satisfies UsageCommandJson,
+ { status: 401 }
+ );
+ }
return createPlainUsageCommandResponse(USAGE_COMMAND_AUTH_REQUIRED_MESSAGE, 401);
}
if (metadata.allowUsageCommand !== true) {
+ if (json) {
+ return Response.json(
+ { allowed: false, error: { message: USAGE_COMMAND_DISABLED_MESSAGE } } satisfies UsageCommandJson,
+ { status: 403 }
+ );
+ }
return createPlainUsageCommandResponse(USAGE_COMMAND_DISABLED_MESSAGE, 403);
}
+ const selection = inferHttpUsageCommandSelection(request);
+ if (json) {
+ return Response.json(await buildUsageCommandJson(metadata, resolvedDeps, selection));
+ }
return createPlainUsageCommandResponse(
- await buildUsageCommandText(metadata, resolvedDeps, inferHttpUsageCommandSelection(request))
+ await buildUsageCommandText(metadata, resolvedDeps, selection)
);
} catch (err) {
const body = buildErrorBody(500, err instanceof Error ? err.message : String(err));
diff --git a/src/server/authz/pipeline.ts b/src/server/authz/pipeline.ts
index 9f4e46bed1eb..d8dacf376d7e 100644
--- a/src/server/authz/pipeline.ts
+++ b/src/server/authz/pipeline.ts
@@ -205,6 +205,7 @@ function drainingResponse(requestId: string): NextResponse {
{ status: 503 }
);
response.headers.set(AUTHZ_HEADER_REQUEST_ID, requestId);
+ response.headers.set("Retry-After", "5");
return response;
}
diff --git a/src/shared/components/ProviderIcon.tsx b/src/shared/components/ProviderIcon.tsx
index aeb6f777ba03..56d54bf0dc27 100644
--- a/src/shared/components/ProviderIcon.tsx
+++ b/src/shared/components/ProviderIcon.tsx
@@ -263,6 +263,7 @@ const KNOWN_PNGS = new Set([
"linkup-search",
"llamafile",
"llamagate",
+ "logfare",
"maritalk",
"nanobot",
"nanogpt",
diff --git a/src/shared/constants/providers.ts b/src/shared/constants/providers.ts
index 23f9c53b39ce..b9b2b6951dbd 100644
--- a/src/shared/constants/providers.ts
+++ b/src/shared/constants/providers.ts
@@ -106,7 +106,6 @@ export const AGGREGATOR_PROVIDER_IDS = new Set([
"empower",
"poe",
"chutes",
- "hackclub",
"freetheai",
"g4f-groq",
"g4f-gemini",
@@ -142,6 +141,7 @@ export const AGGREGATOR_PROVIDER_IDS = new Set([
"void-ai",
"helixmind",
"tabitoken",
+ "logfare",
]);
export const ENTERPRISE_CLOUD_PROVIDER_IDS = new Set([
@@ -237,9 +237,7 @@ export function isSelfHostedChatProvider(providerId: unknown): boolean {
const EXPLICIT_OPTIONAL_APIKEY_PROVIDER_IDS = new Set([
"searxng-search",
"firecrawl",
- "pollinations",
"copilot-web",
- "hackclub",
"g4f-groq",
"g4f-gemini",
"g4f-pollinations",
diff --git a/src/shared/constants/providers/apikey/gateways.ts b/src/shared/constants/providers/apikey/gateways.ts
index 2baf13d3aaed..0b8d07759f3a 100644
--- a/src/shared/constants/providers/apikey/gateways.ts
+++ b/src/shared/constants/providers/apikey/gateways.ts
@@ -1265,6 +1265,29 @@ export const APIKEY_PROVIDERS_GATEWAYS = {
apiHint:
"Create a helix- key and use https://helixmind.online/v1. OpenAI requests use Bearer authentication; the Anthropic-compatible messages endpoint accepts x-api-key.",
},
+ // Logfare (https://logfare.ai) — free OpenAI-compatible inference, live-verified
+ // 2026-08-21 (real /v1/models catalog; 11 chat-capable models incl. kimi-k3,
+ // deepseek-v4-pro, glm-5.2, gpt-5.6-luna). Key issued instantly at /register
+ // (username/password, no email). ⚠️ Logfare logs every request in exchange for
+ // free inference (opt out at /consent) — surfaced in freeNote per the catalog
+ // convention for data-collecting free providers.
+ logfare: {
+ id: "logfare",
+ alias: "logfare",
+ name: "Logfare",
+ icon: "auto_awesome",
+ color: "#22C55E",
+ textIcon: "LF",
+ website: "https://logfare.ai",
+ hasFree: true,
+ freeNote:
+ "Free OpenAI-compatible inference — no rate limits, no card. Logfare logs every request (prompts, completions, metadata) for internal research; opt out at /consent. Read https://logfare.ai/tos and https://logfare.ai/privacy before use.",
+ authHint:
+ "Create a free account at https://logfare.ai/register (username/password, no email verification) to get an instant API key, then paste it here as a Bearer token.",
+ apiHint:
+ "Create a free API key at https://logfare.ai/register, then use https://logfare.ai/v1 as the OpenAI-compatible base URL. Note the request-logging policy: prompts, completions and metadata are logged for research (opt out at https://logfare.ai/consent).",
+ passthroughModels: true,
+ },
// TabiToken (https://tabitoken.com) — NewAPI-based Claude gateway. Its public pricing
// endpoint lists a Claude-only catalog (Opus 5 / 4.8, each with a -thinking variant),
// every model accepting the Anthropic and OpenAI protocols.
diff --git a/src/shared/constants/providers/web-cookie.ts b/src/shared/constants/providers/web-cookie.ts
index 72d1440d1f5e..65e63ac615d3 100644
--- a/src/shared/constants/providers/web-cookie.ts
+++ b/src/shared/constants/providers/web-cookie.ts
@@ -323,14 +323,9 @@ export const WEB_COOKIE_PROVIDERS = {
icon: "auto_awesome",
color: "#2563EB",
textIcon: "KW",
- // Kimi official-partnership aff link (2026-07) — the "Kimi Coding Plan"
- // tracking link (same origin as the plain www.kimi.com login flow below,
- // so the "Open {host}" credential guide in WebSessionCredentialGuide.tsx /
- // AddApiKeyModal.tsx is unaffected: origin, not path, decides localStorage
- // access). Was `https://www.kimi.com` (no aff attribution).
- website: "https://www.kimi.com/code?aff=omniroute",
+ website: "https://www.kimi.ai",
authHint:
- "Paste access_token from www.kimi.com DevTools → Application → Local Storage. A legacy kimi-auth cookie is also accepted.",
+ "Paste access_token from www.kimi.ai DevTools → Application → Local Storage. A legacy kimi-auth cookie is also accepted.",
subscriptionRisk: true,
riskNoticeVariant: "webCookie",
},
diff --git a/src/shared/middleware/chatBodyAdmission.ts b/src/shared/middleware/chatBodyAdmission.ts
index 1c3c25b904b8..9b20d78e5aea 100644
--- a/src/shared/middleware/chatBodyAdmission.ts
+++ b/src/shared/middleware/chatBodyAdmission.ts
@@ -18,6 +18,7 @@
import { CORS_HEADERS } from "../utils/cors";
import { createHmac } from "crypto";
import v8 from "node:v8";
+import { trackRequest } from "../../lib/gracefulShutdown";
function parsePositiveInt(value: string | undefined, fallback: number): number {
const parsed = Number.parseInt(String(value), 10);
@@ -229,6 +230,7 @@ export class ChatAdmissionController {
tryAcquireHealthyHeadroom(): ChatAdmissionLease | null {
if (this.#activeHealthy >= this.healthyHeadroom) return null;
this.#activeHealthy += 1;
+ const done = trackRequest();
let released = false;
return {
get released() {
@@ -238,6 +240,7 @@ export class ChatAdmissionController {
if (released) return;
released = true;
this.#activeHealthy = Math.max(0, this.#activeHealthy - 1);
+ done();
},
};
}
@@ -264,6 +267,7 @@ export class ChatAdmissionController {
tryAcquireHeavy(): ChatAdmissionLease | null {
if (this.#activeHeavy >= this.maxHeavyInFlight) return null;
this.#activeHeavy += 1;
+ const done = trackRequest();
let released = false;
return {
get released() {
@@ -273,6 +277,7 @@ export class ChatAdmissionController {
if (released) return;
released = true;
this.#activeHeavy = Math.max(0, this.#activeHeavy - 1);
+ done();
this.#dispatchFair();
},
};
diff --git a/src/shared/network/outboundUrlGuard.ts b/src/shared/network/outboundUrlGuard.ts
index e7175da0bc54..45a7ebde7bed 100644
--- a/src/shared/network/outboundUrlGuard.ts
+++ b/src/shared/network/outboundUrlGuard.ts
@@ -1,4 +1,10 @@
-import { isIP } from "node:net";
+import { ipVersion, isPrivateHost, normalizeHost } from "./privateHost";
+
+// #11122: the host classification lives in `./privateHost.ts` because
+// `open-sse/config/providerRegistry.ts` imports it from a module reachable by a browser
+// bundle, and `node:net` cannot be resolved there. Re-exported so every existing caller of
+// `isPrivateHost` from this module keeps working unchanged.
+export { isPrivateHost };
export const PROVIDER_URL_BLOCKED_MESSAGE = "Blocked private or local provider URL";
export const CLOUD_METADATA_BLOCKED_MESSAGE = "Blocked cloud-metadata endpoint";
@@ -29,61 +35,6 @@ export class OutboundUrlGuardError extends Error {
}
}
-function normalizeHost(hostname: string) {
- const normalized = hostname.trim().toLowerCase();
- if (normalized.startsWith("[") && normalized.endsWith("]")) {
- return normalized.slice(1, -1);
- }
- return normalized;
-}
-
-export function isPrivateHost(hostname: string) {
- const normalized = normalizeHost(hostname);
- if (!normalized) return true;
-
- if (
- normalized === "localhost" ||
- normalized === "0.0.0.0" ||
- // `::` is the IPv6 twin of `0.0.0.0`: connecting to it reaches a service bound
- // to the IPv6 loopback, so it has to be refused alongside its IPv4 spelling.
- normalized === "::" ||
- normalized === "127.0.0.1" ||
- normalized === "::1" ||
- normalized.endsWith(".localhost") ||
- normalized.endsWith(".local") ||
- // `.internal` is reserved for private use (ICANN-style) and is the
- // hostname suffix used by GCP/Azure metadata probes
- // (e.g. `metadata.google.internal`).
- normalized.endsWith(".internal") ||
- normalized.startsWith("::ffff:")
- ) {
- return true;
- }
-
- if (isIP(normalized) === 4) {
- const octets = normalized.split(".").map((segment) => parseInt(segment, 10));
- const [a, b] = octets;
-
- if (a === 0 || a === 10 || a === 127) return true;
- if (a === 169 && b === 254) return true;
- if (a === 192 && b === 168) return true;
- if (a === 172 && b >= 16 && b <= 31) return true;
- if (a === 100 && b >= 64 && b <= 127) return true;
- return false;
- }
-
- if (isIP(normalized) === 6) {
- return (
- normalized === "::1" ||
- normalized.startsWith("fc") ||
- normalized.startsWith("fd") ||
- normalized.startsWith("fe80:")
- );
- }
-
- return false;
-}
-
// WHATWG URL serialises an IPv4-mapped IPv6 address as hextets, so
// `http://[::ffff:169.254.169.254]/` reaches these helpers as `::ffff:a9fe:a9fe`.
// Matching the dotted spelling alone therefore misses every mapped address that
@@ -92,7 +43,7 @@ function mappedIpv4Host(hostname: string): string | null {
const normalized = normalizeHost(hostname);
if (!normalized.startsWith("::ffff:")) return null;
const embedded = normalized.slice("::ffff:".length);
- if (isIP(embedded) === 4) return embedded;
+ if (ipVersion(embedded) === 4) return embedded;
const hextets = embedded.split(":");
if (hextets.length !== 2) return null;
const [high, low] = hextets.map((part) =>
@@ -202,3 +153,4 @@ export function parseAndValidateNonMetadataUrl(input: string | URL) {
// opencode.ts) where no `tsconfig.json` is present to resolve the `@/*` path alias. Keeping
// this module free of ANY `@/`-aliased import is what makes it safe to load from the CLI.
// Do not add a `@/`-aliased import here — see docs/security/… (packaging) and #7682.
+// The same rule binds `./privateHost.ts`, which this module re-exports from.
diff --git a/src/shared/network/privateHost.ts b/src/shared/network/privateHost.ts
new file mode 100644
index 000000000000..f3120e3d1bfd
--- /dev/null
+++ b/src/shared/network/privateHost.ts
@@ -0,0 +1,103 @@
+// Host classification shared by the outbound URL guard and the provider registry.
+//
+// #11122: `open-sse/config/providerRegistry.ts` needs `isPrivateHost`, and that module is
+// reachable from `ProviderDetailPageClient.tsx`. `outboundUrlGuard.ts` reached for `node:net`'s
+// `isIP`, so importing it from the registry broke the browser bundle with
+// `Could not resolve "node:net"` (caught by tests/unit/media-page-client-browser-bundle.test.ts,
+// which has been red on the release branch since #11122 merged).
+// The classification therefore lives here, on a pure-JS `ipVersion`, with NO platform imports.
+//
+// Two constraints this module MUST keep — both enforced by tests:
+// 1. No `node:*` import: it is bundled for the browser.
+// 2. No `@/`-aliased import: `./outboundUrlGuard.ts` re-exports from here and is loaded by the
+// packaged CLI (`omniroute setup-opencode`), where no tsconfig resolves the alias (#7682).
+
+// Vendored from Node's own `lib/internal/net.js` so `ipVersion` stays verdict-for-verdict
+// identical to `isIP` — a NARROWER match would silently reclassify a private address as public
+// and open the very egress the guard exists to close. `tests/unit/private-host-ip-parity-11122`
+// asserts that parity against `node:net` directly.
+const V4_SEG = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
+const V4_STR = `(?:${V4_SEG}\\.){3}${V4_SEG}`;
+const V6_SEG = "(?:[0-9a-fA-F]{1,4})";
+
+const IPV4_RE = new RegExp(`^${V4_STR}$`);
+
+const IPV6_RE = new RegExp(
+ "^(?:" +
+ `(?:${V6_SEG}:){7}(?:${V6_SEG}|:)|` +
+ `(?:${V6_SEG}:){6}(?:${V4_STR}|:${V6_SEG}|:)|` +
+ `(?:${V6_SEG}:){5}(?::${V4_STR}|(?::${V6_SEG}){1,2}|:)|` +
+ `(?:${V6_SEG}:){4}(?:(?::${V6_SEG}){0,1}:${V4_STR}|(?::${V6_SEG}){1,3}|:)|` +
+ `(?:${V6_SEG}:){3}(?:(?::${V6_SEG}){0,2}:${V4_STR}|(?::${V6_SEG}){1,4}|:)|` +
+ `(?:${V6_SEG}:){2}(?:(?::${V6_SEG}){0,3}:${V4_STR}|(?::${V6_SEG}){1,5}|:)|` +
+ `(?:${V6_SEG}:){1}(?:(?::${V6_SEG}){0,4}:${V4_STR}|(?::${V6_SEG}){1,6}|:)|` +
+ `(?::(?:(?::${V6_SEG}){0,5}:${V4_STR}|(?::${V6_SEG}){1,7}|:))` +
+ ")(?:%[0-9a-zA-Z-.:]{1,64})?$"
+);
+
+// Longest legal literal is 45 chars (`ffff:…:255.255.255.255`) plus a `%zone`. Every quantifier
+// above is bounded, and this guard keeps the alternation from ever seeing a long hostile string
+// (AGENTS.md → "Regex Security (ReDoS)").
+const MAX_IP_LITERAL_LENGTH = 110;
+
+/** Pure-JS `node:net#isIP`: 4, 6, or 0 when the string is not an IP literal. */
+export function ipVersion(host: string): 0 | 4 | 6 {
+ if (!host || host.length > MAX_IP_LITERAL_LENGTH) return 0;
+ if (IPV4_RE.test(host)) return 4;
+ return IPV6_RE.test(host) ? 6 : 0;
+}
+
+export function normalizeHost(hostname: string) {
+ const normalized = hostname.trim().toLowerCase();
+ if (normalized.startsWith("[") && normalized.endsWith("]")) {
+ return normalized.slice(1, -1);
+ }
+ return normalized;
+}
+
+export function isPrivateHost(hostname: string) {
+ const normalized = normalizeHost(hostname);
+ if (!normalized) return true;
+
+ if (
+ normalized === "localhost" ||
+ normalized === "0.0.0.0" ||
+ // `::` is the IPv6 twin of `0.0.0.0`: connecting to it reaches a service bound
+ // to the IPv6 loopback, so it has to be refused alongside its IPv4 spelling.
+ normalized === "::" ||
+ normalized === "127.0.0.1" ||
+ normalized === "::1" ||
+ normalized.endsWith(".localhost") ||
+ normalized.endsWith(".local") ||
+ // `.internal` is reserved for private use (ICANN-style) and is the
+ // hostname suffix used by GCP/Azure metadata probes
+ // (e.g. `metadata.google.internal`).
+ normalized.endsWith(".internal") ||
+ normalized.startsWith("::ffff:")
+ ) {
+ return true;
+ }
+
+ if (ipVersion(normalized) === 4) {
+ const octets = normalized.split(".").map((segment) => parseInt(segment, 10));
+ const [a, b] = octets;
+
+ if (a === 0 || a === 10 || a === 127) return true;
+ if (a === 169 && b === 254) return true;
+ if (a === 192 && b === 168) return true;
+ if (a === 172 && b >= 16 && b <= 31) return true;
+ if (a === 100 && b >= 64 && b <= 127) return true;
+ return false;
+ }
+
+ if (ipVersion(normalized) === 6) {
+ return (
+ normalized === "::1" ||
+ normalized.startsWith("fc") ||
+ normalized.startsWith("fd") ||
+ normalized.startsWith("fe80:")
+ );
+ }
+
+ return false;
+}
diff --git a/src/shared/services/opencodeConfig.ts b/src/shared/services/opencodeConfig.ts
index a4bbd6559120..a91ca5069c5c 100644
--- a/src/shared/services/opencodeConfig.ts
+++ b/src/shared/services/opencodeConfig.ts
@@ -84,11 +84,29 @@ export const buildOpenCodeProviderConfig = ({
};
};
+export const buildOpenCodeV2ProviderConfig = (
+ input: OpenCodeConfigInput
+): Record => {
+ const v1Config = buildOpenCodeProviderConfig(input);
+ return {
+ name: v1Config.name,
+ package: "@opencode-ai/ai/providers/openai-compatible",
+ settings: {
+ baseURL: v1Config.options.baseURL,
+ apiKey: v1Config.options.apiKey,
+ },
+ models: v1Config.models,
+ };
+};
+
export const buildOpenCodeConfigDocument = (input: OpenCodeConfigInput) => ({
$schema: "https://opencode.ai/config.json",
provider: {
omniroute: buildOpenCodeProviderConfig(input),
},
+ providers: {
+ omniroute: buildOpenCodeV2ProviderConfig(input),
+ },
});
export const mergeOpenCodeConfig = (
@@ -100,18 +118,18 @@ export const mergeOpenCodeConfig = (
? existingConfig
: {};
- // Same guard as the root above, one level down. Spreading a non-object here
- // does not throw, it splays the value into index keys: an existing
- // `"provider": ["a", "b"]` merged to `{"0": "a", "1": "b", omniroute: ... }`
- // and a string was exploded one character per key. mergeOpenCodeConfigText
- // refuses the same input outright, so the two disagreed on what to do with a
- // malformed config.
const existingProvider = (safeConfig as Record).provider;
const safeProvider =
existingProvider && typeof existingProvider === "object" && !Array.isArray(existingProvider)
? (existingProvider as Record)
: {};
+ const existingProviders = (safeConfig as Record).providers;
+ const safeProviders =
+ existingProviders && typeof existingProviders === "object" && !Array.isArray(existingProviders)
+ ? (existingProviders as Record)
+ : {};
+
return {
...safeConfig,
$schema: safeConfig.$schema || "https://opencode.ai/config.json",
@@ -119,6 +137,10 @@ export const mergeOpenCodeConfig = (
...safeProvider,
omniroute: buildOpenCodeProviderConfig(input),
},
+ providers: {
+ ...safeProviders,
+ omniroute: buildOpenCodeV2ProviderConfig(input),
+ },
};
};
@@ -127,6 +149,7 @@ export const mergeOpenCodeConfigText = (
input: OpenCodeConfigInput
) => {
const providerConfig = buildOpenCodeProviderConfig(input);
+ const v2ProviderConfig = buildOpenCodeV2ProviderConfig(input);
const content = typeof existingText === "string" ? existingText : "";
const trimmedContent = content.trim();
@@ -161,6 +184,11 @@ export const mergeOpenCodeConfigText = (
const providerEdits = modify(nextText, ["provider", "omniroute"], providerConfig, {
formattingOptions: { insertSpaces: true, tabSize: 2 },
});
+ nextText = applyEdits(nextText, providerEdits);
+
+ const v2ProviderEdits = modify(nextText, ["providers", "omniroute"], v2ProviderConfig, {
+ formattingOptions: { insertSpaces: true, tabSize: 2 },
+ });
- return applyEdits(nextText, providerEdits);
+ return applyEdits(nextText, v2ProviderEdits);
};
diff --git a/src/shared/types/utilization.ts b/src/shared/types/utilization.ts
index 36f0d7dabcf3..0a1e9dc900d6 100644
--- a/src/shared/types/utilization.ts
+++ b/src/shared/types/utilization.ts
@@ -260,7 +260,9 @@ export interface ComboAutopilotReport {
degradedCount: number;
downCount: number;
issueCount: number;
- actionableCount: number;
+ suggestionCount: number;
+ /** @deprecated Use suggestionCount instead. Kept as an alias for backward compatibility; remove after 2 releases. */
+ actionableCount?: number;
};
combos: ComboAutopilotCombo[];
}
diff --git a/src/shared/utils/noAuthProviders.ts b/src/shared/utils/noAuthProviders.ts
index ac025be9f868..83b3235da7ec 100644
--- a/src/shared/utils/noAuthProviders.ts
+++ b/src/shared/utils/noAuthProviders.ts
@@ -22,8 +22,10 @@ export function isProviderBlockedByIdOrAlias(
): boolean {
const blockedProviderSet = normalizeBlockedProviderSet(blockedProviders);
const provider = getProviderById(providerId) as ProviderWithAlias | undefined;
+ const baseId = providerId.replace(/-search$/, "");
return (
blockedProviderSet.has(providerId) ||
+ blockedProviderSet.has(baseId) ||
(typeof provider?.alias === "string" && blockedProviderSet.has(provider.alias))
);
}
diff --git a/src/shared/utils/rateLimiter.ts b/src/shared/utils/rateLimiter.ts
index bb268ba5f039..7b36a2173697 100644
--- a/src/shared/utils/rateLimiter.ts
+++ b/src/shared/utils/rateLimiter.ts
@@ -3,6 +3,10 @@ import type Redis from "ioredis";
// Redis is optional. When REDIS_URL is unset, use a process-local fallback
// instead of probing localhost on every API request.
const REDIS_URL = process.env.REDIS_URL?.trim() || "";
+
+// Namespace prefix for all OmniRoute Redis keys. Prevents key collisions when
+// OmniRoute shares a Redis instance with other apps (e.g. on 127.0.0.1:6379).
+const REDIS_KEY_PREFIX = process.env.REDIS_KEY_PREFIX?.trim() || "omniroute:";
if (process.env.NODE_ENV === "production" && !REDIS_URL) {
console.warn("[REDIS] REDIS_URL is not set in production. Using in-memory rate limiting.");
}
@@ -72,6 +76,7 @@ export function getRedisClient(): Promise {
const client = new RedisCtor(REDIS_URL, {
maxRetriesPerRequest: 3,
enableReadyCheck: false,
+ keyPrefix: REDIS_KEY_PREFIX,
retryStrategy(times) {
return Math.min(times * 50, 2000); // Exponential backoff
},
diff --git a/src/shared/validation/helpers.ts b/src/shared/validation/helpers.ts
index 4e486c7287d3..c811d6d4bf02 100644
--- a/src/shared/validation/helpers.ts
+++ b/src/shared/validation/helpers.ts
@@ -4,6 +4,10 @@ import { z } from "zod";
type ValidationErrorDetail = {
field: string;
message: string;
+ // Present for `unrecognized_keys` issues: the unknown key names that were
+ // refused (e.g. a typo'd override key). Surfaced by callers so clients can
+ // tell exactly which keys were rejected.
+ keys?: string[];
};
type ValidationErrorPayload = {
@@ -45,6 +49,9 @@ export function validateBody(
details: issues.map((e) => ({
field: e.path.join("."),
message: e.message,
+ ...(("keys" in e && (e as { keys?: string[] }).keys)
+ ? { keys: (e as { keys: string[] }).keys }
+ : {}),
})),
},
};
diff --git a/src/shared/validation/schemas/combo.ts b/src/shared/validation/schemas/combo.ts
index edeca47e729a..db825e11cc9d 100644
--- a/src/shared/validation/schemas/combo.ts
+++ b/src/shared/validation/schemas/combo.ts
@@ -321,7 +321,7 @@ export const createComboSchema = z
.object({
name: comboNameSchema,
description: z.string().max(2000).optional(),
- models: z.array(comboModelEntry).optional().default([]),
+ models: z.array(comboModelEntry).min(1, "a combo requires at least one model"),
strategy: comboStrategySchema.optional().default("priority"),
config: comboRuntimeConfigSchema.optional(),
allowedProviders: z.array(z.string().trim().min(1).max(200)).max(100).optional(),
@@ -380,8 +380,9 @@ export const updateComboSchema = z
.object({
name: comboNameSchema.optional(),
description: z.string().max(2000).optional().nullable(),
- // Creation may leave `models` empty (`omniroute combo create` drafts one
- // that way); an update may not, or a working combo loses every target.
+ // An update may not remove every model from a combo, or a working combo
+ // loses every target. Creation refuses an empty list too: since the CLI
+ // gained --models (#10954), an empty draft has no remaining legitimate path.
models: z
.array(comboModelEntry)
.min(1, "an update cannot remove every model from a combo")
diff --git a/src/shared/validation/schemas/provider.ts b/src/shared/validation/schemas/provider.ts
index b3272f70fb64..4cfe7afff453 100644
--- a/src/shared/validation/schemas/provider.ts
+++ b/src/shared/validation/schemas/provider.ts
@@ -420,6 +420,25 @@ export const providerNodeValidateSchema = z.object({
modelId: z.string().trim().max(200).optional().or(z.literal("")),
});
+// rate-limit override numeric fields must reject operator intent loss.
+// `z.coerce.number()` silently turns "" into 0 and "60abc" into NaN, which
+// would drop or distort the value instead of rejecting it. Preprocess first so
+// an empty/non-numeric string fails validation (surfaced as a 400), while still
+// coercing legit numeric strings like "60".
+function rateLimitOverrideNumber(max: number) {
+ return z.preprocess(
+ (raw) => {
+ if (typeof raw === "string") {
+ if (raw.trim() === "") return NaN;
+ const parsed = Number(raw);
+ return Number.isNaN(parsed) ? raw : parsed;
+ }
+ return raw;
+ },
+ z.coerce.number().int().min(0).max(max)
+ );
+}
+
export const updateProviderConnectionSchema = z
.object({
name: z.string().max(200).optional(),
@@ -468,17 +487,24 @@ export const updateProviderConnectionSchema = z
projectId: z.union([z.string(), z.null()]).optional(),
// Per-connection rate limit overrides — overrides the global RequestQueueSettings
// for this connection. Set to null to clear all overrides.
+ // Per-connection rate limit overrides — overrides the global
+ // RequestQueueSettings for this connection. Set to null to clear all
+ // overrides. `.strict()` rejects unknown keys (e.g. a typo'd `tmp`) with a
+ // 400 instead of silently stripping them: the operator's intent is
+ // never dropped without an error. `.nullable()` (rather than a
+ // `z.union([z.null(), …])`) keeps the `unrecognized_keys` issue at the top
+ // level so the rejected key name survives into the 400 response.
rateLimitOverrides: z
- .union([
- z.null(),
- z.object({
- rpm: z.coerce.number().int().min(0).max(1_000_000).optional(),
- tpm: z.coerce.number().int().min(0).max(100_000_000).optional(),
- tpd: z.coerce.number().int().min(0).max(10_000_000_000).optional(),
- minTime: z.coerce.number().int().min(0).max(60_000).optional(),
- maxConcurrent: z.coerce.number().int().min(0).max(10_000).optional(),
- }),
- ])
+ .object({
+ rpm: rateLimitOverrideNumber(1_000_000).optional(),
+ tpm: rateLimitOverrideNumber(100_000_000).optional(),
+ tpd: rateLimitOverrideNumber(10_000_000_000).optional(),
+ minTime: rateLimitOverrideNumber(60_000).optional(),
+ maxConcurrent: rateLimitOverrideNumber(10_000).optional(),
+ })
+ .partial()
+ .strict()
+ .nullable()
.optional(),
proxyEnabled: z.boolean().optional(),
perKeyProxyEnabled: z.boolean().optional(),
diff --git a/src/shared/validation/settingsSchemas.ts b/src/shared/validation/settingsSchemas.ts
index 388e3f73c74f..beefb5fc8f32 100644
--- a/src/shared/validation/settingsSchemas.ts
+++ b/src/shared/validation/settingsSchemas.ts
@@ -259,6 +259,48 @@ export const updateSettingsSchema = z.object({
})
)
.optional(),
+ /**
+ * Operator-declared per-provider error rules. Consulted BEFORE the built-in
+ * `providerRuleRegistry` in open-sse/config/providerErrorRules.ts so an
+ * operator can add a scope/cooldown/reason override for a provider without
+ * editing the catalog. Matches are plain case-insensitive SUBSTRINGS of the
+ * error body (never RegExp) to keep the classification hot path ReDoS-safe.
+ * Bounded to 50 rules total so a misconfigured setting cannot blow up the
+ * matcher.
+ */
+ providerErrorRules: z
+ .record(
+ z.string().trim().min(1).max(100),
+ z.array(
+ z.object({
+ status: z.number().int().min(100).max(599),
+ match: z.string().min(1).max(200),
+ scope: z.enum(["model", "provider", "connection"]),
+ reason: z
+ .enum([
+ "auth_error",
+ "quota_exhausted",
+ "rate_limit_exceeded",
+ "model_capacity",
+ "server_error",
+ "unknown",
+ ])
+ .optional(),
+ cooldownMs: z.number().int().min(0).max(86_400_000).optional(),
+ })
+ )
+ )
+ .optional()
+ .superRefine((value, ctx) => {
+ if (!value) return;
+ const total = Object.values(value).reduce((n, rules) => n + rules.length, 0);
+ if (total > 50) {
+ ctx.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: `providerErrorRules: at most 50 rules total, got ${total}`,
+ });
+ }
+ }),
// #6168: global session-stickiness opt-out (per-combo config overrides this).
disableSessionStickiness: z.boolean().optional(),
/** Keep eligible combo targets close to the provider-side prompt cache. */
diff --git a/src/sse/handlers/chat.ts b/src/sse/handlers/chat.ts
index 3ec6e6c6d6c2..49a29c1b69f4 100644
--- a/src/sse/handlers/chat.ts
+++ b/src/sse/handlers/chat.ts
@@ -1851,7 +1851,7 @@ async function handleSingleModelChat(
modelPinned: runtimeOptions?.modelPinned ?? false,
routingComboId: runtimeOptions?.routingComboId ?? null,
sessionAffinityKey: runtimeOptions.sessionAffinityKey ?? null,
- reasoningTransportFallback: runtimeOptions.reasoningTransportFallback ?? "skip",
+ reasoningTransportFallback: runtimeOptions.reasoningTransportFallback ?? "drop",
managedLease: runtimeOptions.managedLease ?? null,
},
runtimeOptions
diff --git a/src/sse/handlers/chatHelpers.ts b/src/sse/handlers/chatHelpers.ts
index 36bd4077408a..bcf9a51c62cd 100644
--- a/src/sse/handlers/chatHelpers.ts
+++ b/src/sse/handlers/chatHelpers.ts
@@ -422,7 +422,7 @@ export async function executeChatWithBreaker({
conversationId = null,
modelPinned = false,
routingComboId = null,
- reasoningTransportFallback = "skip",
+ reasoningTransportFallback = "drop",
sessionAffinityKey = null,
managedLease = null,
}: ExecuteChatWithBreakerOptions): Promise {
diff --git a/src/types/databaseSettings.ts b/src/types/databaseSettings.ts
index 6bcc210e5fd2..2b4820e19825 100644
--- a/src/types/databaseSettings.ts
+++ b/src/types/databaseSettings.ts
@@ -44,6 +44,7 @@ export interface DatabaseSettings {
quotaSnapshots: number;
compressionAnalytics: number;
mcpAudit: number;
+ configAudit: number;
a2aEvents: number;
callLogs: number;
usageHistory: number;
@@ -114,6 +115,7 @@ export const DEFAULT_DATABASE_SETTINGS: Omit",
- "Content-Type": "application/json"
- },
- "nonStream": {
- "Authorization": "Bearer ",
- "Content-Type": "application/json"
- },
- "oauth": {
- "Accept": "text/event-stream",
- "Authorization": "Bearer ",
- "Content-Type": "application/json"
- }
- },
- "url": {
- "nonStream": "https://ai.hackclub.com/proxy/v1/chat/completions",
- "stream": "https://ai.hackclub.com/proxy/v1/chat/completions"
- }
- },
"hailuo-web": {
"format": "openai",
"headers": {
@@ -2826,8 +2803,8 @@
}
},
"url": {
- "nonStream": "https://www.hailuo.ai",
- "stream": "https://www.hailuo.ai"
+ "nonStream": "https://chat.minimax.io",
+ "stream": "https://chat.minimax.io"
}
},
"haiper": {
@@ -3364,8 +3341,8 @@
}
},
"url": {
- "nonStream": "https://www.kimi.com",
- "stream": "https://www.kimi.com"
+ "nonStream": "https://www.kimi.ai",
+ "stream": "https://www.kimi.ai"
}
},
"kiro": {
@@ -3608,6 +3585,29 @@
"stream": "https://arena.ai/nextjs-api/stream/create-evaluation"
}
},
+ "logfare": {
+ "format": "openai",
+ "headers": {
+ "apiKey": {
+ "Accept": "text/event-stream",
+ "Authorization": "Bearer ",
+ "Content-Type": "application/json"
+ },
+ "nonStream": {
+ "Authorization": "Bearer ",
+ "Content-Type": "application/json"
+ },
+ "oauth": {
+ "Accept": "text/event-stream",
+ "Authorization": "Bearer ",
+ "Content-Type": "application/json"
+ }
+ },
+ "url": {
+ "nonStream": "https://logfare.ai/v1/chat/completions",
+ "stream": "https://logfare.ai/v1/chat/completions"
+ }
+ },
"longcat": {
"format": "openai",
"headers": {
diff --git a/tests/unit/account-fallback-service.test.ts b/tests/unit/account-fallback-service.test.ts
index 3711e6217c80..266179ec7a53 100644
--- a/tests/unit/account-fallback-service.test.ts
+++ b/tests/unit/account-fallback-service.test.ts
@@ -453,6 +453,25 @@ test("hasPerModelQuota returns true for GitHub Copilot provider (#1624)", () =>
assert.equal(hasPerModelQuota("github", "gpt-5-mini"), true);
});
+test("hasPerModelQuota honors shared-registry passthrough providers (#11071)", () => {
+ // These declare passthroughModels:true in src/shared/constants/providers/, but are absent
+ // from the open-sse REGISTRY passthrough set and are neither local nor self-hosted — so the
+ // isLocalProvider/isSelfHostedChatProvider branch (#11078) never reaches them. Without the
+ // shared-registry lookup a missing model on one of these cools the WHOLE connection.
+ assert.equal(hasPerModelQuota("novita"), true);
+ assert.equal(hasPerModelQuota("uncloseai"), true);
+ assert.equal(hasPerModelQuota("orcarouter"), true);
+
+ // Already covered by the local/self-hosted branch — asserted so this port cannot regress it.
+ assert.equal(hasPerModelQuota("ollama-local"), true);
+ assert.equal(hasPerModelQuota("lm-studio"), true);
+ assert.equal(hasPerModelQuota("vllm"), true);
+
+ // Neither declared in the shared registry nor local: a failure here is still connection-wide.
+ assert.equal(hasPerModelQuota("openai"), false);
+ assert.equal(hasPerModelQuota("anthropic"), false);
+});
+
test("Codex Spark 429s are scoped away from normal Codex models", () => {
const connectionId = `codex-${Date.now()}`;
clearModelLock("codex", connectionId, "gpt-5.3-codex-spark");
@@ -1659,7 +1678,11 @@ test("#10460: model-unsupported 400 handles various phrasings", async () => {
// Verify connection stays healthy after each iteration
const conn = await providersDb.getProviderConnectionById(id);
assert.ok(!conn.rateLimitedUntil, `"${errorText}" must not rate-limit connection`);
- assert.notStrictEqual(conn.testStatus, "unavailable", `"${errorText}" must not mark unavailable`);
+ assert.notStrictEqual(
+ conn.testStatus,
+ "unavailable",
+ `"${errorText}" must not mark unavailable`
+ );
}
});
@@ -1692,7 +1715,11 @@ test("#10460: non-400 status with model-unsupported text does NOT trigger guard"
"test-model"
);
- assert.strictEqual(result.shouldFallback, true, "non-400 must not be short-circuited by model guard");
+ assert.strictEqual(
+ result.shouldFallback,
+ true,
+ "non-400 must not be short-circuited by model guard"
+ );
// The key assertion: guard returns shouldFallback:false. If we get here with
// shouldFallback:true, the guard did NOT fire (correct behavior).
});
@@ -1723,7 +1750,11 @@ test("#10460: auth-credential 400 text does NOT match model-unsupported guard",
// This text does NOT match MODEL_ACCESS_DENIED_PATTERNS (verified by regex test)
// so it falls through to checkFallbackError which returns shouldFallback:false for generic 400
- assert.strictEqual(result.shouldFallback, false, "auth-credential 400 must not be caught by model guard");
+ assert.strictEqual(
+ result.shouldFallback,
+ false,
+ "auth-credential 400 must not be caught by model guard"
+ );
// The generic 400 path returns cooldownMs:0 — same as the guard, but the
// connection was NOT touched (no rateLimitedUntil set). This distinguishes
// it from the normal fallback path which would set a cooldown.
@@ -1737,7 +1768,11 @@ test("#10460: guard early return does not touch DB (distinguishes from normal pa
// Guard path: model-unsupported 400 → shouldFallback:false, cooldownMs:0, no DB change
const guardResult = await auth.markAccountUnavailable(
- connId, 400, "The requested model is not supported", "github", "test-model"
+ connId,
+ 400,
+ "The requested model is not supported",
+ "github",
+ "test-model"
);
assert.strictEqual(guardResult.shouldFallback, false);
assert.strictEqual(guardResult.cooldownMs, 0);
diff --git a/tests/unit/account-rotation.test.ts b/tests/unit/account-rotation.test.ts
index f4864ee2dd84..a682f02a0d8a 100644
--- a/tests/unit/account-rotation.test.ts
+++ b/tests/unit/account-rotation.test.ts
@@ -7,6 +7,8 @@ import {
markSuccess,
maskAccountId,
isNetworkErrorRotatable,
+ isEmptyUpstreamRejection,
+ extractChatcmplId,
type RotatableAccount,
} from "../../open-sse/executors/accountRotation.ts";
@@ -114,3 +116,100 @@ describe("accountRotation", () => {
assert.strictEqual(isNetworkErrorRotatable(withoutProxy), false);
});
});
+
+describe("isEmptyUpstreamRejection", () => {
+ it("matches the observed malformed completion envelope (no error field, empty content, null finish_reason)", () => {
+ const observed =
+ '{"id":"chatcmpl_44fn2g6e7kk","object":"chat.completion","created":1787419957,"model":"muse-spark-1.2-contributor-free","choices":[{"index":0,"message":{"role":"assistant"},"finish_reason":null}]}';
+ assert.strictEqual(isEmptyUpstreamRejection(400, observed), true);
+ });
+
+ it("does not match a non-400 status", () => {
+ const observed =
+ '{"id":"chatcmpl_44fn2g6e7kk","object":"chat.completion","created":1787419957,"model":"muse-spark-1.2-contributor-free","choices":[{"index":0,"message":{"role":"assistant"},"finish_reason":null}]}';
+ assert.strictEqual(isEmptyUpstreamRejection(200, observed), false);
+ assert.strictEqual(isEmptyUpstreamRejection(429, observed), false);
+ assert.strictEqual(isEmptyUpstreamRejection(502, observed), false);
+ });
+
+ it("does not match when an error field is present", () => {
+ const withError = JSON.stringify({
+ error: { message: "bad request", type: "invalid_request_error" },
+ });
+ assert.strictEqual(isEmptyUpstreamRejection(400, withError), false);
+ const emptyError = JSON.stringify({ error: {} });
+ assert.strictEqual(isEmptyUpstreamRejection(400, emptyError), false);
+ });
+
+ it("does not match when content is non-empty or tool_calls present", () => {
+ const nonEmpty = JSON.stringify({
+ choices: [{ message: { role: "assistant", content: "hi" }, finish_reason: "stop" }],
+ });
+ assert.strictEqual(isEmptyUpstreamRejection(400, nonEmpty), false);
+
+ const toolCalls = JSON.stringify({
+ choices: [
+ { message: { role: "assistant", tool_calls: [{ id: "x" }] }, finish_reason: "tool_calls" },
+ ],
+ });
+ assert.strictEqual(isEmptyUpstreamRejection(400, toolCalls), false);
+ });
+
+ it("does not match when content is a non-string non-null value (number, block array)", () => {
+ const numericContent = JSON.stringify({
+ choices: [{ message: { role: "assistant", content: 123 }, finish_reason: null }],
+ });
+ assert.strictEqual(
+ isEmptyUpstreamRejection(400, numericContent),
+ false,
+ "non-string non-null content is not eligible"
+ );
+
+ const reasoningContent = JSON.stringify({
+ choices: [
+ { message: { role: "assistant", reasoning_content: "thinking" }, finish_reason: null },
+ ],
+ });
+ assert.strictEqual(isEmptyUpstreamRejection(400, reasoningContent), false);
+ });
+
+ it("does not match when choices or message are absent", () => {
+ const noChoices = JSON.stringify({ id: "chatcmpl_x", model: "muse" });
+ assert.strictEqual(isEmptyUpstreamRejection(400, noChoices), false);
+ const noMessage = JSON.stringify({ choices: [{ finish_reason: null }] });
+ assert.strictEqual(isEmptyUpstreamRejection(400, noMessage), false);
+ });
+
+ it("does not match when finish_reason is a literal value (not null)", () => {
+ const stopReason = JSON.stringify({
+ choices: [{ message: { role: "assistant" }, finish_reason: "stop" }],
+ });
+ assert.strictEqual(isEmptyUpstreamRejection(400, stopReason), false);
+ });
+
+ it("matches an empty string content (treated as eligible)", () => {
+ const emptyContent = JSON.stringify({
+ choices: [{ message: { role: "assistant", content: "" }, finish_reason: null }],
+ });
+ assert.strictEqual(isEmptyUpstreamRejection(400, emptyContent), true);
+ });
+
+ it("returns false for unparseable JSON rather than throwing", () => {
+ assert.strictEqual(isEmptyUpstreamRejection(400, "not json"), false);
+ assert.strictEqual(isEmptyUpstreamRejection(400, ""), false);
+ });
+});
+
+describe("extractChatcmplId", () => {
+ it("extracts the chatcmpl id from an observed envelope", () => {
+ const observed =
+ '{"id":"chatcmpl_44fn2g6e7kk","object":"chat.completion","created":1787419957,"model":"muse-spark-1.2-contributor-free","choices":[{"index":0,"message":{"role":"assistant"},"finish_reason":null}]}';
+ assert.strictEqual(extractChatcmplId(observed), "chatcmpl_44fn2g6e7kk");
+ });
+
+ it("falls back to 'unknown' when no id is present", () => {
+ assert.strictEqual(extractChatcmplId("{choices:[]}"), "unknown");
+ assert.strictEqual(extractChatcmplId(""), "unknown");
+ assert.strictEqual(extractChatcmplId("not json"), "unknown");
+ });
+});
diff --git a/tests/unit/authz/pipeline.test.ts b/tests/unit/authz/pipeline.test.ts
index 34703f270ecf..6f6469e804eb 100644
--- a/tests/unit/authz/pipeline.test.ts
+++ b/tests/unit/authz/pipeline.test.ts
@@ -306,6 +306,7 @@ test("runAuthzPipeline rejects new API requests during shutdown drain", async ()
assert.equal(response.status, 503);
assert.equal(body.error.code, "SERVICE_UNAVAILABLE");
+ assert.equal(response.headers.get("retry-after"), "5");
});
test("runAuthzPipeline rejects rewritten API aliases during shutdown drain", async () => {
@@ -319,6 +320,7 @@ test("runAuthzPipeline rejects rewritten API aliases during shutdown drain", asy
assert.equal(response.status, 503);
assert.equal(response.headers.get("x-omniroute-route-class"), "CLIENT_API");
assert.equal(body.error.code, "SERVICE_UNAVAILABLE");
+ assert.equal(response.headers.get("retry-after"), "5");
});
test("runAuthzPipeline allows dashboard sessions to read model catalog aliases", async () => {
diff --git a/tests/unit/build/optional-transformers-dependency.test.ts b/tests/unit/build/optional-transformers-dependency.test.ts
index 7ad60fb09c4b..cf5997a5f598 100644
--- a/tests/unit/build/optional-transformers-dependency.test.ts
+++ b/tests/unit/build/optional-transformers-dependency.test.ts
@@ -9,40 +9,52 @@ function readJson>(relPath: string): T {
return JSON.parse(readFileSync(join(repoRoot, relPath), "utf8")) as T;
}
-test("@huggingface/transformers is a regular dependency so npm ci never skips it", () => {
- // #9962 deliberately moved @huggingface/transformers out of optionalDependencies:
- // as an optional dep, npm silently skipped the whole subtree on Node 24/26 (old
- // pin dragged onnxruntime-node@1.21.0 whose NAN build no longer compiles), which
- // broke `npm ci`/`next build` with "Can't resolve @huggingface/transformers"
- // (lazy import in src/lib/memory/embedding/transformersLocal.ts). As a regular
- // dep with onnxruntime-node@~1.24.3 (napi prebuilds, no node-gyp) it stays
- // installable and the memory embedding path requires() cleanly.
+test("ONNX chain (@huggingface/transformers + onnxruntime-node) stays optional so Termux/Android installs succeed", () => {
+ // #11095: onnxruntime-node declares os ["win32","darwin","linux"], so while
+ // these lived in `dependencies` every npm install on Android/Termux aborted
+ // with a fatal EBADPLATFORM. As optionalDependencies npm skips only the
+ // unsupported-platform subtree (with a warning) and installs normally
+ // everywhere else. This deliberately reverses the MECHANISM of #9962 while
+ // keeping its goal: #9962's skip happened because the old onnxruntime-node@
+ // 1.21.0 pin built from source (NAN) and failed to compile on Node 24/26;
+ // the current 1.24.3 pin ships napi prebuilds, so on supported platforms the
+ // chain always installs and `npm ci`/`next build` keep resolving it. On
+ // platforms where it IS skipped, both consumers degrade gracefully via lazy/
+ // dynamic imports (asserted below).
const pkg = readJson<{
dependencies?: Record;
optionalDependencies?: Record;
+ overrides?: Record;
}>("package.json");
assert.equal(
pkg.dependencies?.["@huggingface/transformers"],
+ undefined,
+ "transformers must NOT be a hard dependency (fatal EBADPLATFORM on Android)"
+ );
+ assert.equal(
+ pkg.optionalDependencies?.["@huggingface/transformers"],
"^4.2.0",
- "transformers must be a regular dependency (never optional) so npm ci cannot skip it"
+ "transformers must be an optionalDependency"
);
- assert.equal(pkg.optionalDependencies?.["@huggingface/transformers"], undefined);
-});
-
-test("transformers + onnxruntime-node are regular dependencies (not optional)", () => {
- const pkg = readJson<{
- dependencies?: Record;
- optionalDependencies?: Record;
- }>("package.json");
-
assert.equal(
pkg.dependencies?.["onnxruntime-node"],
+ undefined,
+ "onnxruntime-node must NOT be a hard dependency (fatal EBADPLATFORM on Android)"
+ );
+ assert.equal(
+ pkg.optionalDependencies?.["onnxruntime-node"],
+ "1.24.3",
+ "onnxruntime-node must be an optionalDependency pinned in lockstep with the overrides pin"
+ );
+ assert.equal(
+ pkg.overrides?.["onnxruntime-node"],
"1.24.3",
- "onnxruntime-node is a regular dep (napi prebuilds, installable on Node 24/26)"
+ "the overrides pin must stay aligned with @huggingface/transformers' own pin (single-copy invariant)"
);
- assert.equal(pkg.optionalDependencies?.["onnxruntime-node"], undefined);
+});
+test("lockfile marks the whole ONNX chain optional", () => {
const lock = readJson<{
packages: Record<
string,
@@ -51,26 +63,61 @@ test("transformers + onnxruntime-node are regular dependencies (not optional)",
dependencies?: Record;
optionalDependencies?: Record;
}
- >;
+ >;
}>("package-lock.json");
assert.equal(
- lock.packages[""]?.dependencies?.["@huggingface/transformers"],
+ lock.packages[""]?.optionalDependencies?.["@huggingface/transformers"],
"^4.2.0",
- "root lock dependencies must hold transformers as a regular (non-optional) dep"
+ "root lock optionalDependencies must hold transformers"
+ );
+ assert.equal(
+ lock.packages[""]?.optionalDependencies?.["onnxruntime-node"],
+ "1.24.3",
+ "root lock optionalDependencies must hold onnxruntime-node"
);
- // Optional flag is only written `true` for genuinely optional packages;
- // regular deps leave it absent/null. Assert each is NOT optional.
assert.ok(
- !lock.packages["node_modules/@huggingface/transformers"]?.optional,
- "transformers must not be marked optional in the lockfile"
+ lock.packages["node_modules/@huggingface/transformers"]?.optional,
+ "transformers must be marked optional in the lockfile"
);
assert.ok(
- !lock.packages["node_modules/onnxruntime-node"]?.optional,
- "onnxruntime-node must not be marked optional in the lockfile"
+ lock.packages["node_modules/onnxruntime-node"]?.optional,
+ "onnxruntime-node must be marked optional in the lockfile"
);
assert.ok(
- !lock.packages["node_modules/onnxruntime-common"]?.optional,
- "onnxruntime-common must not be marked optional in the lockfile"
+ lock.packages["node_modules/onnxruntime-common"]?.optional,
+ "onnxruntime-common must be marked optional in the lockfile"
+ );
+});
+
+test("every @huggingface/transformers consumer loads it lazily so absent installs degrade gracefully", () => {
+ // If any module ever switches to a STATIC import of the optional chain,
+ // startup crashes on platforms where npm skipped it (Android/Termux).
+ // transformersLocal.ts must keep its lazy await import() (D8/D25);
+ // onnxWorker.ts must keep its runtime-variable dynamicImport indirection.
+
+ const embeddingSrc = readFileSync(
+ join(repoRoot, "src/lib/memory/embedding/transformersLocal.ts"),
+ "utf8"
+ );
+ assert.doesNotMatch(
+ embeddingSrc,
+ /^\s*import\s+(?:[^'"]*?\s+from\s+)?["']@huggingface\/transformers["']/m,
+ "transformersLocal.ts must not statically import @huggingface/transformers"
+ );
+ assert.match(
+ embeddingSrc,
+ /await import\(["']@huggingface\/transformers["']\)/,
+ "transformersLocal.ts must load @huggingface/transformers via await import()"
+ );
+
+ const workerSrc = readFileSync(
+ join(repoRoot, "open-sse/services/compression/engines/llmlingua/onnxWorker.ts"),
+ "utf8"
+ );
+ assert.doesNotMatch(
+ workerSrc,
+ /^\s*import\s+(?:[^'"]*?\s+from\s+)?["']@huggingface\/transformers["']/m,
+ "onnxWorker.ts must not statically import @huggingface/transformers"
);
});
diff --git a/tests/unit/call-logs-row-filter.test.ts b/tests/unit/call-logs-row-filter.test.ts
new file mode 100644
index 000000000000..24090389f6e8
--- /dev/null
+++ b/tests/unit/call-logs-row-filter.test.ts
@@ -0,0 +1,47 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { rowMatchesFilter } from "../../src/app/api/usage/call-logs/route.ts";
+
+test.describe("call-logs rowMatchesFilter unit tests", () => {
+ const baseRow = {
+ id: "log-1",
+ status: 200,
+ model: "openai/gpt-4o",
+ provider: "openai",
+ providerDisplay: "OpenAI Main",
+ account: "Work Account",
+ apiKeyName: "DevKey",
+ comboName: "SmartRouter",
+ correlationId: "corr-12345",
+ path: "/v1/chat/completions",
+ error: null,
+ };
+
+ test("status filter matches ok, error, and explicit status codes", () => {
+ assert.equal(rowMatchesFilter(baseRow, { status: "ok" }), true);
+ assert.equal(rowMatchesFilter(baseRow, { status: "error" }), false);
+ assert.equal(rowMatchesFilter(baseRow, { status: 200 }), true);
+ assert.equal(rowMatchesFilter(baseRow, { status: 500 }), false);
+
+ const errorRow = { ...baseRow, status: 500, error: "Internal Error" };
+ assert.equal(rowMatchesFilter(errorRow, { status: "ok" }), false);
+ assert.equal(rowMatchesFilter(errorRow, { status: "error" }), true);
+ });
+
+ test("provider filter matches provider name and excludes mismatched in-memory rows", () => {
+ assert.equal(rowMatchesFilter(baseRow, { provider: "openai" }), true);
+ assert.equal(rowMatchesFilter(baseRow, { provider: "anthropic" }), false);
+ });
+
+ test("model filter matches model name and excludes mismatched in-memory rows", () => {
+ assert.equal(rowMatchesFilter(baseRow, { model: "gpt-4o" }), true);
+ assert.equal(rowMatchesFilter(baseRow, { model: "claude-3-5-sonnet" }), false);
+ });
+
+ test("search query matches across haystack fields", () => {
+ assert.equal(rowMatchesFilter(baseRow, { search: "SmartRouter" }), true);
+ assert.equal(rowMatchesFilter(baseRow, { search: "DevKey" }), true);
+ assert.equal(rowMatchesFilter(baseRow, { search: "corr-12345" }), true);
+ assert.equal(rowMatchesFilter(baseRow, { search: "non-existent" }), false);
+ });
+});
diff --git a/tests/unit/capture-critical-db-state.test.ts b/tests/unit/capture-critical-db-state.test.ts
index 0194b5c92f60..fcf2a017b7e6 100644
--- a/tests/unit/capture-critical-db-state.test.ts
+++ b/tests/unit/capture-critical-db-state.test.ts
@@ -6,12 +6,13 @@ import path from "node:path";
// Shared across all tests — the module caches DATA_DIR / SQLITE_FILE at load time,
// so we must create the temp dir and import exactly once.
+type CoreModule = typeof import("../../src/lib/db/core.ts");
let tempDir: string;
let originalDataDir: string | undefined;
-let getDbInstance: any;
-let resetDbInstance: any;
-let ensureDbInitialized: any;
-let closeDbInstance: any;
+let getDbInstance: CoreModule["getDbInstance"];
+let resetDbInstance: CoreModule["resetDbInstance"];
+let ensureDbInitialized: CoreModule["ensureDbInitialized"];
+let closeDbInstance: CoreModule["closeDbInstance"];
before(async () => {
tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-db-test-"));
diff --git a/tests/unit/chat-body-admission.test.ts b/tests/unit/chat-body-admission.test.ts
index e4707402a159..05afae869c82 100644
--- a/tests/unit/chat-body-admission.test.ts
+++ b/tests/unit/chat-body-admission.test.ts
@@ -16,6 +16,7 @@ const {
resolveSelfLoopBearer,
} = admissionModule;
const { withEarlyStreamKeepalive } = await import("../../open-sse/utils/earlyStreamKeepalive.ts");
+const { getActiveRequestCount } = await import("../../src/lib/gracefulShutdown.ts");
/**
* Save/restore the env-var keys that `resolveSelfLoopBearer` reads so tests can
@@ -49,6 +50,25 @@ function chatRequest(body: string, contentLength: string | null = String(body.le
});
}
+test("heavyweight leases are counted for SIGTERM drain (#11015)", () => {
+ globalThis.__omnirouteShutdown = { init: true, shuttingDown: false, activeRequests: 0 };
+ const controller = new ChatAdmissionController(2);
+ const before = getActiveRequestCount();
+ const lease = controller.tryAcquireHeavy();
+ assert.ok(lease);
+ assert.equal(getActiveRequestCount(), before + 1);
+ const headroom = controller.tryAcquireHealthyHeadroom();
+ assert.ok(headroom);
+ assert.equal(getActiveRequestCount(), before + 2);
+ lease.release();
+ assert.equal(getActiveRequestCount(), before + 1);
+ headroom.release();
+ assert.equal(getActiveRequestCount(), before);
+ lease.release();
+ headroom.release();
+ assert.equal(getActiveRequestCount(), before);
+});
+
test("small known body is admitted without consuming heavyweight capacity", async () => {
const controller = new ChatAdmissionController(1);
const result = await admitChatRequest(chatRequest("{}"), {
diff --git a/tests/unit/chatcore-translation-paths.test.ts b/tests/unit/chatcore-translation-paths.test.ts
index 08cc564cc4e5..6ecb0487889c 100644
--- a/tests/unit/chatcore-translation-paths.test.ts
+++ b/tests/unit/chatcore-translation-paths.test.ts
@@ -369,7 +369,7 @@ async function invokeChatCore({
onCredentialsRefreshed = null,
onRequestSuccess = null,
sessionAffinityKey = null,
- reasoningTransportFallback = "skip",
+ reasoningTransportFallback = "drop",
managedLease = null,
cachedSettings = null,
}: any = {}) {
@@ -631,7 +631,7 @@ test("chatCore translates a streaming Responses upstream for a Chat client", asy
assert.match(streamed, /"content":"ok"/);
assert.match(streamed, /data: \[DONE\]/);
});
-test("chatCore rejects opaque reasoning for unknown Responses targets unless explicitly enabled", async () => {
+test("chatCore drops opaque reasoning for plaintext Responses targets by default (#10959)", async () => {
const reasoningItems = [
{ id: "rs_valid", type: "reasoning", encrypted_content: "encrypted-blob" },
{ type: "reasoning", encrypted_content: "" },
@@ -640,7 +640,7 @@ test("chatCore rejects opaque reasoning for unknown Responses targets unless exp
{ id: "fc_call", type: "function_call", call_id: "call_1", name: "search", arguments: "{}" },
];
- const rejected = await invokeChatCore({
+ const dropped = await invokeChatCore({
provider: "openai-compatible-sp-openai",
model: "gpt-5.4",
endpoint: "/v1/responses",
@@ -656,9 +656,12 @@ test("chatCore rejects opaque reasoning for unknown Responses targets unless exp
responseFormat: "openai-responses",
});
- assert.equal(rejected.result.success, false);
- assert.equal(rejected.result.status, 400);
- assert.equal(rejected.calls.length, 0);
+ assert.equal(dropped.result.success, true);
+ assert.equal(dropped.calls.length, 1);
+ assert.deepEqual(
+ dropped.call.body.input.filter((item) => item.type === "reasoning"),
+ [{ type: "reasoning", summary: [{ text: "not self-contained" }] }]
+ );
const enabled = await invokeChatCore({
provider: "openai-compatible-sp-openai",
@@ -682,7 +685,7 @@ test("chatCore rejects opaque reasoning for unknown Responses targets unless exp
assert.deepEqual(
input.filter((item) => item.type === "reasoning"),
[
- { id: "rs_valid", type: "reasoning", encrypted_content: "encrypted-blob" },
+ { id: "rs_valid", type: "reasoning", encrypted_content: "encrypted-blob", summary: [] }, // summary defaulted by #11110
{ type: "reasoning", summary: [{ text: "not self-contained" }] },
]
);
@@ -693,9 +696,9 @@ test("chatCore rejects opaque reasoning for unknown Responses targets unless exp
assert.equal(input.find((item) => item.type === "function_call")?.id, undefined);
});
-test("chatCore applies Chat reasoning compatibility before stream mode diverges", async () => {
+test("chatCore drops incompatible Chat reasoning before stream mode diverges (#10959)", async () => {
for (const stream of [false, true]) {
- const rejected = await invokeChatCore({
+ const dropped = await invokeChatCore({
provider: "openai-compatible-sp-openai",
model: "gpt-5.4",
endpoint: "/v1/chat/completions",
@@ -728,14 +731,14 @@ test("chatCore applies Chat reasoning compatibility before stream mode diverges"
},
});
- assert.equal(rejected.result.success, false, `stream=${stream}`);
- assert.equal(rejected.result.status, 400, `stream=${stream}`);
- assert.equal(rejected.calls.length, 0, `stream=${stream}`);
+ assert.equal(dropped.result.success, true, `stream=${stream}`);
+ assert.equal(dropped.calls.length, 1, `stream=${stream}`);
+ assert.equal(dropped.call.body.messages[0].reasoning_details, undefined, `stream=${stream}`);
}
});
-test("chatCore can drop incompatible reasoning for an opted-in Combo attempt", async () => {
- const dropped = await invokeChatCore({
+test("chatCore preserves Combo skip behavior for incompatible reasoning", async () => {
+ const skipped = await invokeChatCore({
provider: "openai-compatible-sp-openai",
model: "gpt-5.4",
endpoint: "/v1/responses",
@@ -757,15 +760,12 @@ test("chatCore can drop incompatible reasoning for an opted-in Combo attempt", a
},
responseFormat: "openai-responses",
isCombo: true,
- reasoningTransportFallback: "drop",
+ reasoningTransportFallback: "skip",
});
- assert.equal(dropped.result.success, true);
- assert.equal(dropped.calls.length, 1);
- assert.equal(
- dropped.call.body.input.some((item) => item.type === "reasoning"),
- false
- );
+ assert.equal(skipped.result.success, false);
+ assert.equal(skipped.result.status, 400);
+ assert.equal(skipped.calls.length, 0);
});
test("chatCore carries Chat reasoning_content into official DeepSeek Responses input", async () => {
@@ -800,6 +800,7 @@ test("chatCore carries Chat reasoning_content into official DeepSeek Responses i
assert.deepEqual(call.body.input.slice(0, 3), [
{
type: "reasoning",
+ summary: [], // defaulted on freshly-built reasoning items (#11129)
content: [{ type: "reasoning_text", text: "Inspect before calling the tool" }],
},
{
@@ -866,7 +867,7 @@ test("chatCore replays nonstream DeepSeek Responses reasoning across a Chat tool
assert.equal(second.result.success, true);
assert.deepEqual(
second.call.body.input.find((item) => item.type === "reasoning"),
- { type: "reasoning", content: [{ type: "reasoning_text", text: reasoning }] }
+ { type: "reasoning", content: [{ type: "reasoning_text", text: reasoning }], summary: [] } // summary defaulted by #11129
);
});
@@ -930,7 +931,7 @@ test("chatCore replays streamed DeepSeek Responses reasoning across a Chat tool
assert.equal(second.result.success, true);
assert.deepEqual(
second.call.body.input.find((item) => item.type === "reasoning"),
- { type: "reasoning", content: [{ type: "reasoning_text", text: reasoning }] }
+ { type: "reasoning", content: [{ type: "reasoning_text", text: reasoning }], summary: [] } // summary defaulted by #11129
);
});
@@ -1132,7 +1133,7 @@ test("chatCore automatically preserves provider-generated opaque reasoning for C
assert.equal(result.success, true);
assert.deepEqual(
call.body.input.filter((item) => item.type === "reasoning"),
- [{ id: "rs_valid", type: "reasoning", encrypted_content: "encrypted-blob" }]
+ [{ id: "rs_valid", type: "reasoning", encrypted_content: "encrypted-blob", summary: [] }] // summary defaulted by #11110
);
assert.equal(
call.body.input.some((item) => item.type === "item_reference"),
diff --git a/tests/unit/claude-code-tool-casing-identity-echo.test.ts b/tests/unit/claude-code-tool-casing-identity-echo.test.ts
new file mode 100644
index 000000000000..63d1edf3d248
--- /dev/null
+++ b/tests/unit/claude-code-tool-casing-identity-echo.test.ts
@@ -0,0 +1,205 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { restoreClaudeToolName } from "../../open-sse/services/claudeCodeToolRemapper.ts";
+import { openaiToClaudeResponse } from "../../open-sse/translator/response/openai-to-claude.ts";
+import { translateNonStreamingResponse } from "../../open-sse/handlers/responseTranslator.ts";
+import { FORMATS } from "../../open-sse/translator/formats.ts";
+
+interface ClaudeEvent {
+ type: string;
+ index?: number;
+ content_block?: { type: string; id?: string; name?: string; input?: unknown };
+}
+
+type TranslatorState = Record;
+
+function firstToolUse(events: ClaudeEvent[] | null): ClaudeEvent["content_block"] {
+ return events?.find(
+ (e) => e.type === "content_block_start" && e.content_block?.type === "tool_use"
+ )?.content_block;
+}
+
+function openaiToolCallChunk(name: string): { choices: Array> } {
+ return {
+ choices: [
+ {
+ delta: {
+ tool_calls: [{ index: 0, id: "call_echo", function: { name, arguments: "" } }],
+ },
+ },
+ ],
+ };
+}
+
+/**
+ * Claude Code 2.1.x added CronCreate/CronList/CronDelete/ScheduleWakeup/
+ * EnterWorktree. The `/loop` skill schedules via CronCreate; upstream gateways
+ * that emit the lowercased name (and echo it into the toolNameMap alias
+ * channel) previously let `croncreate` reach Claude Code un-restored, which
+ * the CLI rejects with "No such tool available" — killing /loop AND every
+ * other native tool call emitted in lowercase form.
+ */
+describe("Claude Code cron-era tool names survive identity-echo alias maps", () => {
+ const ECHO_MAPS = [
+ ["identity entry croncreate→croncreate", new Map([["croncreate", "croncreate"]])],
+ ["cloak-direction entry CronCreate→croncreate", new Map([["CronCreate", "croncreate"]])],
+ [
+ "identity + unrelated aliases",
+ new Map([
+ ["subdispatch", "SubDispatch"],
+ ["croncreate", "croncreate"],
+ ]),
+ ],
+ ] as const;
+
+ for (const [label, map] of ECHO_MAPS) {
+ it(`restoreClaudeToolName upgrades echoed lowercase cron tools — ${label}`, () => {
+ assert.equal(restoreClaudeToolName("croncreate", map), "CronCreate");
+ assert.equal(restoreClaudeToolName("cronlist", map), "CronList");
+ assert.equal(restoreClaudeToolName("crondelete", map), "CronDelete");
+ assert.equal(restoreClaudeToolName("schedulewakeup", map), "ScheduleWakeup");
+ assert.equal(restoreClaudeToolName("enterworktree", map), "EnterWorktree");
+ assert.equal(restoreClaudeToolName("bash", map), "Bash");
+ assert.equal(restoreClaudeToolName("taskcreate", map), "TaskCreate");
+ assert.equal(restoreClaudeToolName("taskupdate", map), "TaskUpdate");
+ assert.equal(restoreClaudeToolName("tasklist", map), "TaskList");
+ assert.equal(restoreClaudeToolName("taskget", map), "TaskGet");
+ });
+
+ it(`openaiToClaudeResponse emits PascalCase content_block.name — ${label}`, () => {
+ const state: TranslatorState = {
+ toolCalls: new Map(),
+ nextBlockIndex: 0,
+ toolNameMap: map,
+ };
+ const block = firstToolUse(
+ openaiToClaudeResponse(openaiToolCallChunk("croncreate"), state) as ClaudeEvent[]
+ );
+ assert.equal(block?.name, "CronCreate");
+ });
+ }
+
+ it("request-side non-identity alias still beats canonical casing", () => {
+ // A client that actually declared a custom lowercase MCP-style name keeps it.
+ const map = new Map([
+ ["read", "mcp__fs__read"],
+ ["croncreate", "CronCreate"],
+ ]);
+ assert.equal(restoreClaudeToolName("read", map), "mcp__fs__read");
+ });
+
+ it("unknown tools with identity entries are preserved verbatim", () => {
+ const map = new Map([["my_custom_tool", "my_custom_tool"]]);
+ assert.equal(restoreClaudeToolName("my_custom_tool", map), "my_custom_tool");
+ });
+
+ it("canonical echo stays canonical on no-map routes (live repro 2026-08-22)", () => {
+ // Live-tested against glm-5.2 via opencode-go: the request declared
+ // CronCreate/Bash, the gateway echoed them TitleCase, and claude-to-openai
+ // builds no _toolNameMap — the old #7926 REVERSE_MAP fallback downcased
+ // the echo to `croncreate`/`bash`, which Claude Code rejects with
+ // "No such tool available", killing those tools for the whole session.
+ // Every restoreClaudeToolName caller converts toward a Claude-format
+ // client, so blind TitleCase→lowercase downcasing has no legitimate
+ // consumer left: legacy lowercase clients are protected by explicit
+ // alias maps (see test above), not by unmapped downcasing.
+ assert.equal(restoreClaudeToolName("TodoWrite", null), "TodoWrite");
+ assert.equal(restoreClaudeToolName("Read", undefined), "Read");
+ assert.equal(restoreClaudeToolName("WebSearch", null), "WebSearch");
+ });
+});
+
+/**
+ * Live-reproduced 2026-08-22: an `ox-alpha-free` upstream answered the
+ * stream:true /v1/messages request with a non-streaming JSON body; omniroute
+ * converted it via translateNonStreamingResponse, which emitted tool_use.name
+ * verbatim ("bash") — Claude Code rejected it with "No such tool available",
+ * killing Bash/Read/Write/CronCreate for the whole session.
+ */
+describe("translateNonStreamingResponse restores Claude Code tool casing", () => {
+ function openaiJson(name: string) {
+ return {
+ id: "202608221120471ad3e3bd71e24afd",
+ object: "chat.completion",
+ choices: [
+ {
+ index: 0,
+ finish_reason: "tool_calls",
+ message: {
+ role: "assistant",
+ content: null,
+ reasoning_content: "The user wants echo ok",
+ tool_calls: [
+ {
+ id: "call_b90e72ccc16f440c88c4f9e6",
+ type: "function",
+ function: { name, arguments: '{"command":"echo ok"}' },
+ },
+ ],
+ },
+ },
+ ],
+ usage: { prompt_tokens: 246, completion_tokens: 35 },
+ };
+ }
+
+ it("upgrades lowercase native tool names with no alias map (live repro)", () => {
+ const out = translateNonStreamingResponse(
+ openaiJson("bash"),
+ FORMATS.OPENAI,
+ FORMATS.CLAUDE,
+ null
+ );
+ const toolUse = out.content.find((b) => b.type === "tool_use");
+ assert.equal(toolUse.name, "Bash");
+ assert.equal(toolUse.input.command, "echo ok");
+ });
+
+ it("upgrades cron-era tools through identity-echo maps", () => {
+ const out = translateNonStreamingResponse(
+ openaiJson("croncreate"),
+ FORMATS.OPENAI,
+ FORMATS.CLAUDE,
+ new Map([["croncreate", "croncreate"]])
+ );
+ assert.equal(out.content.find((b) => b.type === "tool_use").name, "CronCreate");
+ });
+
+ it("request-side aliases still win over canonical casing", () => {
+ const out = translateNonStreamingResponse(
+ openaiJson("read"),
+ FORMATS.OPENAI,
+ FORMATS.CLAUDE,
+ new Map([["read", "mcp__fs__read"]])
+ );
+ assert.equal(out.content.find((b) => b.type === "tool_use").name, "mcp__fs__read");
+ });
+
+ it("keeps canonical casing the upstream echoed verbatim when no alias map exists (live repro #11085)", () => {
+ // Live-tested on the Claude Code → OpenAI-style upstream route: the request
+ // declares CronCreate/Bash, the gateway echoes them TitleCase, and
+ // claude-to-openai builds no _toolNameMap — the #7926 REVERSE_MAP fallback
+ // must not downcase a canonical name back into "No such tool available".
+ const out = translateNonStreamingResponse(
+ openaiJson("CronCreate"),
+ FORMATS.OPENAI,
+ FORMATS.CLAUDE,
+ null
+ );
+ assert.equal(out.content.find((b) => b.type === "tool_use").name, "CronCreate");
+ assert.equal(restoreClaudeToolName("Bash", null), "Bash");
+ assert.equal(restoreClaudeToolName("WebSearch", null), "WebSearch");
+ assert.equal(restoreClaudeToolName("TaskCreate", new Map()), "TaskCreate");
+ });
+
+ it("declared lowercase form still wins when an explicit alias maps canonical → lowercase", () => {
+ // Legacy OpenCode/XML-style clients declare `bash`; request-side cloak
+ // records { CronCreate→croncreate }-style aliases and restoreClaudeToolName
+ // must keep honoring them even when the upstream echoes the canonical form.
+ assert.equal(
+ restoreClaudeToolName("CronCreate", new Map([["CronCreate", "croncreate"]])),
+ "croncreate"
+ );
+ assert.equal(restoreClaudeToolName("Read", new Map([["Read", "read"]])), "read");
+ });
+});
diff --git a/tests/unit/claude-tool-name-casing-fix.test.ts b/tests/unit/claude-tool-name-casing-fix.test.ts
index c02fd09286e1..5c11d1652bce 100644
--- a/tests/unit/claude-tool-name-casing-fix.test.ts
+++ b/tests/unit/claude-tool-name-casing-fix.test.ts
@@ -50,10 +50,13 @@ describe("Claude Code Tool Name Casing Fixes", () => {
assert.equal(restoreClaudeToolName("exitplanmode"), "ExitPlanMode");
});
- it("restoreClaudeToolName keeps the #7926 TitleCase→lowercase fallback with no map", () => {
- // Clients with no request-side map (XML / OpenCode-style) expect lowercase.
- assert.equal(restoreClaudeToolName("TodoWrite"), "todowrite");
- assert.equal(restoreClaudeToolName("Read"), "read");
+ it("restoreClaudeToolName keeps canonical TitleCase with no map (#11085 live repro)", () => {
+ // Live-tested 2026-08-22: no-map routes (Claude Code → OpenAI-style
+ // upstreams) receive the gateway's TitleCase echo and must keep it —
+ // downcasing made Claude Code reject its own tools. XML/OpenCode-style
+ // lowercase clients are protected by explicit alias maps instead.
+ assert.equal(restoreClaudeToolName("TodoWrite"), "TodoWrite");
+ assert.equal(restoreClaudeToolName("Read"), "Read");
});
it("restoreClaudeToolName prefers toolNameMap over the static map", () => {
@@ -150,9 +153,7 @@ describe("Claude Code Tool Name Casing Fixes", () => {
choices: [
{
delta: {
- tool_calls: [
- { index: 0, id: "call_123", function: { name: "bash", arguments: "" } },
- ],
+ tool_calls: [{ index: 0, id: "call_123", function: { name: "bash", arguments: "" } }],
},
},
],
diff --git a/tests/unit/cli-combo-create-models-10954.test.ts b/tests/unit/cli-combo-create-models-10954.test.ts
index dc53459d6ed5..52fabf8c1690 100644
--- a/tests/unit/cli-combo-create-models-10954.test.ts
+++ b/tests/unit/cli-combo-create-models-10954.test.ts
@@ -90,7 +90,15 @@ test("combo create — parses --models without throwing (Commander option regist
});
await prog.parseAsync(
- ["node", "x", "combo", "create", "my-combo", "--models", "openai/gpt-4o,anthropic/claude-3-opus"],
+ [
+ "node",
+ "x",
+ "combo",
+ "create",
+ "my-combo",
+ "--models",
+ "openai/gpt-4o,anthropic/claude-3-opus",
+ ],
{ from: "node" }
);
@@ -222,3 +230,26 @@ test("combo create (HTTP) — POST /api/combos body carries the parsed models",
else process.env.DATA_DIR = ORIGINAL_DATA_DIR;
}
});
+
+// Regression for the follow-up of #11011: with --models available, creating
+// an empty combo is no longer a legitimate path on either transport.
+test("combo create without any model is refused before reaching a transport", async () => {
+ await withComboEnv(async () => {
+ const errors: string[] = [];
+ const originalError = console.error;
+ console.error = (msg?: unknown) => {
+ errors.push(String(msg));
+ };
+ try {
+ const mod = await import("../../bin/cli/commands/combo.mjs");
+ const rc = await mod.runComboCreateCommand("guard-test");
+ assert.equal(rc, 1);
+ } finally {
+ console.error = originalError;
+ }
+ assert.ok(
+ errors.some((m) => m.includes("--models")),
+ `stderr should name --models, got: ${errors.join(" | ")}`
+ );
+ });
+});
diff --git a/tests/unit/cline-model-format-11099.test.ts b/tests/unit/cline-model-format-11099.test.ts
new file mode 100644
index 000000000000..3e5a87de43c7
--- /dev/null
+++ b/tests/unit/cline-model-format-11099.test.ts
@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { getModelsByProviderId } from "../../open-sse/config/providerModels.ts";
+import { parseClineRecommendedModels } from "../../open-sse/services/clinepassModels.ts";
+
+test("#11099: Cline provider catalog model IDs use valid modelType/model format", () => {
+ const models = getModelsByProviderId("cline");
+ assert.ok(models.length > 0, "cline provider must expose models");
+
+ for (const model of models) {
+ assert.match(
+ model.id,
+ /^[a-z0-9-]+-?[a-z0-9-]*\/[a-z0-9._:-]+$/i,
+ `Model ID '${model.id}' must follow provider/model format`
+ );
+ assert.notEqual(
+ model.id.split("/")[0],
+ "zai",
+ "Model ID must use 'z-ai' instead of invalid 'zai'"
+ );
+ }
+});
+
+test("#11099: parseClineRecommendedModels correctly extracts recommended/free models", () => {
+ const mockPayload = {
+ recommended: [
+ { id: "moonshotai/kimi-k3", name: "kimi-k3" },
+ { id: "x-ai/grok-4.5", name: "grok-4.5" },
+ ],
+ free: [{ id: "deepseek/deepseek-v4-flash", name: "deepseek-v4-flash" }],
+ };
+
+ const parsed = parseClineRecommendedModels(mockPayload);
+ assert.equal(parsed.length, 3);
+ assert.equal(parsed[0].id, "moonshotai/kimi-k3");
+ assert.equal(parsed[1].id, "x-ai/grok-4.5");
+ assert.equal(parsed[2].id, "deepseek/deepseek-v4-flash");
+});
diff --git a/tests/unit/codex-drop-nonstandard-events.test.ts b/tests/unit/codex-drop-nonstandard-events.test.ts
index d2aff5481498..dec24970ca5a 100644
--- a/tests/unit/codex-drop-nonstandard-events.test.ts
+++ b/tests/unit/codex-drop-nonstandard-events.test.ts
@@ -17,6 +17,19 @@ function sseResponse(body: string): Response {
});
}
+function chunkedSseResponse(chunks: string[]): Response {
+ const encoder = new TextEncoder();
+ return new Response(
+ new ReadableStream({
+ start(controller) {
+ for (const chunk of chunks) controller.enqueue(encoder.encode(chunk));
+ controller.close();
+ },
+ }),
+ { status: 200, headers: { "content-type": "text/event-stream" } }
+ );
+}
+
async function readAll(res: Response): Promise {
return await res.text();
}
@@ -61,10 +74,10 @@ describe("codexDropNonstandardEvents (#11014)", () => {
describe("filterNonstandardCodexSse (#4715)", () => {
it("drops codex.* event blocks but keeps standard response.* events", async () => {
const stream =
- "event: response.created\ndata: {\"type\":\"response.created\"}\n\n" +
+ 'event: response.created\ndata: {"type":"response.created"}\n\n' +
"event: codex.rate_limits\n\n" +
- "event: response.output_text.delta\ndata: {\"delta\":\"hi\"}\n\n" +
- "event: response.completed\ndata: {\"type\":\"response.completed\"}\n\n";
+ 'event: response.output_text.delta\ndata: {"delta":"hi"}\n\n' +
+ 'event: response.completed\ndata: {"type":"response.completed"}\n\n';
const out = await readAll(filterNonstandardCodexSse(sseResponse(stream)));
assert.ok(!out.includes("codex.rate_limits"), "codex.* frame must be stripped");
assert.ok(out.includes("response.created"), "standard events preserved");
@@ -72,18 +85,31 @@ describe("filterNonstandardCodexSse (#4715)", () => {
assert.ok(out.includes("response.completed"), "terminal event preserved");
});
+ it("filters CRLF-framed events split across transport chunks", async () => {
+ const response = chunkedSseResponse([
+ 'event: response.created\r\ndata: {"type":"response.created"}\r\n\r',
+ "\nevent: codex.rate_limits\r\n\r\n",
+ 'event: response.completed\r\ndata: {"type":"response.completed"}\r\n\r\n',
+ ]);
+
+ const out = await readAll(filterNonstandardCodexSse(response));
+
+ assert.ok(!out.includes("codex.rate_limits"), "codex.* frame must be stripped");
+ assert.ok(out.includes("response.created"), "standard events preserved");
+ assert.ok(out.includes("response.completed"), "terminal event preserved");
+ });
+
it("passes through non-SSE responses untouched", async () => {
- const json = new Response("{\"ok\":true}", {
+ const json = new Response('{"ok":true}', {
status: 200,
headers: { "content-type": "application/json" },
});
const out = filterNonstandardCodexSse(json);
- assert.equal(await out.text(), "{\"ok\":true}");
+ assert.equal(await out.text(), '{"ok":true}');
});
it("drops a trailing codex.* block with no double-newline terminator (flush path)", async () => {
- const stream =
- "event: response.created\ndata: {}\n\n" + "event: codex.token_count\ndata: {}";
+ const stream = "event: response.created\ndata: {}\n\n" + "event: codex.token_count\ndata: {}";
const out = await readAll(filterNonstandardCodexSse(sseResponse(stream)));
assert.ok(out.includes("response.created"));
assert.ok(!out.includes("codex.token_count"));
diff --git a/tests/unit/columns-validation.test.ts b/tests/unit/columns-validation.test.ts
new file mode 100644
index 000000000000..41f70cddeb25
--- /dev/null
+++ b/tests/unit/columns-validation.test.ts
@@ -0,0 +1,24 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+ sanitizeRateLimitOverrides,
+ sanitizeQuotaWindowThresholds,
+} from "@/lib/db/providers/columns";
+
+test("sanitizeRateLimitOverrides surfaces rejected keys (blocking, not silent)", () => {
+ const r = sanitizeRateLimitOverrides({ rpm: 10, foo: 1, tpm: -1 });
+ assert.deepEqual(r.sanitized, { rpm: 10 });
+ assert.deepEqual(r.rejected.sort(), ["foo", "tpm"]);
+});
+
+test("sanitizeQuotaWindowThresholds surfaces key-too-long and out-of-range", () => {
+ const r = sanitizeQuotaWindowThresholds({ ["a".repeat(65)]: 50, win: 101 });
+ assert.ok(r.rejected.length >= 1);
+ assert.ok(r.rejected.includes("win"));
+});
+
+test("valid input yields no rejected keys", () => {
+ const r = sanitizeRateLimitOverrides({ rpm: 10, tpm: 20 });
+ assert.deepEqual(r.rejected, []);
+ assert.deepEqual(r.sanitized, { rpm: 10, tpm: 20 });
+});
diff --git a/tests/unit/combo-bracket-names.test.ts b/tests/unit/combo-bracket-names.test.ts
index 32844173cc15..0f4d8af0de92 100644
--- a/tests/unit/combo-bracket-names.test.ts
+++ b/tests/unit/combo-bracket-names.test.ts
@@ -30,6 +30,7 @@ test.after(() => {
test("combo schemas accept names with spaces and square brackets", () => {
const createResult = schemas.createComboSchema.safeParse({
name: "Claude [1m]",
+ models: ["anthropic/claude-3-opus"],
});
const updateResult = schemas.updateComboSchema.safeParse({
name: "Claude [1m]",
diff --git a/tests/unit/combo-context-length.test.ts b/tests/unit/combo-context-length.test.ts
index f47539d64ad2..c416b4d8be38 100644
--- a/tests/unit/combo-context-length.test.ts
+++ b/tests/unit/combo-context-length.test.ts
@@ -46,6 +46,7 @@ test.after(async () => {
test("createComboSchema accepts valid context_length", () => {
const result = schemas.createComboSchema.safeParse({
name: "TestCombo",
+ models: ["openai/gpt-4o-mini"],
context_length: 128000,
});
assert.equal(result.success, true);
@@ -54,6 +55,7 @@ test("createComboSchema accepts valid context_length", () => {
test("createComboSchema rejects context_length below minimum (1000)", () => {
const result = schemas.createComboSchema.safeParse({
name: "TestCombo",
+ models: ["openai/gpt-4o-mini"],
context_length: 999,
});
assert.equal(result.success, false);
@@ -62,6 +64,7 @@ test("createComboSchema rejects context_length below minimum (1000)", () => {
test("createComboSchema rejects context_length above maximum (2000000)", () => {
const result = schemas.createComboSchema.safeParse({
name: "TestCombo",
+ models: ["openai/gpt-4o-mini"],
context_length: 2000001,
});
assert.equal(result.success, false);
@@ -70,12 +73,14 @@ test("createComboSchema rejects context_length above maximum (2000000)", () => {
test("createComboSchema accepts context_length at exact boundaries", () => {
const min = schemas.createComboSchema.safeParse({
name: "MinCombo",
+ models: ["openai/gpt-4o-mini"],
context_length: 1000,
});
assert.equal(min.success, true);
const max = schemas.createComboSchema.safeParse({
name: "MaxCombo",
+ models: ["openai/gpt-4o-mini"],
context_length: 2000000,
});
assert.equal(max.success, true);
@@ -84,6 +89,7 @@ test("createComboSchema accepts context_length at exact boundaries", () => {
test("createComboSchema rejects non-integer context_length", () => {
const result = schemas.createComboSchema.safeParse({
name: "TestCombo",
+ models: ["openai/gpt-4o-mini"],
context_length: 128000.5,
});
assert.equal(result.success, false);
@@ -92,6 +98,7 @@ test("createComboSchema rejects non-integer context_length", () => {
test("createComboSchema accepts omitted context_length", () => {
const result = schemas.createComboSchema.safeParse({
name: "TestCombo",
+ models: ["openai/gpt-4o-mini"],
});
assert.equal(result.success, true);
});
diff --git a/tests/unit/combo-empty-models.test.ts b/tests/unit/combo-empty-models.test.ts
index 1486628ec537..95f32813a34c 100644
--- a/tests/unit/combo-empty-models.test.ts
+++ b/tests/unit/combo-empty-models.test.ts
@@ -24,9 +24,9 @@ test("an update cannot remove every model from a combo", () => {
assert.equal(updateComboSchema.safeParse({ name: "renamed" }).success, true);
});
-test("creating a combo with no model stays allowed — the CLI does it on purpose", () => {
- assert.equal(createComboSchema.safeParse({ name: "drafted", models: [] }).success, true);
- assert.equal(createComboSchema.safeParse({ name: "drafted" }).success, true);
+test("creating a combo without a model is refused at the boundary", () => {
+ assert.equal(createComboSchema.safeParse({ name: "drafted", models: [] }).success, false);
+ assert.equal(createComboSchema.safeParse({ name: "drafted" }).success, false);
});
test("the copilot createCombo tool stores targets where the router looks for them", async () => {
diff --git a/tests/unit/combo-health-autopilot-counter.test.ts b/tests/unit/combo-health-autopilot-counter.test.ts
new file mode 100644
index 000000000000..1bd8330753cd
--- /dev/null
+++ b/tests/unit/combo-health-autopilot-counter.test.ts
@@ -0,0 +1,108 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import type {
+ ComboForecastResponse,
+ ComboHealthResponse,
+ ProviderAutopilotReport,
+} from "../../src/shared/types/utilization.ts";
+import { buildComboHealthAutopilotReport } from "../../src/lib/monitoring/comboHealthAutopilot.ts";
+
+function healthResponse(): ComboHealthResponse {
+ return {
+ timeRange: "24h",
+ combos: [
+ {
+ comboId: "c1",
+ comboName: "my-combo",
+ strategy: "fallback",
+ models: [],
+ targetHealth: [
+ {
+ executionKey: "e1",
+ stepId: "s1",
+ model: "m",
+ provider: "p",
+ connectionId: null,
+ label: null,
+ requests: 5,
+ successRate: 90,
+ avgLatencyMs: 100,
+ lastStatus: "error",
+ lastUsedAt: null,
+ quotaRemainingPct: 50,
+ quotaIsExhausted: false,
+ quotaTrend: "stable",
+ quotaScope: "provider",
+ },
+ ],
+ quotaHealth: { providers: [], worstRemainingPct: 100 },
+ usageSkew: { modelDistribution: [], giniCoefficient: 0 },
+ performance: { avgLatencyMs: 100, successRate: 1.0, totalRequests: 10 },
+ },
+ ],
+ };
+}
+
+function forecastResponse(): ComboForecastResponse {
+ return {
+ timeRange: "24h",
+ horizon: "30d",
+ asOf: new Date(0).toISOString(),
+ method: "linear_history",
+ combos: [],
+ };
+}
+
+function providerHealthResponse(): ProviderAutopilotReport {
+ return { providers: [] } as unknown as ProviderAutopilotReport;
+}
+
+function buildOptions() {
+ return {
+ range: "24h" as const,
+ horizon: "30d" as const,
+ healthResponse: healthResponse(),
+ forecastResponse: forecastResponse(),
+ providerHealthResponse: providerHealthResponse(),
+ };
+}
+
+describe("combo health autopilot counter", () => {
+ it("exposes suggestionCount and keeps actionableCount alias", async () => {
+ const report = await buildComboHealthAutopilotReport(buildOptions());
+ assert.equal(typeof report.summary.suggestionCount, "number");
+ assert.equal(report.summary.actionableCount, report.summary.suggestionCount);
+ const expected = report.combos.reduce(
+ (sum, combo) =>
+ sum + combo.issues.reduce((issueSum, issue) => issueSum + issue.actions.length, 0),
+ 0
+ );
+ assert.equal(report.summary.suggestionCount, expected);
+ });
+
+ it("run_combo_test action links the dashboard with the combo id", async () => {
+ const report = await buildComboHealthAutopilotReport(buildOptions());
+ const actions = report.combos.flatMap((combo) => combo.issues.flatMap((i) => i.actions));
+ const runTest = actions.find((a) => a.type === "run_combo_test");
+ assert.ok(runTest, "run_combo_test action should exist");
+ assert.equal(typeof runTest.href, "string");
+ assert.ok(runTest.href?.includes("c1"), "href must carry the combo id");
+ assert.equal(
+ runTest.href?.includes("/api/combos/test?comboId="),
+ false,
+ "href must not target the GET-only API route (405)"
+ );
+ });
+
+ it("keeps every action in manual mode", async () => {
+ const report = await buildComboHealthAutopilotReport(buildOptions());
+ for (const combo of report.combos) {
+ for (const issue of combo.issues) {
+ for (const action of issue.actions) {
+ assert.equal(action.mode, "manual");
+ }
+ }
+ }
+ });
+});
diff --git a/tests/unit/compression/ccr-non-mcp-full-prompt-loss-7746.test.ts b/tests/unit/compression/ccr-non-mcp-full-prompt-loss-7746.test.ts
index 0f4abd534e64..a646744871c4 100644
--- a/tests/unit/compression/ccr-non-mcp-full-prompt-loss-7746.test.ts
+++ b/tests/unit/compression/ccr-non-mcp-full-prompt-loss-7746.test.ts
@@ -15,6 +15,7 @@ import { describe, it, before } from "node:test";
import assert from "node:assert/strict";
import {
ccrEngine,
+ getCcrStoreStats,
resetCcrStore,
retrieveBlock,
} from "../../../open-sse/services/compression/engines/ccr/index.ts";
@@ -54,39 +55,117 @@ describe("issue #7746 — CCR must not reduce the sole user prompt to a bare, un
});
it("prompt fixture is realistically sized (>= default 600-char minChars)", () => {
- assert.ok(REPORTER_PROMPT.length >= 600, `fixture must be >= 600 chars, got ${REPORTER_PROMPT.length}`);
+ assert.ok(
+ REPORTER_PROMPT.length >= 600,
+ `fixture must be >= 600 chars, got ${REPORTER_PROMPT.length}`
+ );
});
- it("does not leave the model with only the bare CCR marker when no retrieve tool is available", () => {
+ it("non-MCP caller: CCR skips entirely — the sole user prompt passes through verbatim", () => {
resetCcrStore();
const body = makeOpenCodeStyleRequestBody();
const result = ccrEngine.apply(body as Record, { stepConfig: {} });
- assert.equal(result.compressed, true, "CCR compressed the sole user message (reproducing the report)");
-
- const messages = result.body.messages as Array<{ role: string; content: string }>;
- const compressedContent = messages[0].content;
- const isBareMarkerOnly = /^\[CCR retrieve hash=[0-9a-f]{24} chars=\d+\]$/.test(compressedContent);
-
+ // #7746 follow-up (forge review outage, 2026-08-22): the preamble guard was
+ // not enough — a non-MCP caller received "[CCR retrieve hash=...] markers"
+ // it had no tool to resolve (upstream saw 112 of ~3.6K tokens). The engine
+ // now refuses to replace content at all when tools[] lacks
+ // omniroute_ccr_retrieve: compressed=false, message content untouched.
assert.equal(
- isBareMarkerOnly,
+ result.compressed,
false,
- "BUG #7746: CCR replaced the ENTIRE sole user message with nothing but the bare " +
- `[CCR retrieve hash=...] marker, permanently losing the original prompt for any ` +
- `non-MCP caller that cannot resolve the marker. Got: ${JSON.stringify(compressedContent)}`
+ "CCR must not compress for a caller without the retrieve tool"
);
+ assert.equal(result.stats, null, "no stats when the engine is skipped");
+ const messages = result.body.messages as Array<{ role: string; content: string }>;
+ assert.equal(messages[0].role, "user", "message role must stay user");
+ assert.equal(
+ messages[0].content,
+ REPORTER_PROMPT,
+ "sole user prompt must pass through verbatim"
+ );
+ assert.equal(messages.length, 1, "no protocol instruction may be injected for non-MCP callers");
+ // Guard regression check: if callerSupportsCcrRetrieve ever returned true
+ // here, the store would silently accumulate blocks no non-MCP caller can
+ // retrieve. After a skip the store must hold nothing for this principal.
+ assert.equal(getCcrStoreStats().entries, 0, "store must stay empty after a non-MCP skip");
});
- it("the original prompt remains fully retrievable by hash even after the guard applies", () => {
+ // tools:[] and unrelated tools are distinct caller shapes that must all be
+ // treated as non-MCP: an empty array and a foreign tool list both mean the
+ // retrieve tool is unreachable.
+ for (const label of ["empty tools array", "unrelated tools"] as const) {
+ it(`non-MCP caller with ${label}: CCR skips entirely`, () => {
+ resetCcrStore();
+ const tools =
+ label === "empty tools array"
+ ? []
+ : [
+ { type: "function", function: { name: "get_weather" } },
+ { type: "function", function: { name: "web_search" } },
+ ];
+ const body = { ...makeOpenCodeStyleRequestBody(), tools };
+ const result = ccrEngine.apply(body as Record, { stepConfig: {} });
+
+ assert.equal(result.compressed, false, `${label} must not compress`);
+ const messages = result.body.messages as Array<{ role: string; content: string }>;
+ assert.equal(messages[0].content, REPORTER_PROMPT, "prompt passes through verbatim");
+ assert.equal(messages.length, 1, "no protocol instruction injected");
+ });
+ }
+
+ // A malformed body (tools as a non-array, or entries of unexpected shape)
+ // must fail OPEN — no compression, never a throw into the request pipeline.
+ for (const malformed of [
+ { tools: "not-an-array" },
+ { tools: [null, 42, "x"] },
+ { tools: [{}, { type: "function" }] },
+ ]) {
+ it(`malformed tools payload (${JSON.stringify(malformed.tools)}): engine skips without throwing`, () => {
+ resetCcrStore();
+ const body = { ...makeOpenCodeStyleRequestBody(), ...malformed };
+ const result = ccrEngine.apply(body as Record, { stepConfig: {} });
+
+ assert.equal(result.compressed, false, "malformed tools must fail open (skip)");
+ const messages = result.body.messages as Array<{ role: string; content: string }>;
+ assert.equal(messages[0].content, REPORTER_PROMPT, "prompt passes through verbatim");
+ assert.equal(
+ getCcrStoreStats().entries,
+ 0,
+ "store must stay empty after a malformed-tools skip"
+ );
+ });
+ }
+
+ it("MCP-capable caller (tools[] advertises omniroute_ccr_retrieve): replacement still runs and stays retrievable", () => {
resetCcrStore();
- const body = makeOpenCodeStyleRequestBody();
+ const body = {
+ ...makeOpenCodeStyleRequestBody(),
+ tools: [{ type: "function", function: { name: "omniroute_ccr_retrieve" } }],
+ };
const result = ccrEngine.apply(body as Record, { stepConfig: {} });
+ assert.equal(result.compressed, true, "CCR still compresses for MCP-capable callers");
const messages = result.body.messages as Array<{ role: string; content: string }>;
- const compressedContent = messages[0].content;
+ // The protocol instruction is injected as a leading system message, so the
+ // compressed conversation is exactly: [instruction, original user message].
+ assert.equal(messages.length, 2, "instruction + user message");
+ assert.equal(messages[0].role, "system", "instruction is a leading system message");
+ assert.ok(
+ typeof messages[0].content === "string" && messages[0].content.length > 0,
+ "instruction content must be non-empty"
+ );
+ assert.ok(
+ messages[0].content.includes("omniroute_ccr_retrieve"),
+ "instruction must teach the retrieve tool contract"
+ );
+ const compressedContent = messages[1].content;
const match = compressedContent.match(/\[CCR retrieve hash=([0-9a-f]{24}) chars=\d+\]/);
- assert.ok(match, "compressed content must still contain a resolvable CCR marker");
- const hash = match![1];
- assert.equal(retrieveBlock(hash), REPORTER_PROMPT, "original prompt must be stored verbatim and retrievable");
+ assert.ok(match, "compressed content must contain a resolvable CCR marker");
+ assert.equal(
+ retrieveBlock(match![1]),
+ REPORTER_PROMPT,
+ "original prompt must be stored verbatim and retrievable"
+ );
});
});
diff --git a/tests/unit/compression/ccr-retrieval-ramp.test.ts b/tests/unit/compression/ccr-retrieval-ramp.test.ts
index 2b475e69bfb0..6e87f7b78773 100644
--- a/tests/unit/compression/ccr-retrieval-ramp.test.ts
+++ b/tests/unit/compression/ccr-retrieval-ramp.test.ts
@@ -78,7 +78,13 @@ describe("ccrEngine.apply — retrieval-aware compression (H8)", () => {
const block = (len: number) => "x".repeat(len);
const run = (content: string, retrievalRampFactor = 2) =>
ccrEngine.apply(
- { messages: [{ role: "user", content }] },
+ // The retrieve tool is advertised — this suite exercises the compression
+ // path itself (H8 ramp); without the tool declaration the #7746 guard
+ // skips the engine entirely.
+ {
+ messages: [{ role: "user", content }],
+ tools: [{ type: "function", function: { name: "omniroute_ccr_retrieve" } }],
+ },
{ stepConfig: { minChars: BASE, retrievalRampFactor }, principalId: P }
);
diff --git a/tests/unit/config-audit-persistence.test.ts b/tests/unit/config-audit-persistence.test.ts
new file mode 100644
index 000000000000..4bad88bc5db4
--- /dev/null
+++ b/tests/unit/config-audit-persistence.test.ts
@@ -0,0 +1,124 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-config-audit-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+process.env.DISABLE_SQLITE_AUTO_BACKUP = "true";
+
+const core = await import("../../src/lib/db/core.ts");
+const cleanup = await import("../../src/lib/db/cleanup.ts");
+const audit = await import("../../src/domain/configAudit.ts");
+
+type CountRow = { c: number };
+
+function resetStorage() {
+ core.resetDbInstance();
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+function countRows(): number {
+ const db = core.getDbInstance();
+ const row = db.prepare("SELECT COUNT(*) AS c FROM config_audit_log").get() as CountRow;
+ return row.c;
+}
+
+function insertOldRow(id: string, daysAgo: number) {
+ const db = core.getDbInstance();
+ const old = new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000).toISOString();
+ db.prepare(
+ `INSERT INTO config_audit_log
+ (id, timestamp, action, target, target_id, target_name, before_json, after_json, diff_json, source, note)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+ ).run(
+ id,
+ old,
+ "update",
+ "provider",
+ "p1",
+ "P1",
+ null,
+ null,
+ JSON.stringify({ added: [], removed: [], changed: [], isEmpty: true }),
+ "api",
+ null
+ );
+}
+
+test.beforeEach(() => {
+ resetStorage();
+});
+
+test.after(() => {
+ resetStorage();
+});
+
+test("recordChange persists to SQLite, not memory", () => {
+ const db = core.getDbInstance();
+ const tableRow = db
+ .prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='config_audit_log'")
+ .get() as CountRow;
+ assert.equal(tableRow.c, 1);
+
+ const e = audit.recordChange("update", "provider", "p1", "My Provider", { a: 1 }, { a: 2 }, "api", null);
+ assert.equal(countRows(), 1);
+
+ const { entries, total } = audit.getAuditLog({ target: "provider" });
+ assert.equal(total, 1);
+ assert.equal(entries[0].id, e.id);
+ assert.deepEqual(entries[0].diff.changed, [{ key: "a", from: 1, to: 2 }]);
+});
+
+test("pagination + filters read from SQLite", () => {
+ audit.recordChange("create", "combo", "c1", "C1", null, { models: ["m1"] }, "dashboard");
+ audit.recordChange("update", "combo", "c1", "C1", { models: ["m1"] }, { models: ["m1", "m2"] }, "api");
+
+ const { entries, total } = audit.getAuditLog({ target: "combo", limit: 1, offset: 0 });
+ assert.equal(total, 2);
+ assert.equal(entries.length, 1);
+});
+
+test("getRollbackState returns the before snapshot", () => {
+ const e = audit.recordChange("update", "policy", "pol1", "Pol", { x: 1 }, { x: 2 }, "api");
+ assert.deepEqual(audit.getRollbackState(e.id), { x: 1 });
+});
+
+test("computeDiff stays pure", () => {
+ const d = audit.computeDiff({ a: 1 }, { a: 2, b: 3 });
+ assert.deepEqual(d.added, ["b"]);
+ assert.deepEqual(d.changed, [{ key: "a", from: 1, to: 2 }]);
+});
+
+test("resetAuditLog clears persisted rows", () => {
+ audit.recordChange("update", "provider", "p1", "P1", { a: 1 }, { a: 2 }, "api");
+ assert.equal(countRows(), 1);
+ audit.resetAuditLog();
+ assert.equal(countRows(), 0);
+});
+
+test("cleanupConfigAudit prunes rows beyond retentionDays", async () => {
+ insertOldRow("audit-old", 40);
+ const r = await cleanup.cleanupConfigAudit(30);
+ assert.equal(r.deleted, 1);
+ assert.equal(countRows(), 0);
+});
+
+test("cleanupConfigAudit keeps recent rows within retention", async () => {
+ insertOldRow("audit-recent", 5);
+ const r = await cleanup.cleanupConfigAudit(30);
+ assert.equal(r.deleted, 0);
+ assert.equal(countRows(), 1);
+});
+
+test("runAutoCleanup includes a configAudit result", async () => {
+ insertOldRow("audit-old-2", 40);
+ const result = await cleanup.runAutoCleanup();
+ assert.ok(result.results.configAudit);
+ assert.equal(typeof result.results.configAudit.deleted, "number");
+ assert.equal(typeof result.results.configAudit.errors, "number");
+ assert.equal(result.results.configAudit.deleted, 1);
+ assert.equal(countRows(), 0);
+});
diff --git a/tests/unit/context-manager-purify-system-first.test.ts b/tests/unit/context-manager-purify-system-first.test.ts
new file mode 100644
index 000000000000..51c658231d0f
--- /dev/null
+++ b/tests/unit/context-manager-purify-system-first.test.ts
@@ -0,0 +1,91 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { compressContext } from "../../open-sse/services/contextManager.ts";
+
+/**
+ * Plan-A root fix for the 2026-08-22 tokenrouter 400s. purifyHistory() used to
+ * splice the `[Context compressed: …]` notice as a SECOND system-role message at
+ * index system.length; strict gateways (TokenRouter, xiaomi-mimo/mimo) reject any
+ * system message at index > 0 with HTTP 400 "System message must be at the
+ * beginning". The notice must now merge into the leading system/developer
+ * message — or prepend a single system message when none exists — so the output
+ * never contains a system role after index 0, for ANY provider.
+ */
+
+function bigTurn(n: number) {
+ return { role: "user", content: `turn ${n}: ${"x".repeat(4_000)}` };
+}
+
+function run(body: Record) {
+ // ~30k tokens of history vs a small target forces Layer-3 purify_history.
+ return compressContext(body, { maxTokens: 5_000, reserveTokens: 0 });
+}
+
+function systemIndices(messages: Array<{ role: string }>) {
+ return messages.map((m, i) => (m.role === "system" ? i : -1)).filter((i) => i >= 0);
+}
+
+test("purify_history merges dropped-notice into existing leading system message", () => {
+ const body = {
+ model: "any-model",
+ messages: [
+ { role: "system", content: "You are a helpful assistant." },
+ ...Array.from({ length: 12 }, (_, i) => bigTurn(i)),
+ ],
+ };
+ const result = run(body);
+ assert.equal(result.compressed, true);
+ const messages = (result.body as { messages: Array> }).messages;
+ assert.deepEqual(systemIndices(messages as Array<{ role: string }>).slice(1), []);
+ const first = messages[0];
+ assert.equal(first.role, "system");
+ const text = String(first.content);
+ assert.match(text, /Context compressed: \d+ earlier messages removed/);
+ assert.match(text, /You are a helpful assistant\./);
+});
+
+test("purify_history prepends a single system notice when no system message exists", () => {
+ const body = {
+ model: "any-model",
+ messages: Array.from({ length: 12 }, (_, i) => bigTurn(i)),
+ };
+ const result = run(body);
+ assert.equal(result.compressed, true);
+ const messages = (result.body as { messages: Array> }).messages;
+ assert.deepEqual(systemIndices(messages as Array<{ role: string }>), [0]);
+ assert.match(String(messages[0].content), /Context compressed: \d+ earlier messages removed/);
+});
+
+test("purify_history merges into leading developer message without adding a second one", () => {
+ const body = {
+ model: "any-model",
+ messages: [
+ { role: "developer", content: "dev instructions" },
+ ...Array.from({ length: 12 }, (_, i) => bigTurn(i)),
+ ],
+ };
+ const result = run(body);
+ assert.equal(result.compressed, true);
+ const messages = (result.body as { messages: Array> }).messages;
+ assert.deepEqual(
+ messages.filter((m) => m.role === "developer").length,
+ 1,
+ "exactly one developer message"
+ );
+ assert.match(String(messages[0].content), /Context compressed: \d+ earlier messages removed/);
+ assert.match(String(messages[0].content), /dev instructions/);
+});
+
+test("no compression means no notice and untouched history", () => {
+ const body = {
+ model: "any-model",
+ messages: [
+ { role: "system", content: "sys" },
+ { role: "user", content: "hi" },
+ ],
+ };
+ const result = run(body);
+ assert.equal(result.compressed, false);
+ const messages = (result.body as { messages: unknown[] }).messages;
+ assert.equal(messages.length, 2);
+});
diff --git a/tests/unit/context-manager.test.ts b/tests/unit/context-manager.test.ts
index 776a3cdc256c..de95d5b6f2d3 100644
--- a/tests/unit/context-manager.test.ts
+++ b/tests/unit/context-manager.test.ts
@@ -75,10 +75,15 @@ for (const modelId of HYPERAGENT_FALLBACK_MODEL_IDS) {
}
test("getTokenLimit: does not force 1M onto non-hyperagent providers serving the same model ids", () => {
- // windsurf declares an explicit per-model contextLength of 200000 for this exact id —
- // a provider-unscoped substring match on "claude-opus-4" would have clobbered it to 1M.
- assert.equal(getTokenLimit("windsurf", "claude-opus-4.7-max"), 200000);
- // bluesminds likewise pins its own claude-opus-4-5 entry to 200000.
+ // windsurf used to pin this exact id at 200000, but its built-in provider entry was
+ // retired (#8228 — replaced by devin-desktop). With no per-provider source left,
+ // #11034 resolves the effort-suffixed variant via its BASE model (`claude-opus-4.7-max`
+ // → `claude-opus-4.7` → canonical `claude-opus-4-7`), whose real catalog window IS 1M.
+ // This is a legitimate base-model resolution, not the forbidden hyperagent default leak:
+ // it comes from the shared model catalog, never from the hyperagent registry scope.
+ assert.equal(getTokenLimit("windsurf", "claude-opus-4.7-max"), 1_000_000);
+ // bluesminds still pins its own claude-opus-4-5 entry to 200000, and that pin must win
+ // over both the name heuristic and any 1M window from sibling providers/catalogs.
assert.equal(getTokenLimit("bluesminds", "claude-opus-4-5"), 200000);
});
diff --git a/tests/unit/db-providers-split.test.ts b/tests/unit/db-providers-split.test.ts
index 220544ba2d4f..284a5193c84d 100644
--- a/tests/unit/db-providers-split.test.ts
+++ b/tests/unit/db-providers-split.test.ts
@@ -52,26 +52,38 @@ describe("providers/columns — normalizeBooleanColumn", () => {
});
describe("providers/columns — sanitizeRateLimitOverrides", () => {
- it("returns null for nullish / non-object / array input", () => {
- assert.equal(sanitizeRateLimitOverrides(null), null);
- assert.equal(sanitizeRateLimitOverrides(undefined), null);
- assert.equal(sanitizeRateLimitOverrides("x"), null);
- assert.equal(sanitizeRateLimitOverrides([1, 2]), null);
+ it("returns {sanitized:null,rejected:[]} for nullish / non-object / array input", () => {
+ assert.deepEqual(sanitizeRateLimitOverrides(null), { sanitized: null, rejected: [] });
+ assert.deepEqual(sanitizeRateLimitOverrides(undefined), { sanitized: null, rejected: [] });
+ assert.deepEqual(sanitizeRateLimitOverrides("x"), { sanitized: null, rejected: [] });
+ assert.deepEqual(sanitizeRateLimitOverrides([1, 2]), { sanitized: null, rejected: [] });
});
- it("keeps only allowed keys with non-negative integers", () => {
- assert.deepEqual(sanitizeRateLimitOverrides({ rpm: 10, bogus: 5, tpm: -1 }), { rpm: 10 });
+ it("keeps only allowed keys with non-negative integers, reports the rest as rejected", () => {
+ assert.deepEqual(sanitizeRateLimitOverrides({ rpm: 10, bogus: 5, tpm: -1 }), {
+ sanitized: { rpm: 10 },
+ rejected: ["bogus", "tpm"],
+ });
});
- it("returns null when nothing valid remains", () => {
- assert.equal(sanitizeRateLimitOverrides({ rpm: 1.5, nope: 3 }), null);
+ it("returns {sanitized:null} when nothing valid remains, with rejected keys", () => {
+ assert.deepEqual(sanitizeRateLimitOverrides({ rpm: 1.5, nope: 3 }), {
+ sanitized: null,
+ rejected: ["rpm", "nope"],
+ });
});
});
describe("providers/columns — sanitizeQuotaWindowThresholds", () => {
- it("keeps only 0-100 integers", () => {
- assert.deepEqual(sanitizeQuotaWindowThresholds({ a: 50, b: 120, c: 0 }), { a: 50, c: 0 });
+ it("keeps only 0-100 integers, reports the rest as rejected", () => {
+ assert.deepEqual(sanitizeQuotaWindowThresholds({ a: 50, b: 120, c: 0 }), {
+ sanitized: { a: 50, c: 0 },
+ rejected: ["b"],
+ });
});
- it("returns null when empty", () => {
- assert.equal(sanitizeQuotaWindowThresholds({ a: 200 }), null);
+ it("returns {sanitized:null} when nothing valid remains, with rejected keys", () => {
+ assert.deepEqual(sanitizeQuotaWindowThresholds({ a: 200 }), {
+ sanitized: null,
+ rejected: ["a"],
+ });
});
});
diff --git a/tests/unit/empty-stream-no-content-8649.test.ts b/tests/unit/empty-stream-no-content-8649.test.ts
index e46157fbe174..918ae7c4c065 100644
--- a/tests/unit/empty-stream-no-content-8649.test.ts
+++ b/tests/unit/empty-stream-no-content-8649.test.ts
@@ -252,3 +252,68 @@ test("#8649 buildStreamErrorChunks-shaped error must not be rewritten as empty c
assert.match(text, /AI Model Not Found/);
assert.doesNotMatch(text, /Provider returned empty content/);
});
+
+test("#8649 a Responses compaction-only stream is real output, not empty content", async () => {
+ // Codex remote compaction V2: POST /v1/responses with a compaction_trigger
+ // input item completes with output = [{type:"compaction", encrypted_content}]
+ // and no assistant text. The watcher's content keys do not include
+ // encrypted_content, so the healthy stream was followed by a synthetic
+ // response.failed ("Provider returned empty content") — which strict
+ // Responses clients reject even after response.completed.
+ const text = await runClientStream(
+ [
+ `data: {"type":"response.in_progress"}\n\n`,
+ `event: response.created\ndata: ${JSON.stringify({
+ type: "response.created",
+ response: { id: "resp_cmp", status: "in_progress", output: [] },
+ })}\n\n`,
+ `event: response.completed\ndata: ${JSON.stringify({
+ type: "response.completed",
+ response: {
+ id: "resp_cmp",
+ status: "completed",
+ output: [
+ { id: "cmp_1", type: "compaction", encrypted_content: "gAAAAABencryptedpayload" },
+ ],
+ },
+ })}\n\n`,
+ ],
+ FORMATS.OPENAI_RESPONSES
+ );
+
+ assert.match(text, /"type":"compaction"/);
+ assert.doesNotMatch(
+ text,
+ /Provider returned empty content|response\.failed/,
+ "a completed compaction response must not be followed by a synthetic failure frame"
+ );
+});
+
+test("#8649 an encrypted-reasoning-only stream is still empty content", async () => {
+ // Inverse of the compaction carve-out: an encrypted reasoning item is not
+ // user-visible output. A turn that produces only a reasoning trace and no
+ // message/tool call is the fake-success shape this guard exists to catch.
+ const text = await runClientStream(
+ [
+ `event: response.created\ndata: ${JSON.stringify({
+ type: "response.created",
+ response: { id: "resp_r", status: "in_progress", output: [] },
+ })}\n\n`,
+ `event: response.completed\ndata: ${JSON.stringify({
+ type: "response.completed",
+ response: {
+ id: "resp_r",
+ status: "completed",
+ output: [{ id: "rs_1", type: "reasoning", encrypted_content: "gAAAAABencryptedtrace" }],
+ },
+ })}\n\n`,
+ ],
+ FORMATS.OPENAI_RESPONSES
+ );
+
+ assert.match(
+ text,
+ /response\.failed|Provider returned empty content/,
+ "a reasoning-only turn must keep tripping the empty-content guard"
+ );
+});
diff --git a/tests/unit/executor-kimi-web.test.ts b/tests/unit/executor-kimi-web.test.ts
index 85b01957dc74..43f894e63a5f 100644
--- a/tests/unit/executor-kimi-web.test.ts
+++ b/tests/unit/executor-kimi-web.test.ts
@@ -1,7 +1,7 @@
-// Tests for the international Kimi web executor (www.kimi.com Connect-RPC API).
+// Tests for the international Kimi web executor (www.kimi.ai Connect-RPC API).
//
// Previously this provider targeted kimi.moonshot.cn; that domain now redirects
-// every non-CN visitor to www.kimi.com, which uses a Connect-RPC streaming API.
+// every non-CN visitor to www.kimi.ai, which uses a Connect-RPC streaming API.
// These tests pin the parser behavior of the Connect envelope framing and the
// JSON event-delta extractor.
@@ -31,7 +31,7 @@ describe("KimiWebExecutor", () => {
assert.match(body.error.code, /HTTP_400|400/);
});
- it("execute targets www.kimi.com (not kimi.moonshot.cn)", async () => {
+ it("execute targets www.kimi.ai (not kimi.moonshot.cn)", async () => {
const executor = new mod.KimiWebExecutor();
let capturedUrl = "";
const originalFetch = globalThis.fetch;
diff --git a/tests/unit/gemini-to-claude-tool-name-case-9008.test.ts b/tests/unit/gemini-to-claude-tool-name-case-9008.test.ts
index 798e130bd6c4..99d655335ebf 100644
--- a/tests/unit/gemini-to-claude-tool-name-case-9008.test.ts
+++ b/tests/unit/gemini-to-claude-tool-name-case-9008.test.ts
@@ -18,8 +18,7 @@ const { claudeToGeminiRequest } =
await import("../../open-sse/translator/request/claude-to-gemini.ts");
const { openaiToGeminiRequest } =
await import("../../open-sse/translator/request/openai-to-gemini.ts");
-const { restoreClaudeToolName } =
- await import("../../open-sse/services/claudeCodeToolRemapper.ts");
+const { restoreClaudeToolName } = await import("../../open-sse/services/claudeCodeToolRemapper.ts");
function toolUseName(events: Array> | null): string | undefined {
const start = (events || []).find(
@@ -27,9 +26,7 @@ function toolUseName(events: Array> | null): string | un
e.type === "content_block_start" &&
(e.content_block as Record | undefined)?.type === "tool_use"
);
- return (start?.content_block as Record | undefined)?.name as
- | string
- | undefined;
+ return (start?.content_block as Record | undefined)?.name as string | undefined;
}
test("#9008 restoreClaudeToolName: preserves PascalCase from the request map", () => {
@@ -50,9 +47,13 @@ test("#9008 restoreClaudeToolName: maps lowercased upstream names back to declar
assert.equal(restoreClaudeToolName("websearch", map), "WebSearch");
});
-test("#9008 restoreClaudeToolName: still lowercases TitleCase when no request map (#7926)", () => {
- assert.equal(restoreClaudeToolName("Bash", null), "bash");
- assert.equal(restoreClaudeToolName("Read", undefined), "read");
+test("#9008 restoreClaudeToolName: keeps canonical TitleCase when no request map (#11085 live repro)", () => {
+ // Live-tested 2026-08-22 (glm via opencode-go → /v1/messages): the gateway
+ // echoed Bash/Read TitleCase and claude-to-openai ships no _toolNameMap;
+ // downcasing here made Claude Code reject its own tools. Legacy lowercase
+ // clients are protected by explicit alias maps instead of blind downcasing.
+ assert.equal(restoreClaudeToolName("Bash", null), "Bash");
+ assert.equal(restoreClaudeToolName("Read", undefined), "Read");
});
test("#9008 Gemini → Claude: PascalCase tool_use survives when upstream echoes TitleCase", () => {
diff --git a/tests/unit/glm-5.3-catalog-and-effort-tiers.test.ts b/tests/unit/glm-5.3-catalog-and-effort-tiers.test.ts
index d14c136e7b3a..5d927de02a8d 100644
--- a/tests/unit/glm-5.3-catalog-and-effort-tiers.test.ts
+++ b/tests/unit/glm-5.3-catalog-and-effort-tiers.test.ts
@@ -1,7 +1,7 @@
import test from "node:test";
import assert from "node:assert/strict";
-// GLM-5.3 support (released 2026-08-14, https://z.ai/blog/glm-5.3).
+// GLM-5.3 support (released 2026-08-14, https://docs.z.ai/guides/llm/glm-5.3).
//
// Upstream ships ONE model id (`glm-5.3`) — effort is a request parameter
// (`reasoning_effort`: low|high|max, default max) on the coding chat/completions
@@ -12,14 +12,15 @@ import assert from "node:assert/strict";
// beta header), the 5.3 tiers use the documented `reasoning_effort` param on the
// OpenAI coding transport.
//
-// Spec caveat: Z.ai has not yet published the default context window — 1M is
-// mirrored from GLM-5.2 (same base model) per operator decision; correct when
-// the official spec lands.
+// Z.AI documents a 1M context window and 128K maximum output.
-const { getRegistryEntry } = await import("../../open-sse/config/providerRegistry.ts");
+const { getRegistryEntry, REGISTRY } = await import("../../open-sse/config/providerRegistry.ts");
const { GlmExecutor } = await import("../../open-sse/executors/glm.ts");
const { MODEL_SPECS } = await import("../../src/shared/constants/modelSpecs.ts");
const { GLM_PRICING } = await import("../../src/shared/constants/pricing/shared-tiers.ts");
+const metadataRegistry = await import("../../src/lib/modelMetadataRegistry.ts");
+const { shouldExposeSyncedEffortVariants, SYNCED_EFFORT_SKIP_PROVIDERS } =
+ await import("../../open-sse/utils/syncedEffortVariants.ts");
const GLM_5_3_IDS = ["glm-5.3", "glm-5.3-high", "glm-5.3-low"] as const;
@@ -38,6 +39,87 @@ function modelIds(provider: string): string[] {
return (entry.models ?? []).map((m) => m.id);
}
+test("shared GLM providers keep their dedicated aliases instead of synthesizing another layer", () => {
+ for (const provider of ["glm", "glm-cn", "glmt"]) {
+ assert.ok(SYNCED_EFFORT_SKIP_PROVIDERS.has(provider), provider);
+ assert.equal(
+ shouldExposeSyncedEffortVariants({
+ id: `${provider}/glm-5.3`,
+ owned_by: provider,
+ capabilities: { effort_tiers: ["low", "high", "max"] },
+ }),
+ false,
+ provider
+ );
+ }
+ assert.equal(SYNCED_EFFORT_SKIP_PROVIDERS.has("zcode"), false);
+});
+
+test("GLM family detection covers numeric, Z1, and bare provider model ids", () => {
+ for (const modelId of [
+ "hf:zai-org/GLM-5.2",
+ "THUDM/GLM-Z1-32B-0414",
+ "THUDM/GLM-Z1-9B-0414",
+ "glm",
+ ]) {
+ assert.equal(metadataRegistry.isGlmFamilyModel(modelId), true, modelId);
+ }
+ assert.equal(metadataRegistry.isGlmFamilyModel("llama-3.3"), false);
+});
+
+test("catalog suppresses inferred tiers for every GLM registry entry without a provider contract", () => {
+ let audited = 0;
+ for (const [provider, entry] of Object.entries(REGISTRY)) {
+ for (const model of entry.models ?? []) {
+ if (!metadataRegistry.isGlmFamilyModel(model.id, model.name)) continue;
+ audited += 1;
+ const enriched = metadataRegistry.enrichCatalogModelEntry({
+ id: `${provider}/${model.id}`,
+ object: "model",
+ owned_by: provider,
+ root: model.id,
+ }) as Record;
+ const capabilities = enriched.capabilities as Record;
+ if (capabilities.supportsThinking === true) {
+ assert.deepEqual(
+ capabilities.effort_tiers,
+ model.supportedThinkingEfforts ?? [],
+ `${provider}/${model.id}`
+ );
+ } else {
+ assert.equal("effort_tiers" in capabilities, false, `${provider}/${model.id}`);
+ }
+ }
+ }
+ assert.ok(audited > 0);
+});
+
+test("catalog exposes only GLM effort tiers that each provider can route", () => {
+ const routedTiers = new Map([
+ ["glm-5.3", ["low", "high", "max"]],
+ ["glm-5.3-high", ["high"]],
+ ["glm-5.3-low", ["low"]],
+ ["glm-5.2", ["high", "max"]],
+ ["glm-5.2-high", ["high"]],
+ ["glm-5.2-max", ["max"]],
+ ]);
+
+ for (const provider of ["glm", "glm-cn", "glmt", "zcode"]) {
+ for (const model of getRegistryEntry(provider)!.models ?? []) {
+ const enriched = metadataRegistry.enrichCatalogModelEntry({
+ id: `${provider}/${model.id}`,
+ object: "model",
+ owned_by: provider,
+ root: model.id,
+ }) as Record;
+ const capabilities = enriched.capabilities as Record;
+ const expected = provider === "zcode" ? [] : (routedTiers.get(model.id) ?? []);
+ assert.equal(capabilities.supportsThinking, true, `${provider}/${model.id}`);
+ assert.deepEqual(capabilities.effort_tiers, expected, `${provider}/${model.id}`);
+ }
+ }
+});
+
for (const provider of ["glm", "glm-cn", "glmt"]) {
test(`${provider} advertises the GLM-5.3 base model and effort tiers (GLM_SHARED_MODELS)`, () => {
const ids = modelIds(provider);
diff --git a/tests/unit/http-status-unprocessable-entity.test.ts b/tests/unit/http-status-unprocessable-entity.test.ts
new file mode 100644
index 000000000000..636e0ebe37f1
--- /dev/null
+++ b/tests/unit/http-status-unprocessable-entity.test.ts
@@ -0,0 +1,7 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { HTTP_STATUS } from "../../open-sse/config/constants.ts";
+
+test("HTTP_STATUS declares UNPROCESSABLE_ENTITY as 422", () => {
+ assert.equal(HTTP_STATUS.UNPROCESSABLE_ENTITY, 422);
+});
diff --git a/tests/unit/is-local-provider-11091.test.ts b/tests/unit/is-local-provider-11091.test.ts
new file mode 100644
index 000000000000..e5adc57b15a6
--- /dev/null
+++ b/tests/unit/is-local-provider-11091.test.ts
@@ -0,0 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { isLocalProvider } from "../../open-sse/config/providerRegistry.ts";
+
+test("isLocalProvider detects RFC1918, CGNAT/Tailscale, and mDNS private hosts", () => {
+ // Local / loopback
+ assert.equal(isLocalProvider("http://localhost:11434/v1"), true);
+ assert.equal(isLocalProvider("http://127.0.0.1:11434/v1"), true);
+
+ // Docker 172.16/12
+ assert.equal(isLocalProvider("http://172.18.0.2:11434/v1"), true);
+
+ // RFC1918 LAN hosts (Issue #11091)
+ assert.equal(isLocalProvider("http://192.168.1.50:11434/v1"), true);
+ assert.equal(isLocalProvider("http://10.0.0.5:11434/v1"), true);
+
+ // Tailscale / CGNAT (100.64/10)
+ assert.equal(isLocalProvider("http://100.64.1.2:11434/v1"), true);
+
+ // Link-local (169.254/16)
+ assert.equal(isLocalProvider("http://169.254.1.1:11434/v1"), true);
+
+ // mDNS / private suffixes
+ assert.equal(isLocalProvider("http://studio.local:11434/v1"), true);
+ assert.equal(isLocalProvider("http://mybox.internal:11434/v1"), true);
+
+ // Public hosts (should be false)
+ assert.equal(isLocalProvider("https://api.openai.com/v1"), false);
+ assert.equal(isLocalProvider("https://api.anthropic.com/v1"), false);
+ assert.equal(isLocalProvider("http://8.8.8.8:8080/v1"), false);
+
+ // Fails open on missing or unparseable input (Issue #11091 review finding)
+ assert.equal(isLocalProvider(null), false);
+ assert.equal(isLocalProvider(undefined), false);
+ assert.equal(isLocalProvider(""), false);
+ assert.equal(isLocalProvider("not a url"), false);
+ assert.equal(isLocalProvider("file:///models"), false);
+});
diff --git a/tests/unit/kimi-partner-aff-links.test.ts b/tests/unit/kimi-partner-aff-links.test.ts
index 2592f03fa223..2db3c56636a0 100644
--- a/tests/unit/kimi-partner-aff-links.test.ts
+++ b/tests/unit/kimi-partner-aff-links.test.ts
@@ -7,9 +7,8 @@ import test from "node:test";
import assert from "node:assert/strict";
const providers = await import("../../src/shared/constants/providers.ts");
-const featuredProviders = await import(
- "../../src/app/(dashboard)/dashboard/providers/featuredProviders.ts"
-);
+const featuredProviders =
+ await import("../../src/app/(dashboard)/dashboard/providers/featuredProviders.ts");
const KIMI_CODING_AFF_URL = "https://www.kimi.com/code?aff=omniroute";
const KIMI_PLATFORM_AFF_URL = "https://platform.kimi.ai?aff=omniroute";
@@ -33,11 +32,11 @@ test("kimi-coding (Kimi Code CLI) top-of-page link: the Kimi Coding Plan aff lin
assert.equal(kimiCoding.website, KIMI_CODING_AFF_URL);
});
-test("kimi-web (Kimi Web) top-of-page link: the Kimi Coding Plan aff link (was the bare kimi.com domain)", () => {
+test("kimi-web (Kimi Web) top-of-page link: points to www.kimi.ai", () => {
const kimiWeb = providers.WEB_COOKIE_PROVIDERS["kimi-web"];
assert.ok(kimiWeb, "kimi-web must still exist in the web-cookie catalog");
assert.equal(kimiWeb.name, "Kimi Web", "display name is unchanged by the rename");
- assert.equal(kimiWeb.website, KIMI_CODING_AFF_URL);
+ assert.equal(kimiWeb.website, "https://www.kimi.ai");
});
test("kimi-coding-apikey (hidden, folds into kimi-coding card) also carries the aff link", () => {
@@ -69,8 +68,6 @@ test("no visible Kimi provider website field still points at the unattributed pl
test("runtime endpoints are untouched by the rename/aff-link changes (moonshot API base URL still api.moonshot.ai)", async () => {
// Guard against the aff-link change ever leaking into a runtime executor
// config — website is a UI navigation field only, never a fetch target.
- const registry = await import(
- "../../open-sse/config/providers/registry/moonshot/index.ts"
- );
+ const registry = await import("../../open-sse/config/providers/registry/moonshot/index.ts");
assert.equal(registry.moonshotProvider.baseUrl, "https://api.moonshot.ai/v1/chat/completions");
});
diff --git a/tests/unit/learned-reasoning-effort-caps.test.ts b/tests/unit/learned-reasoning-effort-caps.test.ts
new file mode 100644
index 000000000000..5d69a342c38f
--- /dev/null
+++ b/tests/unit/learned-reasoning-effort-caps.test.ts
@@ -0,0 +1,126 @@
+import { test, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+ REASONING_EFFORT_ORDER,
+ parseReasoningEffortEnum,
+ recordLearnedReasoningEffort,
+ getLearnedReasoningEffort,
+ __test_resetLearnedReasoningEffortCaps,
+} from "../../open-sse/services/learnedReasoningEffortCaps.ts";
+
+beforeEach(() => {
+ __test_resetLearnedReasoningEffortCaps();
+});
+
+after(() => {
+ __test_resetLearnedReasoningEffortCaps();
+});
+
+// ── REASONING_EFFORT_ORDER ──────────────────────────────────────────────────
+
+test("REASONING_EFFORT_ORDER is none < minimal < low < medium < high < xhigh < max", () => {
+ assert.deepEqual(REASONING_EFFORT_ORDER, [
+ "none",
+ "minimal",
+ "low",
+ "medium",
+ "high",
+ "xhigh",
+ "max",
+ ]);
+});
+
+// ── parseReasoningEffortEnum ────────────────────────────────────────────────
+
+test("parseReasoningEffortEnum extracts the real OVH 422 enum (backtick-quoted)", () => {
+ const err =
+ "Failed to deserialize the JSON body into the target type: reasoning_effort: " +
+ "unknown variant `xhigh`, expected one of `none`, `high`, `medium`, `low`, `minimal`";
+ assert.deepEqual(parseReasoningEffortEnum(err), ["none", "high", "medium", "low", "minimal"]);
+});
+
+test("parseReasoningEffortEnum extracts a bare comma/and-joined enum with annotations", () => {
+ const err =
+ "Unexpected reasoning effort high. Supported types are xhigh (default), medium, and low.";
+ assert.deepEqual(parseReasoningEffortEnum(err), ["xhigh", "medium", "low"]);
+});
+
+test("parseReasoningEffortEnum drops unrecognized tokens", () => {
+ const err = "expected one of `none`, `turbo`, `high`";
+ assert.deepEqual(parseReasoningEffortEnum(err), ["none", "high"]);
+});
+
+test("parseReasoningEffortEnum returns null for unrelated error text", () => {
+ assert.equal(parseReasoningEffortEnum("connection refused"), null);
+ assert.equal(parseReasoningEffortEnum(""), null);
+ assert.equal(parseReasoningEffortEnum(null), null);
+ assert.equal(parseReasoningEffortEnum(undefined), null);
+});
+
+test("parseReasoningEffortEnum returns null when the list has no recognized token", () => {
+ assert.equal(parseReasoningEffortEnum("expected one of `foo`, `bar`"), null);
+});
+
+// ── recordLearnedReasoningEffort / getLearnedReasoningEffort ───────────────
+
+test("records the highest recognized value from the accepted list", () => {
+ const learned = recordLearnedReasoningEffort("ovh", "qwen3-coder-30b-a3b-instruct", [
+ "none",
+ "high",
+ "medium",
+ "low",
+ "minimal",
+ ]);
+ assert.equal(learned, "high");
+ assert.equal(getLearnedReasoningEffort("ovh", "qwen3-coder-30b-a3b-instruct"), "high");
+});
+
+test("returns null and stores nothing when acceptedValues has no recognized token", () => {
+ const learned = recordLearnedReasoningEffort("acme", "model-x", ["foo", "bar"]);
+ assert.equal(learned, null);
+ assert.equal(getLearnedReasoningEffort("acme", "model-x"), null);
+});
+
+test("monotonic decrease: a later, higher accepted-list never ratchets the cap back up", () => {
+ recordLearnedReasoningEffort("acme", "model-x", ["none", "low", "medium"]);
+ const learned = recordLearnedReasoningEffort("acme", "model-x", [
+ "none",
+ "low",
+ "medium",
+ "high",
+ "xhigh",
+ ]);
+ assert.equal(learned, "medium");
+ assert.equal(getLearnedReasoningEffort("acme", "model-x"), "medium");
+});
+
+test("a later, lower accepted-list does ratchet the cap down", () => {
+ recordLearnedReasoningEffort("acme", "model-x", ["none", "low", "medium", "high"]);
+ const learned = recordLearnedReasoningEffort("acme", "model-x", ["none", "low"]);
+ assert.equal(learned, "low");
+ assert.equal(getLearnedReasoningEffort("acme", "model-x"), "low");
+});
+
+test("getLearnedReasoningEffort returns null for unknown provider+model", () => {
+ assert.equal(getLearnedReasoningEffort("acme", "unknown-model"), null);
+});
+
+test("getLearnedReasoningEffort is keyed case-insensitively on provider+model", () => {
+ recordLearnedReasoningEffort("OVH", "Qwen3-Coder-30B", ["none", "high"]);
+ assert.equal(getLearnedReasoningEffort("ovh", "qwen3-coder-30b"), "high");
+ assert.equal(getLearnedReasoningEffort("OVH", "QWEN3-CODER-30B"), "high");
+});
+
+test("different providers for the same model id have independent caps", () => {
+ recordLearnedReasoningEffort("ovh", "shared-model", ["none", "high"]);
+ assert.equal(getLearnedReasoningEffort("openrouter", "shared-model"), null);
+});
+
+test("handles empty/null provider or model gracefully", () => {
+ assert.equal(getLearnedReasoningEffort("", "m"), null);
+ assert.equal(getLearnedReasoningEffort("p", ""), null);
+ assert.equal(getLearnedReasoningEffort(null, "m"), null);
+ assert.equal(getLearnedReasoningEffort("p", null), null);
+ assert.equal(recordLearnedReasoningEffort("", "m", ["high"]), null);
+ assert.equal(recordLearnedReasoningEffort("p", "", ["high"]), null);
+});
diff --git a/tests/unit/local-redis-status.test.ts b/tests/unit/local-redis-status.test.ts
new file mode 100644
index 000000000000..956930664230
--- /dev/null
+++ b/tests/unit/local-redis-status.test.ts
@@ -0,0 +1,38 @@
+/**
+ * tests/unit/local-redis-status.test.ts
+ *
+ * Coverage for src/app/api/local/redis/status/route.ts:
+ * - The status endpoint must report OmniRoute as "connected" whenever the
+ * native REDIS_URL is reachable — not only when a Docker/Podman container
+ * is present. This is the production path used by this instance
+ * (redis on 127.0.0.1:6379, no container).
+ *
+ * Verified at the source-contract level (the route imports Next.js + the route
+ * guard, which is heavy to import in the native runner and would make the test
+ * environment-dependent on a live container runtime).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STATUS_SRC = path.resolve(__dirname, "../../src/app/api/local/redis/status/route.ts");
+const src = fs.readFileSync(STATUS_SRC, "utf8");
+
+test("redis status: reports running via REDIS_URL reachability, not only Docker", () => {
+ assert.ok(src.includes("parseRedisUrl"), "status route must parse REDIS_URL");
+ assert.ok(
+ src.includes("redisUrlReachable"),
+ "status route must probe REDIS_URL reachability"
+ );
+ assert.ok(
+ src.includes("redisUrlConfigured"),
+ "status route must report whether REDIS_URL is configured"
+ );
+ assert.ok(
+ src.includes("const running = container.running || redisUrlReachable;"),
+ "status route must treat a reachable native REDIS_URL as a connected state"
+ );
+});
diff --git a/tests/unit/local-rerank-logging.test.ts b/tests/unit/local-rerank-logging.test.ts
new file mode 100644
index 000000000000..3c6ec6279458
--- /dev/null
+++ b/tests/unit/local-rerank-logging.test.ts
@@ -0,0 +1,215 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-rerank-test-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const { invalidateDbCache } = await import("../../src/lib/db/readCache.ts");
+const { createProviderNode, createProviderConnection } =
+ await import("../../src/lib/db/providers.ts");
+const { getCallLogs, getCallLogById, waitForCallLogSaves } =
+ await import("../../src/lib/usage/callLogs.ts");
+const { POST } = await import("../../src/app/api/v1/rerank/route.ts");
+
+interface RerankSuccessResponse {
+ results: Array<{ index: number; relevance_score: number }>;
+}
+
+interface CallLogRow {
+ id: string;
+ model: string;
+ provider: string;
+ status: number;
+ error?: string;
+ connectionId?: string;
+}
+
+test.describe("Local rerank provider logging and fallback", () => {
+ const originalFetch = globalThis.fetch;
+
+ test.after(() => {
+ globalThis.fetch = originalFetch;
+ core.resetDbInstance();
+ try {
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ } catch {
+ // ignore
+ }
+ });
+
+ test("successfully logs local rerank calls and attaches metadata headers", async () => {
+ const now = new Date().toISOString();
+ await createProviderNode({
+ id: "vram",
+ name: "vram",
+ type: "openai",
+ prefix: "vram",
+ baseUrl: "http://127.0.0.1:8000/v1",
+ createdAt: now,
+ updatedAt: now,
+ });
+
+ await createProviderConnection({
+ id: "conn-vram-1",
+ provider: "vram",
+ authType: "apikey",
+ name: "vram-local",
+ apiKey: "test-token",
+ createdAt: now,
+ updatedAt: now,
+ });
+
+ invalidateDbCache("nodes");
+ invalidateDbCache("connections");
+
+ globalThis.fetch = async (url: string | URL | Request, init?: RequestInit) => {
+ assert.equal(String(url), "http://127.0.0.1:8000/v1/rerank");
+ const parsedBody = JSON.parse(String(init?.body || "{}"));
+ assert.equal(parsedBody.model, "BAAI/bge-reranker-v2-m3");
+ assert.equal(parsedBody.query, "test query");
+ assert.deepEqual(parsedBody.documents, ["doc1", "doc2"]);
+
+ return new Response(
+ JSON.stringify({
+ results: [
+ { index: 0, relevance_score: 0.95 },
+ { index: 1, relevance_score: 0.2 },
+ ],
+ }),
+ { status: 200, headers: { "Content-Type": "application/json" } }
+ );
+ };
+
+ const req = new Request("http://localhost:20128/api/v1/rerank", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ model: "vram/BAAI/bge-reranker-v2-m3",
+ query: "test query",
+ documents: ["doc1", "doc2"],
+ }),
+ });
+
+ const res = await POST(req, {} as Record);
+ assert.equal(res.status, 200);
+ assert.equal(res.headers.get("x-omniroute-provider"), "vram");
+ assert.equal(res.headers.get("x-omniroute-model"), "BAAI/bge-reranker-v2-m3");
+
+ const json = (await res.json()) as RerankSuccessResponse;
+ assert.equal(json.results.length, 2);
+
+ await waitForCallLogSaves(15000);
+
+ const logs = (await getCallLogs({ limit: 10 })) as unknown as CallLogRow[];
+ const logEntry = logs.find((l) => l.model === "vram/BAAI/bge-reranker-v2-m3");
+ assert.ok(logEntry, "Expected call log entry for local rerank");
+ assert.equal(logEntry.provider, "vram");
+ assert.equal(logEntry.status, 200);
+
+ const detail = await getCallLogById(logEntry.id);
+ assert.deepEqual(detail?.requestBody, {
+ model: "vram/BAAI/bge-reranker-v2-m3",
+ query: "test query",
+ documents: ["doc1", "doc2"],
+ });
+ assert.deepEqual(detail?.responseBody, {
+ results: [
+ { index: 0, relevance_score: 0.95 },
+ { index: 1, relevance_score: 0.2 },
+ ],
+ });
+ });
+
+ test("falls back from /v1/rerank to /rerank when local provider returns 404", async () => {
+ const now = new Date().toISOString();
+ await createProviderNode({
+ id: "infinity",
+ name: "infinity",
+ type: "openai",
+ prefix: "infinity",
+ baseUrl: "http://127.0.0.1:7997",
+ createdAt: now,
+ updatedAt: now,
+ });
+
+ await createProviderConnection({
+ id: "conn-infinity-1",
+ provider: "infinity",
+ authType: "apikey",
+ name: "infinity-local",
+ apiKey: "test-token",
+ createdAt: now,
+ updatedAt: now,
+ });
+
+ invalidateDbCache("nodes");
+ invalidateDbCache("connections");
+
+ const urlsAttempted: string[] = [];
+ globalThis.fetch = async (url: string | URL | Request) => {
+ urlsAttempted.push(String(url));
+ if (String(url).endsWith("/v1/rerank")) {
+ return new Response("Not Found", { status: 404 });
+ }
+ return new Response(
+ JSON.stringify({
+ results: [{ index: 0, relevance_score: 0.99 }],
+ }),
+ { status: 200, headers: { "Content-Type": "application/json" } }
+ );
+ };
+
+ const req = new Request("http://localhost:20128/api/v1/rerank", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ model: "infinity/bge-reranker-large",
+ query: "search",
+ documents: ["doc1"],
+ }),
+ });
+
+ const res = await POST(req, {} as Record);
+ assert.equal(res.status, 200);
+ assert.deepEqual(urlsAttempted, [
+ "http://127.0.0.1:7997/v1/rerank",
+ "http://127.0.0.1:7997/rerank",
+ ]);
+ });
+
+ test("records error call log when local provider returns 500", async () => {
+ globalThis.fetch = async () => {
+ return new Response(JSON.stringify({ detail: "Local backend failure" }), {
+ status: 500,
+ headers: { "Content-Type": "application/json" },
+ });
+ };
+
+ const req = new Request("http://localhost:20128/api/v1/rerank", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ model: "vram/BAAI/bge-reranker-v2-m3",
+ query: "test query",
+ documents: ["doc1"],
+ }),
+ });
+
+ const res = await POST(req, {} as Record);
+ assert.equal(res.status, 500);
+
+ await waitForCallLogSaves(15000);
+
+ const logs = (await getCallLogs({ limit: 10 })) as unknown as CallLogRow[];
+ const logEntry = logs.find(
+ (l) => l.model === "vram/BAAI/bge-reranker-v2-m3" && l.status === 500
+ );
+ assert.ok(logEntry, "Expected 500 call log entry for local rerank failure");
+ assert.equal(logEntry.provider, "vram");
+ assert.equal(logEntry.error, "Local backend failure");
+ });
+});
diff --git a/tests/unit/logfare-registry.test.ts b/tests/unit/logfare-registry.test.ts
new file mode 100644
index 000000000000..d5439cd1b23e
--- /dev/null
+++ b/tests/unit/logfare-registry.test.ts
@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { logfareProvider } from "../../open-sse/config/providers/registry/logfare/index.ts";
+
+const { APIKEY_PROVIDERS } = await import(
+ "../../src/shared/constants/providers.ts"
+);
+const { REGISTRY: providerRegistry } =
+ await import("../../open-sse/config/providerRegistry.ts");
+const { NAMED_OPENAI_STYLE_PROVIDERS, isNamedOpenAIStyleProvider } =
+ await import(
+ "../../src/app/api/providers/[id]/models/discovery/providerSets.ts"
+ );
+
+const SPEC = {
+ id: "logfare",
+ alias: "logfare",
+ name: "Logfare",
+ website: "https://logfare.ai",
+ chatUrl: "https://logfare.ai/v1/chat/completions",
+ modelsUrl: "https://logfare.ai/v1/models",
+};
+
+test("logfareProvider registry entry has correct configuration", () => {
+ assert.equal(logfareProvider.id, "logfare");
+ assert.equal(logfareProvider.alias, "logfare");
+ assert.equal(logfareProvider.format, "openai");
+ assert.equal(logfareProvider.executor, "default");
+ assert.equal(logfareProvider.baseUrl, SPEC.chatUrl);
+ assert.equal(logfareProvider.modelsUrl, SPEC.modelsUrl);
+ assert.equal(logfareProvider.authType, "apikey");
+ assert.equal(logfareProvider.authHeader, "bearer");
+ // Catalog is discovered live from /v1/models; no hardcoded seed.
+ assert.equal(logfareProvider.passthroughModels, true);
+ assert.equal(logfareProvider.models.length, 0);
+});
+
+test("APIKEY_PROVIDERS.logfare is registered with the canonical identity", () => {
+ const entry = APIKEY_PROVIDERS[SPEC.id];
+ assert.ok(entry, `APIKEY_PROVIDERS.${SPEC.id} must be defined`);
+ assert.equal(entry.id, SPEC.id);
+ assert.equal(entry.alias, SPEC.alias);
+ assert.equal(entry.name, SPEC.name);
+ assert.equal(entry.website, SPEC.website);
+ assert.equal(entry.hasFree, true);
+ assert.equal(typeof entry.freeNote, "string");
+ assert.equal(typeof entry.apiHint, "string");
+ assert.match(entry.color, /^#[0-9A-Fa-f]{6}$/);
+});
+
+test("providerRegistry exposes the OpenAI-compatible chat completions URL", () => {
+ assert.equal(providerRegistry[SPEC.id].baseUrl, SPEC.chatUrl);
+ assert.equal(providerRegistry[SPEC.id].modelsUrl, SPEC.modelsUrl);
+});
+
+test("logfare is classified as a named OpenAI-style provider (live-fetch path)", () => {
+ assert.ok(
+ NAMED_OPENAI_STYLE_PROVIDERS.has(SPEC.id),
+ "logfare must be in NAMED_OPENAI_STYLE_PROVIDERS for live /v1/models fetch"
+ );
+ assert.equal(isNamedOpenAIStyleProvider(SPEC.id), true);
+});
diff --git a/tests/unit/memory-system-first-6135.test.ts b/tests/unit/memory-system-first-6135.test.ts
index 7104007ae641..339f83792cf0 100644
--- a/tests/unit/memory-system-first-6135.test.ts
+++ b/tests/unit/memory-system-first-6135.test.ts
@@ -49,6 +49,11 @@ describe("injectMemory system-must-be-first (#6135)", () => {
it("flags xiaomi-mimo (and alias mimo) as system-must-be-first", () => {
assert.equal(systemMessageMustBeFirst("xiaomi-mimo"), true);
assert.equal(systemMessageMustBeFirst("mimo"), true);
+ // tokenrouter: confirmed live 2026-08-22 — mid-array system message
+ // (e.g. the purifyHistory compression notice) -> HTTP 400
+ // "System message must be at the beginning".
+ assert.equal(systemMessageMustBeFirst("tokenrouter"), true);
+ assert.equal(systemMessageMustBeFirst("TokenRouter"), true); // case-insensitive
// default: unlisted providers keep current (non-first-constrained) behavior
assert.equal(systemMessageMustBeFirst("anthropic"), false);
assert.equal(systemMessageMustBeFirst(null), false);
diff --git a/tests/unit/oauth-device-flow-11164.test.ts b/tests/unit/oauth-device-flow-11164.test.ts
new file mode 100644
index 000000000000..48cdb23b6406
--- /dev/null
+++ b/tests/unit/oauth-device-flow-11164.test.ts
@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+test("device code normalization handles camelCase, snake_case, and authUrl without returning undefined", () => {
+ const cases = [
+ {
+ input: { userCode: "ABCD-1234", verificationUri: "https://auth.example.com" },
+ expectedCode: "ABCD-1234",
+ expectedUri: "https://auth.example.com",
+ },
+ {
+ input: { user_code: "EFGH-5678", verification_uri: "https://auth.example.com/device" },
+ expectedCode: "EFGH-5678",
+ expectedUri: "https://auth.example.com/device",
+ },
+ {
+ input: { authUrl: "https://studio.example.com/auth" },
+ expectedCode: "",
+ expectedUri: "https://studio.example.com/auth",
+ },
+ ];
+
+ for (const c of cases) {
+ const userCode = c.input.userCode ?? c.input.user_code ?? "";
+ const verificationUri =
+ c.input.verificationUriComplete ??
+ c.input.verification_uri_complete ??
+ c.input.verificationUri ??
+ c.input.verification_uri ??
+ c.input.authUrl ??
+ c.input.url ??
+ "";
+
+ assert.equal(userCode, c.expectedCode);
+ assert.equal(verificationUri, c.expectedUri);
+ assert.notEqual(verificationUri, "undefined");
+ }
+});
diff --git a/tests/unit/ollama-404-model-lockout-11071.test.ts b/tests/unit/ollama-404-model-lockout-11071.test.ts
new file mode 100644
index 000000000000..f58c29c07b97
--- /dev/null
+++ b/tests/unit/ollama-404-model-lockout-11071.test.ts
@@ -0,0 +1,66 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-ollama-404-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const providersDb = await import("../../src/lib/db/providers.ts");
+const auth = await import("../../src/sse/services/auth.ts");
+const { hasPerModelQuota, isModelLocked } = await import("../../open-sse/services/accountFallback.ts");
+
+async function resetStorage() {
+ core.resetDbInstance();
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+test.after(() => {
+ core.resetDbInstance();
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+});
+
+test("hasPerModelQuota returns true for ollama-local and ollama providers", () => {
+ assert.equal(hasPerModelQuota("ollama-local"), true);
+ assert.equal(hasPerModelQuota("ollama"), true);
+});
+
+test("markAccountUnavailable locks only the missing model on a 404 from ollama-local", async () => {
+ await resetStorage();
+
+ const connection = await providersDb.createProviderConnection({
+ provider: "ollama-local",
+ authType: "none",
+ baseUrl: "http://127.0.0.1:11434/v1",
+ isActive: true,
+ });
+
+ const result = await auth.markAccountUnavailable(
+ connection.id,
+ 404,
+ "model 'model-b' not found",
+ "ollama-local",
+ "model-b"
+ );
+
+ assert.equal(result.shouldFallback, true);
+
+ // The missing model must be locked
+ assert.equal(isModelLocked("ollama-local", connection.id, "model-b"), true);
+
+ // The connection in DB must remain active / not marked unavailable for sibling models
+ const connInDb = await providersDb.getProviderConnectionById(connection.id);
+ assert.notEqual(connInDb?.testStatus, "unavailable", "connection should not be marked unavailable connection-wide on a 404 model-not-found error");
+
+ // getProviderCredentials must still serve sibling models
+ const selectedForSibling = await auth.getProviderCredentials(
+ "ollama-local",
+ null,
+ null,
+ "model-a"
+ );
+ assert.ok(selectedForSibling && !("allExpired" in selectedForSibling), "sibling model-a must still be selected on the same connection");
+});
diff --git a/tests/unit/opencode-empty-rejection-rotation.test.ts b/tests/unit/opencode-empty-rejection-rotation.test.ts
new file mode 100644
index 000000000000..784a4b83a747
--- /dev/null
+++ b/tests/unit/opencode-empty-rejection-rotation.test.ts
@@ -0,0 +1,416 @@
+import { describe, it, beforeEach, afterEach, before, after } from "node:test";
+import assert from "node:assert";
+import net from "node:net";
+import { OpencodeExecutor } from "../../open-sse/executors/opencode.ts";
+import type { ExecutorLog, ProviderCredentials } from "../../open-sse/executors/base.ts";
+import { resolveProxyForRequest } from "../../open-sse/utils/proxyFetch.ts";
+import {
+ isEmptyUpstreamRejection,
+ extractChatcmplId,
+} from "../../open-sse/executors/accountRotation.ts";
+
+/**
+ * Empty-upstream-rejection rotation (#design opencode-empty-rejection-rotation).
+ *
+ * An upstream 400 whose body carries no usable completion (the observed malformed
+ * envelope: `choices[0].message` with no error field, no real content,
+ * `finish_reason: null`) must be rotated/retried instead of propagated as a fatal
+ * success — that was killing subagent sessions. These tests pin the wiring:
+ *
+ * 1. A 400 empty rejection rotates to the next account (and its proxy).
+ * 2. The retry budget is bounded: +1 attempt for a single account, exactly N
+ * for an N-account all-empty run (propagate the last 400, never loop forever).
+ * 3. A 400 carrying a real error field (or non-empty content) still propagates
+ * immediately — no cooldown, no success, no rotation.
+ * 4. The 200/success path is never cloned or read (anti-bufferisation).
+ *
+ * The dispatch layer is mocked by stubbing globalThis.fetch (exactly what the
+ * #4954 proxy integration test does). Three throwaway TCP listeners stand in for
+ * the per-account proxies so runWithProxyContext's reachability probe passes.
+ */
+
+const log: ExecutorLog = { debug() {}, info() {}, warn() {}, error() {} };
+
+const ACCOUNT_A = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+const ACCOUNT_B = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+const ACCOUNT_C = "cccccccccccccccccccccccccccccccc";
+
+const EMPTY_BODY =
+ '{"id":"chatcmpl_44fn2g6e7kk","object":"chat.completion","created":1787419957,"model":"muse-spark-1.2-contributor-free","choices":[{"index":0,"message":{"role":"assistant"},"finish_reason":null}]}';
+const ERROR_BODY = JSON.stringify({
+ error: { message: "bad request", type: "invalid_request_error" },
+});
+
+let serverA: net.Server;
+let serverB: net.Server;
+let serverC: net.Server;
+let portA = 0;
+let portB = 0;
+let portC = 0;
+
+function listen(server: net.Server): Promise {
+ return new Promise((resolve) => {
+ server.listen(0, "127.0.0.1", () => {
+ resolve((server.address() as net.AddressInfo).port);
+ });
+ });
+}
+
+before(async () => {
+ serverA = net.createServer((s) => s.destroy());
+ serverB = net.createServer((s) => s.destroy());
+ serverC = net.createServer((s) => s.destroy());
+ portA = await listen(serverA);
+ portB = await listen(serverB);
+ portC = await listen(serverC);
+});
+
+after(() => {
+ serverA?.close();
+ serverB?.close();
+ serverC?.close();
+});
+
+function portFor(fp: string): number {
+ if (fp === ACCOUNT_A) return portA;
+ if (fp === ACCOUNT_B) return portB;
+ return portC;
+}
+
+/** `fingerprints` accounts; `proxied` is the subset that get a dedicated proxy
+ * (defaults to all). A proxy-less account shares the default egress. */
+function credentialsFor(
+ fingerprints: string[],
+ proxied: string[] = [...fingerprints]
+): ProviderCredentials {
+ return {
+ apiKey: null,
+ accessToken: null,
+ connectionId: "noauth",
+ providerSpecificData: {
+ fingerprints,
+ ...(proxied.length > 0 && {
+ accountProxies: proxied.map((fp) => ({
+ fingerprint: fp,
+ proxy: { type: "http", host: "127.0.0.1", port: portFor(fp) },
+ })),
+ }),
+ },
+ };
+}
+
+/** A Response subclass that counts clone() so we can assert the executor never
+ * buffers a 200/streaming response. Note: `clone()` returns a plain Response, so
+ * only `clone()` is reliably counted (a read on the clone hits the native
+ * method, not this override) — counting clones is the meaningful invariant. */
+class SpyResponse extends Response {
+ static clones = 0;
+ clone(): Response {
+ SpyResponse.clones++;
+ return super.clone();
+ }
+}
+
+interface PlanStep {
+ status: number;
+ body?: string;
+ throw?: Error;
+}
+
+describe("OpencodeExecutor empty-rejection rotation", () => {
+ let originalFetch: typeof globalThis.fetch;
+ let observed: Array<{ source: string; host: string | null; port: string | null }>;
+ const GUARD_FLAG = "NETWORK_ROTATION_SHARED_EGRESS_GUARD";
+ let savedGuardFlag: string | undefined;
+
+ beforeEach(() => {
+ originalFetch = globalThis.fetch;
+ observed = [];
+ SpyResponse.clones = 0;
+ savedGuardFlag = process.env[GUARD_FLAG];
+ delete process.env[GUARD_FLAG];
+ });
+
+ afterEach(() => {
+ globalThis.fetch = originalFetch;
+ if (savedGuardFlag === undefined) delete process.env[GUARD_FLAG];
+ else process.env[GUARD_FLAG] = savedGuardFlag;
+ });
+
+ function installFetch(plan: PlanStep[]) {
+ let call = 0;
+ globalThis.fetch = (async (input: RequestInfo | URL) => {
+ const url =
+ typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+ const resolved = resolveProxyForRequest(url);
+ observed.push({
+ source: resolved.source,
+ host: resolved.proxyUrl ? new URL(resolved.proxyUrl).hostname : null,
+ port: resolved.proxyUrl ? new URL(resolved.proxyUrl).port : null,
+ });
+ const step = plan[Math.min(call, plan.length - 1)];
+ call++;
+ if (step.throw) throw step.throw;
+ return new SpyResponse(step.body ?? JSON.stringify({ ok: step.status === 200 }), {
+ status: step.status,
+ headers: { "Content-Type": "application/json" },
+ });
+ }) as typeof globalThis.fetch;
+ }
+
+ /**
+ * Launches the executor. Asserts the predicate itself behaves (regression guard
+ * for the design's signature — the wiring tests below depend on it).
+ */
+ it("predicate matches the observed envelope and rejects real errors", () => {
+ assert.strictEqual(isEmptyUpstreamRejection(400, EMPTY_BODY), true);
+ assert.strictEqual(isEmptyUpstreamRejection(200, EMPTY_BODY), false);
+ assert.strictEqual(isEmptyUpstreamRejection(400, ERROR_BODY), false);
+ assert.strictEqual(extractChatcmplId(EMPTY_BODY), "chatcmpl_44fn2g6e7kk");
+ });
+
+ it("rotates to the next account on an empty 400 rejection (loop)", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([{ status: 400, body: EMPTY_BODY }, { status: 200 }]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A, ACCOUNT_B]),
+ log,
+ });
+
+ assert.strictEqual(
+ (result as { response: Response }).response.status,
+ 200,
+ "must rotate past the empty 400"
+ );
+ assert.ok(observed.length >= 2, "should have dispatched on a second account");
+ assert.ok(
+ observed.some((o) => o.port === String(portA)),
+ "first attempt on account A"
+ );
+ assert.ok(
+ observed.some((o) => o.port === String(portB)),
+ "rotated attempt on account B"
+ );
+ });
+
+ it("caps an all-empty N-account run at N attempts and propagates the last 400 intact", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([
+ { status: 400, body: EMPTY_BODY },
+ { status: 400, body: EMPTY_BODY },
+ { status: 400, body: EMPTY_BODY },
+ { status: 200 },
+ ]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A, ACCOUNT_B, ACCOUNT_C]),
+ log,
+ });
+
+ assert.strictEqual(
+ (result as { response: Response }).response.status,
+ 400,
+ "must propagate the last empty 400"
+ );
+ assert.strictEqual(observed.length, 3, "must NOT exceed N attempts (no infinite loop)");
+ assert.ok(SpyResponse.clones >= 1, "the empty 400 path must read the body to classify it");
+ const propagated = await (result as { response: Response }).response.clone().text();
+ assert.strictEqual(propagated, EMPTY_BODY, "propagated 400 body must stay intact");
+ for (const p of observed) {
+ assert.strictEqual(p.source, "context", "every dispatch must egress through a proxy context");
+ }
+ });
+
+ it("retries the same proxied account once when it is the only account", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([
+ { status: 400, body: EMPTY_BODY },
+ { status: 400, body: EMPTY_BODY },
+ ]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A]),
+ log,
+ });
+
+ assert.strictEqual((result as { response: Response }).response.status, 400);
+ assert.strictEqual(observed.length, 2, "exactly one bounded retry on the sole account");
+ assert.ok(
+ observed.every((o) => o.port === String(portA)),
+ "both attempts egress through the single account's proxy"
+ );
+ });
+
+ it("coexists with 429 rotation and 200 success in the same request", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([{ status: 429 }, { status: 400, body: EMPTY_BODY }, { status: 200 }]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A, ACCOUNT_B, ACCOUNT_C]),
+ log,
+ });
+
+ assert.strictEqual(
+ (result as { response: Response }).response.status,
+ 200,
+ "final response should succeed"
+ );
+ assert.strictEqual(observed.length, 3, "429 + empty-400 + success across three accounts");
+ assert.ok(
+ observed.some((o) => o.port === String(portA)),
+ "account A (429)"
+ );
+ assert.ok(
+ observed.some((o) => o.port === String(portB)),
+ "account B (empty 400)"
+ );
+ assert.ok(
+ observed.some((o) => o.port === String(portC)),
+ "account C (200)"
+ );
+ });
+
+ it("propagates a 400 carrying an error field immediately (no rotation)", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([{ status: 400, body: ERROR_BODY }]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A, ACCOUNT_B]),
+ log,
+ });
+
+ assert.strictEqual(
+ (result as { response: Response }).response.status,
+ 400,
+ "real error 400 must propagate"
+ );
+ assert.strictEqual(observed.length, 1, "must NOT rotate on a genuine error 400");
+ });
+
+ it("never clones or reads the body of a 200 via the loop", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([{ status: 200 }, { status: 200 }, { status: 200 }]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A, ACCOUNT_B, ACCOUNT_C]),
+ log,
+ });
+
+ assert.strictEqual((result as { response: Response }).response.status, 200);
+ assert.strictEqual(SpyResponse.clones, 0, "loop 200 must never be cloned");
+ });
+
+ it("retries once via the fast path when a direct account answers an empty 400", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([
+ { status: 400, body: EMPTY_BODY },
+ { status: 400, body: EMPTY_BODY },
+ ]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A], []),
+ log,
+ });
+
+ assert.strictEqual((result as { response: Response }).response.status, 400);
+ assert.strictEqual(observed.length, 2, "fast path must retry the direct account exactly once");
+ });
+
+ it("propagates the second 400 intact when the fast path retries and empty-rejects again", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([
+ { status: 400, body: EMPTY_BODY },
+ { status: 400, body: EMPTY_BODY },
+ ]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A], []),
+ log,
+ });
+
+ assert.strictEqual((result as { response: Response }).response.status, 400);
+ const propagated = await (result as { response: Response }).response.clone().text();
+ assert.strictEqual(propagated, EMPTY_BODY, "second rejection propagates with intact body");
+ assert.strictEqual(observed.length, 2, "exactly one retry, no loop");
+ });
+
+ it("never clones or reads the body of a 200 via the fast path", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([{ status: 200 }]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ credentials: credentialsFor([ACCOUNT_A], []),
+ log,
+ });
+
+ assert.strictEqual((result as { response: Response }).response.status, 200);
+ assert.strictEqual(SpyResponse.clones, 0, "fast path 200 must never be cloned");
+ });
+
+ it("rotates to a proxied account after a proxy-less account empty-rejects (shared-egress guard on by default)", async () => {
+ const exec = new OpencodeExecutor("opencode-zen");
+ installFetch([{ status: 400, body: EMPTY_BODY }, { status: 200 }]);
+
+ const result = await exec.execute({
+ model: "deepseek-v4-flash-free",
+ body: { messages: [{ role: "user", content: "hi" }], stream: false },
+ stream: false,
+ signal: null,
+ // A proxy-less, B proxied: B must still be tried and succeed.
+ credentials: credentialsFor([ACCOUNT_A, ACCOUNT_B], [ACCOUNT_B]),
+ log,
+ });
+
+ assert.strictEqual(
+ (result as { response: { status: number } }).response.status,
+ 200,
+ "the proxied account (B) must still be tried and must succeed"
+ );
+ assert.strictEqual(observed.length, 2, "exactly one empty rejection (A) then one success (B)");
+ assert.ok(
+ observed.some((o) => o.source === "direct"),
+ "first dispatch on the proxy-less account"
+ );
+ assert.ok(
+ observed.some((o) => o.port === String(portB)),
+ "rotated dispatch on the proxied account"
+ );
+ });
+});
diff --git a/tests/unit/opencode-v2-config-11070.test.ts b/tests/unit/opencode-v2-config-11070.test.ts
new file mode 100644
index 000000000000..71bd8a953781
--- /dev/null
+++ b/tests/unit/opencode-v2-config-11070.test.ts
@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const opencodeConfig = await import("../../src/shared/services/opencodeConfig.ts");
+
+test("buildOpenCodeConfigDocument includes both V1 (provider) and V2 (providers) definitions", () => {
+ const doc = opencodeConfig.buildOpenCodeConfigDocument({
+ baseUrl: "http://localhost:20128/v1",
+ apiKey: "{env:OMNIROUTE_API_KEY}",
+ models: ["auto/best-coding"],
+ });
+
+ assert.ok(doc.provider?.omniroute, "V1 provider.omniroute must be present");
+ assert.equal(doc.provider.omniroute.npm, "@ai-sdk/openai-compatible");
+ assert.equal(doc.provider.omniroute.options.baseURL, "http://localhost:20128/v1");
+
+ assert.ok(doc.providers?.omniroute, "V2 providers.omniroute must be present");
+ assert.equal(doc.providers.omniroute.package, "@opencode-ai/ai/providers/openai-compatible");
+ assert.equal(doc.providers.omniroute.settings.baseURL, "http://localhost:20128/v1");
+ assert.equal(doc.providers.omniroute.settings.apiKey, "{env:OMNIROUTE_API_KEY}");
+ assert.ok(doc.providers.omniroute.models["auto/best-coding"].limit, "V2 model limit must be present");
+});
+
+test("mergeOpenCodeConfig preserves existing properties and updates both provider and providers", () => {
+ const existing = {
+ $schema: "https://opencode.ai/config.json",
+ customField: "keep-me",
+ };
+
+ const merged = opencodeConfig.mergeOpenCodeConfig(existing, {
+ baseUrl: "http://localhost:20128/v1",
+ apiKey: "sk_test_key",
+ models: ["auto/best-coding"],
+ });
+
+ assert.equal(merged.customField, "keep-me");
+ assert.ok(merged.provider?.omniroute);
+ assert.ok(merged.providers?.omniroute);
+ assert.equal(merged.providers.omniroute.settings.apiKey, "sk_test_key");
+});
diff --git a/tests/unit/opencode-zen-go-shared-models.test.ts b/tests/unit/opencode-zen-go-shared-models.test.ts
index 8c3079ad1556..c1fb49e97d5f 100644
--- a/tests/unit/opencode-zen-go-shared-models.test.ts
+++ b/tests/unit/opencode-zen-go-shared-models.test.ts
@@ -24,3 +24,16 @@ test("every OPENCODE_ZEN_GO_SHARED_MODELS entry is present, unmodified, exactly
test("OPENCODE_ZEN_GO_SHARED_MODELS is frozen (no accidental cross-registry mutation)", () => {
assert.ok(Object.isFrozen(OPENCODE_ZEN_GO_SHARED_MODELS));
});
+
+test("referenced non-shared model ids remain present", () => {
+ const goIds = new Set(opencode_goProvider.models.map((m) => m.id));
+ const zenIds = new Set(opencode_zenProvider.models.map((m) => m.id));
+ for (const id of ["minimax-m3", "glm-5.1"]) {
+ assert.ok(goIds.has(id) || zenIds.has(id), `expected ${id} in go or zen`);
+ }
+});
+
+test("models[0] is the intended dashboard default", () => {
+ assert.equal(opencode_goProvider.models[0].id, "glm-5.2");
+ assert.equal(opencode_zenProvider.models[0].id, "big-pickle");
+});
diff --git a/tests/unit/perplexity-discovery-filter.test.ts b/tests/unit/perplexity-discovery-filter.test.ts
new file mode 100644
index 000000000000..853364674651
--- /dev/null
+++ b/tests/unit/perplexity-discovery-filter.test.ts
@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { PROVIDER_MODELS_CONFIG } from "../../src/app/api/providers/[id]/models/discovery/providerModelsConfig.ts";
+
+// Regression guard for #11060 — Perplexity's /v1/models endpoint lists the
+// Agent API catalog (vendor-prefixed ids like "anthropic/claude-fable-5"), but
+// chat requests always go to the classic /chat/completions endpoint, which only
+// accepts the Sonar family. Without a PROVIDER_MODELS_CONFIG entry, generic
+// model import pulled those agent-style ids into the connection's chat model
+// list and every routed request failed with 400 "Invalid model". The discovery
+// entry must exist and its parseResponse must keep only Sonar-family ids.
+
+test("perplexity has a discovery entry in PROVIDER_MODELS_CONFIG", () => {
+ const cfg = PROVIDER_MODELS_CONFIG.perplexity;
+ assert.ok(cfg, "expected a perplexity entry in PROVIDER_MODELS_CONFIG");
+ assert.equal(cfg.method, "GET");
+ assert.equal(cfg.url, "https://api.perplexity.ai/v1/models");
+ assert.equal(typeof cfg.parseResponse, "function");
+});
+
+test("perplexity parseResponse keeps only the Sonar family (#11060)", () => {
+ const cfg = PROVIDER_MODELS_CONFIG.perplexity;
+ const models = cfg.parseResponse({
+ object: "list",
+ data: [
+ { id: "anthropic/claude-fable-5", object: "model", owned_by: "anthropic" },
+ { id: "sonar-pro", object: "model", owned_by: "perplexity" },
+ { id: "sonar", object: "model", owned_by: "perplexity" },
+ ],
+ }) as Array<{ id: string }>;
+
+ assert.deepEqual(
+ models.map((model) => model.id),
+ ["sonar-pro", "sonar"]
+ );
+});
+
+test("perplexity parseResponse keeps every Sonar variant and drops non-Sonar ids", () => {
+ const cfg = PROVIDER_MODELS_CONFIG.perplexity;
+ const models = cfg.parseResponse({
+ data: [
+ { id: "sonar-deep-research" },
+ { id: "sonar-reasoning-pro" },
+ { id: "sonar-pro" },
+ { id: "sonar" },
+ { id: "openai/gpt-5" },
+ { id: "sonarish" },
+ ],
+ }) as Array<{ id: string }>;
+
+ assert.deepEqual(
+ models.map((model) => model.id),
+ ["sonar-deep-research", "sonar-reasoning-pro", "sonar-pro", "sonar"]
+ );
+});
+
+test("perplexity parseResponse tolerates empty and malformed payloads", () => {
+ const cfg = PROVIDER_MODELS_CONFIG.perplexity;
+ assert.deepEqual(cfg.parseResponse({ data: [] }), []);
+ assert.deepEqual(cfg.parseResponse(undefined), []);
+ assert.deepEqual(cfg.parseResponse({}), []);
+});
diff --git a/tests/unit/pollinations-api-key-required-11096.test.ts b/tests/unit/pollinations-api-key-required-11096.test.ts
new file mode 100644
index 000000000000..8b69fb833121
--- /dev/null
+++ b/tests/unit/pollinations-api-key-required-11096.test.ts
@@ -0,0 +1,11 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { providerAllowsOptionalApiKey } from "../../src/shared/constants/providers.js";
+
+test("pollinations provider requires an API key and does not allow optional API key", () => {
+ assert.equal(
+ providerAllowsOptionalApiKey("pollinations"),
+ false,
+ "pollinations must require an API key because anonymous completions are no longer supported"
+ );
+});
diff --git a/tests/unit/private-host-ip-parity-11122.test.ts b/tests/unit/private-host-ip-parity-11122.test.ts
new file mode 100644
index 000000000000..3fb4f1049012
--- /dev/null
+++ b/tests/unit/private-host-ip-parity-11122.test.ts
@@ -0,0 +1,135 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { isIP } from "node:net";
+import { fileURLToPath } from "node:url";
+
+import { build } from "esbuild";
+
+import { ipVersion, isPrivateHost } from "../../src/shared/network/privateHost.ts";
+
+// #11122 — that PR pointed `isLocalProvider()` at `isPrivateHost`, imported from
+// `outboundUrlGuard.ts` (which imports `node:net`). `open-sse/config/providerRegistry.ts` is in
+// the `ProviderDetailPageClient.tsx` graph, so the browser bundle broke and
+// media-page-client-browser-bundle.test.ts went red on release/v3.8.50. `isPrivateHost` moved
+// here to fix it; two things must hold for that move to be safe:
+// 1. `ipVersion` agrees with `node:net#isIP` on every input — a NARROWER match would classify
+// a private address as public and open the egress the guard exists to close.
+// 2. The module stays bundleable for the browser (no `node:*`, no `@/` alias).
+
+const REPO_ROOT = fileURLToPath(new URL("../..", import.meta.url));
+
+const LITERALS = [
+ // IPv4 — valid
+ "0.0.0.0",
+ "127.0.0.1",
+ "10.0.0.1",
+ "100.64.0.1",
+ "169.254.169.254",
+ "172.16.0.1",
+ "172.31.255.254",
+ "192.168.1.50",
+ "8.8.8.8",
+ "255.255.255.255",
+ // IPv4 — invalid spellings node rejects
+ "010.1.1.1",
+ "1.2.3.4.5",
+ "1.2.3",
+ "256.1.1.1",
+ "1.2.3.-1",
+ "1.2.3.4 ",
+ " 1.2.3.4",
+ "1.2.3.04",
+ // IPv6 — valid
+ "::",
+ "::1",
+ "fd00::1",
+ "fe80::1",
+ "fc00::abcd",
+ "2001:db8::1",
+ "2001:0db8:0000:0000:0000:0000:0000:0001",
+ "::ffff:192.168.1.1",
+ "::ffff:a9fe:a9fe",
+ "64:ff9b::8.8.8.8",
+ "fe80::1%eth0",
+ "fe80::1%25",
+ // IPv6 — invalid
+ ":::",
+ "2001:db8::1::2",
+ "fe80::1%",
+ "gggg::1",
+ "2001:db8:::1",
+ // not IP literals at all
+ "",
+ "localhost",
+ "studio.local",
+ "api.openai.com",
+ "0x7f.1",
+ "2130706433",
+ "..",
+ "999",
+];
+
+test("ipVersion matches node:net#isIP across IP literals and near-misses", () => {
+ for (const host of LITERALS) {
+ assert.equal(
+ ipVersion(host),
+ isIP(host),
+ `ipVersion disagreed with isIP for ${JSON.stringify(host)}`
+ );
+ }
+});
+
+test("ipVersion matches node:net#isIP across generated IPv4 permutations", () => {
+ const segments = ["0", "00", "01", "9", "10", "099", "127", "192", "255", "256", "300", ""];
+ for (const a of segments) {
+ for (const b of segments) {
+ const host = `${a}.${b}.${a}.${b}`;
+ assert.equal(ipVersion(host), isIP(host), `ipVersion disagreed with isIP for ${host}`);
+ }
+ }
+});
+
+test("ipVersion matches node:net#isIP across generated IPv6 permutations", () => {
+ const groups = ["", "0", "1", "abcd", "ffff", "fffff", "xyz"];
+ for (const g of groups) {
+ for (const host of [`${g}::1`, `::${g}`, `${g}:${g}::${g}`, `2001:db8::${g}`, `[${g}::1]`]) {
+ assert.equal(ipVersion(host), isIP(host), `ipVersion disagreed with isIP for ${host}`);
+ }
+ }
+});
+
+test("an over-long input is rejected rather than fed to the alternation", () => {
+ // The length guard is the ReDoS bound (AGENTS.md → "Regex Security"). Node agrees: no legal
+ // literal is this long, so the fast path costs no accuracy.
+ const long = `${"f".repeat(200)}::1`;
+ assert.equal(ipVersion(long), 0);
+ assert.equal(isIP(long), 0);
+});
+
+test("isPrivateHost keeps its verdicts after the move", () => {
+ for (const host of ["", "localhost", "127.0.0.1", "::1", "[::1]", "10.1.2.3", "192.168.0.15"]) {
+ assert.equal(isPrivateHost(host), true, `expected private: ${JSON.stringify(host)}`);
+ }
+ for (const host of ["api.openai.com", "8.8.8.8", "172.32.0.1", "2001:db8::1"]) {
+ assert.equal(isPrivateHost(host), false, `expected public: ${host}`);
+ }
+});
+
+test("privateHost stays browser-bundle safe", async () => {
+ // The direct guard for the regression: providerRegistry -> privateHost is in the
+ // ProviderDetailPageClient graph, so a `node:*` import here breaks the dashboard build.
+ await assert.doesNotReject(
+ build({
+ absWorkingDir: REPO_ROOT,
+ entryPoints: [
+ fileURLToPath(new URL("../../src/shared/network/privateHost.ts", import.meta.url)),
+ ],
+ bundle: true,
+ format: "esm",
+ logLevel: "silent",
+ platform: "browser",
+ tsconfig: "tsconfig.json",
+ write: false,
+ })
+ );
+});
diff --git a/tests/unit/provider-connections-quota-threshold.test.ts b/tests/unit/provider-connections-quota-threshold.test.ts
index 5caaeea36993..e7812557e994 100644
--- a/tests/unit/provider-connections-quota-threshold.test.ts
+++ b/tests/unit/provider-connections-quota-threshold.test.ts
@@ -106,18 +106,36 @@ test("updateProviderConnection with explicit null clears the column entirely", a
assert.ok(reread.quotaWindowThresholds === null || reread.quotaWindowThresholds === undefined);
});
-test("DB serializer drops out-of-range values silently", async () => {
- // The DB module sanitizes the map on the way in; values outside 0-100 or
- // non-integers are pruned. This is a defense in depth — the Zod schema
- // already rejects them at the API boundary, but the DB shouldn't trust.
- const created = await providersDb.createProviderConnection({
- provider: "codex",
- authType: "apikey",
- name: "Codex Sanitize",
- apiKey: "sk-san",
- quotaWindowThresholds: { window5h: 95, bogus: 999, fractional: 1.5 },
- });
- assert.deepEqual(created.quotaWindowThresholds, { window5h: 95 });
+test("DB serializer refuses out-of-range / invalid values instead of dropping silently", async () => {
+ // the DB module must refuse the write (throw) rather than
+ // silently prune invalid keys/values on the way in, so operator intent is
+ // never lost without an error. The Zod schema already rejects at the API
+ // boundary; this is defense in depth for direct DB writers (seed/scripts).
+ await assert.rejects(
+ () =>
+ providersDb.createProviderConnection({
+ provider: "codex",
+ authType: "apikey",
+ name: "Codex Sanitize",
+ apiKey: "sk-san",
+ quotaWindowThresholds: { window5h: 95, bogus: 999, fractional: 1.5 },
+ }),
+ /rejected keys/
+ );
+});
+
+test("DB serializer refuses unknown rate-limit override keys instead of dropping silently", async () => {
+ await assert.rejects(
+ () =>
+ providersDb.createProviderConnection({
+ provider: "codex",
+ authType: "apikey",
+ name: "Codex Sanitize RLO",
+ apiKey: "sk-san-2",
+ rateLimitOverrides: { rpm: 10, bogus: 999, tpm: -1 },
+ }),
+ /rejected keys/
+ );
});
test("updateProviderConnectionSchema accepts a valid window map", () => {
diff --git a/tests/unit/provider-error-rules-operator.test.ts b/tests/unit/provider-error-rules-operator.test.ts
new file mode 100644
index 000000000000..6f8c9e52ef81
--- /dev/null
+++ b/tests/unit/provider-error-rules-operator.test.ts
@@ -0,0 +1,135 @@
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+ getProviderErrorRuleMatch,
+ setOperatorProviderErrorRules,
+ resolveRuleMatchBody,
+ honorsRuleLockScope,
+ type OperatorProviderErrorRule,
+} from "../../open-sse/config/providerErrorRules.ts";
+
+describe("operator error rules", () => {
+ beforeEach(() => {
+ // Isolate each test from the settings-backed cache.
+ setOperatorProviderErrorRules(undefined);
+ });
+
+ it("operator rule overrides the catalog registry for a provider", () => {
+ const op: Record = {
+ nvidia: [{ status: 404, match: "Not found for account", scope: "model", cooldownMs: 1000 }],
+ };
+ const m = getProviderErrorRuleMatch("nvidia", 404, null, "Not found for account id 123", op);
+ assert.ok(m, "operator rule should match");
+ assert.equal(m.scope, "model");
+ assert.equal(m.cooldownMs, 1000);
+ });
+
+ it("operator rule wins even when a catalog rule would also match", () => {
+ const op: Record = {
+ openrouter: [{ status: 402, match: "credits exhausted", scope: "model" }],
+ };
+ const m = getProviderErrorRuleMatch("openrouter", 402, null, "credits exhausted on key", op);
+ assert.ok(m);
+ // Catalog rule for openrouter/402 uses scope "connection"; the operator
+ // override must take precedence.
+ assert.equal(m.scope, "model");
+ });
+
+ it("operator can reclassify a 401 before the global permanent rule", () => {
+ const op: Record = {
+ acme: [
+ { status: 401, match: "transient quota", scope: "connection", reason: "quota_exhausted" },
+ ],
+ };
+ const m = getProviderErrorRuleMatch("acme", 401, null, "transient quota — retry shortly", op);
+ assert.ok(m);
+ assert.equal(m.scope, "connection");
+ assert.equal(m.reason, "quota_exhausted");
+ });
+
+ it("unknown provider with no operator rule returns null (no throw)", () => {
+ const m = getProviderErrorRuleMatch("unknown-provider", 402, null, "anything");
+ assert.equal(m, null);
+ });
+
+ it("substring match is case-insensitive", () => {
+ const op: Record = {
+ nvidia: [{ status: 404, match: "NOT FOUND", scope: "model" }],
+ };
+ const m = getProviderErrorRuleMatch("nvidia", 404, null, "Body says Not Found Here", op);
+ assert.ok(m);
+ assert.equal(m.scope, "model");
+ });
+
+ it("status must match before the substring is considered", () => {
+ const op: Record = {
+ nvidia: [{ status: 404, match: "not found", scope: "model" }],
+ };
+ // 500 with the same body text must NOT match a 404 rule.
+ const m = getProviderErrorRuleMatch("nvidia", 500, null, "not found for account", op);
+ assert.equal(m, null);
+ });
+
+ it("without an operator override the catalog registry is intact", () => {
+ const m = getProviderErrorRuleMatch("openrouter", 402, null, "credits exhausted on key");
+ assert.ok(m);
+ assert.equal(m.scope, "connection");
+ assert.equal(m.cooldownMs, 2 * 60 * 1000);
+ });
+
+ it("reads the settings-backed cache via setOperatorProviderErrorRules", () => {
+ setOperatorProviderErrorRules({
+ nvidia: [{ status: 404, match: "Not found", scope: "model" }],
+ });
+ const m = getProviderErrorRuleMatch("nvidia", 404, null, "Not found for account");
+ assert.ok(m);
+ assert.equal(m.scope, "model");
+ // Provider key lookup is case-insensitive.
+ const m2 = getProviderErrorRuleMatch("NVIDIA", 404, null, "Not found here");
+ assert.ok(m2);
+ assert.equal(m2.scope, "model");
+ });
+
+ // Regression coverage for #11104's original gap: an operator rule for any
+ // provider outside the built-in FULL_TEXT_RULE_PROVIDERS/
+ // HONORS_RULE_LOCK_SCOPE_PROVIDERS allowlists was silently text-blind (only
+ // {code,type} reached the matcher) and had its declared scope dropped by the
+ // persistence layer. Declaring an operator rule for a provider must be
+ // sufficient by itself — no separate allowlist entry required.
+ describe("operator rule bypasses the built-in allowlists", () => {
+ it("resolveRuleMatchBody hands the full error text once an operator rule exists for the provider", () => {
+ setOperatorProviderErrorRules({
+ acme: [{ status: 404, match: "model withdrawn", scope: "model" }],
+ });
+ const body = resolveRuleMatchBody("acme", { code: "not_found" }, "Model withdrawn upstream");
+ assert.equal(body, "Model withdrawn upstream");
+ });
+
+ it("resolveRuleMatchBody keeps returning the structured error for a provider with no operator rule", () => {
+ const body = resolveRuleMatchBody("acme", { code: "not_found" }, "Model withdrawn upstream");
+ assert.deepEqual(body, { code: "not_found" });
+ });
+
+ it("honorsRuleLockScope is true once an operator rule exists for the provider", () => {
+ assert.equal(honorsRuleLockScope("acme"), false);
+ setOperatorProviderErrorRules({
+ acme: [{ status: 404, match: "model withdrawn", scope: "model" }],
+ });
+ assert.equal(honorsRuleLockScope("acme"), true);
+ });
+
+ it("an operator rule for a non-allowlisted provider matches on raw body text end to end", () => {
+ setOperatorProviderErrorRules({
+ acme: [{ status: 404, match: "model withdrawn", scope: "model" }],
+ });
+ const body = resolveRuleMatchBody(
+ "acme",
+ { code: "not_found" },
+ "Error: model withdrawn upstream"
+ );
+ const m = getProviderErrorRuleMatch("acme", 404, null, body);
+ assert.ok(m, "operator rule should match once resolveRuleMatchBody hands it the raw text");
+ assert.equal(m.scope, "model");
+ });
+ });
+});
diff --git a/tests/unit/provider-route-schemas.test.ts b/tests/unit/provider-route-schemas.test.ts
index ca61c4f28d0c..30b5d4bd8c26 100644
--- a/tests/unit/provider-route-schemas.test.ts
+++ b/tests/unit/provider-route-schemas.test.ts
@@ -5,17 +5,19 @@ const { createProviderSchema, providersBatchTestSchema } =
await import("../../src/shared/validation/schemas.ts");
const { providerAllowsOptionalApiKey } = await import("../../src/shared/constants/providers.ts");
-test("Pollinations is treated as a keyless-capable provider", () => {
- assert.equal(providerAllowsOptionalApiKey("pollinations"), true);
+// #11117: Pollinations no longer serves anonymous requests (401 without a key),
+// so it left EXPLICIT_OPTIONAL_APIKEY_PROVIDER_IDS — key is now required.
+test("Pollinations requires an API key", () => {
+ assert.equal(providerAllowsOptionalApiKey("pollinations"), false);
});
-test("createProviderSchema allows Pollinations without apiKey", () => {
+test("createProviderSchema rejects Pollinations without apiKey", () => {
const result = createProviderSchema.safeParse({
provider: "pollinations",
name: "Pollinations",
});
- assert.equal(result.success, true);
+ assert.equal(result.success, false);
});
test("providersBatchTestSchema accepts cloud-agent batch mode", () => {
diff --git a/tests/unit/providers-constants-split.test.ts b/tests/unit/providers-constants-split.test.ts
index 3eabac24bb96..e22b3fd4e835 100644
--- a/tests/unit/providers-constants-split.test.ts
+++ b/tests/unit/providers-constants-split.test.ts
@@ -25,7 +25,7 @@
// #10729) brings it to 229; Token Kiosk (gateways, #10722) — merged in the same
// merge-train batch — independently bumped the gateways family too, landing at 231; Freebuff
// (gateways, #10531) brings it to 232. #8864 moves uncloseai (gateways family) into
-// NOAUTH_PROVIDERS, dropping the APIKEY_PROVIDERS count to 231.
+// NOAUTH_PROVIDERS, dropping the APIKEY_PROVIDERS count to 231. Logfare (gateways, #10987) brings it back to 232.
import { test } from "node:test";
import assert from "node:assert/strict";
@@ -54,12 +54,12 @@ test("barrel still exports every catalog + key helpers", () => {
}
});
-test("APIKEY_PROVIDERS merges the 6 family files into 231 entries (no loss / no dup)", async () => {
+test("APIKEY_PROVIDERS merges the 6 family files into 232 entries (no loss / no dup)", async () => {
const keys = Object.keys((P as Record).APIKEY_PROVIDERS);
- assert.equal(keys.length, 231);
- assert.equal(new Set(keys).size, 231, "duplicate keys after spread-merge");
+ assert.equal(keys.length, 232);
+ assert.equal(new Set(keys).size, 232, "duplicate keys after spread-merge");
// the merged object's entry-count equals the sum of the 6 semantic family files; families are a
- // strict partition (every provider in exactly one), so the sum must be exactly 231.
+ // strict partition (every provider in exactly one), so the sum must be exactly 232.
const families: [string, string][] = [
["gateways", "APIKEY_PROVIDERS_GATEWAYS"],
["frontier-labs", "APIKEY_PROVIDERS_FRONTIER"],
@@ -79,7 +79,7 @@ test("APIKEY_PROVIDERS merges the 6 family files into 231 entries (no loss / no
seen.add(k);
}
}
- assert.equal(famTotal, 231, "families must partition all 231 providers");
+ assert.equal(famTotal, 232, "families must partition all 232 providers");
});
test("AI_PROVIDERS Proxy aggregates all sections; lookups resolve", () => {
diff --git a/tests/unit/providers-patch-400.test.ts b/tests/unit/providers-patch-400.test.ts
new file mode 100644
index 000000000000..8ec1cbdf3bc8
--- /dev/null
+++ b/tests/unit/providers-patch-400.test.ts
@@ -0,0 +1,42 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { updateProviderConnectionSchema } from "@/shared/validation/schemas/provider";
+
+test("PATCH rateLimitOverrides {rpm:\"60\"} coerces to a valid number", () => {
+ const r = updateProviderConnectionSchema.safeParse({ rateLimitOverrides: { rpm: "60" } });
+ assert.equal(r.success, true);
+});
+
+test("unknown key in rateLimitOverrides is rejected (no silent drop)", () => {
+ const r = updateProviderConnectionSchema.safeParse({ rateLimitOverrides: { rpm: 10, foo: 1 } });
+ assert.equal(r.success, false);
+ const flaggedFoo = r.error!.issues.some(
+ (i) => i.path.includes("foo") || (i as { keys?: string[] }).keys?.includes("foo") || i.message.includes("foo")
+ );
+ assert.ok(
+ flaggedFoo,
+ `expected an issue flagging "foo", got: ${JSON.stringify(r.error!.issues)}`
+ );
+});
+
+test("quotaWindowThresholds key longer than 64 chars is rejected", () => {
+ const r = updateProviderConnectionSchema.safeParse({
+ quotaWindowThresholds: { ["a".repeat(65)]: 50 },
+ });
+ assert.equal(r.success, false);
+});
+
+test("empty string rate limit value is rejected (coerce \"\"→0 trap)", () => {
+ const r = updateProviderConnectionSchema.safeParse({ rateLimitOverrides: { rpm: "" } });
+ assert.equal(r.success, false);
+});
+
+test("non-numeric rate limit value is rejected", () => {
+ const r = updateProviderConnectionSchema.safeParse({ rateLimitOverrides: { rpm: "60abc" } });
+ assert.equal(r.success, false);
+});
+
+test("quotaWindowThresholds value outside 0-100 is rejected", () => {
+ const r = updateProviderConnectionSchema.safeParse({ quotaWindowThresholds: { win: 101 } });
+ assert.equal(r.success, false);
+});
diff --git a/tests/unit/providers/uncloseai-noauth.test.ts b/tests/unit/providers-uncloseai-noauth.test.ts
similarity index 100%
rename from tests/unit/providers/uncloseai-noauth.test.ts
rename to tests/unit/providers-uncloseai-noauth.test.ts
diff --git a/tests/unit/quota-redis-store.test.ts b/tests/unit/quota-redis-store.test.ts
index 3b9d5ded4c03..5a5ae936dc88 100644
--- a/tests/unit/quota-redis-store.test.ts
+++ b/tests/unit/quota-redis-store.test.ts
@@ -20,6 +20,9 @@ import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-redis-store-"));
process.env.DATA_DIR = TEST_DATA_DIR;
@@ -282,3 +285,16 @@ test("redisQuotaStore: resetRedisQuotaStore resets the store singleton", async (
// After reset, a new instance is created
assert.ok(store2, "Should create new instance after reset");
});
+
+test("redis namespace prefix: quota store KEY_PREFIX derives from REDIS_KEY_PREFIX", () => {
+ const quotaSrc = fs.readFileSync(
+ path.resolve(__dirname, "../../src/lib/quota/redisQuotaStore.ts"),
+ "utf8"
+ );
+ assert.ok(
+ quotaSrc.includes('process.env.REDIS_KEY_PREFIX?.trim() || "omniroute:"') &&
+ quotaSrc.includes("const KEY_PREFIX = `") &&
+ quotaSrc.includes("quota`"),
+ "redisQuotaStore KEY_PREFIX must derive from REDIS_KEY_PREFIX env, defaulting to omniroute:quota"
+ );
+});
diff --git a/tests/unit/rate-limiter-redis-optional.test.ts b/tests/unit/rate-limiter-redis-optional.test.ts
index edbce9b53d7d..8f23f3eafeee 100644
--- a/tests/unit/rate-limiter-redis-optional.test.ts
+++ b/tests/unit/rate-limiter-redis-optional.test.ts
@@ -41,3 +41,14 @@ test("#2357 checkRateLimit falls back when REDIS_URL is unset", () => {
"checkRateLimit must route to the in-memory fallback when Redis is disabled"
);
});
+
+test("redis namespace prefix: rate limiter + auth cache keys are namespaced", () => {
+ assert.ok(
+ src.includes('process.env.REDIS_KEY_PREFIX?.trim() || "omniroute:"'),
+ "rateLimiter must read REDIS_KEY_PREFIX with an omniroute: default"
+ );
+ assert.ok(
+ src.includes("keyPrefix: REDIS_KEY_PREFIX"),
+ "rateLimiter must pass the prefix as the ioredis keyPrefix so all keys are namespaced"
+ );
+});
diff --git a/tests/unit/reasoning-cache.test.ts b/tests/unit/reasoning-cache.test.ts
index e13dfec7a95e..db538a803140 100644
--- a/tests/unit/reasoning-cache.test.ts
+++ b/tests/unit/reasoning-cache.test.ts
@@ -664,6 +664,7 @@ describe("Reasoning Replay Cache — Translator Replay", () => {
{
type: "reasoning",
content: [{ type: "reasoning_text", text: "Cached Chat continuation reasoning" }],
+ summary: [],
}
);
});
@@ -751,47 +752,70 @@ describe("Reasoning Replay Cache — Translator Replay", () => {
assert.equal(lookupReasoning(callId), "Authentic provider reasoning");
});
- it("should never cache Responses summaries or opaque plaintext companions", () => {
- for (const [suffix, reasoningItem] of [
- [
- "summary",
- {
- type: "reasoning",
- summary: [{ type: "summary_text", text: "Display-only summary" }],
- },
- ],
- [
- "mixed",
- {
- type: "reasoning",
- encrypted_content: "opaque-provider-state",
- content: [{ type: "reasoning_text", text: "Unsafe plaintext companion" }],
- summary: [{ type: "summary_text", text: "Display-only mixed summary" }],
- },
- ],
- ] as const) {
- clearReasoningCacheAll();
- const callId = `call_nonstream_${suffix}_reasoning`;
- const translated = translateNonStreamingResponse(
- {
- object: "response",
- model: "deepseek-v4-flash",
- output: [
- reasoningItem,
- { type: "function_call", call_id: callId, name: "read_file", arguments: "{}" },
- ],
- },
- FORMATS.OPENAI_RESPONSES,
- FORMATS.OPENAI
- ) as { choices?: Array<{ message?: Record }> };
- const message = translated.choices?.[0]?.message;
-
- assert.ok(message);
- assert.equal(message.reasoning_content, undefined);
- assert.ok(Array.isArray(message.reasoning_summary));
- assert.equal(cacheReasoningFromAssistantMessage(message, "deepseek", "deepseek-v4-flash"), 0);
- assert.equal(lookupReasoning(callId), null);
- }
+ it("preserves plaintext reasoning from a mixed plaintext + encrypted_content item (#10949)", () => {
+ clearReasoningCacheAll();
+ const callId = "call_nonstream_mixed_reasoning";
+ const translated = translateNonStreamingResponse(
+ {
+ object: "response",
+ model: "deepseek-v4-flash",
+ output: [
+ {
+ type: "reasoning",
+ content: [
+ {
+ type: "reasoning_text",
+ text: "Let me start by reading the directory to understand the structure of the corpus.",
+ },
+ ],
+ encrypted_content: "",
+ summary: [],
+ },
+ { type: "function_call", call_id: callId, name: "read_file", arguments: "{}" },
+ ],
+ },
+ FORMATS.OPENAI_RESPONSES,
+ FORMATS.OPENAI
+ ) as { choices?: Array<{ message?: Record }> };
+ const message = translated.choices?.[0]?.message;
+
+ assert.ok(message);
+ assert.equal(
+ message.reasoning_content,
+ "Let me start by reading the directory to understand the structure of the corpus."
+ );
+ assert.equal(cacheReasoningFromAssistantMessage(message, "deepseek", "deepseek-v4-flash"), 1);
+ assert.equal(
+ lookupReasoning(callId),
+ "Let me start by reading the directory to understand the structure of the corpus."
+ );
+ });
+
+ it("should never cache summary-only Responses reasoning", () => {
+ clearReasoningCacheAll();
+ const callId = "call_nonstream_summary_reasoning";
+ const translated = translateNonStreamingResponse(
+ {
+ object: "response",
+ model: "deepseek-v4-flash",
+ output: [
+ {
+ type: "reasoning",
+ summary: [{ type: "summary_text", text: "Display-only summary" }],
+ },
+ { type: "function_call", call_id: callId, name: "read_file", arguments: "{}" },
+ ],
+ },
+ FORMATS.OPENAI_RESPONSES,
+ FORMATS.OPENAI
+ ) as { choices?: Array<{ message?: Record }> };
+ const message = translated.choices?.[0]?.message;
+
+ assert.ok(message);
+ assert.equal(message.reasoning_content, undefined);
+ assert.ok(Array.isArray(message.reasoning_summary));
+ assert.equal(cacheReasoningFromAssistantMessage(message, "deepseek", "deepseek-v4-flash"), 0);
+ assert.equal(lookupReasoning(callId), null);
});
it("should preserve client-provided reasoning content", () => {
diff --git a/tests/unit/reasoning-effort-clamp-and-retry.test.ts b/tests/unit/reasoning-effort-clamp-and-retry.test.ts
new file mode 100644
index 000000000000..a97ac16df095
--- /dev/null
+++ b/tests/unit/reasoning-effort-clamp-and-retry.test.ts
@@ -0,0 +1,110 @@
+import { test, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { BaseExecutor } from "../../open-sse/executors/base.ts";
+import {
+ getLearnedReasoningEffort,
+ recordLearnedReasoningEffort,
+ __test_resetLearnedReasoningEffortCaps,
+} from "../../open-sse/services/learnedReasoningEffortCaps.ts";
+
+const OVH_422_BODY = JSON.stringify({
+ error: {
+ message:
+ "Failed to deserialize the JSON body into the target type: reasoning_effort: " +
+ "unknown variant `xhigh`, expected one of `none`, `high`, `medium`, `low`, `minimal`",
+ },
+});
+
+// Passthrough executor: returns the body unchanged so we assert on exactly what
+// base.ts sends upstream.
+class SimpleExecutor extends BaseExecutor {
+ constructor() {
+ super("openai-compatible-chat-eaff6869", {
+ baseUrls: ["https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/chat/completions"],
+ });
+ }
+ async transformRequest(_model: string, body: Record) {
+ return { ...body };
+ }
+}
+
+beforeEach(() => {
+ __test_resetLearnedReasoningEffortCaps();
+});
+
+after(() => {
+ __test_resetLearnedReasoningEffortCaps();
+});
+
+test("422 'unknown variant xhigh, expected one of ...' clamps reasoning_effort and retries once", async () => {
+ const executor = new SimpleExecutor();
+ const originalFetch = globalThis.fetch;
+ const capturedBodies: Record[] = [];
+
+ globalThis.fetch = async (_url: string | URL | Request, init: RequestInit = {}) => {
+ const body = JSON.parse(String(init.body));
+ capturedBodies.push(body);
+ if (capturedBodies.length === 1) {
+ return new Response(OVH_422_BODY, {
+ status: 422,
+ headers: { "Content-Type": "application/json" },
+ });
+ }
+ return new Response(JSON.stringify({ ok: true }), {
+ status: 200,
+ headers: { "Content-Type": "application/json" },
+ });
+ };
+
+ try {
+ const result = await executor.execute({
+ model: "qwen3-coder-30b-a3b-instruct",
+ body: { reasoning_effort: "xhigh" },
+ stream: false,
+ credentials: {},
+ });
+ assert.equal(capturedBodies.length, 2);
+ assert.equal(capturedBodies[0].reasoning_effort, "xhigh");
+ assert.equal(capturedBodies[1].reasoning_effort, "high");
+ assert.equal(
+ getLearnedReasoningEffort("openai-compatible-chat-eaff6869", "qwen3-coder-30b-a3b-instruct"),
+ "high"
+ );
+ assert.equal(result.response.status, 200);
+ } finally {
+ globalThis.fetch = originalFetch;
+ }
+});
+
+test("a second request for the same provider+model sends the learned value on the first try", async () => {
+ const executor = new SimpleExecutor();
+ const originalFetch = globalThis.fetch;
+ const capturedBodies: Record[] = [];
+
+ globalThis.fetch = async (_url: string | URL | Request, init: RequestInit = {}) => {
+ const body = JSON.parse(String(init.body));
+ capturedBodies.push(body);
+ return new Response(JSON.stringify({ ok: true }), {
+ status: 200,
+ headers: { "Content-Type": "application/json" },
+ });
+ };
+
+ try {
+ recordLearnedReasoningEffort(
+ "openai-compatible-chat-eaff6869",
+ "qwen3-coder-30b-a3b-instruct",
+ ["none", "high", "medium", "low", "minimal"]
+ );
+ await executor.execute({
+ model: "qwen3-coder-30b-a3b-instruct",
+ body: { reasoning_effort: "xhigh" },
+ stream: false,
+ credentials: {},
+ });
+ assert.equal(capturedBodies.length, 1);
+ assert.equal(capturedBodies[0].reasoning_effort, "high");
+ } finally {
+ globalThis.fetch = originalFetch;
+ }
+});
diff --git a/tests/unit/reasoning-effort-learned-capability.test.ts b/tests/unit/reasoning-effort-learned-capability.test.ts
new file mode 100644
index 000000000000..210a451341e5
--- /dev/null
+++ b/tests/unit/reasoning-effort-learned-capability.test.ts
@@ -0,0 +1,91 @@
+import { test, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { sanitizeReasoningEffortForProvider } from "../../open-sse/executors/base/reasoningEffort.ts";
+import {
+ recordLearnedReasoningEffort,
+ __test_resetLearnedReasoningEffortCaps,
+} from "../../open-sse/services/learnedReasoningEffortCaps.ts";
+
+beforeEach(() => {
+ __test_resetLearnedReasoningEffortCaps();
+});
+
+after(() => {
+ __test_resetLearnedReasoningEffortCaps();
+});
+
+test("unregistered/custom provider+model: no learned cap yet sends xhigh unchanged", () => {
+ const body = { reasoning_effort: "xhigh" };
+ const result = sanitizeReasoningEffortForProvider(
+ body,
+ "openai-compatible-chat-eaff6869",
+ "qwen3-coder-30b-a3b-instruct"
+ ) as { reasoning_effort: string };
+ assert.equal(result.reasoning_effort, "xhigh");
+});
+
+test("unregistered/custom provider+model: a learned cap clamps xhigh down to it", () => {
+ recordLearnedReasoningEffort("openai-compatible-chat-eaff6869", "qwen3-coder-30b-a3b-instruct", [
+ "none",
+ "high",
+ "medium",
+ "low",
+ "minimal",
+ ]);
+ const body = { reasoning_effort: "xhigh" };
+ const result = sanitizeReasoningEffortForProvider(
+ body,
+ "openai-compatible-chat-eaff6869",
+ "qwen3-coder-30b-a3b-instruct"
+ ) as { reasoning_effort: string };
+ assert.equal(result.reasoning_effort, "high");
+});
+
+test("learned cap only clamps when the requested effort is above it", () => {
+ recordLearnedReasoningEffort("acme", "model-x", ["none", "low", "medium"]);
+ const body = { reasoning_effort: "low" };
+ const result = sanitizeReasoningEffortForProvider(body, "acme", "model-x") as {
+ reasoning_effort: string;
+ };
+ assert.equal(result.reasoning_effort, "low");
+});
+
+test("registry says supportsXHighEffort:false (and no supportsMax path) with a learned cap below 'high': uses the learned cap, not the hardcoded 'high'", () => {
+ // claude-haiku-4-5 is registered with supportsXHighEffort:false
+ // (open-sse/config/providers/registry/claude/index.ts) and its family is
+ // excluded from supportsClaudeMaxEffort (CLAUDE_MAX_EFFORT_UNSUPPORTED_FAMILY_PATTERNS
+ // in providerModels.ts), so it reaches the hardcoded-"high" line today —
+ // a real registry-covered case. Teach a lower cap and confirm it wins.
+ recordLearnedReasoningEffort("claude", "claude-haiku-4-5-20251001", ["none", "low", "medium"]);
+ const body = { reasoning_effort: "xhigh" };
+ const result = sanitizeReasoningEffortForProvider(
+ body,
+ "claude",
+ "claude-haiku-4-5-20251001"
+ ) as {
+ reasoning_effort: string;
+ };
+ assert.equal(result.reasoning_effort, "medium");
+});
+
+test("registry says supportsXHighEffort:false with no learned cap: falls back to hardcoded 'high' (unchanged behavior)", () => {
+ const body = { reasoning_effort: "xhigh" };
+ const result = sanitizeReasoningEffortForProvider(
+ body,
+ "claude",
+ "claude-haiku-4-5-20251001"
+ ) as {
+ reasoning_effort: string;
+ };
+ assert.equal(result.reasoning_effort, "high");
+});
+
+test("deepseek's non-ordinal max<->xhigh translation is untouched by the learned-cap catch-all", () => {
+ recordLearnedReasoningEffort("deepseek", "deepseek-v4", ["none", "low"]);
+ const body = { reasoning_effort: "xhigh" };
+ const result = sanitizeReasoningEffortForProvider(body, "deepseek", "deepseek-v4") as {
+ reasoning_effort: string;
+ };
+ // deepseek's special case returns early — xhigh -> max, never reaches the catch-all.
+ assert.equal(result.reasoning_effort, "max");
+});
diff --git a/tests/unit/reasoning-input-policy-summary-11108.test.ts b/tests/unit/reasoning-input-policy-summary-11108.test.ts
new file mode 100644
index 000000000000..4317225dfb2b
--- /dev/null
+++ b/tests/unit/reasoning-input-policy-summary-11108.test.ts
@@ -0,0 +1,145 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+const { applyReasoningInputPolicy } =
+ await import("../../open-sse/services/reasoningInputPolicy.ts");
+
+test("#11108 applyReasoningInputPolicy defaults summary on a kept opaque reasoning item", () => {
+ const body: Record = {
+ input: [
+ {
+ type: "reasoning",
+ id: "rs_example",
+ encrypted_content: "opaque-blob",
+ },
+ ],
+ };
+
+ applyReasoningInputPolicy(body, "responses", {
+ provider: "opencode",
+ preserveEncryptedReasoning: true,
+ });
+
+ const input = body.input as Record[];
+ assert.equal(input.length, 1);
+ assert.deepEqual(input[0].summary, []);
+});
+
+test("#11108 applyReasoningInputPolicy preserves an existing summary on a kept reasoning item", () => {
+ const body: Record = {
+ input: [
+ {
+ type: "reasoning",
+ id: "rs_example",
+ encrypted_content: "opaque-blob",
+ summary: [{ type: "summary_text", text: "Planning." }],
+ },
+ ],
+ };
+
+ applyReasoningInputPolicy(body, "responses", {
+ provider: "opencode",
+ preserveEncryptedReasoning: true,
+ });
+
+ const input = body.input as Record[];
+ assert.deepEqual(input[0].summary, [{ type: "summary_text", text: "Planning." }]);
+});
+
+test("#11108 applyReasoningInputPolicy defaults summary on an opaque item surviving incompatible-drop", () => {
+ // Mixed item (plaintext + opaque) on an opaque-only transport is incompatible;
+ // dropIncompatibleResponsesReasoning() strips the plaintext content but keeps
+ // the opaque item alive — it must still get a default `summary`.
+ const body: Record = {
+ input: [
+ {
+ type: "reasoning",
+ id: "rs_mixed",
+ content: [{ type: "reasoning_text", text: "inspect first" }],
+ encrypted_content: "opaque-blob",
+ },
+ ],
+ };
+
+ const result = applyReasoningInputPolicy(body, "responses", {
+ provider: "codex",
+ onIncompatibleReasoning: "drop",
+ });
+
+ assert.equal(result.incompatibleReasoning, false);
+ const input = body.input as Record[];
+ assert.equal(input.length, 1);
+ assert.equal(input[0].content, undefined);
+ assert.equal(input[0].encrypted_content, "opaque-blob");
+ assert.deepEqual(input[0].summary, []);
+});
+
+test("#11108 applyReasoningInputPolicy strips a non-string id on a kept opaque reasoning item", () => {
+ // Same gap class as the summary fix above: opencode/zen also omits `id`
+ // entirely (surfaced by the client as `id: null`) on opaque-only reasoning
+ // items instead of a `rs_...` string. Replaying that shape verbatim trips
+ // strict Responses-API validators with "Expected 'id' to be a string."
+ const body: Record = {
+ input: [
+ {
+ type: "reasoning",
+ id: null,
+ encrypted_content: "opaque-blob",
+ },
+ ],
+ };
+
+ applyReasoningInputPolicy(body, "responses", {
+ provider: "opencode",
+ preserveEncryptedReasoning: true,
+ });
+
+ const input = body.input as Record[];
+ assert.equal(input.length, 1);
+ assert.equal("id" in input[0], false);
+});
+
+test("#11108 applyReasoningInputPolicy strips a non-string id on a non-reasoning item (function_call)", () => {
+ // Same gap class, generic branch: any non-"reasoning" input item (function_call,
+ // message, ...) only stripped `id` when it was already a valid string, so a
+ // malformed `id` (e.g. `null`, mirroring the opencode/zen omission pattern)
+ // on a function_call item survived replay untouched.
+ const body: Record = {
+ input: [
+ {
+ type: "function_call",
+ id: null,
+ call_id: "call_abc",
+ name: "bash",
+ arguments: "{}",
+ },
+ ],
+ };
+
+ applyReasoningInputPolicy(body, "responses", { provider: "opencode" });
+
+ const input = body.input as Record[];
+ assert.equal(input.length, 1);
+ assert.equal("id" in input[0], false);
+ assert.equal(input[0].call_id, "call_abc");
+});
+
+test("#11108 applyReasoningInputPolicy preserves a valid string id on a kept opaque reasoning item", () => {
+ const body: Record = {
+ input: [
+ {
+ type: "reasoning",
+ id: "rs_example",
+ encrypted_content: "opaque-blob",
+ },
+ ],
+ };
+
+ applyReasoningInputPolicy(body, "responses", {
+ provider: "opencode",
+ preserveEncryptedReasoning: true,
+ });
+
+ const input = body.input as Record[];
+ assert.equal(input[0].id, "rs_example");
+});
diff --git a/tests/unit/remove-hackclub-11118.test.ts b/tests/unit/remove-hackclub-11118.test.ts
new file mode 100644
index 000000000000..9dc39fe1b32d
--- /dev/null
+++ b/tests/unit/remove-hackclub-11118.test.ts
@@ -0,0 +1,7 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { REGISTRY } from "../../open-sse/config/providers/index.ts";
+
+test("hackclub provider is removed from REGISTRY", () => {
+ assert.equal("hackclub" in REGISTRY, false);
+});
diff --git a/tests/unit/responses-input-sanitizer-name.test.ts b/tests/unit/responses-input-sanitizer-name.test.ts
index 7ac09604c7bc..4eec2d6c10e0 100644
--- a/tests/unit/responses-input-sanitizer-name.test.ts
+++ b/tests/unit/responses-input-sanitizer-name.test.ts
@@ -73,6 +73,23 @@ test("keeps valid server reasoning item ids", () => {
assert.equal(result[0].id, "rs_123");
});
+test("strips a non-string reasoning item id instead of passing it through (#11108)", () => {
+ // Same gap class fixed in reasoningInputPolicy.ts: some upstreams (e.g.
+ // opencode/zen) send `id: null` instead of omitting it. The previous
+ // `typeof record.id !== "string"` guard returned the record unchanged in
+ // that case, letting a malformed id reach a strict Responses-API upstream.
+ const items = [
+ {
+ id: null,
+ type: "reasoning",
+ summary: [{ type: "summary_text", text: "cached reasoning" }],
+ },
+ ];
+ const result = sanitizeResponsesInputItems(items) as Array>;
+ assert.equal("id" in result[0], false);
+ assert.equal(result[0].type, "reasoning");
+});
+
test("normalizes user image_url content parts to input_image", () => {
const items = [
{
diff --git a/tests/unit/responses-parallel-tool-calls-index.test.ts b/tests/unit/responses-parallel-tool-calls-index.test.ts
new file mode 100644
index 000000000000..f825f8700bac
--- /dev/null
+++ b/tests/unit/responses-parallel-tool-calls-index.test.ts
@@ -0,0 +1,294 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const { openaiResponsesToOpenAIResponse } =
+ await import("../../open-sse/translator/response/openai-responses.ts");
+
+// Issue: 2+ `function_call` items opened (response.output_item.added) before any of
+// them closes (response.output_item.done) — a genuine parallel tool-call dispatch —
+// causes `state.toolCallIndex` (only incremented in the `.done` handler) to stay at 0
+// for every "added" header chunk. Clients that key their tool-call accumulator by
+// `delta.tool_calls[].index` (e.g. opencode's github-copilot chat-language-model
+// stream parser) then see the *first* `.done` argument chunk at index 1/2 with no
+// prior header and no `id`, and throw "Expected 'id' to be a string."
+test("Responses -> OpenAI: parallel function_call items get distinct index+id on the added header", () => {
+ const state = {};
+
+ const added0 = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_0", name: "task" },
+ },
+ state
+ );
+ const added1 = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_1", name: "task" },
+ },
+ state
+ );
+ const added2 = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_2", name: "task" },
+ },
+ state
+ );
+
+ const headers = [added0, added1, added2].map((r) => r.choices[0].delta.tool_calls[0]);
+
+ assert.deepEqual(
+ headers.map((h) => h.index),
+ [0, 1, 2],
+ "each parallel tool call must get its own header index, not all 0"
+ );
+ assert.deepEqual(
+ headers.map((h) => h.id),
+ ["call_0", "call_1", "call_2"]
+ );
+
+ const done0 = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_0", name: "task", arguments: '{"i":0}' },
+ },
+ state
+ );
+ const done1 = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_1", name: "task", arguments: '{"i":1}' },
+ },
+ state
+ );
+ const done2 = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_2", name: "task", arguments: '{"i":2}' },
+ },
+ state
+ );
+
+ assert.deepEqual(
+ [done0, done1, done2].map((r) => r.choices[0].delta.tool_calls[0].index),
+ [0, 1, 2],
+ "argument chunks must reuse the SAME index assigned at .added time for each call_id"
+ );
+});
+
+test("Responses -> OpenAI: parallel calls closed out of order keep their own index", () => {
+ const state = {};
+
+ for (const callId of ["call_a", "call_b", "call_c"]) {
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: callId, name: "task" },
+ },
+ state
+ );
+ }
+
+ // Close in reverse order: c, then a, then b.
+ const doneC = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_c", name: "task", arguments: "{}" },
+ },
+ state
+ );
+ const doneA = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_a", name: "task", arguments: "{}" },
+ },
+ state
+ );
+ const doneB = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_b", name: "task", arguments: "{}" },
+ },
+ state
+ );
+
+ assert.equal(doneC.choices[0].delta.tool_calls[0].index, 2);
+ assert.equal(doneA.choices[0].delta.tool_calls[0].index, 0);
+ assert.equal(doneB.choices[0].delta.tool_calls[0].index, 1);
+});
+
+test("Responses -> OpenAI: argument deltas interleaved across 2 parallel calls do not get glued together", () => {
+ const state = {};
+
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_x", name: "Read", id: "fc_call_x" },
+ },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_y", name: "Read", id: "fc_call_y" },
+ },
+ state
+ );
+
+ // Interleave argument deltas by item_id — x, y, x, y — before either closes.
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", item_id: "fc_call_x", delta: '{"filePath"' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", item_id: "fc_call_y", delta: '{"filePath"' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", item_id: "fc_call_x", delta: ':"/a.txt"}' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", item_id: "fc_call_y", delta: ':"/b.txt"}' },
+ state
+ );
+
+ const doneX = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_x", name: "Read" },
+ },
+ state
+ );
+ const doneY = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_y", name: "Read" },
+ },
+ state
+ );
+
+ assert.equal(doneX.choices[0].delta.tool_calls[0].function.arguments, '{"filePath":"/a.txt"}');
+ assert.equal(doneY.choices[0].delta.tool_calls[0].function.arguments, '{"filePath":"/b.txt"}');
+});
+
+test("Responses -> OpenAI: a deferred (nameless) call that never resolves a name never consumes an index", () => {
+ const state = {};
+
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_deferred", name: "" },
+ },
+ state
+ );
+ const done = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_deferred", name: " " },
+ },
+ state
+ );
+
+ assert.equal(done, null);
+ assert.equal(state.toolCallIndex, 0);
+});
+
+test("Responses -> OpenAI: argument deltas interleaved across 2 parallel calls resolve by output_index when the upstream omits item_id", () => {
+ const state = {};
+
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ output_index: 0,
+ item: { type: "function_call", call_id: "call_p", name: "Read" },
+ },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ output_index: 1,
+ item: { type: "function_call", call_id: "call_q", name: "Read" },
+ },
+ state
+ );
+
+ // No item_id on any of these deltas — only output_index, which the Responses API
+ // guarantees on every streamed event regardless of whether item_id is also sent.
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", output_index: 0, delta: '{"filePath"' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", output_index: 1, delta: '{"filePath"' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", output_index: 0, delta: ':"/p.txt"}' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", output_index: 1, delta: ':"/q.txt"}' },
+ state
+ );
+
+ const doneP = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_p", name: "Read" },
+ },
+ state
+ );
+ const doneQ = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: { type: "function_call", call_id: "call_q", name: "Read" },
+ },
+ state
+ );
+
+ assert.equal(doneP.choices[0].delta.tool_calls[0].function.arguments, '{"filePath":"/p.txt"}');
+ assert.equal(doneQ.choices[0].delta.tool_calls[0].function.arguments, '{"filePath":"/q.txt"}');
+});
+
+test("Responses -> OpenAI: 2 parallel Agent calls still open at stream end each get their own flush chunk", () => {
+ const state = {};
+
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_agent0", name: "Agent" },
+ },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", output_index: 0, delta: '{"task":"a"}' },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.added",
+ item: { type: "function_call", call_id: "call_agent1", name: "Agent" },
+ },
+ state
+ );
+ openaiResponsesToOpenAIResponse(
+ { type: "response.function_call_arguments.delta", output_index: 1, delta: '{"task":"b"}' },
+ state
+ );
+
+ // Stream ends (chunk === null) before either call's output_item.done arrives.
+ const flushed = openaiResponsesToOpenAIResponse(null, state);
+
+ assert.ok(Array.isArray(flushed));
+ const argChunks = flushed.filter((c) => c.choices[0].delta.tool_calls);
+ assert.deepEqual(
+ argChunks.map((c) => c.choices[0].delta.tool_calls[0].index).sort(),
+ [0, 1],
+ "each still-open parallel call must get its own flush chunk, at its own index"
+ );
+ const finalChunk = flushed[flushed.length - 1];
+ assert.equal(finalChunk.choices[0].finish_reason, "tool_calls");
+});
diff --git a/tests/unit/search-blocked-providers-11100.test.ts b/tests/unit/search-blocked-providers-11100.test.ts
new file mode 100644
index 000000000000..1c5c775e86ec
--- /dev/null
+++ b/tests/unit/search-blocked-providers-11100.test.ts
@@ -0,0 +1,11 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getAllSearchProviders } from "../../open-sse/config/searchRegistry.ts";
+
+test("getAllSearchProviders filters out blocked providers", () => {
+ const all = getAllSearchProviders();
+ assert.ok(all.some((p) => p.id === "serper-search"));
+
+ const filtered = getAllSearchProviders(["serper-search"]);
+ assert.equal(filtered.some((p) => p.id === "serper-search"), false);
+});
diff --git a/tests/unit/stream-continuation-wiring.test.ts b/tests/unit/stream-continuation-wiring.test.ts
index 2f246e325d4b..36a6f445d1fc 100644
--- a/tests/unit/stream-continuation-wiring.test.ts
+++ b/tests/unit/stream-continuation-wiring.test.ts
@@ -47,9 +47,15 @@ async function collectText(stream: ReadableStream): Promise
const ROLE = 'data: {"choices":[{"delta":{"role":"assistant"}}]}\n\n';
const content = (s: string) => `data: {"choices":[{"delta":{"content":${JSON.stringify(s)}}}]}\n\n`;
+const reasoning = (s: string) =>
+ `data: {"choices":[{"delta":{"reasoning_content":${JSON.stringify(s)}}}]}\n\n`;
+const finishStopNoContent = 'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n';
+const finishLengthNoContent = 'data: {"choices":[{"delta":{},"finish_reason":"length"}]}\n\n';
+
test("mid-stream continuation: stitches the suffix after a silent post-commit truncation", async () => {
- // Commits on chunk 1, emits "Hello wor", then ends WITHOUT a terminal marker (silent cut).
- const initial = streamFrom([ROLE, content("Hello wor")]);
+ // Commits on chunk 1, emits "Hello there world", then ends WITHOUT a terminal marker
+ // (silent cut).
+ const initial = streamFrom([ROLE, content("Hello there world")]);
let finalizeCount = 0;
let continueArg = "";
@@ -60,15 +66,22 @@ test("mid-stream continuation: stitches the suffix after a silent post-commit tr
now: steppingClock(),
continueStream: async (soFar: string) => {
continueArg = soFar;
- // The model re-emits a small overlap ("wor") which must be trimmed away.
- return streamFrom([ROLE, content("world!"), "data: [DONE]\n\n"]);
+ // The model re-emits only a partial tail of what was already sent ("there world",
+ // 11 chars — above the 8-char threshold, but NOT the full emitted text, unlike a
+ // full-string overlap this stays a discriminating test of trimContinuationOverlap's
+ // partial-tail trim, not just its "accept everything" path) before continuing.
+ return streamFrom([ROLE, content("there world, nice to meet you!"), "data: [DONE]\n\n"]);
},
});
const out = await collectText(stream);
const scan = scanOpenAiSseText(out);
- assert.equal(continueArg, "Hello wor", "continuation is prefilled with the text already sent");
- assert.equal(scan.text, "Hello world!", "client sees the full answer, overlap trimmed, exactly once");
+ assert.equal(continueArg, "Hello there world", "continuation is prefilled with the text already sent");
+ assert.equal(
+ scan.text,
+ "Hello there world, nice to meet you!",
+ "client sees the full answer, partial overlap trimmed, exactly once"
+ );
assert.equal(scan.terminal, true, "the recovered stream ends with a terminal marker");
assert.equal(finalizeCount, 1, "finalize runs exactly once");
});
@@ -80,7 +93,7 @@ test("mid-stream continuation: recovers a post-commit transport error too", asyn
const stream = createRecoverableStream(initial, async () => null, {
finalize: () => {},
now: steppingClock(),
- continueStream: async () => streamFrom([content("answer done."), "data: [DONE]\n\n"]),
+ continueStream: async () => streamFrom([content("Partial answer done."), "data: [DONE]\n\n"]),
});
const scan = scanOpenAiSseText(await collectText(stream));
assert.equal(scan.text, "Partial answer done.");
@@ -115,3 +128,167 @@ test("tool-call in flight is never continued (would corrupt tool JSON)", async (
await collectText(stream);
assert.equal(continued, false, "continuation must NOT fire once a tool call has started streaming");
});
+
+test("mid-stream continuation: a zero-overlap restart is rejected, never concatenated raw", async () => {
+ // Truncates silently after real, non-empty text — canContinue() fires.
+ const initial = streamFrom([ROLE, content("Tous les faits sont reunis")]);
+ let continuations = 0;
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ maxContinuations: 1,
+ continueStream: async () => {
+ continuations += 1;
+ // The model ignores the assistant prefill and restarts on an unrelated sentence —
+ // zero characters of overlap with what was already emitted.
+ return streamFrom([
+ content("Je complete le design - derniere verification"),
+ "data: [DONE]\n\n",
+ ]);
+ },
+ });
+ const out = await collectText(stream);
+ const scan = scanOpenAiSseText(out);
+ assert.equal(
+ scan.text,
+ "Tous les faits sont reunis",
+ "the unrelated restart must never be appended to the already-emitted text"
+ );
+ assert.equal(scan.terminal, true, "closes cleanly instead of leaving the client hanging");
+ assert.equal(continuations, 1, "bounded by maxContinuations — does not loop forever");
+});
+
+test("mid-stream continuation: a nonzero overlap below the threshold is rejected too", async () => {
+ // Genuine 4-character overlap ("pret"), well under the 8-char threshold — this is the
+ // false-negative case a naive `overlapChars === 0` check would miss (a restart that
+ // happens to share a short accidental fragment with the emitted tail): must still be
+ // treated as a suspected restart, not accepted as a genuine resume.
+ const initial = streamFrom([ROLE, content("Le design est pret")]);
+ let continuations = 0;
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ maxContinuations: 1,
+ continueStream: async () => {
+ continuations += 1;
+ // Shares only "pret" (4 chars) with the emitted tail, then diverges completely.
+ return streamFrom([content("pret a partir de zero"), "data: [DONE]\n\n"]);
+ },
+ });
+ const scan = scanOpenAiSseText(await collectText(stream));
+ assert.equal(
+ scan.text,
+ "Le design est pret",
+ "a below-threshold (but nonzero) overlap must not be accepted as a real resume"
+ );
+ assert.equal(continuations, 1);
+});
+
+test("mid-stream continuation: a real overlap at or above the threshold is still stitched correctly", async () => {
+ // Regression guard: the existing happy path (first test in this file, whose updated
+ // fixture re-emits the 11-char partial tail "there world") still passes below — this test
+ // adds an overlap AT the threshold boundary to prove Task 3's new check does not fire when
+ // it shouldn't.
+ const initial = streamFrom([ROLE, content("The answer to this question")]);
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ continueStream: async () =>
+ // "question" (8 chars) overlaps the tail of emittedText exactly at the threshold.
+ streamFrom([content("question is forty-two."), "data: [DONE]\n\n"]),
+ });
+ const scan = scanOpenAiSseText(await collectText(stream));
+ assert.equal(
+ scan.text,
+ "The answer to this question is forty-two.",
+ "an overlap meeting the threshold is trimmed and stitched, not rejected"
+ );
+});
+
+test("mid-stream continuation: a clean stop with reasoning-only output (no answer) triggers a continuation", async () => {
+ const initial = streamFrom([
+ ROLE,
+ reasoning("the model thinks through the problem here..."),
+ finishStopNoContent,
+ ]);
+ let continueArg = "__unset__";
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ continueStream: async (soFar: string) => {
+ continueArg = soFar;
+ return streamFrom([content("Here is the actual answer."), "data: [DONE]\n\n"]);
+ },
+ });
+ const out = await collectText(stream);
+ const scan = scanOpenAiSseText(out);
+ assert.equal(continueArg, "", "nothing usable was emitted — the re-request has an empty prefill");
+ assert.equal(
+ scan.text,
+ "Here is the actual answer.",
+ "the client gets a real answer instead of silence"
+ );
+ assert.equal(scan.terminal, true);
+});
+
+test("mid-stream continuation: a clean stop with truly empty output (no text, no reasoning) is left unchanged", async () => {
+ const initial = streamFrom([ROLE, finishStopNoContent]);
+ let continued = false;
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ continueStream: async () => {
+ continued = true;
+ return streamFrom([content("nope"), "data: [DONE]\n\n"]);
+ },
+ });
+ await collectText(stream);
+ assert.equal(
+ continued,
+ false,
+ "no reasoning trace means there is nothing to act on — do not guess"
+ );
+});
+
+test("mid-stream continuation: finish_reason 'length' with reasoning-only output does NOT trigger a continuation", async () => {
+ // Regression guard for a blocker found in cross-review: widening the gate to any
+ // terminal marker (instead of the literal finish_reason "stop") would wrongly spend a
+ // continuation attempt on a token-limit cutoff, which is out of this fix's scope.
+ const initial = streamFrom([
+ ROLE,
+ reasoning("the model was still thinking when it hit the token limit..."),
+ finishLengthNoContent,
+ ]);
+ let continued = false;
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ continueStream: async () => {
+ continued = true;
+ return streamFrom([content("nope"), "data: [DONE]\n\n"]);
+ },
+ });
+ await collectText(stream);
+ assert.equal(continued, false, "finish_reason 'length' is out of scope for this fix");
+});
+
+test("mid-stream continuation: real content alongside reasoning at a clean stop is left unchanged (non-regression)", async () => {
+ const initial = streamFrom([
+ ROLE,
+ reasoning("thinking..."),
+ content("The real answer."),
+ finishStopNoContent,
+ ]);
+ let continued = false;
+ const stream = createRecoverableStream(initial, async () => null, {
+ finalize: () => {},
+ now: steppingClock(),
+ continueStream: async () => {
+ continued = true;
+ return streamFrom([content("nope"), "data: [DONE]\n\n"]);
+ },
+ });
+ const scan = scanOpenAiSseText(await collectText(stream));
+ assert.equal(continued, false, "real content was delivered — nothing to recover");
+ assert.equal(scan.text, "The real answer.");
+});
diff --git a/tests/unit/stream-continuation.test.ts b/tests/unit/stream-continuation.test.ts
index caffe936df9d..8a1da37ce9d6 100644
--- a/tests/unit/stream-continuation.test.ts
+++ b/tests/unit/stream-continuation.test.ts
@@ -21,6 +21,30 @@ test("scanOpenAiSseText accumulates content deltas and flags an OpenAI-compat st
assert.equal(r.terminal, false);
});
+test("scanOpenAiSseText accumulates reasoning_content deltas separately from content", () => {
+ const sse =
+ 'data: {"choices":[{"delta":{"role":"assistant"}}]}\n\n' +
+ 'data: {"choices":[{"delta":{"reasoning_content":"thinking..."}}]}\n\n' +
+ 'data: {"choices":[{"delta":{"reasoning_content":" more"}}]}\n\n';
+ const r = scanOpenAiSseText(sse);
+ assert.equal(r.reasoningText, "thinking... more");
+ assert.equal(r.text, "", "reasoning_content must never leak into the visible text field");
+ assert.equal(r.parsedOpenAi, true);
+});
+
+test("scanOpenAiSseText captures the literal finish_reason value", () => {
+ const stop = scanOpenAiSseText('data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n');
+ assert.equal(stop.finishReason, "stop");
+
+ const length = scanOpenAiSseText(
+ 'data: {"choices":[{"delta":{"content":"x"},"finish_reason":"length"}]}\n\n'
+ );
+ assert.equal(length.finishReason, "length");
+
+ const none = scanOpenAiSseText('data: {"choices":[{"delta":{"content":"x"}}]}\n\n');
+ assert.equal(none.finishReason, null, "no finish_reason seen means null, not a guessed default");
+});
+
test("scanOpenAiSseText detects the terminal [DONE] marker", () => {
const r = scanOpenAiSseText('data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n');
assert.equal(r.text, "hi");
@@ -65,6 +89,15 @@ test("makeContinuationBody refuses bodies without a messages array or empty text
assert.equal(makeContinuationBody(null as never, "t"), null);
});
+test("makeContinuationBody accepts an empty prefill by re-sending the messages unchanged", () => {
+ const body = { model: "x", stream: true, messages: [{ role: "user", content: "hi" }] };
+ const out = makeContinuationBody(body, "");
+ assert.ok(out, "an empty prefill must still produce a re-request body, not null");
+ assert.equal(out!.messages.length, 1, "no empty assistant turn is appended");
+ assert.deepEqual(out!.messages[0], { role: "user", content: "hi" });
+ assert.equal(out!.stream, true);
+});
+
// ── trimContinuationOverlap ───────────────────────────────────────────────────
test("trimContinuationOverlap removes a duplicated seam so the join is append-only", () => {
diff --git a/tests/unit/stream-handler.test.ts b/tests/unit/stream-handler.test.ts
index d19a13f351e4..8c19c088021b 100644
--- a/tests/unit/stream-handler.test.ts
+++ b/tests/unit/stream-handler.test.ts
@@ -167,6 +167,41 @@ test("createDisconnectAwareStream treats cancel after Responses completed as suc
assert.equal(disconnectHandled, false);
});
+test("createDisconnectAwareStream recognizes a large Responses compaction completion", async () => {
+ let errorHandled = false;
+ const completed = `event: response.completed\ndata: ${JSON.stringify({
+ type: "response.completed",
+ response: {
+ status: "completed",
+ output: [{ type: "compaction", encrypted_content: "x".repeat(5000) }],
+ },
+ })}\n\n`;
+ const transformStream = {
+ readable: new ReadableStream({
+ start(controller) {
+ controller.enqueue(encoder.encode(completed));
+ controller.close();
+ },
+ }),
+ writable: createNoopAbortWritable(),
+ };
+
+ const stream = createDisconnectAwareStream(
+ transformStream,
+ createStreamController({
+ clientResponseFormat: FORMATS.OPENAI_RESPONSES,
+ onError() {
+ errorHandled = true;
+ },
+ })
+ );
+ const text = await readStreamText(stream);
+
+ assert.equal(text, completed);
+ assert.equal(errorHandled, false);
+ assert.doesNotMatch(text, /response\.failed/);
+});
+
test("createDisconnectAwareStream: Gemini 503 high-demand error becomes SSE error chunk with message preserved", async () => {
const geminiMsg =
"[503]: This model is currently experiencing high demand. Spikes in demand are usually temporary. Please try again later.";
diff --git a/tests/unit/stream-payload-collector.test.ts b/tests/unit/stream-payload-collector.test.ts
index e8869bb8bfe1..63b96c5eaf60 100644
--- a/tests/unit/stream-payload-collector.test.ts
+++ b/tests/unit/stream-payload-collector.test.ts
@@ -2,6 +2,7 @@ import test from "node:test";
import assert from "node:assert/strict";
const collector = await import("../../open-sse/utils/streamPayloadCollector.ts");
+import { splitConcatenatedToolCallArguments } from "../../open-sse/utils/streamPayloadCollector.ts";
test("compactStructuredStreamPayload returns null for null input", () => {
assert.equal(collector.compactStructuredStreamPayload(null), null);
@@ -413,3 +414,33 @@ test("#9315: getSummary() returns undefined when no format was configured (unaff
c.push({ choices: [{ index: 0, delta: { content: "hi" } }] });
assert.equal(c.getSummary(), undefined);
});
+
+test("splitConcatenatedToolCallArguments — two back-to-back JSON objects", () => {
+ const a = JSON.stringify({ tool: "x", args: "1" });
+ const b = JSON.stringify({ tool: "y", args: "2" });
+ const out = splitConcatenatedToolCallArguments(a + b);
+ assert.deepEqual(out, [a, b]); // >=2 valid values -> split (array of parts)
+});
+
+test("splitConcatenatedToolCallArguments — nested object + escaped quotes stay single JSON", () => {
+ const a = JSON.stringify({ a: 'he said "hi"', b: { c: 1 } });
+ const single = a; // a is ONE valid JSON object -> no split
+ const out = splitConcatenatedToolCallArguments(single);
+ assert.equal(out, null); // single valid JSON -> untouched (null)
+});
+
+test("splitConcatenatedToolCallArguments — braces/quotes inside strings exercise escaped scanner", () => {
+ // Two valid JSON values whose string bodies contain braces and escaped quotes.
+ // Concatenated they reach the inString/escaped state machine (not the JSON.parse
+ // fast path), so this covers the case the owner asked about.
+ const a = JSON.stringify({ cmd: 'echo "}{" ; x' });
+ const b = JSON.stringify({ cmd: "{[not json]}" });
+ const out = splitConcatenatedToolCallArguments(a + b);
+ assert.deepEqual(out, [a, b]); // >=2 valid values -> split into parts
+});
+
+test("splitConcatenatedToolCallArguments — top-level array is single value", () => {
+ const arr = JSON.stringify([{ tool: "x" }, { tool: "y" }]);
+ const out = splitConcatenatedToolCallArguments(arr);
+ assert.equal(out, null); // one value boundary (array) -> not split
+});
diff --git a/tests/unit/stream-recovery-toolcall.test.ts b/tests/unit/stream-recovery-toolcall.test.ts
new file mode 100644
index 000000000000..7f3a76534332
--- /dev/null
+++ b/tests/unit/stream-recovery-toolcall.test.ts
@@ -0,0 +1,178 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+ createRecoverableStream,
+ TruncatedStreamError,
+ scanOpenAiSseText,
+} from "../../open-sse/services/streamRecovery.ts";
+
+const enc = new TextEncoder();
+
+// Deliver the SSE chunk on the first read, then error on the second read so the
+// holdback window has committed (post-commit truncation) before the cut.
+function makeStream(sse: string): ReadableStream {
+ let n = 0;
+ return new ReadableStream({
+ pull(c) {
+ n += 1;
+ if (n === 1) {
+ c.enqueue(enc.encode(sse));
+ return;
+ }
+ c.error(new TruncatedStreamError());
+ },
+ });
+}
+
+// A clock that jumps past HOLDBACK_MS on the second read so the very first pushed
+// chunk commits the holdback window immediately (post-commit truncation path).
+function jumpingClock(): () => number {
+ let t = 0;
+ return () => (t += 1000);
+}
+
+describe("scanOpenAiSseText: terminal vs in-flight tool call", () => {
+ it("tool_calls without finish_reason → inFlight true, terminal false", () => {
+ const sse =
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_1","function":{"name":"lookup"}}]}}]}\n\n';
+ const r = scanOpenAiSseText(sse);
+ assert.equal(r.sawToolCall, true);
+ assert.equal(r.sawToolCallInFlight, true);
+ assert.equal(r.terminal, false);
+ });
+
+ it("complete tool_calls + finish_reason + [DONE] → terminal true, inFlight false", () => {
+ const sse =
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_1","function":{"name":"lookup","arguments":"{}"}}]}}]}\n' +
+ 'data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}\n' +
+ "data: [DONE]\n\n";
+ const r = scanOpenAiSseText(sse);
+ assert.equal(r.sawToolCall, true);
+ assert.equal(r.terminal, true);
+ assert.equal(r.sawToolCallInFlight, false);
+ });
+
+ it("plain text → no tool call", () => {
+ const sse = 'data: {"choices":[{"index":0,"delta":{"content":"hello"}}]}\n\n';
+ const r = scanOpenAiSseText(sse);
+ assert.equal(r.sawToolCall, false);
+ assert.equal(r.sawToolCallInFlight, false);
+ assert.equal(r.terminal, false);
+ });
+
+ it("complete tool_calls WITHOUT [DONE] → terminal false, inFlight false (the actual fix)", () => {
+ // This is the case the original plan promised to unblock: the tool call itself is
+ // done (finish_reason: "tool_calls"), but the overall stream/turn has not sent its
+ // own terminal marker yet — a truncation right here is recoverable.
+ const sse =
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_1","function":{"name":"lookup","arguments":"{}"}}]}}]}\n' +
+ 'data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}\n\n';
+ const r = scanOpenAiSseText(sse);
+ assert.equal(r.sawToolCall, true);
+ assert.equal(r.sawToolCallInFlight, false);
+ assert.equal(r.terminal, false);
+ });
+});
+
+describe("stream recovery does not duplicate an in-flight tool call", () => {
+ it("truncation with an in-flight tool call → no continuation", async () => {
+ let continued = false;
+ const sse =
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"c1","function":{"name":"f"}}]}}]}\n\n';
+ const wrapped = createRecoverableStream(makeStream(sse), async () => null, {
+ finalize: () => {},
+ now: jumpingClock(),
+ continueStream: async () => {
+ continued = true;
+ return null;
+ },
+ });
+ const reader = wrapped.getReader();
+ try {
+ for (;;) {
+ const r = await reader.read();
+ if (r.done) break;
+ }
+ } catch {
+ // the in-flight tool call makes the stream close without continuing
+ }
+ assert.equal(continued, false);
+ });
+
+ it("truncation right after a completed tool call → continuation attempted (the real 91% gain)", async () => {
+ // Text was emitted, THEN the tool call completed (finish_reason: "tool_calls"), THEN
+ // the connection drops before a [DONE]/other terminal marker. Before this fix, the
+ // blunt `emittedToolCall` guard blocked recovery here even though the call itself is
+ // done and only trailing prose was lost — this is the exact case the plan promised
+ // to unblock and the pre-fix table proved was a no-op.
+ let continued = false;
+ const sse =
+ 'data: {"choices":[{"index":0,"delta":{"content":"Let me check that. "}}]}\n' +
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"c1","function":{"name":"f","arguments":"{}"}}]}}]}\n' +
+ 'data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}\n\n';
+ const wrapped = createRecoverableStream(makeStream(sse), async () => null, {
+ finalize: () => {},
+ now: jumpingClock(),
+ continueStream: async () => {
+ continued = true;
+ return null;
+ },
+ });
+ const reader = wrapped.getReader();
+ try {
+ for (;;) {
+ const r = await reader.read();
+ if (r.done) break;
+ }
+ } catch {
+ // no-op
+ }
+ assert.equal(continued, true);
+ });
+
+ it("truncation of plain text → continuation attempted", async () => {
+ let continued = false;
+ const sse = 'data: {"choices":[{"index":0,"delta":{"content":"hello "}}]}\n\n';
+ const wrapped = createRecoverableStream(makeStream(sse), async () => null, {
+ finalize: () => {},
+ now: jumpingClock(),
+ continueStream: async () => {
+ continued = true;
+ return null;
+ },
+ });
+ const reader = wrapped.getReader();
+ try {
+ for (;;) {
+ const r = await reader.read();
+ if (r.done) break;
+ }
+ } catch {
+ // no-op
+ }
+ assert.equal(continued, true);
+ });
+
+ it("naive removal of the tool-call guard would duplicate a partial tool call", () => {
+ // The blunt `sawToolCall` flag is true for BOTH a complete tool call and a
+ // partial (in-flight) one. The new `sawToolCallInFlight` flag is the only
+ // signal that tells them apart: a naive guard keyed on `sawToolCall` would
+ // block the complete call AND let the partial one through to the
+ // continuation, where trimContinuationOverlap (text-only) cannot de-duplicate
+ // the replayed tool_calls arguments.
+ const ssePartial =
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_1","function":{"name":"lookup","arguments":"{\\"q\\""}}]}}]}\n\n';
+ const sseFull =
+ 'data: {"choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_1","function":{"name":"lookup","arguments":"{\\"q\\":\\"x\\"}"}}]}}]}\n' +
+ 'data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}\n\n';
+ const scanPartial = scanOpenAiSseText(ssePartial);
+ const scanFull = scanOpenAiSseText(sseFull);
+ // The blunt flag cannot distinguish them.
+ assert.equal(scanPartial.sawToolCall, true);
+ assert.equal(scanFull.sawToolCall, true);
+ // The in-flight flag can — and that is what keeps canContinue false only for
+ // the partial tool call, so the continuation never replays it.
+ assert.equal(scanPartial.sawToolCallInFlight, true);
+ assert.equal(scanFull.sawToolCallInFlight, false);
+ });
+});
diff --git a/tests/unit/strip-reasoning-blobs-agentic-context-1599.test.ts b/tests/unit/strip-reasoning-blobs-agentic-context-1599.test.ts
index cab5e9c37f53..8b3059236dd1 100644
--- a/tests/unit/strip-reasoning-blobs-agentic-context-1599.test.ts
+++ b/tests/unit/strip-reasoning-blobs-agentic-context-1599.test.ts
@@ -8,7 +8,7 @@ import { omitEncryptedReasoningForLog } from "../../src/lib/logPayloads.ts";
// Responses reasoning replay is target-scoped. Plaintext DeepSeek state and
// provider-generated opaque state are never interchangeable.
-test("unknown Responses targets reject opaque reasoning and ignore display summaries", () => {
+test("unknown Responses targets drop opaque reasoning and preserve display summaries (#10959)", () => {
const body: Record = {
input: [
{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] },
@@ -24,11 +24,14 @@ test("unknown Responses targets reject opaque reasoning and ignore display summa
],
};
- const originalInput = structuredClone(body.input);
const result = applyReasoningInputPolicy(body, "responses");
- assert.equal(result.incompatibleReasoning, true);
- assert.deepEqual(body.input, originalInput, "rejection must not mutate the request");
+ assert.equal(result.incompatibleReasoning, false);
+ assert.deepEqual(body.input, [
+ { type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] },
+ { type: "reasoning", summary: [{ text: "display only" }] },
+ { type: "function_call", name: "search", arguments: "{}", call_id: "call_1" },
+ ]);
});
test("unannotated targets preserve plaintext Responses reasoning without synthetic IDs", () => {
@@ -132,7 +135,7 @@ test("Chat drop removes opaque state while preserving plaintext and summary deta
]);
});
-test("DeepSeek rejects plaintext reasoning carrying opaque provider state", () => {
+test("DeepSeek projects plaintext reasoning carrying opaque provider state onto the plaintext transport (#10949)", () => {
for (const opaqueField of ["signature", "format"] as const) {
const body: Record = {
input: [
@@ -148,13 +151,11 @@ test("DeepSeek rejects plaintext reasoning carrying opaque provider state", () =
const result = applyReasoningInputPolicy(body, "responses", { provider: "deepseek" });
- assert.equal(result.incompatibleReasoning, true, opaqueField);
+ assert.equal(result.incompatibleReasoning, false, opaqueField);
assert.deepEqual(body.input, [
{
- id: "rs_mixed123",
type: "reasoning",
content: [{ type: "reasoning_text", text: "untrusted companion" }],
- [opaqueField]: "provider-state",
},
{ type: "message", role: "user", content: [{ type: "input_text", text: "continue" }] },
]);
@@ -199,6 +200,49 @@ test("drop fallback removes only the incompatible active transport and preserves
assert.equal(opaqueReasoning.encrypted_content, "provider-state");
});
+test("mixed plaintext + opaque reasoning follows the target transport instead of rejecting (#10949)", () => {
+ const mixedReasoning = {
+ id: "rs_mixed",
+ type: "reasoning",
+ content: [{ type: "reasoning_text", text: "inspect first" }],
+ encrypted_content: "provider-state",
+ summary: [{ type: "summary_text", text: "display only" }],
+ };
+
+ // Plaintext target (deepseek): keep the portable plaintext, strip opaque state.
+ const toPlaintext: Record = {
+ input: [structuredClone(mixedReasoning)],
+ };
+ const plaintextResult = applyReasoningInputPolicy(toPlaintext, "responses", {
+ provider: "deepseek",
+ });
+ assert.equal(plaintextResult.incompatibleReasoning, false);
+ assert.deepEqual(toPlaintext.input, [
+ {
+ type: "reasoning",
+ content: [{ type: "reasoning_text", text: "inspect first" }],
+ summary: [{ type: "summary_text", text: "display only" }],
+ },
+ ]);
+
+ // Opaque target (openai): keep the provider state, strip the plaintext.
+ const toOpaque: Record = {
+ input: [structuredClone(mixedReasoning)],
+ };
+ const opaqueResult = applyReasoningInputPolicy(toOpaque, "responses", {
+ provider: "openai",
+ });
+ assert.equal(opaqueResult.incompatibleReasoning, false);
+ assert.deepEqual(toOpaque.input, [
+ {
+ id: "rs_mixed",
+ type: "reasoning",
+ encrypted_content: "provider-state",
+ summary: [{ type: "summary_text", text: "display only" }],
+ },
+ ]);
+});
+
test("drop fallback preserves reasoning when its transport is compatible", () => {
const body: Record = {
input: [
@@ -274,7 +318,11 @@ test("explicit custom target opt-in remains an opaque transport override", () =>
const result = applyReasoningInputPolicy(body, "responses", { preserveEncryptedReasoning: true });
assert.equal(result.incompatibleReasoning, false);
- assert.deepEqual(body.input, [{ type: "reasoning", encrypted_content: "encrypted-blob" }]);
+ // #11108: a kept opaque item defaults `summary` when the source omitted it —
+ // some upstreams reject `input[]` reasoning items missing the field entirely.
+ assert.deepEqual(body.input, [
+ { type: "reasoning", encrypted_content: "encrypted-blob", summary: [] },
+ ]);
});
test("preserved opaque reasoning remains redacted from log copies", () => {
diff --git a/tests/unit/token-health-check-kimi.test.ts b/tests/unit/token-health-check-kimi.test.ts
index c5d487762603..87b816952879 100644
--- a/tests/unit/token-health-check-kimi.test.ts
+++ b/tests/unit/token-health-check-kimi.test.ts
@@ -18,11 +18,10 @@ describe("Kimi Background Health Sweep", () => {
it("triggers refresh when Kimi token is within jittered expiration window", async () => {
const nowSec = Math.floor(Date.now() / 1000);
- // Token expiring in 30s. The production jitter threshold is 60-240s, so
- // remainingSec=30 is always <= threshold and must trigger a refresh.
+ // Token expiring in 90 seconds (within 60-240s window)
const token =
"eyJhbGciOiJIUzUxMiJ9." +
- Buffer.from(JSON.stringify({ exp: nowSec + 30, iat: nowSec })).toString("base64url") +
+ Buffer.from(JSON.stringify({ exp: nowSec + 90, iat: nowSec })).toString("base64url") +
".sig";
let calledRefresh = false;
diff --git a/tests/unit/translator-openai-responses-req.test.ts b/tests/unit/translator-openai-responses-req.test.ts
index e0d0a5177318..2a05f57310e8 100644
--- a/tests/unit/translator-openai-responses-req.test.ts
+++ b/tests/unit/translator-openai-responses-req.test.ts
@@ -172,28 +172,26 @@ test("Responses -> Chat keeps summary-only reasoning out of continuation state",
assert.equal(result.messages[0].reasoning_content, undefined);
});
-test("Responses -> Chat rejects opaque reasoning instead of replaying its plaintext companion", () => {
- assert.throws(
- () =>
- openaiResponsesToOpenAIRequest(
- "deepseek-v4-pro",
+test("Responses -> Chat replays the plaintext companion of an opaque reasoning item (#10949)", () => {
+ const result = openaiResponsesToOpenAIRequest(
+ "deepseek-v4-pro",
+ {
+ input: [
{
- input: [
- {
- id: "rs_opaque",
- type: "reasoning",
- encrypted_content: "opaque-provider-state",
- content: [{ type: "reasoning_text", text: "Untrusted plaintext companion" }],
- summary: [{ type: "summary_text", text: "Display summary" }],
- },
- { type: "function_call", call_id: "call_1", name: "search", arguments: "{}" },
- ],
+ id: "rs_opaque",
+ type: "reasoning",
+ encrypted_content: "opaque-provider-state",
+ content: [{ type: "reasoning_text", text: "Untrusted plaintext companion" }],
+ summary: [{ type: "summary_text", text: "Display summary" }],
},
- false,
- { _preserveReasoningContent: true }
- ),
- /Reasoning continuation is not compatible/
- );
+ { type: "function_call", call_id: "call_1", name: "search", arguments: "{}" },
+ ],
+ },
+ false,
+ { _preserveReasoningContent: true }
+ ) as { messages: Array> };
+
+ assert.equal(result.messages[0].reasoning_content, "Untrusted plaintext companion");
});
test("Responses -> Chat merges assistant text that follows a function call", () => {
@@ -475,6 +473,7 @@ test("Chat -> Responses defaults unannotated targets to plaintext reasoning", ()
{
type: "reasoning",
content: [{ type: "reasoning_text", text: "Inspect the repository first" }],
+ summary: [],
},
{
type: "function_call",
@@ -513,6 +512,7 @@ test("Chat -> DeepSeek Responses accepts the plaintext reasoning alias", () => {
assert.deepEqual(result.input[0], {
type: "reasoning",
content: [{ type: "reasoning_text", text: "Alias plaintext reasoning" }],
+ summary: [],
});
});
diff --git a/tests/unit/translator-resp-openai-responses.test.ts b/tests/unit/translator-resp-openai-responses.test.ts
index 27cc877f2ef2..2253c655ac7a 100644
--- a/tests/unit/translator-resp-openai-responses.test.ts
+++ b/tests/unit/translator-resp-openai-responses.test.ts
@@ -423,6 +423,52 @@ test("Responses -> OpenAI: preserves non-object Read JSON-string arguments", ()
assert.equal(done.choices[0].delta.tool_calls[0].function.arguments, "null");
});
+test("Responses -> OpenAI: mixed plaintext + encrypted_content reasoning replays its plaintext (#10949)", () => {
+ const state = {};
+ const done = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: {
+ type: "reasoning",
+ id: "rs_mixed",
+ content: [
+ {
+ type: "reasoning_text",
+ text: "Let me start by reading the directory to understand the structure of the corpus.",
+ },
+ ],
+ encrypted_content: "",
+ summary: [],
+ },
+ },
+ state
+ );
+
+ assert.ok(done, "mixed reasoning item must surface a delta");
+ assert.equal(
+ done.choices[0].delta.reasoning_content,
+ "Let me start by reading the directory to understand the structure of the corpus."
+ );
+});
+
+test("Responses -> OpenAI: opaque-only reasoning still emits no fabricated plaintext", () => {
+ const state = {};
+ const done = openaiResponsesToOpenAIResponse(
+ {
+ type: "response.output_item.done",
+ item: {
+ type: "reasoning",
+ id: "rs_opaque_only",
+ encrypted_content: "",
+ summary: [],
+ },
+ },
+ state
+ );
+
+ assert.equal(done, null);
+});
+
test("Responses -> OpenAI: strips empty optional args from JSON-string output_item.done arguments", () => {
const state = {};
openaiResponsesToOpenAIResponse(
diff --git a/tests/unit/translator-resp-openai-to-claude.test.ts b/tests/unit/translator-resp-openai-to-claude.test.ts
index 59e58c05220f..f8f1cfcfdbd6 100644
--- a/tests/unit/translator-resp-openai-to-claude.test.ts
+++ b/tests/unit/translator-resp-openai-to-claude.test.ts
@@ -105,7 +105,9 @@ test("OpenAI stream: internal reasoning replay placeholder stays hidden from Cla
const result = flatten([placeholder, text]);
assert.equal(
- result.some((event) => event.type === "content_block_start" && event.content_block?.type === "thinking"),
+ result.some(
+ (event) => event.type === "content_block_start" && event.content_block?.type === "thinking"
+ ),
false
);
assert.equal(result[0].type, "message_start");
@@ -217,10 +219,7 @@ test("OpenAI stream: multi-chunk content without the placeholder passes through
textDeltas.map((event) => event.delta.text),
["Hello, ", "world.", " Bye."]
);
- assert.equal(
- textDeltas.map((event) => event.delta.text).join(""),
- "Hello, world. Bye."
- );
+ assert.equal(textDeltas.map((event) => event.delta.text).join(""), "Hello, world. Bye.");
});
test("OpenAI stream: tool calls strip Claude OAuth prefix and keep cache usage", () => {
@@ -427,9 +426,11 @@ test("OpenAI stream: XML block in content becomes tool_use at finish",
// message_start → (no text block since all content was XML)
assert.equal(result[0].type, "message_start");
// At finish: tool_use content_block_start
- const toolStart = result.find((e) => e.type === "content_block_start" && e.content_block?.type === "tool_use");
+ const toolStart = result.find(
+ (e) => e.type === "content_block_start" && e.content_block?.type === "tool_use"
+ );
assert.ok(toolStart, "expected tool_use content_block_start");
- assert.equal(toolStart.content_block.name, "bash"); // normalized via REVERSE_MAP
+ assert.equal(toolStart.content_block.name, "Bash"); // canonical echo kept (#11085 live repro)
assert.deepEqual(toolStart.content_block.input, { command: "ls -la" });
// tool_use content_block_stop
const toolStop = result.find((e) => e.type === "content_block_stop");
@@ -465,7 +466,7 @@ test("OpenAI stream: XML invoke block across two streaming chunks", () => {
choices: [
{
index: 0,
- delta: { content: 'hosts ' },
+ delta: { content: "hosts" },
finish_reason: null,
},
],
@@ -487,9 +488,11 @@ test("OpenAI stream: XML invoke block across two streaming chunks", () => {
// Buffer should be cleared after chunk2
assert.equal(state._xmlInvokeBuffer, "", "buffer cleared after complete block");
- const toolStart = result.find((e) => e.type === "content_block_start" && e.content_block?.type === "tool_use");
+ const toolStart = result.find(
+ (e) => e.type === "content_block_start" && e.content_block?.type === "tool_use"
+ );
assert.ok(toolStart, "expected tool_use content_block_start");
- assert.equal(toolStart.content_block.name, "read");
+ assert.equal(toolStart.content_block.name, "Read"); // canonical echo kept (#11085 live repro)
assert.deepEqual(toolStart.content_block.input, { file_path: "/etc/hosts" });
});
@@ -538,15 +541,25 @@ test("OpenAI stream: text before XML block is emitted as text content", () => {
const result = flatten([chunk1, chunk2, chunk3]);
// "Checking..." should be emitted as text
- const textDeltas = result.filter((e) => e.type === "content_block_delta" && e.delta?.type === "text_delta");
+ const textDeltas = result.filter(
+ (e) => e.type === "content_block_delta" && e.delta?.type === "text_delta"
+ );
assert.ok(textDeltas.length > 0, "expected at least one text delta");
- assert.ok(textDeltas.some((d) => d.delta.text.includes("Checking...")), "text before XML preserved");
- assert.ok(textDeltas.some((d) => d.delta.text.includes("Done.")), "text after XML preserved");
+ assert.ok(
+ textDeltas.some((d) => d.delta.text.includes("Checking...")),
+ "text before XML preserved"
+ );
+ assert.ok(
+ textDeltas.some((d) => d.delta.text.includes("Done.")),
+ "text after XML preserved"
+ );
// Tool call should still be emitted
- const toolStart = result.find((e) => e.type === "content_block_start" && e.content_block?.type === "tool_use");
+ const toolStart = result.find(
+ (e) => e.type === "content_block_start" && e.content_block?.type === "tool_use"
+ );
assert.ok(toolStart, "expected tool_use content_block_start");
- assert.equal(toolStart.content_block.name, "bash");
+ assert.equal(toolStart.content_block.name, "Bash"); // canonical echo kept (#11085 live repro)
assert.deepEqual(toolStart.content_block.input, { command: "date" });
});
diff --git a/tests/unit/ui/add-api-key-modal-enter-key.test.ts b/tests/unit/ui/add-api-key-modal-enter-key.test.ts
deleted file mode 100644
index 2532eb297ea8..000000000000
--- a/tests/unit/ui/add-api-key-modal-enter-key.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-
-describe("AddApiKeyModal Enter key submit (#10995)", () => {
- it("AddApiKeyModal attaches onKeyDown Enter handler to the API Key input", () => {
- const modalPath = path.resolve(
- process.cwd(),
- "src/app/(dashboard)/dashboard/providers/[id]/components/modals/AddApiKeyModal.tsx"
- );
- const content = fs.readFileSync(modalPath, "utf8");
- assert.ok(
- content.includes("onKeyDown"),
- "AddApiKeyModal must contain onKeyDown event handler for Enter key validation"
- );
- assert.ok(
- content.includes('e.key === "Enter"'),
- "onKeyDown handler must check for Enter key press"
- );
- assert.ok(
- content.includes("handleValidate()"),
- "Enter key press must invoke handleValidate()"
- );
- });
-});
diff --git a/tests/unit/ui/add-api-key-modal-enter-key.test.tsx b/tests/unit/ui/add-api-key-modal-enter-key.test.tsx
new file mode 100644
index 000000000000..1c28a13230f0
--- /dev/null
+++ b/tests/unit/ui/add-api-key-modal-enter-key.test.tsx
@@ -0,0 +1,104 @@
+// @vitest-environment jsdom
+//
+// #10995 — Enter key in AddApiKeyModal triggers key validation without requiring a mouse click on Check.
+import React, { act } from "react";
+import { createRoot } from "react-dom/client";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+vi.mock("next-intl", () => ({
+ useTranslations: () => (key: string) => key,
+}));
+
+const { default: AddApiKeyModal } =
+ await import("../../../src/app/(dashboard)/dashboard/providers/[id]/components/modals/AddApiKeyModal");
+
+const containers: Array<{ root: ReturnType; el: HTMLDivElement }> = [];
+
+function render(props: Record) {
+ const el = document.createElement("div");
+ document.body.appendChild(el);
+ const root = createRoot(el);
+ act(() => {
+ root.render(
+ undefined}
+ onClose={() => {}}
+ {...(props as any)}
+ />
+ );
+ });
+ containers.push({ root, el });
+ return el;
+}
+
+function setInputValue(input: HTMLInputElement, value: string) {
+ const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value")!.set!;
+ act(() => {
+ setter.call(input, value);
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ });
+}
+
+function dispatchKeyDown(element: HTMLElement, key: string) {
+ act(() => {
+ element.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true, cancelable: true }));
+ });
+}
+
+describe("AddApiKeyModal Enter key submit (#10995)", () => {
+ let originalFetch: typeof global.fetch;
+
+ beforeEach(() => {
+ originalFetch = global.fetch;
+ });
+
+ afterEach(() => {
+ global.fetch = originalFetch;
+ for (const { root, el } of containers) {
+ act(() => root.unmount());
+ el.remove();
+ }
+ containers.length = 0;
+ });
+
+ it("does not trigger validation on Enter when input is empty", () => {
+ const fetchMock = vi.fn().mockResolvedValue({
+ ok: true,
+ json: async () => ({ valid: true }),
+ });
+ global.fetch = fetchMock as any;
+
+ const el = render({});
+ const input = el.querySelector('input[type="password"]');
+ expect(input).toBeTruthy();
+
+ dispatchKeyDown(input!, "Enter");
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
+ it("triggers validation on Enter key press when API key is provided", async () => {
+ const fetchMock = vi.fn().mockResolvedValue({
+ ok: true,
+ json: async () => ({ valid: true }),
+ });
+ global.fetch = fetchMock as any;
+
+ const el = render({});
+ const input = el.querySelector('input[type="password"]');
+ expect(input).toBeTruthy();
+
+ setInputValue(input!, "sk-test1234567890");
+ dispatchKeyDown(input!, "Enter");
+
+ expect(fetchMock).toHaveBeenCalledWith(
+ "/api/providers/validate",
+ expect.objectContaining({
+ method: "POST",
+ body: expect.stringContaining("sk-test1234567890"),
+ })
+ );
+ });
+});
diff --git a/tests/unit/ui/cheaperInferenceSponsorBanner.test.tsx b/tests/unit/ui/cheaperInferenceSponsorBanner.test.tsx
new file mode 100644
index 000000000000..b86f4188c6a3
--- /dev/null
+++ b/tests/unit/ui/cheaperInferenceSponsorBanner.test.tsx
@@ -0,0 +1,92 @@
+// @vitest-environment jsdom
+/**
+ * CheaperInferenceSponsorBanner — render gate (localStorage dismissal), CTA
+ * pointing at our link.omniroute.online branded short link, and discreet
+ * partner-link note. Mirrors kimiSponsorBanner.test.tsx, minus the version gate
+ * (this banner is a durable partnership, not a time-boxed offer).
+ */
+import React from "react";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const STORAGE_KEY = "omniroute-cheaperinference-sponsor-banner-dismissed-v1";
+const DISMISS_EVENT = "omniroute:cheaperinference-sponsor-banner-dismissed";
+const SHORT_URL = "https://link.omniroute.online/cheaper";
+
+vi.mock("next-intl", () => ({ useTranslations: () => (k: string) => k }));
+vi.mock("@/shared/components/ProviderIcon", () => ({ default: () => null }));
+
+async function renderBanner(): Promise {
+ vi.resetModules();
+ const { default: CheaperInferenceSponsorBanner } =
+ await import("../../../src/app/(dashboard)/dashboard/CheaperInferenceSponsorBanner");
+
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ act(() => {
+ root.render( = {}) {
+ return {
+ now: () => NOW,
+ isValidApiKey: async (apiKey: string) => apiKey === "sk-allowed",
+ getApiKeyMetadata: async () => ({
+ id: "key-allowed",
+ name: "panel key",
+ allowUsageCommand: true,
+ usageLimitEnabled: true,
+ }),
+ getProviderConnections: async () => [
+ { id: "conn-claude", provider: "claude", isActive: true },
+ { id: "conn-codex", provider: "codex", isActive: true },
+ ],
+ getAllProviderLimitsCache: () => ({
+ "conn-claude": {
+ plan: "Claude Max",
+ quotas: {
+ weekly: { used: 25, total: 100, remaining: 75, resetAt: "2026-08-25T03:00:00.000Z" },
+ },
+ message: null,
+ fetchedAt: new Date(NOW).toISOString(),
+ },
+ "conn-codex": {
+ plan: "Codex Pro",
+ quotas: {
+ weekly: { used: 9, total: 100, remaining: 91, resetAt: "2026-08-24T03:00:00.000Z" },
+ },
+ message: null,
+ fetchedAt: new Date(NOW).toISOString(),
+ },
+ }),
+ getProviderConnectionById: async () => null,
+ getProviderLimitsCache: () => null,
+ getQuotaPolicy: async () => ({ defaultThresholdPercent: 0, providerWindowDefaults: {} }),
+ getApiKeyUsageLimitStatus: async () => LIMIT_STATUS,
+ ...overrides,
+ };
+}
+
+test("om-usage ?format=json returns the structured personal + provider quota", async () => {
+ const response = await handleInternalUsageCommandHttpRequest(
+ new Request("http://localhost/api/usage/om-usage?format=json", {
+ headers: { Authorization: "Bearer sk-allowed" },
+ }),
+ allowedDeps()
+ );
+
+ assert.equal(response.status, 200);
+ assert.match(response.headers.get("content-type") ?? "", /application\/json/);
+ const body = (await response.json()) as {
+ allowed: boolean;
+ personal: { dailySpentUsd: number } | null;
+ provider: { provider: string; connectionId: string } | null;
+ };
+ assert.equal(body.allowed, true);
+ assert.equal(body.personal?.dailySpentUsd, 1.25);
+ assert.equal(body.provider?.provider, "claude");
+ assert.equal(body.provider?.connectionId, "conn-claude");
+});
+
+test("om-usage without ?format stays text/plain (the historical contract)", async () => {
+ const response = await handleInternalUsageCommandHttpRequest(
+ new Request("http://localhost/api/usage/om-usage", {
+ headers: { Authorization: "Bearer sk-allowed" },
+ }),
+ allowedDeps()
+ );
+
+ assert.equal(response.status, 200);
+ assert.match(response.headers.get("content-type") ?? "", /text\/plain/);
+ const text = await response.text();
+ assert.match(text, /Personal quota/);
+ assert.match(text, /Provider quota/);
+});
+
+test("om-usage ?format=json returns every connection under providers[], not just the selected one", async () => {
+ // #11191 — a panel needs Codex + Claude side by side; the single `provider`
+ // pick is a terminal presentation choice, the collector had them all.
+ const response = await handleInternalUsageCommandHttpRequest(
+ new Request("http://localhost/api/usage/om-usage?format=json", {
+ headers: { Authorization: "Bearer sk-allowed" },
+ }),
+ allowedDeps()
+ );
+
+ assert.equal(response.status, 200);
+ const body = (await response.json()) as {
+ allowed: boolean;
+ provider: { provider: string } | null;
+ providers: Array<{ provider: string }>;
+ };
+ assert.equal(body.allowed, true);
+ const names = body.providers.map((s) => s.provider).sort();
+ assert.deepEqual(names, ["claude", "codex"]);
+ // the single-pick field is still present and one of them
+ assert.ok(["claude", "codex"].includes(body.provider?.provider ?? ""));
+});
+
+test("om-usage ?format=json reports a disallowed key as structured allowed:false", async () => {
+ // A usage panel must tell "this key may not ask" apart from "no data yet",
+ // which a bare 403 text body cannot express.
+ const response = await handleInternalUsageCommandHttpRequest(
+ new Request("http://localhost/api/usage/om-usage?format=json", {
+ headers: { Authorization: "Bearer sk-allowed" },
+ }),
+ allowedDeps({
+ getApiKeyMetadata: async () => ({ id: "key-off", allowUsageCommand: false }),
+ })
+ );
+
+ assert.equal(response.status, 403);
+ const body = (await response.json()) as { allowed: boolean };
+ assert.equal(body.allowed, false);
+});
+
+test("om-usage ?format=json rejects an invalid key and never leaks a stack trace", async () => {
+ const response = await handleInternalUsageCommandHttpRequest(
+ new Request("http://localhost/api/usage/om-usage?format=json", {
+ headers: { Authorization: "Bearer sk-wrong" },
+ }),
+ allowedDeps()
+ );
+
+ assert.equal(response.status, 401);
+ const body = (await response.json()) as { allowed: boolean; error?: { message?: string } };
+ assert.equal(body.allowed, false);
+ assert.ok(
+ !body.error?.message?.includes("at /"),
+ "error bodies must not carry stack frames (ERROR_SANITIZATION)"
+ );
+});
diff --git a/tests/unit/validate-response-quality.test.ts b/tests/unit/validate-response-quality.test.ts
index de4b5f47dc3a..6a918155e565 100644
--- a/tests/unit/validate-response-quality.test.ts
+++ b/tests/unit/validate-response-quality.test.ts
@@ -24,6 +24,20 @@ test("returns valid=true for SSE with 'data:' lines", async () => {
assert.strictEqual(res.valid, true);
});
+test("returns valid=true for SSE opening with a ':' comment line (e.g. OpenRouter keep-alive)", async () => {
+ const res = await validateResponseQuality(
+ makeResponse(': OPENROUTER PROCESSING\n\ndata: {"foo":"bar"}\n\n'),
+ false,
+ {}
+ );
+ assert.strictEqual(res.valid, true);
+});
+
+test("returns valid=true for an SSE stream with leading whitespace before the first frame", async () => {
+ const res = await validateResponseQuality(makeResponse('\n\ndata: {"foo":"bar"}\n\n'), false, {});
+ assert.strictEqual(res.valid, true);
+});
+
test("returns valid=false for non-JSON non-SSE text", async () => {
const res = await validateResponseQuality(makeResponse("Hello world"), false, {});
assert.strictEqual(res.valid, false);
diff --git a/tests/unit/webhook-discord-dispatcher.test.ts b/tests/unit/webhook-discord-dispatcher.test.ts
index 4a49c3ba2ef0..605f4aa86b77 100644
--- a/tests/unit/webhook-discord-dispatcher.test.ts
+++ b/tests/unit/webhook-discord-dispatcher.test.ts
@@ -1,5 +1,6 @@
import test from "node:test";
import assert from "node:assert/strict";
+import { WEBHOOK_EVENT_VALUES } from "../../src/lib/webhooks/eventDescriptions.ts";
const { buildDiscordPayload } = await import("../../src/lib/webhooks/integrations/discord.ts");
@@ -14,15 +15,7 @@ test("buildDiscordPayload — request.failed produces embed with model", () => {
});
test("buildDiscordPayload — all WEBHOOK_EVENTS return object with content or embeds", () => {
- const events = [
- "request.completed",
- "request.failed",
- "provider.error",
- "provider.recovered",
- "quota.exceeded",
- "combo.switched",
- "test.ping",
- ] as const;
+ const events = WEBHOOK_EVENT_VALUES;
for (const event of events) {
const payload = buildDiscordPayload(event, {});
assert.ok(
@@ -33,7 +26,7 @@ test("buildDiscordPayload — all WEBHOOK_EVENTS return object with content or e
});
test("buildDiscordPayload — embeds have title and color fields", () => {
- const payload = buildDiscordPayload("provider.error", { provider: "openai" });
+ const payload = buildDiscordPayload("request.failed", { provider: "openai" });
assert.ok(Array.isArray(payload.embeds) && payload.embeds.length > 0, "should have embeds");
const embed = payload.embeds![0];
assert.ok(typeof embed.title === "string" && embed.title.length > 0, "embed must have title");
diff --git a/tests/unit/webhook-slack-dispatcher.test.ts b/tests/unit/webhook-slack-dispatcher.test.ts
index 44b34626cf28..ad91a774e38d 100644
--- a/tests/unit/webhook-slack-dispatcher.test.ts
+++ b/tests/unit/webhook-slack-dispatcher.test.ts
@@ -1,5 +1,6 @@
import test from "node:test";
import assert from "node:assert/strict";
+import { WEBHOOK_EVENT_VALUES } from "../../src/lib/webhooks/eventDescriptions.ts";
const { buildSlackPayload } = await import("../../src/lib/webhooks/integrations/slack.ts");
@@ -30,8 +31,8 @@ test("buildSlackPayload — test.ping produces a ping/test message", () => {
);
});
-test("buildSlackPayload — provider.error includes provider context", () => {
- const payload = buildSlackPayload("provider.error", { provider: "openai", model: "gpt-4" });
+test("buildSlackPayload — request.failed includes provider context", () => {
+ const payload = buildSlackPayload("request.failed", { provider: "openai" });
const combined = JSON.stringify(payload);
assert.ok(
combined.includes("Provider") ||
@@ -43,15 +44,7 @@ test("buildSlackPayload — provider.error includes provider context", () => {
});
test("buildSlackPayload — all WEBHOOK_EVENTS produce valid payloads with text field", () => {
- const events = [
- "request.completed",
- "request.failed",
- "provider.error",
- "provider.recovered",
- "quota.exceeded",
- "combo.switched",
- "test.ping",
- ] as const;
+ const events = WEBHOOK_EVENT_VALUES;
for (const event of events) {
const payload = buildSlackPayload(event, {});
assert.ok(
diff --git a/tests/unit/webhook-telegram-dispatcher.test.ts b/tests/unit/webhook-telegram-dispatcher.test.ts
index eeb5ee2c92bf..29bf2f586c41 100644
--- a/tests/unit/webhook-telegram-dispatcher.test.ts
+++ b/tests/unit/webhook-telegram-dispatcher.test.ts
@@ -1,5 +1,6 @@
import test from "node:test";
import assert from "node:assert/strict";
+import { WEBHOOK_EVENT_VALUES } from "../../src/lib/webhooks/eventDescriptions.ts";
const { buildTelegramPayload, buildTelegramUrl } =
await import("../../src/lib/webhooks/integrations/telegram.ts");
@@ -77,15 +78,7 @@ test("buildTelegramPayload — chat_id matches provided value for groups", () =>
});
test("buildTelegramPayload — all WEBHOOK_EVENTS produce valid payloads with chat_id", () => {
- const events = [
- "request.completed",
- "request.failed",
- "provider.error",
- "provider.recovered",
- "quota.exceeded",
- "combo.switched",
- "test.ping",
- ] as const;
+ const events = WEBHOOK_EVENT_VALUES;
for (const event of events) {
const payload = buildTelegramPayload(event, {}, "99999");
assert.equal(payload.chat_id, "99999");
diff --git a/tests/unit/webhooks-ghost-events.test.ts b/tests/unit/webhooks-ghost-events.test.ts
index 427b0467a76e..a5d26e6019ce 100644
--- a/tests/unit/webhooks-ghost-events.test.ts
+++ b/tests/unit/webhooks-ghost-events.test.ts
@@ -30,4 +30,16 @@ describe("webhook catalogue", () => {
const { notifyWebhookEvent } = await import("../../src/lib/webhookDispatcher.ts");
assert.equal(typeof notifyWebhookEvent, "function");
});
+
+ it("every builder accepts every value in WEBHOOK_EVENT_VALUES without throwing", async () => {
+ const { buildDiscordPayload } = await import("../../src/lib/webhooks/integrations/discord.ts");
+ const { buildSlackPayload } = await import("../../src/lib/webhooks/integrations/slack.ts");
+ const { buildTelegramPayload } =
+ await import("../../src/lib/webhooks/integrations/telegram.ts");
+ for (const event of WEBHOOK_EVENT_VALUES) {
+ assert.doesNotThrow(() => buildDiscordPayload(event, {}));
+ assert.doesNotThrow(() => buildSlackPayload(event, {}));
+ assert.doesNotThrow(() => buildTelegramPayload(event, {}, "99999"));
+ }
+ });
});
diff --git a/tests/unit/zcode-executor.test.ts b/tests/unit/zcode-executor.test.ts
index c82e7b336839..db4a8586bee9 100644
--- a/tests/unit/zcode-executor.test.ts
+++ b/tests/unit/zcode-executor.test.ts
@@ -26,6 +26,8 @@ function requestBody() {
test("ZCode accepts GLM Coding Plan models and rejects unsafe/unknown ids", async () => {
const { resolveZcodeModel } = await loadZcodeExecutor();
assert.deepEqual(resolveZcodeModel("glm-5.2"), { ok: true, model: "glm-5.2" });
+ assert.equal(resolveZcodeModel("glm-5.2-high").ok, false);
+ assert.equal(resolveZcodeModel("glm-5.3-low").ok, false);
assert.equal(resolveZcodeModel("-unexpected").ok, false);
assert.equal(resolveZcodeModel("unknown-model").ok, false);
});
@@ -70,7 +72,7 @@ test("ZCode buffers the completed turn into OpenAI SSE when stream=true", async
});
const result = await executor.execute({
- model: "glm-5.2-high",
+ model: "glm-5.2",
body: requestBody(),
stream: true,
credentials: {},
diff --git a/tests/unit/zcode-provider.test.ts b/tests/unit/zcode-provider.test.ts
index 3acf3c862c4f..e882ab5fd91b 100644
--- a/tests/unit/zcode-provider.test.ts
+++ b/tests/unit/zcode-provider.test.ts
@@ -10,5 +10,18 @@ test("ZCode provider registry exposes a local no-auth GLM Coding Plan backend",
assert.equal(zcodeProvider.baseUrl, "zcode://app-server/stdio");
assert.equal(zcodeProvider.authType, "none");
assert.equal(zcodeProvider.authHeader, "none");
- assert.equal(zcodeProvider.models.some((model) => model.id === "glm-5.2"), true);
+ assert.equal(
+ zcodeProvider.models.some((model) => model.id === "glm-5.2"),
+ true
+ );
+ for (const alias of ["glm-5.3-high", "glm-5.3-low", "glm-5.2-high", "glm-5.2-max"]) {
+ assert.equal(
+ zcodeProvider.models.some((model) => model.id === alias),
+ false,
+ alias
+ );
+ }
+ for (const model of zcodeProvider.models) {
+ assert.deepEqual(model.supportedThinkingEfforts, [], model.id);
+ }
});