fix(chat): detect severity-classifier format in claudeClassifierCompat short-circuit (#11289)

.github/workflows/opencode-plugin-ci.yml

@@ -2,11 +2,11 @@ name: opencode-plugin CI
 
 on:
   push:
-    branches: [main, "release/**"]
+    branches: [main, release/v3.8.2]
     paths:
       - "@omniroute/opencode-plugin/**"
   pull_request:
-    branches: [main, "release/**"]
+    branches: [main, release/v3.8.2]
     paths:
       - "@omniroute/opencode-plugin/**"
     types: [opened, synchronize, reopened, ready_for_review]

@omniroute/opencode-plugin/tests/provider.test.ts

@@ -104,10 +104,7 @@ test("models: extracts apiKey from ctx.auth (type=api) and calls fetcher with it
   // #6859: dynamic-hook catalog keys use the unprefixed omnirouteProviderId
   // ("omniroute"), not the OC-gate-prefixed hook.id ("opencode-omniroute") —
   // that prefix must never leak into anything OmniRoute's server parses.
-  // #10345/#10821: bare combo ids (owned_by: "combo") stay unprefixed —
-  // OpenCode looks up `-m <plugin>/<combo>` as model id `<combo>` under the
-  // plugin provider, so `claude-primary` here carries no provider prefix.
-  assert.ok(out["claude-primary"]);
+  assert.ok(out["omniroute/claude-primary"]);
 });
 
 test("models: returns {} when ctx.auth is null/undefined/wrong-type/empty-key", async () => {
@@ -162,15 +159,11 @@ test("models: maps a sample /v1/models entry to ModelV2 (sanity)", async () => {
   // omnirouteProviderId ("omniroute") — the OC-gate prefix ("opencode-")
   // must stay OC-internal (hook.id / AuthHook.provider) and never leak into
   // anything OmniRoute's own server parses for credential lookup.
-  // #10345/#10821: bare **combo** ids (owned_by: "combo", e.g.
-  // "claude-primary") must also stay unprefixed — OpenCode looks up
-  // `-m <plugin>/<combo>` as model id `<combo>` under the plugin provider.
-  const claude = out["claude-primary"];
+  const claude = out["omniroute/claude-primary"];
   assert.ok(claude, "claude-primary present");
-  // `mapRawModelToModelV2` leaves bare combo ids unprefixed (see
-  // src/index.ts mapRawModelToModelV2) so OC's `-m <plugin>/<combo>` lookup
-  // resolves the combo id directly.
-  assert.equal(claude.id, "claude-primary");
+  // `mapRawModelToModelV2` stamps the provider prefix on the id so OC's
+  // static-catalog reader resolves `(providerID, modelID)` from the key.
+  assert.equal(claude.id, "omniroute/claude-primary");
   assert.equal(claude.name, "claude-primary");
   assert.equal(claude.providerID, "omniroute");
   assert.equal(claude.api.id, "openai-compatible");

changelog.d/fixes/10851-openapi-spec-auth-contract.md

@@ -1 +0,0 @@
-- Document the conditional management authentication and 401/403 responses for `GET /api/openapi/spec`.

changelog.d/fixes/11297-opencode-subagent-sessionid.md

@@ -1 +0,0 @@
-- **fix(translator):** preserve omitted OpenCode `subagent.sessionID` values — optional default-less plain strings now use the Responses `null = omit` sentinel and are stripped before the client sees the tool call, so Codex/Responses no longer invent filler session IDs ([#11297](https://github.com/diegosouzapw/OmniRoute/pull/11297)) — thanks @ofonseca-pyming

changelog.d/maintenance/11018-database-cache-docs.md

@@ -1 +0,0 @@
-- **docs(database):** align the SQLite cache guide with the 65,536 KiB runtime default, supported 1–1,000,000 KiB range, and live Settings application behavior ([#11018](https://github.com/diegosouzapw/OmniRoute/issues/11018))

docs/openapi.yaml

@@ -6866,11 +6866,7 @@ paths:
         Returns a structured JSON catalog parsed from this `openapi.yaml`,
         including info, servers, tags, schemas, and a flat list of endpoints
         (method, path, tags, summary, security, parameters, responses).
-        Used by the in-app API explorer. When `requireLogin` is enabled, this
-        management endpoint requires an authenticated dashboard session;
-        otherwise it is available without authentication.
-      security:
-        - ManagementSessionAuth: []
+        Used by the in-app API explorer.
       responses:
         "200":
           description: Parsed OpenAPI catalog
@@ -6924,10 +6920,6 @@ paths:
                       type: string
         "404":
           description: openapi.yaml file not found on disk
-        "401":
-          $ref: "#/components/responses/ManagementAuthenticationRequired"
-        "403":
-          $ref: "#/components/responses/ManagementInvalidToken"
         "500":
           description: Failed to parse OpenAPI spec
 

docs/ops/DATABASE_GUIDE.md

@@ -1,7 +1,7 @@
 ---
 title: "Database Schema & Operations Guide"
-version: 3.8.50
-lastUpdated: 2026-08-23
+version: 3.8.40
+lastUpdated: 2026-06-28
 ---
 
 # Database Schema & Operations Guide
@@ -43,17 +43,12 @@ For **single-user, single-instance** deployments (the primary OmniRoute use case
 db.pragma("journal_mode = WAL");
 db.pragma("busy_timeout = 2000");
 db.pragma("synchronous = NORMAL");
-db.pragma(`cache_size = -${DEFAULT_DATABASE_SETTINGS.optimization.cacheSize}`);
+// Settings > System & Storage > Cache Size is applied as KiB.
+db.pragma("cache_size = -16384");
 ```
 
 WAL allows **concurrent reads** during writes — important for the dashboard, which queries while requests are being recorded.
 
-The default cache size is **65,536 KiB (64 MiB)**. SQLite interprets a negative
-`cache_size` as an approximate upper bound in KiB and allocates pages on demand.
-**Settings > System & Storage > Cache Size** accepts integer values from **1 to
-1,000,000 KiB**; saving the setting applies it to the live database connection,
-and OmniRoute restores the persisted value at startup.
-
 ---
 
 ## Database Location

open-sse/handlers/chatCore.ts

@@ -380,7 +380,6 @@ import { isCompactResponsesEndpoint } from "../executors/codex.ts";
 import { persistCodexChildQuotaResponse } from "../services/codexAccount/index.ts";
 import { invalidateCodexQuotaCache } from "../services/codexQuotaFetcher.ts";
 import { translateNonStreamingResponse } from "./responseTranslator.ts";
-import { extractToolSchemaMap } from "../translator/response/openai-responses/toolSchemas.ts";
 import { unwrapClineNonStreamingEnvelope } from "./chatCore/clineResponseEnvelope.ts";
 import { extractUsageFromResponse } from "./usageExtractor.ts";
 import {
@@ -4913,14 +4912,12 @@ export async function handleChatCore({
 
     // Translate response to client's expected format (usually OpenAI)
     // Pass toolNameMap so Claude OAuth proxy_ prefix is stripped in tool_use blocks (#605)
-    const responseToolSchemas = extractToolSchemaMap(finalBody || translatedBody || body);
     let translatedResponse = needsTranslation(responsePayloadFormat, clientResponseFormat)
       ? translateNonStreamingResponse(
           responseBody,
           responsePayloadFormat,
           clientResponseFormat,
-          responseToolNameMap,
-          responseToolSchemas
+          responseToolNameMap
         )
       : responseBody;
     const memoryExtractionResponse = translatedResponse;
@@ -4947,8 +4944,7 @@ export async function handleChatCore({
               responseBody,
               responsePayloadFormat,
               FORMATS.OPENAI,
-              responseToolNameMap,
-              responseToolSchemas
+              responseToolNameMap
             )
           : responseBody;
       const firstChoice = cacheResponse?.choices?.[0];
@@ -5471,8 +5467,7 @@ export async function handleChatCore({
                 streamBody,
                 clientResponseFormat,
                 FORMATS.OPENAI,
-                responseToolNameMap,
-                extractToolSchemaMap(finalBody || translatedBody || body)
+                responseToolNameMap
               ) as Record<string, unknown>)
             : streamBody;
         const choices = cacheStreamBody.choices as

open-sse/handlers/responseTranslator.ts

@@ -13,7 +13,6 @@ import {
 import { restoreClaudeToolName } from "../services/claudeCodeToolRemapper.ts";
 import { extractReplayableResponsesReasoningText } from "../services/reasoningInputPolicy.ts";
 import { sanitizeToolId } from "../translator/helpers/schemaCoercion.ts";
-import { stripEmptyOptionalToolArgs } from "../translator/response/openai-responses/pureHelpers.ts";
 
 type JsonRecord = Record<string, unknown>;
 
@@ -136,28 +135,24 @@ function findBestMessageText(output: unknown[]): {
  * Handles different provider response formats (Gemini, Claude, etc.)
  *
  * @param toolNameMap - Optional Map<prefixedName, originalName> for Claude OAuth tool name stripping
- * @param toolSchemas - Optional Map<toolName, parametersSchema> for schema-aware optional-arg cleanup
  */
 export function translateNonStreamingResponse(
   responseBody: JsonRecord,
   targetFormat: string,
   sourceFormat: string,
-  toolNameMap?: Map<string, string> | null,
-  toolSchemas?: Map<string, JsonRecord> | null
+  toolNameMap?: Map<string, string> | null
 ): JsonRecord;
 export function translateNonStreamingResponse(
   responseBody: unknown,
   targetFormat: string,
   sourceFormat: string,
-  toolNameMap?: Map<string, string> | null,
-  toolSchemas?: Map<string, JsonRecord> | null
+  toolNameMap?: Map<string, string> | null
 ): unknown;
 export function translateNonStreamingResponse(
   responseBody: unknown,
   targetFormat: string,
   sourceFormat: string,
-  toolNameMap?: Map<string, string> | null,
-  toolSchemas?: Map<string, JsonRecord> | null
+  toolNameMap?: Map<string, string> | null
 ): unknown {
   // If already in source format, return as-is
   if (targetFormat === sourceFormat) {
@@ -224,11 +219,6 @@ export function translateNonStreamingResponse(
           toString(itemObj.id) ||
           `call_${Date.now()}_${toolCalls.length}`;
         let argsToEmit = itemObj.arguments;
-        const rawName = toString(itemObj.name);
-        const toolSchema = toolSchemas?.get(rawName);
-        if (toolSchema) {
-          argsToEmit = stripEmptyOptionalToolArgs(argsToEmit, rawName, toolSchema);
-        }
         if (argsToEmit != null && typeof argsToEmit === "object" && !Array.isArray(argsToEmit)) {
           const cleaned: JsonRecord = { ...(argsToEmit as JsonRecord) };
           for (const [k, v] of Object.entries(cleaned)) {
@@ -239,6 +229,7 @@ export function translateNonStreamingResponse(
 
         const fnArgs =
           typeof argsToEmit === "string" ? argsToEmit : JSON.stringify(argsToEmit || {});
+        const rawName = toString(itemObj.name);
         // Strip Claude OAuth proxy_ prefix using toolNameMap
         const resolvedName = caseInsensitiveToolNameLookup(rawName, toolNameMap) ?? rawName;
         toolCalls.push({

open-sse/services/learnedReasoningEffortCaps.ts

@@ -12,21 +12,7 @@
  * `sanitizeReasoningEffortForProvider` in `executors/base/reasoningEffort.ts`)
  * so the 4xx→retry round-trip is paid at most once per process per provider+model.
  *
- * `clampToLearned` implements nearest-tier clamping: smallest accepted >= demand,
- * falling back to the greatest accepted when demand exceeds every accepted value.
- * (#11295 — unified with the static "declared" clamp in
- * `executors/base/reasoningEffort.ts`, which already used nearest-tier semantics.
- * Before #11295, this learned clamp was downgrade-only — greatest accepted <=
- * demand — so the SAME accepted set {low,high,max} produced medium→low here but
- * medium→high via the declared path: identical inputs, opposite outputs,
- * depending only on whether the model had a static registry entry. #11274's
- * DeepSeek native mapping is the precedent for nearest-tier. This also fixes a
- * standalone bug: a request BELOW the learned floor (e.g. none/minimal on a
- * model that only ever advertised {low,high,max}) used to return null — no
- * clamp — so the too-low value passed straight through to the upstream, which
- * 400'd again on every subsequent request without ever learning a lower floor.
- * Nearest-tier naturally fixes this too: the smallest accepted value is always
- * >= any demand below the floor, so it is returned instead of null.
+ * `clampToLearned` implements downgrade-only clamping: greatest accepted <= demand.
  *
  * In-memory only (same operator-accepted tradeoff as the thinking-budget cache):
  * restart resets, the first request after a restart may re-learn at the cost of
@@ -146,39 +132,25 @@ export function recordLearnedReasoningEffort(
 }
 
 /**
- * Return the nearest-tier accepted value for effortStr: the smallest accepted
- * value with rank >= effortStr's rank, or — when effortStr's rank exceeds every
- * accepted value (demand above the learned ceiling) — the greatest accepted
- * value. Returns null only when effortStr is already accepted (no clamp
- * needed), empty, or not a recognized member of REASONING_EFFORT_ORDER.
- *
- * Mirrors the declared-capability clamp in `executors/base/reasoningEffort.ts`
- * (#11295): both now use nearest-tier semantics so the same accepted set
- * produces the same mapping regardless of whether the model has a static
- * registry entry or was only learned reactively from an upstream 4xx.
+ * Return the greatest accepted value <= effortStr (downgrade only), or null
+ * if effortStr is already accepted, below the minimum, or not in ORDER.
  */
 export function clampToLearned(effortStr: string, accepted: Set<string>): string | null {
   if (!effortStr || accepted.has(effortStr)) return null;
   const rank = rankOf(effortStr);
   if (rank === -1) return null;
-
-  let nearestAbove: string | null = null;
-  let nearestAboveRank = Infinity;
-  let highest: string | null = null;
-  let highestRank = -1;
+  const minRank = Math.min(...[...accepted].map((v) => rankOf(v)));
+  if (rank < minRank) return null;
+  let best: string | null = null;
+  let bestRank = -1;
   for (const v of accepted) {
     const r = rankOf(v);
-    if (r < 0) continue;
-    if (r >= rank && r < nearestAboveRank) {
-      nearestAboveRank = r;
-      nearestAbove = v;
-    }
-    if (r > highestRank) {
-      highestRank = r;
-      highest = v;
+    if (r <= rank && r > bestRank) {
+      bestRank = r;
+      best = v;
     }
   }
-  return nearestAbove ?? highest;
+  return best;
 }
 
 // Matches prose shapes: OVH's "@ai-sdk/openai-compatible" deserializer

open-sse/translator/helpers/schemaCoercion.ts

@@ -290,31 +290,6 @@ export function coerceToolSchemas(tools: unknown): unknown {
   });
 }
 
-const NULL_OMISSION_NOTE = "null = omit this parameter";
-
-function schemaTypeIncludes(type: unknown, wanted: string): boolean {
-  return type === wanted || (Array.isArray(type) && type.includes(wanted));
-}
-
-function isPlainStringType(type: unknown): boolean {
-  return type === "string" || (Array.isArray(type) && type.length === 1 && type[0] === "string");
-}
-
-function appendNullOmissionMarker(description: unknown): string {
-  if (typeof description === "string" && description.length > 0) {
-    return description.includes(NULL_OMISSION_NOTE)
-      ? description
-      : `${description} (${NULL_OMISSION_NOTE})`;
-  }
-  return NULL_OMISSION_NOTE;
-}
-
-function widenTypeWithNull(type: unknown): unknown {
-  if (typeof type === "string") return [type, "null"];
-  if (Array.isArray(type) && !type.includes("null")) return [...type, "null"];
-  return type;
-}
-
 // #7023 — Responses API strict mode forces every "optional" tool property into
 // `required`, so a model that intends to OMIT an optional enum property (no declared
 // `default`) must still emit a concrete value (e.g. Agent.isolation:"remote"). Neither
@@ -324,11 +299,7 @@ function widenTypeWithNull(type: unknown): unknown {
 // `null` (see pureHelpers.ts::isDroppableNullEntry). Scope: top-level
 // `properties[key].enum` only — does not recurse into `items`/`anyOf`/`oneOf` branches
 // (no real-world case beyond Agent.isolation is documented; extend with a concrete repro).
-function shouldInjectNullOmission(
-  key: string,
-  propSchema: unknown,
-  required: Set<string>
-): boolean {
+function shouldInjectNullOmission(key: string, propSchema: unknown, required: Set<string>): boolean {
   return (
     isPlainObject(propSchema) &&
     Array.isArray(propSchema.enum) &&
@@ -341,38 +312,19 @@ function widenPropertyForNullOmission(propSchema: JsonRecord): JsonRecord {
   const widened: JsonRecord = { ...propSchema };
   const enumValues = propSchema.enum as unknown[];
   widened.enum = enumValues.includes(null) ? enumValues : [...enumValues, null];
-  widened.type = widenTypeWithNull(propSchema.type);
-  widened.description = appendNullOmissionMarker(propSchema.description);
+  if (typeof propSchema.type === "string") {
+    widened.type = [propSchema.type, "null"];
+  } else if (Array.isArray(propSchema.type) && !propSchema.type.includes("null")) {
+    widened.type = [...propSchema.type, "null"];
+  }
+  const note = "null = omit this parameter";
+  widened.description =
+    typeof propSchema.description === "string" && propSchema.description.length > 0
+      ? `${propSchema.description} (${note})`
+      : note;
   return widened;
 }
 
-// OpenCode `subagent.sessionID` (and any other optional default-less plain string) has
-// the same strict-mode omission problem as #7023 enums, but no enum to widen. Inject
-// the same nullable-union sentinel on top-level `properties[key]` only — do not recurse
-// into `items`/`anyOf`/`$defs`, and do not touch enums (owned by the helper above).
-function shouldInjectStringNullOmission(
-  key: string,
-  propSchema: unknown,
-  required: Set<string>
-): boolean {
-  return (
-    isPlainObject(propSchema) &&
-    !Array.isArray(propSchema.enum) &&
-    isPlainStringType(propSchema.type) &&
-    !schemaTypeIncludes(propSchema.type, "null") &&
-    !required.has(key) &&
-    !hasOwn(propSchema, "default")
-  );
-}
-
-function widenStringPropertyForNullOmission(propSchema: JsonRecord): JsonRecord {
-  return {
-    ...propSchema,
-    type: widenTypeWithNull(propSchema.type),
-    description: appendNullOmissionMarker(propSchema.description),
-  };
-}
-
 export function injectOptionalEnumOmissionSentinel(schema: unknown): unknown {
   if (!isPlainObject(schema) || !isPlainObject(schema.properties)) return schema;
 
@@ -404,43 +356,6 @@ export function injectOptionalEnumOmissionForTools(tools: unknown): unknown {
   });
 }
 
-export function injectOptionalStringOmissionSentinel(schema: unknown): unknown {
-  if (!isPlainObject(schema) || !isPlainObject(schema.properties)) return schema;
-
-  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-  let changed = false;
-  const nextProperties: JsonRecord = { ...schema.properties };
-
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    if (!shouldInjectStringNullOmission(key, propSchema, required)) continue;
-    nextProperties[key] = widenStringPropertyForNullOmission(propSchema as JsonRecord);
-    changed = true;
-  }
-
-  if (!changed) return schema;
-  return { ...schema, properties: nextProperties };
-}
-
-export function injectOptionalStringOmissionForTools(tools: unknown): unknown {
-  if (!Array.isArray(tools)) return tools;
-
-  return tools.map((tool) => {
-    if (!isPlainObject(tool)) return tool;
-
-    const result: JsonRecord = { ...tool };
-    if (isPlainObject(result.function) && "parameters" in result.function) {
-      result.function = {
-        ...result.function,
-        parameters: injectOptionalStringOmissionSentinel(result.function.parameters),
-      };
-    }
-    if ("parameters" in result && !isPlainObject(result.function)) {
-      result.parameters = injectOptionalStringOmissionSentinel(result.parameters);
-    }
-    return result;
-  });
-}
-
 export function sanitizeToolDescriptions(tools: unknown): unknown {
   if (!Array.isArray(tools)) return tools;
   return tools.map((tool) => sanitizeToolDescription(tool));

open-sse/translator/index.ts

@@ -18,7 +18,6 @@ import {
   coerceToolSchemas,
   injectEmptyReasoningContentForToolCalls,
   injectOptionalEnumOmissionForTools,
-  injectOptionalStringOmissionForTools,
   sanitizeToolDescriptions,
 } from "./helpers/schemaCoercion.ts";
 import { getRequestTranslator, getResponseTranslator } from "./registry.ts";
@@ -596,12 +595,6 @@ export function translateRequest(
   }
 
   if (result.tools !== undefined) {
-    // Plain-string omission must run before coerceToolSchemas() strips `default`,
-    // so defaulted optional strings stay unsentinelled. Enum injection stays after
-    // coercion to preserve the #7023 pipeline.
-    if (targetFormat === FORMATS.OPENAI_RESPONSES) {
-      result.tools = injectOptionalStringOmissionForTools(result.tools);
-    }
     result.tools = coerceToolSchemas(result.tools);
     result.tools = sanitizeToolDescriptions(result.tools);
     if (targetFormat === FORMATS.OPENAI_RESPONSES) {

open-sse/translator/response/openai-responses.ts

@@ -866,13 +866,13 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
 
 function openaiResponsesToOpenAIResponseStream(chunk, state) {
   if (!chunk) {
-    // Iterate every still-open call with a buffered argument payload — argument
-    // deltas are buffered for every tool, so an incomplete stream must flush every
-    // buffered call, not only the historical uppercase Agent path.
+    // Iterate every still-open call needing schema-aware normalization, not just a
+    // single one — multiple parallel calls can each be pending here if the stream
+    // ends before their output_item.done arrives.
     const pendingNormalized: Array<{ index: number; argsStr: string }> = [];
     if (state.toolCallByCallId instanceof Map) {
       for (const entry of state.toolCallByCallId.values()) {
-        if (entry.argsBuffer) {
+        if (entry.needsNormalization && entry.argsBuffer) {
           const toolSchema = state.toolSchemas?.get(entry.name);
           const argsToEmit = stripEmptyOptionalToolArgs(entry.argsBuffer, entry.name, toolSchema);
           pendingNormalized.push({

open-sse/translator/response/openai-responses/pureHelpers.ts

@@ -56,35 +56,21 @@ function isDroppableEmptyEntry(entry, propSchema, required, key, allowlisted) {
   return allowlisted || (propSchema != null && !required.has(key));
 }
 
-function schemaTypeIncludes(type, wanted) {
-  return type === wanted || (Array.isArray(type) && type.includes(wanted));
-}
-
-function hasOmissionSentinel(propSchema) {
-  if (!propSchema || typeof propSchema !== "object") return false;
-  if (
-    typeof propSchema.description !== "string" ||
-    !propSchema.description.includes("null = omit this parameter")
-  ) {
-    return false;
-  }
-  return (
-    schemaTypeIncludes(propSchema.type, "null") ||
-    (Array.isArray(propSchema.enum) && propSchema.enum.includes(null))
-  );
-}
-
-// #7023 — the request-side counterpart widens no-default optional properties to accept
-// `null`, meaning "omitted" (OpenAI's own nullable-union idiom for Responses-API strict
-// mode). Enums use injectOptionalEnumOmissionSentinel; plain strings use
-// injectOptionalStringOmissionSentinel. Drop the key when the model follows that idiom
-// for a non-required, schema-declared property, or when OmniRoute's marker is present
-// even after an upstream strictifies the field into `required`.
+// #7023 — the request-side counterpart (injectOptionalEnumOmissionSentinel) widens
+// no-default optional enum properties to accept `null`, meaning "omitted" (OpenAI's own
+// nullable-union idiom for Responses-API strict mode). Drop the key when the model
+// follows that idiom for a non-required, schema-declared property.
 function isDroppableNullEntry(entry, propSchema, required, key, toolName) {
   if (entry !== null) return false;
   if (toolName === "Agent") return true;
   if (propSchema == null) return false;
-  return !required.has(key) || hasOmissionSentinel(propSchema);
+  const omissionSentinel =
+    typeof propSchema === "object" &&
+    Array.isArray(propSchema.enum) &&
+    propSchema.enum.includes(null) &&
+    typeof propSchema.description === "string" &&
+    propSchema.description.includes("null = omit this parameter");
+  return !required.has(key) || omissionSentinel;
 }
 
 function stripEmptyOptionalToolArgsObject(value, toolName, schema) {
@@ -124,11 +110,7 @@ export function stripEmptyOptionalToolArgs(value, toolName, schema) {
     // supplied (schema-aware normalization is not restricted to the allowlist).
     // "Agent" also passes without a schema: isDroppableNullEntry drops its null
     // omission sentinels even when the strict schema snapshot is unavailable (#9423).
-    if (
-      !hasUsableSchema(schema) &&
-      !STRIPPABLE_EMPTY_ARG_TOOLS.has(toolName) &&
-      toolName !== "Agent"
-    ) {
+    if (!hasUsableSchema(schema) && !STRIPPABLE_EMPTY_ARG_TOOLS.has(toolName) && toolName !== "Agent") {
       return value;
     }
     try {

skills/cli-mcp/SKILL.md

@@ -75,3 +75,76 @@ omniroute mcp call <tool> [argsJson]
 ```bash
 omniroute mcp scopes
 ```
+
+### `mcp tools`
+
+**Example:**
+
+```bash
+omniroute mcp tools
+```
+
+### `mcp list`
+
+**Flags:**
+
+- `--scope <s>`
+
+**Example:**
+
+```bash
+omniroute mcp list
+```
+
+### `mcp info <name>`
+
+**Example:**
+
+```bash
+omniroute mcp info <name>
+```
+
+### `mcp schema <name>`
+
+**Flags:**
+
+- `--io <kind>`
+
+**Example:**
+
+```bash
+omniroute mcp schema <name>
+```
+
+### `mcp audit`
+
+**Example:**
+
+```bash
+omniroute mcp audit
+```
+
+### `mcp tail`
+
+**Flags:**
+
+- `--follow`
+- `--limit <n>`
+
+**Example:**
+
+```bash
+omniroute mcp tail
+```
+
+### `mcp stats`
+
+**Flags:**
+
+- `--period <p>`
+
+**Example:**
+
+```bash
+omniroute mcp stats
+```

src/app/(dashboard)/dashboard/providers/[id]/components/AdaptaTutorialModal.tsx

@@ -7,10 +7,6 @@ type AdaptaTutorialModalProps = {
   onClose: () => void;
 };
 
-// The Adapta CTA href points at https://link.omniroute.online/adapta (our own
-// shortener, the `adapta` slug) so the click lands in our Kutt metrics. The visible
-// link text intentionally stays the real domain (agent.adapta.one/agentic-chat) so
-// users still see where they are going.
 export function AdaptaTutorialModal({ isOpen, onClose }: AdaptaTutorialModalProps) {
   const t = useTranslations("providers.adaptaTutorial");
 
@@ -33,7 +29,7 @@ export function AdaptaTutorialModal({ isOpen, onClose }: AdaptaTutorialModalProp
               <p className="text-text-muted mt-0.5">
                 {t("step1DescPrefix")}{" "}
                 <a
-                  href="https://link.omniroute.online/adapta"
+                  href="https://agent.adapta.one/agentic-chat"
                   target="_blank"
                   rel="noopener noreferrer"
                   className="underline text-primary"

src/app/api/oauth/kiro/auto-import/route.ts

@@ -439,22 +439,13 @@ type ProviderConnectionLike = {
  * whose stored `providerSpecificData.profileArn` matches the given ARN.
  * Returns null when profileArn is undefined/null or no match is found.
  *
- * #10815 hardened `findKiroConnectionByIdentity` to require an account-level
- * identifier (email or clientId) alongside a matching profileArn before
- * trusting the match — distinct Builder ID accounts (Google/GitHub social
- * login) can share the same CodeWhisperer profile ARN, and matching on ARN
- * alone let a second social login silently overwrite the first connection.
- * `email`/`clientId` here let a caller supply that account identifier; the
- * real `saveAndRespond()` call sites already do (see below).
- *
  * Exported for unit tests (#3615).
  */
 export function findKiroConnectionByProfileArn(
   connections: ProviderConnectionLike[],
-  profileArn: string | undefined,
-  accountIdentity?: { email?: string | null; clientId?: string | null }
+  profileArn: string | undefined
 ): ProviderConnectionLike | null {
-  return findKiroConnectionByIdentity(connections, { profileArn, ...accountIdentity });
+  return findKiroConnectionByIdentity(connections, { profileArn });
 }
 
 // ── Save to OmniRoute DB ──────────────────────────────────────────────────────

src/app/api/providers/[id]/route.ts

@@ -29,7 +29,6 @@ import { canUpdateProviderApiKey } from "@/shared/providers/webSessionCredential
 import {
   refreshConnectionRateLimits,
   enableRateLimitProtection,
-  disableRateLimitProtection,
 } from "@/../open-sse/services/rateLimitManager";
 import {
   finalizeValidatedChatGptWebCodexSecrets,
@@ -343,18 +342,10 @@ export async function PUT(request: Request, { params }: { params: Promise<{ id:
 
     // If rateLimitOverrides was included in the request, refresh the in-memory
     // rate limiter state so the change takes effect without a server restart.
-    // Only (re)enable enforcement when rate limit protection is actually
-    // persisted for this connection — this route never lets a caller flip
-    // `rateLimitProtection` itself, so any drift here would silently start
-    // queuing requests through Bottleneck for a connection whose DB row (and
-    // the dashboard toggle reading it) both still say "off" (#11278).
+    // Also ensure rate limit protection is active so the limiter is enforced.
     if (rateLimitOverrides !== undefined) {
       refreshConnectionRateLimits(id, updated?.rateLimitOverrides ?? null);
-      if (updated?.rateLimitProtection === true) {
-        enableRateLimitProtection(id);
-      } else {
-        disableRateLimitProtection(id);
-      }
+      enableRateLimitProtection(id);
     }
 
     // Hide sensitive fields

src/app/api/v1/models/catalog.ts

@@ -265,6 +265,10 @@ async function buildUnifiedModelsResponseCore(
     // try would let a crash here propagate as an unhandled rejection instead
     // (catalogCache.ts's in-flight coalescing does not fully consume rejections).
     const hiddenModelsByProvider = getHiddenModelsByProvider();
+    const isModelHiddenBulk = (providerId: string, modelId: string): boolean => {
+      const hiddenSet = hiddenModelsByProvider.get(providerId);
+      return hiddenSet ? hiddenSet.has(modelId) : false;
+    };
     let settings: Record<string, any> = {};
     try {
       settings = await getSettings();
@@ -373,35 +377,6 @@ async function buildUnifiedModelsResponseCore(
     const resolvePublicOwnerId = (providerId: string, canonicalProviderId: string): string =>
       providerIdToPrefix[providerId] || canonicalProviderId;
 
-    // #11300: the visibility toggle on a provider's dashboard page persists the
-    // hidden-model row under whatever key the route's `[id]` param happened to be
-    // (a node UUID, an alias like `cc`/`gh`/`cx`, or a canonical provider id) —
-    // see `PATCH /api/provider-models`. The catalog loops below each key their own
-    // lookup differently (raw connection provider, canonical id, or alias), so a
-    // single-key lookup missed the override whenever the write key and the read key
-    // diverged. Check every key a model could plausibly have been hidden under:
-    // the raw key passed in, its resolved canonical provider id, that canonical id's
-    // alias, and the compatible-provider-node prefix for either.
-    const isModelHiddenBulk = (
-      providerKey: string | null | undefined,
-      modelId: string,
-      canonicalProviderId?: string | null
-    ): boolean => {
-      if (!providerKey || !modelId) return false;
-      const canonical = canonicalProviderId || resolveCanonicalProviderId(providerKey);
-      const alias =
-        providerIdToAlias[canonical] || providerIdToAlias[providerKey] || undefined;
-      const nodePrefix = providerIdToPrefix[providerKey] || providerIdToPrefix[canonical];
-      const keysToCheck = [providerKey, canonical, alias, nodePrefix].filter(
-        (k): k is string => Boolean(k)
-      );
-      for (const key of keysToCheck) {
-        const hiddenSet = hiddenModelsByProvider.get(key);
-        if (hiddenSet?.has(modelId)) return true;
-      }
-      return false;
-    };
-
     // Get combos
     let combos = [];
     await yieldCatalogBuildTurn();
@@ -980,7 +955,7 @@ async function buildUnifiedModelsResponseCore(
         if (!isModelSelectable(canonicalProviderId, model.id)) continue;
         if (!providerSupportsModel(canonicalProviderId, model.id)) continue;
         const aliasId = `${alias}/${model.id}`;
-        if (isModelHiddenBulk(alias, model.id, canonicalProviderId)) continue;
+        if (isModelHiddenBulk(canonicalProviderId, model.id)) continue;
         if (isExcludedByProviderConnections(canonicalProviderId, model.id)) continue;
         if (shouldHidePaid(canonicalProviderId, model.id, (model as { pricing?: unknown }).pricing))
           continue;
@@ -1043,15 +1018,7 @@ async function buildUnifiedModelsResponseCore(
 
     for (const modelId of CODEX_NATIVE_UNPREFIXED_MODELS) {
       if (!providerSupportsModel("codex", modelId)) continue;
-      // #11300: a codex-native unprefixed model can also be hidden via the
-      // `openai` provider page (codex runs on the openai-compatible connection)
-      // or via the `cx` alias — check all three so a hide from any of them
-      // suppresses the bare model id here.
-      if (
-        isModelHiddenBulk("codex", modelId) ||
-        isModelHiddenBulk("openai", modelId)
-      )
-        continue;
+      if (isModelHiddenBulk("codex", modelId)) continue;
 
       const alias = providerIdToAlias.codex || "cx";
       const aliasId = `${alias}/${modelId}`;
@@ -1112,7 +1079,7 @@ async function buildUnifiedModelsResponseCore(
           if (canonicalProviderId === "codex" && isCodexDiscoveryModelExcluded(sm)) {
             continue;
           }
-          if (isModelHiddenBulk(providerId, sm.id, canonicalProviderId)) continue;
+          if (isModelHiddenBulk(providerId, sm.id)) continue;
           if (isExcludedByProviderConnections(canonicalProviderId, sm.id)) continue;
           // #6457: some upstream discovery catalogs (e.g. HuggingFace's live
           // `/v1/models`) return image/diffusion models with no modality info,
@@ -1531,7 +1498,7 @@ async function buildUnifiedModelsResponseCore(
           if (!isUnifiedChatSourceModelSelectable(canonicalProviderId, { ...model, id: modelId }))
             continue;
           if (model.isHidden === true) continue;
-          if (isModelHiddenBulk(providerId, modelId, canonicalProviderId)) continue;
+          if (isModelHiddenBulk(canonicalProviderId, modelId)) continue;
           if (isExcludedByProviderConnections(canonicalProviderId, modelId)) continue;
           // #6328: apply hidePaidModels to user-defined custom rows too.
           // Custom entries do not carry pricing, so shouldHidePaid() decides
@@ -1715,7 +1682,7 @@ async function buildUnifiedModelsResponseCore(
           continue;
         }
 
-        if (isModelHiddenBulk(providerKey, modelId, canonicalProviderId)) continue;
+        if (isModelHiddenBulk(canonicalProviderId, modelId)) continue;
         if (isExcludedByProviderConnections(canonicalProviderId, modelId)) continue;
         // #6328: apply hidePaidModels to alias-backed rows too. Alias mappings
         // point at providerKey/modelId with no pricing, so shouldHidePaid()
@@ -1789,7 +1756,7 @@ async function buildUnifiedModelsResponseCore(
       for (const model of fallbackModels) {
         const modelId = typeof model.id === "string" ? model.id : null;
         if (!modelId) continue;
-        if (isModelHiddenBulk(providerId, modelId, canonicalProviderId)) continue;
+        if (isModelHiddenBulk(canonicalProviderId, modelId)) continue;
         if (isExcludedByProviderConnections(canonicalProviderId, modelId)) continue;
         // #6328: apply hidePaidModels to managed-fallback rows too. Compatible
         // provider fallbacks lack pricing; shouldHidePaid() decides via the

src/i18n/messages/pt-BR.json

@@ -1267,7 +1267,6 @@
     "agentBridgeSubtitle": "Interceptar tráfego de agentes IDE",
     "trafficInspector": "Inspector de Tráfego",
     "trafficInspectorSubtitle": "Monitorar chamadas LLM + debugar tráfego HTTPS",
-    "trafficInspectorPurpose": "Veja exatamente o que sua aplicação envia e recebe dos provedores de IA. Funciona com qualquer cliente compatível com OpenAI.",
     "cliCode": "CLI Code's",
     "cliCodeSubtitle": "Ferramentas de código que apontam para o OmniRoute",
     "cliAgents": "CLI Agents",
@@ -1869,16 +1868,7 @@
     "directDownloadHint": "Ou baixe o formato do instalador respectivo diretamente:",
     "releaseNotes": "Notas de Lançamento",
     "readMore": "Leia Mais",
-    "noAuthLabel": "Sem Autenticação",
-    "readinessEyebrow": "Prepare-se para rotear",
-    "readinessTitle": "Envie sua primeira requisição",
-    "readinessSubtitle": "Quatro pequenos passos. O OmniRoute verifica a prontidão conforme você avança.",
-    "readinessStep1": "Conecte um provedor",
-    "readinessStep2": "Configure a autenticação do endpoint",
-    "readinessStep3": "Copie seu endpoint",
-    "readinessStep4": "Envie uma requisição de teste",
-    "readinessContinue": "Continuar configuração",
-    "readinessDismiss": "Dispensar por agora"
+    "noAuthLabel": "Sem Autenticação"
   },
   "analytics": {
     "title": "Análises",
@@ -6710,18 +6700,6 @@
     "sidebarVisibility": "Hide sidebar items",
     "sidebarVisibilityDesc": "Hide any sidebar navigation entry to reduce visual clutter.",
     "sidebarVisibilityHint": "Any sidebar section is hidden automatically when a...",
-    "presetAll": "Tudo",
-    "presetAllDesc": "Mostrar tudo",
-    "presetEssentials": "Essenciais",
-    "presetEssentialsDesc": "Caminho para iniciantes - Ferramentas avançadas continuam pesquisáveis",
-    "presetMinimal": "Mínimo",
-    "presetMinimalDesc": "Apenas páginas principais",
-    "presetDeveloper": "Desenvolvedor",
-    "presetDeveloperDesc": "Ferramentas de dev & proxy",
-    "presetAdmin": "Admin",
-    "presetAdminDesc": "Monitoramento & auditoria",
-    "settingsSidebarTitle": "Personalização da Barra Lateral",
-    "settingsSidebarDesc": "Escolha quais itens da barra lateral exibir. Essenciais mantém as ferramentas avançadas pesquisáveis.",
     "hideHealthLogs": "Ocultar Logs de Health Check",
     "hideHealthLogsDesc": "Quando ATIVADO, suprime mensagens [HealthCheck] no console do servidor",
     "themeAccent": "Cor do tema",

src/i18n/messages/vi.json

@@ -1267,7 +1267,6 @@
     "agentBridgeSubtitle": "Chặn lưu lượng agent IDE",
     "trafficInspector": "Traffic Inspector",
     "trafficInspectorSubtitle": "Giám sát lệnh gọi LLM + gỡ lỗi mọi lưu lượng HTTPS",
-    "trafficInspectorPurpose": "Xem chính xác những gì ứng dụng của bạn gửi đến và nhận từ các nhà cung cấp AI. Hoạt động với bất kỳ ứng dụng khách nào tương thích với OpenAI.",
     "cliCode": "CLI Code",
     "cliCodeSubtitle": "Các công cụ lập trình trỏ đến OmniRoute",
     "cliAgents": "CLI Agents",
@@ -1869,16 +1868,7 @@
     "directDownloadHint": "Hoặc tải trực tiếp định dạng trình cài đặt phù hợp:",
     "releaseNotes": "Ghi chú phát hành",
     "readMore": "Đọc thêm",
-    "noAuthLabel": "Không xác thực",
-    "readinessEyebrow": "Chuẩn bị định tuyến",
-    "readinessTitle": "Gửi yêu cầu đầu tiên của bạn",
-    "readinessSubtitle": "Bốn bước nhỏ. OmniRoute kiểm tra mức độ sẵn sàng khi bạn thực hiện.",
-    "readinessStep1": "Kết nối một nhà cung cấp",
-    "readinessStep2": "Định cấu hình xác thực endpoint",
-    "readinessStep3": "Sao chép endpoint của bạn",
-    "readinessStep4": "Gửi một yêu cầu thử nghiệm",
-    "readinessContinue": "Tiếp tục thiết lập",
-    "readinessDismiss": "Bỏ qua lúc này"
+    "noAuthLabel": "Không xác thực"
   },
   "analytics": {
     "title": "Phân tích",
@@ -6710,18 +6700,6 @@
     "sidebarVisibility": "Ẩn các mục trên thanh bên",
     "sidebarVisibilityDesc": "Ẩn bất kỳ mục điều hướng nào trên thanh bên để giảm bớt sự lộn xộn về mặt trực quan mà không vô hiệu hóa bất kỳ tính năng nào",
     "sidebarVisibilityHint": "Bất kỳ phần nào trên thanh bên sẽ tự động bị ẩn khi tất cả các mục bên trong nó đều bị ẩn",
-    "presetAll": "Tất cả",
-    "presetAllDesc": "Hiển thị mọi thứ",
-    "presetEssentials": "Thiết yếu",
-    "presetEssentialsDesc": "Lộ trình cho người mới bắt đầu - Công cụ nâng cao vẫn có thể tìm kiếm",
-    "presetMinimal": "Tối giản",
-    "presetMinimalDesc": "Chỉ các trang cốt lõi",
-    "presetDeveloper": "Nhà phát triển",
-    "presetDeveloperDesc": "Công cụ dev & proxy",
-    "presetAdmin": "Quản trị",
-    "presetAdminDesc": "Giám sát & kiểm toán",
-    "settingsSidebarTitle": "Tùy chỉnh thanh bên",
-    "settingsSidebarDesc": "Chọn các mục trên thanh bên sẽ hiển thị. Thiết yếu giữ cho các công cụ nâng cao vẫn có thể tìm kiếm.",
     "hideHealthLogs": "Ẩn nhật ký kiểm tra sức khỏe",
     "hideHealthLogsDesc": "Khi BẬT, sẽ chặn các thông báo [HealthCheck] trong bảng điều khiển máy chủ",
     "themeAccent": "Màu chủ đề",

src/lib/memory/__tests__/injection.test.ts

@@ -188,32 +188,6 @@ describe("injectMemory — edge cases", () => {
   });
 });
 
-describe("injectMemory — Claude-family cache-safe splice gate (#11290)", () => {
-  test("does not splice mid-array on anthropic when the last turn before the splice point is plain assistant text", () => {
-    const request = makeRequest({
-      messages: [
-        { role: "system", content: "SYSTEM PROMPT" },
-        { role: "user", content: "turn 1 question" },
-        { role: "assistant", content: "turn 1 answer" },
-        { role: "user", content: "turn 2 question" },
-      ],
-    });
-    const memories = [makeMemory("dark mode")];
-
-    const result = injectMemory(request, memories, "anthropic", { cacheSafe: true });
-
-    // The plain-text assistant turn must stay immediately followed by the final user
-    // turn — no system message spliced between them (that shape is what Opus 5 rejects
-    // with HTTP 400, #11290). Memory is merged into the leading system message instead.
-    expect(result.messages).toHaveLength(4);
-    expect(result.messages[0].role).toBe("system");
-    expect(result.messages[0].content).toContain("Memory context: dark mode");
-    expect(result.messages[0].content).toContain("SYSTEM PROMPT");
-    expect(result.messages[2]).toEqual({ role: "assistant", content: "turn 1 answer" });
-    expect(result.messages[3]).toEqual({ role: "user", content: "turn 2 question" });
-  });
-});
-
 describe("shouldInjectMemory", () => {
   test("returns true when messages are present and enabled not set", () => {
     const request = makeRequest();

src/lib/memory/injection.ts

@@ -12,10 +12,6 @@
 
 import { Memory } from "./types";
 import { logger } from "../../../open-sse/utils/logger.ts";
-import {
-  isAnthropicCompatibleProvider,
-  isClaudeCodeCompatibleProvider,
-} from "../../shared/constants/providers";
 
 const log = logger("MEMORY_INJECTION");
 
@@ -174,43 +170,6 @@ function injectSystemFirst(
   return { ...request, messages: [memorySystemMessage, ...messages] };
 }
 
-/**
- * #11290: providers in the Claude family (direct Anthropic, and any
- * anthropic-compatible / Claude-Code-compatible passthrough connection) — the
- * ones affected by the stricter Opus 5 message-ordering validation described
- * below. Deliberately narrower than `systemMessageMustBeFirst()`'s strict-set:
- * this only gates the cache-safe mid-array splice, not the leading-system-message
- * requirement, so non-Claude providers keep the #3890 cache-hit optimization
- * unconditionally.
- */
-function isClaudeFamilyProvider(provider: string | null | undefined): boolean {
-  if (!provider) return false;
-  const normalized = provider.toLowerCase().trim();
-  return (
-    normalized === "claude" ||
-    normalized === "anthropic" ||
-    isClaudeCodeCompatibleProvider(provider) ||
-    isAnthropicCompatibleProvider(provider)
-  );
-}
-
-/**
- * True when an assistant message's content ends in a server-side tool result
- * block (e.g. `web_search_tool_result`, `code_execution_tool_result`,
- * `mcp_tool_result` — any Anthropic content block whose type ends in
- * `_tool_result`, produced by a server-executed tool rather than a
- * client-executed one). `content` is typed as `string` on `ChatMessage` for
- * the common case, but the Claude-native wire shape carries an array of
- * content blocks — this only recognizes that richer shape.
- */
-function endsWithServerToolResult(message: ChatMessage | undefined): boolean {
-  if (!message || message.role !== "assistant") return false;
-  const content = message.content as unknown;
-  if (!Array.isArray(content) || content.length === 0) return false;
-  const lastBlock = content[content.length - 1] as { type?: unknown } | null | undefined;
-  return typeof lastBlock?.type === "string" && lastBlock.type.endsWith("_tool_result");
-}
-
 /**
  * Place a memory message at the #3890 cache-safe anchor (just before the last
  * user turn) when one exists, else prepend it. Shared by the system and user
@@ -263,24 +222,6 @@ export function injectMemory(
     return injectSystemFirst(request, messages, memoryText, memories.length);
   }
 
-  // #11290: Claude Opus 5 tightened server-side validation of the cache-safe
-  // mid-array splice — a system message spliced right after a plain-text assistant
-  // turn is rejected with HTTP 400 (the immediately preceding message must end in a
-  // server-side tool result for a following system message to be accepted). Rather
-  // than adding "claude"/"anthropic" outright to `systemMessageMustBeFirst()` (which
-  // would revert the #3890 cache-hit optimization for every Claude request, including
-  // the ones that work fine today), only fall back to the leading-system-message
-  // placement for the specific requests where the turn right before the splice point
-  // isn't a server tool result.
-  if (
-    supportsSystem &&
-    cacheSafeIndex >= 0 &&
-    isClaudeFamilyProvider(provider) &&
-    !endsWithServerToolResult(messages[cacheSafeIndex - 1])
-  ) {
-    return injectSystemFirst(request, messages, memoryText, memories.length);
-  }
-
   // Strategy 1 (system): prepend before existing system messages, preserving the
   // caller's own instructions. Strategy 2 (user, e.g. o1-mini): inject as a user
   // message. Both honor the #3890 cache-safe anchor via placeMessage.

src/lib/usage/providerLimits.ts

@@ -499,25 +499,6 @@ export async function maybeClearRecoveredQuotaState(
       // the previous synthetic-cooldown guard.
       return connection;
     }
-  } else if (
-    connection.rateLimitedUntil &&
-    new Date(connection.rateLimitedUntil).getTime() > Date.now()
-  ) {
-    // Universal fallback guard for every lastErrorType other than
-    // "quota_exhausted" (which gets the more precise per-window check above,
-    // and may legitimately release early once the REAL window has reset even
-    // while a synthetic rateLimitedUntil is still in the future). A future
-    // rateLimitedUntil is a hard statement made by the 429/error handler that
-    // persisted it (src/sse/services/auth.ts, src/app/api/providers/[id]/test/
-    // route.ts) — no quota poll finding *some* usable window elsewhere should
-    // be able to overrule it. Before this fix, ANY lastErrorType other than
-    // "quota_exhausted" skipped straight to hasTransientState/
-    // clearRecoveredProviderState() below with no rateLimitedUntil check at
-    // all, so a multi-day cooldown (observed: 146h, Z.AI weekly quota) got
-    // cleared on the very next quota sync a few minutes later — a
-    // self-restart/burn loop that kept burning real upstream calls against a
-    // known-exhausted connection (#11277).
-    return connection;
   }
 
   const hasTransientState =

tests/unit/11018-database-cache-docs.test.ts

@@ -1,15 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { DEFAULT_DATABASE_SETTINGS } from "../../src/types/databaseSettings.ts";
-
-const guide = readFileSync(new URL("../../docs/ops/DATABASE_GUIDE.md", import.meta.url), "utf8");
-
-test("database guide keeps cache tuning aligned with runtime settings (#11018)", () => {
-  const defaultCacheSize = DEFAULT_DATABASE_SETTINGS.optimization.cacheSize;
-
-  assert.match(guide, new RegExp(`${defaultCacheSize.toLocaleString("en-US")} KiB`));
-  assert.match(guide, /1 to\s+1,000,000 KiB/);
-  assert.match(guide, /saving the setting applies it to the live database connection/);
-  assert.match(guide, /restores the persisted value at startup/);
-});

tests/unit/compression-cli-rest-fallback-6571.test.ts

@@ -2,15 +2,9 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 // Repro for #6571 — REST-fallback path of `omniroute compression` (hit only when
-// the MCP surface is not mounted, i.e. mcpCall()'s 404/501 branch) uses the
+// /api/mcp/tools/call is not mounted, i.e. mcpCall()'s 404/501 branch) uses the
 // nonexistent `engine` field instead of the canonical `defaultMode` field, and
 // the table renderer prints "[object Object]" for nested object cells.
-//
-// #10960 moved the MCP transport from the never-mounted `/api/mcp/tools/call`
-// to the real Streamable HTTP endpoint `/api/mcp/stream` (mcpClient.mjs ->
-// callMcpEndpoint()). The REST-fallback trigger in these mocks must match
-// that endpoint, not the retired one, or mcpCallTool() throws on an
-// unmocked fetch instead of exercising the fallback path this test targets.
 
 type MockResponse = Pick<Response, "ok" | "status" | "headers" | "json" | "text">;
 
@@ -51,7 +45,7 @@ test("restCompressionStatus (via runCompressionStatus REST fallback) should surf
   const origFetch = globalThis.fetch;
   globalThis.fetch = (async (url: string | URL | Request) => {
     const u = String(url);
-    if (u.includes("/api/mcp/stream")) return makeResp({ error: "not mounted" }, 404);
+    if (u.includes("/api/mcp/tools/call")) return makeResp({ error: "not mounted" }, 404);
     if (u.includes("/api/settings/compression")) {
       // Canonical server payload — NOTE: field is `defaultMode`, there is no `engine` key.
       // src/lib/db/compression.ts COMPRESSION_MODES / GET route just returns getCompressionSettings().
@@ -91,7 +85,7 @@ test("restSetEngine (via runCompressionEngineSet REST fallback) should PUT `defa
   const putBodies: Record<string, unknown>[] = [];
   globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
     const u = String(url);
-    if (u.includes("/api/mcp/stream")) return makeResp({ error: "not mounted" }, 404);
+    if (u.includes("/api/mcp/tools/call")) return makeResp({ error: "not mounted" }, 404);
     if (u.includes("/api/settings/compression") && init?.method === "PUT") {
       const body = init?.body ? JSON.parse(String(init.body)) : {};
       putBodies.push(body);

tests/unit/hidden-models-leak-v1-models-11300.test.ts

@@ -1,177 +0,0 @@
-/**
- * #11300 — Models toggled to "Hidden" on Provider pages are still listed in
- * `GET /v1/models`.
- *
- * `PATCH /api/provider-models?provider=<key>&modelId=<id>` persists the hidden
- * override under whatever key the dashboard's `[id]` route param happened to be
- * (an alias like `cc`/`gh`/`cx`, a canonical provider id, a compatible-provider
- * node UUID, or its configured prefix). `catalog.ts`'s `isModelHiddenBulk()` did
- * a single-key lookup, so a model stayed listed in `/v1/models` whenever the key
- * used to READ diverged from the key used to WRITE:
- *
- *  - Static `PROVIDER_MODELS` loop checked only `canonicalProviderId` — a model
- *    hidden under the alias (e.g. `cc` for Claude Code) never matched.
- *  - The Codex-native-unprefixed loop checked only `"codex"` — a model hidden
- *    via the `openai` provider page (codex often shares the openai-compatible
- *    connection) never matched.
- *  - The synced-discovery loop checked only the raw connection `providerId` —
- *    a model hidden via the compatible-provider node's configured *prefix*
- *    (the identifier the operator actually sees/uses on that node's page)
- *    never matched.
- */
-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-11300-hidden-leak-"));
-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 modelsDb = await import("../../src/lib/db/models.ts");
-const { mergeModelCompatOverride } = await import("../../src/lib/localDb.ts");
-const v1ModelsCatalog = await import("../../src/app/api/v1/models/catalog.ts");
-
-async function resetStorage() {
-  core.resetDbInstance();
-  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
-  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
-  v1ModelsCatalog.__resetCatalogBuilderRunsForTest();
-}
-
-test.beforeEach(async () => {
-  await resetStorage();
-});
-
-test.after(async () => {
-  core.resetDbInstance();
-  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
-});
-
-async function fetchCatalogIds(): Promise<string[]> {
-  const response = await v1ModelsCatalog.getUnifiedModelsResponse(
-    new Request("http://localhost/api/v1/models")
-  );
-  assert.equal(response.status, 200);
-  const body = (await response.json()) as { data: Array<{ id: string }> };
-  assert.ok(Array.isArray(body.data), "response has data array");
-  return body.data.map((m) => m.id);
-}
-
-test("#11300 A: hiding a static model under its ALIAS (cc) excludes it under both cc/ and claude/ ids", async () => {
-  await providersDb.createProviderConnection({
-    provider: "claude",
-    authType: "apikey",
-    name: "claude-main",
-    apiKey: "sk-test-11300a",
-    isActive: true,
-    testStatus: "active",
-    providerSpecificData: {},
-  });
-
-  // Sanity: before hiding, the model is advertised.
-  let ids = await fetchCatalogIds();
-  assert.ok(
-    ids.includes("cc/claude-opus-5"),
-    `expected cc/claude-opus-5 to be listed before hiding — got ${JSON.stringify(ids.filter((i) => i.includes("claude-opus-5")))}`
-  );
-
-  // Operator hides the model on the provider page, whose route param is the
-  // alias "cc" (not the canonical "claude").
-  mergeModelCompatOverride("cc", "claude-opus-5", { isHidden: true });
-
-  ids = await fetchCatalogIds();
-  assert.ok(
-    !ids.includes("cc/claude-opus-5"),
-    `#11300 RED: cc/claude-opus-5 hidden under alias "cc" must not appear — got ${JSON.stringify(ids.filter((i) => i.includes("claude-opus-5")))}`
-  );
-  assert.ok(
-    !ids.includes("claude/claude-opus-5"),
-    `#11300 RED: claude/claude-opus-5 hidden under alias "cc" must not appear either`
-  );
-});
-
-test("#11300 B: hiding a codex-native unprefixed model under \"openai\" excludes the bare model id", async () => {
-  await providersDb.createProviderConnection({
-    provider: "codex",
-    authType: "oauth",
-    name: "codex-main",
-    apiKey: "sk-test-11300b",
-    isActive: true,
-    testStatus: "active",
-    providerSpecificData: {},
-  });
-
-  const nativeModelId = "gpt-5.6-sol";
-
-  let ids = await fetchCatalogIds();
-  assert.ok(
-    ids.includes(nativeModelId),
-    `expected bare "${nativeModelId}" to be listed before hiding — got ${JSON.stringify(ids.filter((i) => i.includes("gpt-5.6-sol")))}`
-  );
-
-  // Hidden via the "openai" provider page (codex native models are commonly
-  // reached through the shared openai-compatible connection).
-  mergeModelCompatOverride("openai", nativeModelId, { isHidden: true });
-
-  ids = await fetchCatalogIds();
-  assert.ok(
-    !ids.includes(nativeModelId),
-    `#11300 RED: bare "${nativeModelId}" hidden under "openai" must not appear — got ${JSON.stringify(ids.filter((i) => i.includes("gpt-5.6-sol")))}`
-  );
-});
-
-test("#11300 C: hiding a compatible-node synced model under its configured PREFIX excludes prefix/<model>", async () => {
-  const NODE_ID = "openai-compatible-chat-11300-c0ffee00-0000-4000-8000-000000000000";
-  const PREFIX = "deepseek-node-11300";
-
-  await providersDb.createProviderNode({
-    id: NODE_ID,
-    type: "openai-compatible",
-    name: "Deepseek Node (11300 probe)",
-    prefix: PREFIX,
-    baseUrl: "https://proxy.example.com",
-    chatPath: "/v1/chat/completions",
-    modelsPath: "/v1/models",
-  });
-  const connection = await providersDb.createProviderConnection({
-    provider: NODE_ID,
-    authType: "apikey",
-    name: "deepseek-node-conn",
-    apiKey: "sk-test-11300c",
-    isActive: true,
-    testStatus: "active",
-    providerSpecificData: {
-      baseUrl: "https://proxy.example.com",
-      chatPath: "/v1/chat/completions",
-      modelsPath: "/v1/models",
-    },
-  });
-
-  const modelId = "deepseek-v4-flash-0731";
-  await modelsDb.replaceSyncedAvailableModelsForConnection(NODE_ID, (connection as { id: string }).id, [
-    { id: modelId, name: "DeepSeek V4 Flash", source: "imported", supportedEndpoints: ["chat"] },
-  ]);
-
-  let ids = await fetchCatalogIds();
-  assert.ok(
-    ids.includes(`${PREFIX}/${modelId}`),
-    `expected ${PREFIX}/${modelId} to be listed before hiding — got ${JSON.stringify(ids.filter((i) => i.includes(modelId)))}`
-  );
-
-  // Operator hides the model via the node's page, which is keyed by the
-  // configured prefix rather than the internal node UUID.
-  mergeModelCompatOverride(PREFIX, modelId, { isHidden: true });
-
-  ids = await fetchCatalogIds();
-  assert.ok(
-    !ids.includes(`${PREFIX}/${modelId}`),
-    `#11300 RED: ${PREFIX}/${modelId} hidden under prefix "${PREFIX}" must not appear — got ${JSON.stringify(ids.filter((i) => i.includes(modelId)))}`
-  );
-  assert.ok(
-    !ids.includes(`${NODE_ID}/${modelId}`),
-    `#11300 RED: ${NODE_ID}/${modelId} hidden under prefix "${PREFIX}" must not appear either`
-  );
-});

tests/unit/kiro-auto-import-name-dedup-3615.test.ts

@@ -113,18 +113,12 @@ test("derived name is never empty or null", () => {
 
 const FAKE_PROFILE_ARN = "arn:aws:iam::123456789012:user/sso-user";
 
-const FAKE_CLIENT_ID = "client-abc";
-
 const fakeConnectionWithArn = {
   id: "conn-abc",
   provider: "kiro",
   authType: "oauth",
   email: null,
-  providerSpecificData: {
-    profileArn: FAKE_PROFILE_ARN,
-    region: "us-east-1",
-    clientId: FAKE_CLIENT_ID,
-  },
+  providerSpecificData: { profileArn: FAKE_PROFILE_ARN, region: "us-east-1" },
 };
 
 const fakeConnectionNoArn = {
@@ -135,29 +129,13 @@ const fakeConnectionNoArn = {
   providerSpecificData: { region: "us-east-1" },
 };
 
-test("findKiroConnectionByProfileArn returns the matching connection when an account identifier agrees", async () => {
-  // #10815 — matching on profileArn alone is unsafe (distinct Builder ID
-  // accounts can share a profile ARN), so the caller must also supply an
-  // account-level identifier (email or clientId) that does not contradict
-  // the stored connection, exactly like saveAndRespond()'s real call sites do.
-  const result = await findKiroConnectionByProfileArn(
-    [fakeConnectionWithArn, fakeConnectionNoArn],
-    FAKE_PROFILE_ARN,
-    { clientId: FAKE_CLIENT_ID }
-  );
-  assert.deepEqual(result, fakeConnectionWithArn);
-});
-
-test("findKiroConnectionByProfileArn returns null for a profileArn-only match with no account identifier (#10815)", async () => {
-  // Guards the #10815 fix: two different Builder ID accounts (Google/GitHub
-  // social login) can share the same CodeWhisperer profile ARN, so trusting
-  // an ARN match without any account identifier would let a second social
-  // login silently overwrite the first connection.
+test("findKiroConnectionByProfileArn returns the matching connection", async () => {
+  // The function should scan existing kiro connections and match by profileArn.
   const result = await findKiroConnectionByProfileArn(
     [fakeConnectionWithArn, fakeConnectionNoArn],
     FAKE_PROFILE_ARN
   );
-  assert.equal(result, null);
+  assert.deepEqual(result, fakeConnectionWithArn);
 });
 
 test("findKiroConnectionByProfileArn returns null when no match exists", async () => {

tests/unit/learned-reasoning-effort-caps.test.ts

@@ -130,18 +130,13 @@ test("a later, lower accepted-list does ratchet the cap down", () => {
   assert.equal((getLearnedReasoningEffort("acme", "model-x") as unknown as Set<string>).size, 2);
 });
 
-// #11295: nearest-tier semantics (smallest accepted >= demand) — unified with
-// the declared/static clamp. Was downgrade-only (greatest accepted <= demand,
-// medium→low) before #11295.
-test("clampToLearned medium→high when accepted is low,high,max (nearest-tier, #11295)", async () => {
+test("clampToLearned medium→low when accepted is low,high,max", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
-  assert.equal(clampToLearned("medium", new Set(["low", "high", "max"])), "high");
+  assert.equal(clampToLearned("medium", new Set(["low", "high", "max"])), "low");
 });
-// #11295: xhigh(rank 5) has no accepted tier >= it among {low,high,max}
-// (max=6 IS >= 5, so nearest-tier picks max) — was downgrade-only high before.
-test("clampToLearned xhigh→max when accepted is low,high,max (nearest-tier, #11295)", async () => {
+test("clampToLearned xhigh→high when accepted is low,high,max", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
-  assert.equal(clampToLearned("xhigh", new Set(["low", "high", "max"])), "max");
+  assert.equal(clampToLearned("xhigh", new Set(["low", "high", "max"])), "high");
 });
 test("clampToLearned ultra→max when accepted is low,high,max", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
@@ -159,25 +154,17 @@ test("clampToLearned returns null when already accepted", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
   assert.equal(clampToLearned("low", new Set(["low", "high", "max"])), null);
 });
-// #11295: a sub-floor demand (below every accepted value) now maps to the
-// accepted floor instead of returning null. Pre-#11295 this returned null —
-// no clamp — so the too-low value passed straight through to the upstream,
-// which 400'd again on every subsequent request without ever learning a
-// lower floor.
-test("clampToLearned maps sub-floor demand to the accepted floor instead of null (#11295)", async () => {
+test("clampToLearned returns null when effort < min (no upgrade)", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
-  assert.equal(clampToLearned("low", new Set(["high", "max"])), "high");
+  assert.equal(clampToLearned("low", new Set(["high", "max"])), null);
 });
 test("clampToLearned returns null for turbo (not in ORDER)", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
   assert.equal(clampToLearned("turbo", new Set(["low", "high", "max"])), null);
 });
-// #11295: none is below the learned floor {low,high,max} — nearest-tier maps
-// it to the floor (low) instead of returning null (no clamp, upstream 400s
-// again with no chance to ever learn a lower floor).
-test("clampToLearned maps none to the floor (low) when accepted is low,high,max (#11295)", async () => {
+test("clampToLearned returns null when effort is none but accepted is low,high,max", async () => {
   const { clampToLearned } = await import("../../open-sse/services/learnedReasoningEffortCaps.ts");
-  assert.equal(clampToLearned("none", new Set(["low", "high", "max"])), "low");
+  assert.equal(clampToLearned("none", new Set(["low", "high", "max"])), null);
 });
 test("recordLearned stores Set and getLearned returns Set", () => {
   const s = recordLearnedReasoningEffort("acme", "m1", ["low", "high", "max"]);

tests/unit/memory-cache-safe-injection.test.ts

@@ -39,20 +39,16 @@ function multiTurn(): ChatRequest {
 
 describe("injectMemory cache-safe positioning (#3890)", () => {
   it("default (cacheSafe off) prepends memory at index 0 — unchanged legacy behavior", () => {
-    const out = injectMemory(multiTurn(), [mem("dark mode")], "openai");
+    const out = injectMemory(multiTurn(), [mem("dark mode")], "anthropic");
     assert.equal(out.messages[0].role, "system");
     assert.ok(out.messages[0].content.includes("Memory context"));
     assert.equal(out.messages[1].content, "SYSTEM PROMPT");
   });
 
-  // Note: "openai" here stands in for any non-Claude-family provider that honors the
-  // cache-safe mid-array splice (e.g. DashScope/Xiaomi MiMo via OpenAI-format
-  // cache_control). Claude-family providers (anthropic/claude/CC-compatible) have their
-  // own, narrower gate covered in the "#11290" describe block below.
   it("cacheSafe inserts memory just before the last user message, preserving the prefix", () => {
     const req = multiTurn();
     const prefixBefore = JSON.stringify(req.messages.slice(0, 3)); // sys, u1, a1
-    const out = injectMemory(req, [mem("dark mode")], "openai", { cacheSafe: true });
+    const out = injectMemory(req, [mem("dark mode")], "anthropic", { cacheSafe: true });
 
     // The cacheable prefix (system + prior turns up to the last assistant) is byte-identical.
     assert.equal(JSON.stringify(out.messages.slice(0, 3)), prefixBefore);
@@ -79,8 +75,8 @@ describe("injectMemory cache-safe positioning (#3890)", () => {
     };
     const turn2 = multiTurn();
 
-    const out1 = injectMemory(turn1, [mem("A")], "openai", { cacheSafe: true });
-    const out2 = injectMemory(turn2, [mem("B")], "openai", { cacheSafe: true });
+    const out1 = injectMemory(turn1, [mem("A")], "anthropic", { cacheSafe: true });
+    const out2 = injectMemory(turn2, [mem("B")], "anthropic", { cacheSafe: true });
 
     // The cache-breakpoint-bearing system message stays at the head, byte-identical, in
     // both turns (and is NOT displaced by the per-query memory) — so the prompt cache
@@ -107,76 +103,3 @@ describe("injectMemory cache-safe positioning (#3890)", () => {
     assert.equal(out.messages[1].content, "SYS");
   });
 });
-
-/**
- * #11290: Claude Opus 5 tightened server-side validation and started rejecting the
- * #3890 cache-safe mid-array splice with HTTP 400 whenever the assistant turn
- * immediately before the splice point is a plain-text turn (not a server-side tool
- * result). These tests pin the narrower, Claude-family-only gate added to
- * `injectMemory()`: fall back to leading-system-message placement in that specific
- * case, while still honoring the mid-array splice everywhere it is safe (non-Claude
- * providers unconditionally, and Claude providers whose preceding turn IS a server
- * tool result).
- */
-describe("injectMemory cache-safe positioning — Claude-family server-tool-result gate (#11290)", () => {
-  it("falls back to leading system-message placement for anthropic when the preceding assistant turn is plain text", () => {
-    const out = injectMemory(multiTurn(), [mem("dark mode")], "anthropic", { cacheSafe: true });
-
-    // No splice: the memory is merged into the leading system message instead of being
-    // inserted right after the plain-text "turn 1 answer" assistant turn.
-    assert.equal(out.messages.length, 4);
-    assert.equal(out.messages[0].role, "system");
-    assert.ok(out.messages[0].content.includes("Memory context: dark mode"));
-    assert.ok(out.messages[0].content.includes("SYSTEM PROMPT"));
-    assert.equal(out.messages[1].content, "turn 1 question");
-    assert.equal(out.messages[2].content, "turn 1 answer");
-    assert.equal(out.messages[3].content, "turn 2 question");
-  });
-
-  it("still splices mid-array for anthropic when the preceding assistant turn ends in a server tool result", () => {
-    const req: ChatRequest = {
-      model: "anthropic/claude-opus-5",
-      messages: [
-        { role: "system", content: "SYSTEM PROMPT" },
-        { role: "user", content: "turn 1 question" },
-        {
-          role: "assistant",
-          content: [
-            { type: "server_tool_use", id: "srvtoolu_1", name: "web_search", input: {} },
-            { type: "web_search_tool_result", tool_use_id: "srvtoolu_1", content: [] },
-          ],
-        } as unknown as ChatRequest["messages"][number],
-        { role: "user", content: "turn 2 question" },
-      ],
-    };
-
-    const out = injectMemory(req, [mem("dark mode")], "anthropic", { cacheSafe: true });
-
-    assert.equal(out.messages.length, 5);
-    assert.equal(out.messages[0].content, "SYSTEM PROMPT");
-    assert.equal(out.messages[3].role, "system");
-    assert.ok(out.messages[3].content.includes("Memory context"));
-    assert.equal(out.messages[4].content, "turn 2 question");
-  });
-
-  it("applies the same fallback to a Claude-Code-compatible passthrough provider id", () => {
-    const out = injectMemory(multiTurn(), [mem("dark mode")], "anthropic-compatible-cc-github-copilot", {
-      cacheSafe: true,
-    });
-
-    assert.equal(out.messages.length, 4);
-    assert.equal(out.messages[0].role, "system");
-    assert.ok(out.messages[0].content.includes("Memory context: dark mode"));
-    assert.ok(out.messages[0].content.includes("SYSTEM PROMPT"));
-  });
-
-  it("does not gate non-Claude providers even without a server tool result", () => {
-    const out = injectMemory(multiTurn(), [mem("dark mode")], "openai", { cacheSafe: true });
-
-    // Unaffected by #11290: the mid-array splice is preserved for non-Claude providers.
-    assert.equal(out.messages.length, 5);
-    assert.equal(out.messages[3].role, "system");
-    assert.ok(out.messages[3].content.includes("Memory context"));
-    assert.equal(out.messages[4].content, "turn 2 question");
-  });
-});

tests/unit/memory-system-first-6135.test.ts

@@ -111,13 +111,7 @@ describe("injectMemory system-must-be-first (#6135)", () => {
 
   it("regression: a NON-flagged provider keeps the existing cache-safe placement", () => {
     const req = multiTurn();
-    // #11290/#11303 added a Claude-family-specific reroute to injectSystemFirst()
-    // for the mid-array splice (a system message right after a plain-text
-    // assistant turn is rejected by Claude Opus 5), so "anthropic" no longer
-    // exercises the plain cache-safe splice path this test targets. Use a
-    // provider outside both the strict-system-first set AND the Claude family
-    // to keep testing the original (still-current) cache-safe behavior.
-    const out = injectMemory(req, [mem("dark mode")], "openai", { cacheSafe: true });
+    const out = injectMemory(req, [mem("dark mode")], "anthropic", { cacheSafe: true });
     // Existing behavior: memory inserted just before the last user message (index 3).
     assert.equal(out.messages[3].role, "system");
     assert.ok(out.messages[3].content.includes("Memory context"));

tests/unit/openai-responses-opencode-subagent-sessionid.test.ts

@@ -1,515 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-// OpenCode `subagent.sessionID` is an optional plain string. Absence means "spawn a
-// new child". Responses/Codex strict mode forces every declared property into
-// `required`, so models invent fillers (`ses_`, `ses_new`, parent IDs) unless
-// OmniRoute offers `null` as the omission sentinel and strips it before the client
-// sees the tool call. This is the string counterpart of the #7023 enum sentinel.
-
-const { injectOptionalStringOmissionSentinel, injectOptionalStringOmissionForTools } =
-  await import("../../open-sse/translator/helpers/schemaCoercion.ts");
-const { stripEmptyOptionalToolArgs } =
-  await import("../../open-sse/translator/response/openai-responses/pureHelpers.ts");
-const { openaiResponsesToOpenAIResponse } =
-  await import("../../open-sse/translator/response/openai-responses.ts");
-const { translateRequest } = await import("../../open-sse/translator/index.ts");
-const { FORMATS } = await import("../../open-sse/translator/formats.ts");
-const { translateNonStreamingResponse } =
-  await import("../../open-sse/handlers/responseTranslator.ts");
-const { extractToolSchemaMap } =
-  await import("../../open-sse/translator/response/openai-responses/toolSchemas.ts");
-
-const OMISSION_MARKER = "null = omit this parameter";
-
-const OPENCODE_SUBAGENT_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    agent: { type: "string" },
-    description: { type: "string" },
-    prompt: { type: "string" },
-    sessionID: {
-      type: "string",
-      description: "Continue a specific previous subagent conversation",
-    },
-    background: { type: "boolean" },
-  },
-  required: ["agent", "description", "prompt"],
-};
-
-const SUBAGENT_TOOL_CHAT = {
-  type: "function",
-  function: {
-    name: "subagent",
-    parameters: structuredClone(OPENCODE_SUBAGENT_SCHEMA),
-  },
-};
-
-const SUBAGENT_TOOL_RESPONSES = {
-  type: "function",
-  name: "subagent",
-  parameters: structuredClone(OPENCODE_SUBAGENT_SCHEMA),
-};
-
-const NATIVE_CUSTOM_TOOL = {
-  type: "custom",
-  name: "apply_patch",
-  format: { type: "grammar", syntax: "lark", definition: "start: /.+/ " },
-};
-
-function findTool(tools, name) {
-  return tools.find((t) => t?.name === name || t?.function?.name === name);
-}
-
-function toolParameters(tool) {
-  return tool.parameters ?? tool.function?.parameters ?? tool.input_schema;
-}
-
-function sessionIdSchema(params) {
-  return params.properties.sessionID;
-}
-
-function assertOmissionSentinel(prop) {
-  assert.deepEqual(prop.type, ["string", "null"]);
-  assert.match(
-    prop.description,
-    new RegExp(OMISSION_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-  );
-  assert.equal(Array.isArray(prop.enum), false);
-}
-
-function collectArgs(chunks) {
-  const list = Array.isArray(chunks) ? chunks : chunks ? [chunks] : [];
-  let raw = "";
-  let finishReason = null;
-  for (const chunk of list) {
-    const choice = chunk?.choices?.[0];
-    if (!choice) continue;
-    const args = choice.delta?.tool_calls?.[0]?.function?.arguments;
-    if (typeof args === "string") raw += args;
-    if (choice.finish_reason) finishReason = choice.finish_reason;
-  }
-  return { raw, finishReason, parsed: raw ? JSON.parse(raw) : null };
-}
-
-test("RED: translateRequest OpenAI→Responses widens optional default-less sessionID", () => {
-  const body = {
-    model: "gpt-5.1-codex",
-    messages: [{ role: "user", content: "hi" }],
-    tools: [structuredClone(SUBAGENT_TOOL_CHAT)],
-  };
-
-  const toResponses = translateRequest(
-    FORMATS.OPENAI,
-    FORMATS.OPENAI_RESPONSES,
-    "gpt-5.1-codex",
-    structuredClone(body)
-  );
-  const tool = findTool(toResponses.tools, "subagent");
-  const params = toolParameters(tool);
-  assertOmissionSentinel(sessionIdSchema(params));
-  assert.equal(params.properties.agent.type, "string");
-  assert.equal(params.properties.background.type, "boolean");
-  assert.deepEqual(params.required, ["agent", "description", "prompt"]);
-});
-
-test("RED: same-format Responses applies string omission without flattening native tools", () => {
-  const body = {
-    model: "gpt-5.1-codex",
-    input: [{ role: "user", content: "hi" }],
-    tools: [structuredClone(SUBAGENT_TOOL_RESPONSES), structuredClone(NATIVE_CUSTOM_TOOL)],
-  };
-
-  const sameFormat = translateRequest(
-    FORMATS.OPENAI_RESPONSES,
-    FORMATS.OPENAI_RESPONSES,
-    "gpt-5.1-codex",
-    structuredClone(body)
-  );
-  const functionTool = findTool(sameFormat.tools, "subagent");
-  assertOmissionSentinel(sessionIdSchema(toolParameters(functionTool)));
-
-  const custom = sameFormat.tools.find((t) => t.name === "apply_patch");
-  assert.equal(custom.type, "custom");
-  assert.deepEqual(custom.format, NATIVE_CUSTOM_TOOL.format);
-  assert.equal(custom.parameters, undefined);
-});
-
-test("characterization: non-Responses target leaves sessionID unchanged", () => {
-  const body = {
-    model: "claude-3-7-sonnet",
-    messages: [{ role: "user", content: "hi" }],
-    tools: [structuredClone(SUBAGENT_TOOL_CHAT)],
-  };
-  const toClaude = translateRequest(
-    FORMATS.OPENAI,
-    FORMATS.CLAUDE,
-    "claude-3-7-sonnet",
-    structuredClone(body)
-  );
-  const tool = toClaude.tools.find((t) => String(t.name).includes("subagent"));
-  const schema = toolParameters(tool);
-  assert.equal(schema.properties.sessionID.type, "string");
-  assert.equal(
-    String(schema.properties.sessionID.description || "").includes(OMISSION_MARKER),
-    false
-  );
-});
-
-test("characterization: required string stays non-nullable; unmarked required null is kept", () => {
-  const requiredOnly = injectOptionalStringOmissionSentinel({
-    type: "object",
-    properties: { sessionID: { type: "string" } },
-    required: ["sessionID"],
-  });
-  assert.equal(requiredOnly.properties.sessionID.type, "string");
-
-  const requiredNull = stripEmptyOptionalToolArgs(
-    { sessionID: null, agent: "explore" },
-    "subagent",
-    {
-      type: "object",
-      properties: { sessionID: { type: "string" }, agent: { type: "string" } },
-      required: ["sessionID", "agent"],
-    }
-  );
-  assert.equal(Object.prototype.hasOwnProperty.call(requiredNull, "sessionID"), true);
-  assert.equal(requiredNull.sessionID, null);
-});
-
-test("characterization: optional string with default stays unsentinelled through translateRequest", () => {
-  const body = {
-    model: "gpt-5.1-codex",
-    messages: [{ role: "user", content: "hi" }],
-    tools: [
-      {
-        type: "function",
-        function: {
-          name: "subagent",
-          parameters: {
-            type: "object",
-            properties: {
-              agent: { type: "string" },
-              sessionID: { type: "string", default: "" },
-            },
-            required: ["agent"],
-          },
-        },
-      },
-    ],
-  };
-  const toResponses = translateRequest(
-    FORMATS.OPENAI,
-    FORMATS.OPENAI_RESPONSES,
-    "gpt-5.1-codex",
-    structuredClone(body)
-  );
-  const params = toolParameters(findTool(toResponses.tools, "subagent"));
-  assert.equal(params.properties.sessionID.type, "string");
-  assert.equal(
-    String(params.properties.sessionID.description || "").includes(OMISSION_MARKER),
-    false
-  );
-});
-
-test("characterization: optional unmarked null is already stripped; real IDs are kept", () => {
-  const optionalSchema = structuredClone(OPENCODE_SUBAGENT_SCHEMA);
-  const stripped = stripEmptyOptionalToolArgs(
-    {
-      agent: "explore",
-      description: "spawn",
-      prompt: "do work",
-      sessionID: null,
-    },
-    "subagent",
-    optionalSchema
-  );
-  assert.equal(Object.prototype.hasOwnProperty.call(stripped, "sessionID"), false);
-
-  const kept = stripEmptyOptionalToolArgs(
-    {
-      agent: "explore",
-      description: "continue",
-      prompt: "do work",
-      sessionID: "ses_valid_child",
-    },
-    "subagent",
-    optionalSchema
-  );
-  assert.equal(kept.sessionID, "ses_valid_child");
-});
-
-test("RED: strictified required sessionID with OmniRoute marker still drops null", () => {
-  const strictified = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      agent: { type: "string" },
-      description: { type: "string" },
-      prompt: { type: "string" },
-      sessionID: {
-        type: ["string", "null"],
-        description: `Continue a specific previous subagent conversation (${OMISSION_MARKER})`,
-      },
-      background: { type: "boolean" },
-    },
-    required: ["agent", "description", "prompt", "sessionID", "background"],
-  };
-  const stripped = stripEmptyOptionalToolArgs(
-    {
-      agent: "explore",
-      description: "spawn",
-      prompt: "do work",
-      sessionID: null,
-    },
-    "subagent",
-    strictified
-  );
-  assert.equal(Object.prototype.hasOwnProperty.call(stripped, "sessionID"), false);
-  assert.equal(stripped.agent, "explore");
-});
-
-test("characterization: empty sessionID is stripped; nested optional strings are not widened", () => {
-  const emptyStripped = stripEmptyOptionalToolArgs(
-    {
-      agent: "explore",
-      description: "spawn",
-      prompt: "do work",
-      sessionID: "",
-    },
-    "subagent",
-    OPENCODE_SUBAGENT_SCHEMA
-  );
-  assert.equal(Object.prototype.hasOwnProperty.call(emptyStripped, "sessionID"), false);
-
-  const nested = injectOptionalStringOmissionSentinel({
-    type: "object",
-    properties: {
-      items: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: { sessionID: { type: "string" } },
-          required: [],
-        },
-      },
-      wrapper: {
-        anyOf: [{ type: "object", properties: { sessionID: { type: "string" } } }],
-      },
-      $defs: {
-        child: { type: "object", properties: { sessionID: { type: "string" } } },
-      },
-    },
-    required: [],
-  });
-  assert.equal(nested.properties.items.items.properties.sessionID.type, "string");
-  assert.equal(nested.properties.wrapper.anyOf[0].properties.sessionID.type, "string");
-  assert.equal(nested.properties.$defs.child.properties.sessionID.type, "string");
-
-  const mixedUnion = injectOptionalStringOmissionSentinel({
-    type: "object",
-    properties: { value: { type: ["string", "number"] } },
-    required: [],
-  });
-  assert.deepEqual(mixedUnion.properties.value.type, ["string", "number"]);
-});
-
-test("characterization: string omission injection is idempotent", () => {
-  const once = injectOptionalStringOmissionSentinel(structuredClone(OPENCODE_SUBAGENT_SCHEMA));
-  const twice = injectOptionalStringOmissionSentinel(once);
-  assertOmissionSentinel(sessionIdSchema(twice));
-  assert.equal(twice.properties.sessionID.description.split(OMISSION_MARKER).length - 1, 1);
-  const toolsOnce = injectOptionalStringOmissionForTools([
-    structuredClone(SUBAGENT_TOOL_RESPONSES),
-  ]);
-  const toolsTwice = injectOptionalStringOmissionForTools(toolsOnce);
-  assertOmissionSentinel(toolParameters(toolsTwice[0]).properties.sessionID);
-});
-
-test("characterization: fragmented deltas + output_item.done emit cleaned lowercase subagent args", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      agent: { type: "string" },
-      description: { type: "string" },
-      prompt: { type: "string" },
-      sessionID: {
-        type: ["string", "null"],
-        description: `Continue a specific previous subagent conversation (${OMISSION_MARKER})`,
-      },
-    },
-    required: ["agent", "description", "prompt"],
-  };
-  const state = { toolSchemas: new Map([["subagent", schema]]) };
-  openaiResponsesToOpenAIResponse(
-    {
-      type: "response.output_item.added",
-      item: { type: "function_call", call_id: "call_1", name: "subagent" },
-    },
-    state
-  );
-  const raw = JSON.stringify({
-    agent: "explore",
-    description: "spawn",
-    prompt: "do work",
-    sessionID: null,
-  });
-  const firstDelta = openaiResponsesToOpenAIResponse(
-    { type: "response.function_call_arguments.delta", delta: raw.slice(0, 40) },
-    state
-  );
-  const secondDelta = openaiResponsesToOpenAIResponse(
-    { type: "response.function_call_arguments.delta", delta: raw.slice(40) },
-    state
-  );
-  const done = openaiResponsesToOpenAIResponse(
-    {
-      type: "response.output_item.done",
-      item: { type: "function_call", call_id: "call_1", name: "subagent", arguments: raw },
-    },
-    state
-  );
-
-  assert.equal(firstDelta, null);
-  assert.equal(secondDelta, null);
-  const args = JSON.parse(done.choices[0].delta.tool_calls[0].function.arguments);
-  assert.equal(Object.prototype.hasOwnProperty.call(args, "sessionID"), false);
-  assert.equal(args.agent, "explore");
-  assert.equal(args.prompt, "do work");
-});
-
-test("RED: incomplete-stream flush emits cleaned lowercase subagent arguments", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      agent: { type: "string" },
-      description: { type: "string" },
-      prompt: { type: "string" },
-      sessionID: {
-        type: ["string", "null"],
-        description: `Continue a specific previous subagent conversation (${OMISSION_MARKER})`,
-      },
-    },
-    required: ["agent", "description", "prompt"],
-  };
-  const state = { toolSchemas: new Map([["subagent", schema]]) };
-  openaiResponsesToOpenAIResponse(
-    {
-      type: "response.output_item.added",
-      item: { type: "function_call", call_id: "call_1", name: "subagent" },
-    },
-    state
-  );
-  const raw = JSON.stringify({
-    agent: "explore",
-    description: "spawn",
-    prompt: "do work",
-    sessionID: null,
-  });
-  openaiResponsesToOpenAIResponse(
-    { type: "response.function_call_arguments.delta", delta: raw },
-    state
-  );
-  const flushed = openaiResponsesToOpenAIResponse(null, state);
-  const { parsed, finishReason } = collectArgs(flushed);
-  assert.ok(parsed);
-  assert.equal(Object.prototype.hasOwnProperty.call(parsed, "sessionID"), false);
-  assert.equal(parsed.agent, "explore");
-  assert.equal(finishReason, "tool_calls");
-});
-
-test("RED: non-streaming Responses translation drops sessionID null when given the schema", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      agent: { type: "string" },
-      description: { type: "string" },
-      prompt: { type: "string" },
-      sessionID: {
-        type: ["string", "null"],
-        description: `Continue a specific previous subagent conversation (${OMISSION_MARKER})`,
-      },
-    },
-    required: ["agent", "description", "prompt", "sessionID"],
-  };
-  const responseBody = {
-    id: "resp_1",
-    object: "response",
-    output: [
-      {
-        type: "function_call",
-        call_id: "call_1",
-        name: "subagent",
-        arguments: JSON.stringify({
-          agent: "explore",
-          description: "spawn",
-          prompt: "do work",
-          sessionID: null,
-        }),
-      },
-    ],
-  };
-  const translated = translateNonStreamingResponse(
-    responseBody,
-    FORMATS.OPENAI_RESPONSES,
-    FORMATS.OPENAI,
-    null,
-    new Map([["subagent", schema]])
-  );
-  const args = JSON.parse(translated.choices[0].message.tool_calls[0].function.arguments);
-  assert.equal(Object.prototype.hasOwnProperty.call(args, "sessionID"), false);
-  assert.equal(args.agent, "explore");
-});
-
-test("characterization: non-streaming keeps a real sessionID and legacy empty cleanup without schema", () => {
-  const withId = translateNonStreamingResponse(
-    {
-      id: "resp_2",
-      object: "response",
-      output: [
-        {
-          type: "function_call",
-          call_id: "call_2",
-          name: "subagent",
-          arguments: JSON.stringify({
-            agent: "explore",
-            description: "continue",
-            prompt: "do work",
-            sessionID: "ses_valid_child",
-          }),
-        },
-      ],
-    },
-    FORMATS.OPENAI_RESPONSES,
-    FORMATS.OPENAI
-  );
-  const kept = JSON.parse(withId.choices[0].message.tool_calls[0].function.arguments);
-  assert.equal(kept.sessionID, "ses_valid_child");
-
-  const noSchema = translateNonStreamingResponse(
-    {
-      id: "resp_3",
-      object: "response",
-      output: [
-        {
-          type: "function_call",
-          call_id: "call_3",
-          name: "other",
-          arguments: { note: "", tags: [] },
-        },
-      ],
-    },
-    FORMATS.OPENAI_RESPONSES,
-    FORMATS.OPENAI
-  );
-  const cleaned = JSON.parse(noSchema.choices[0].message.tool_calls[0].function.arguments);
-  assert.equal(Object.prototype.hasOwnProperty.call(cleaned, "note"), false);
-  assert.equal(Object.prototype.hasOwnProperty.call(cleaned, "tags"), false);
-});
-
-test("characterization: extractToolSchemaMap still keys OpenCode subagent by lowercase name", () => {
-  const map = extractToolSchemaMap({ tools: [structuredClone(SUBAGENT_TOOL_RESPONSES)] });
-  assert.ok(map?.has("subagent"));
-  assert.equal(map.get("subagent").properties.sessionID.type, "string");
-});

tests/unit/openapi-security-tiers.test.ts

@@ -34,21 +34,6 @@ test("every x-loopback-only path matches a LOCAL_ONLY prefix in routeGuard.ts",
   }
 });
 
-test("GET /api/openapi/spec documents its conditional management auth contract", () => {
-  const operation = paths["/api/openapi/spec"]?.get;
-
-  assert.deepEqual(operation?.security, [{ ManagementSessionAuth: [] }]);
-  assert.match(operation?.description ?? "", /When `requireLogin` is enabled/);
-  assert.equal(
-    operation?.responses?.["401"]?.$ref,
-    "#/components/responses/ManagementAuthenticationRequired"
-  );
-  assert.equal(
-    operation?.responses?.["403"]?.$ref,
-    "#/components/responses/ManagementInvalidToken"
-  );
-});
-
 test("every x-always-protected path matches ALWAYS_PROTECTED_API_PATHS in routeGuard.ts", () => {
   for (const [pathStr, methods] of Object.entries(paths)) {
     if (!methods || typeof methods !== "object") continue;

tests/unit/provider-limits-recovery.test.ts

@@ -83,25 +83,7 @@ test.after(async () => {
 });
 
 test("successful GLM quota refresh clears transient rate-limit state", async () => {
-  // The cooldown must already be EXPIRED for a successful refresh to clear it
-  // (#11277: a rateLimitedUntil still in the future is a hard statement from
-  // the error handler that persisted it — no quota poll may overrule it,
-  // regardless of lastErrorType). Before #11277's fix this test used a
-  // still-future rateLimitedUntil and asserted it got cleared anyway, which
-  // was the same defect class as the reported bug, just a shorter window.
-  const connection = await providersDb.createProviderConnection({
-    provider: "glm",
-    authType: "apikey",
-    name: `GLM Recovery ${Date.now()}`,
-    apiKey: "glm-test-key",
-    testStatus: "unavailable",
-    rateLimitedUntil: new Date(Date.now() - 60_000).toISOString(),
-    lastError: "rate limit exceeded",
-    lastErrorType: "rate_limited",
-    lastErrorSource: "executor",
-    errorCode: 429,
-    backoffLevel: 2,
-  });
+  const connection = await createGlmConnectionWithTransientCooldown();
   const connectionId = (connection as { id: string }).id;
 
   await withMockedFetch((() => glmQuotaResponse()) as typeof fetch, async () => {
@@ -119,39 +101,6 @@ test("successful GLM quota refresh clears transient rate-limit state", async ()
   assert.equal(updated.backoffLevel, 0, "backoffLevel should be reset to 0");
 });
 
-test("a still-future rateLimitedUntil is not cleared by a successful quota refresh, regardless of lastErrorType (#11277)", async () => {
-  const stillFutureRateLimitedUntil = new Date(Date.now() + 60_000).toISOString();
-  const connection = await providersDb.createProviderConnection({
-    provider: "glm",
-    authType: "apikey",
-    name: `GLM Still Cooling ${Date.now()}`,
-    apiKey: "glm-test-key",
-    testStatus: "unavailable",
-    rateLimitedUntil: stillFutureRateLimitedUntil,
-    lastError: "rate limit exceeded",
-    lastErrorType: "rate_limited",
-    lastErrorSource: "executor",
-    errorCode: 429,
-    backoffLevel: 2,
-  });
-  const connectionId = (connection as { id: string }).id;
-
-  await withMockedFetch((() => glmQuotaResponse()) as typeof fetch, async () => {
-    await providerLimits.fetchAndPersistProviderLimits(connectionId, "manual");
-  });
-
-  const updated = (await providersDb.getProviderConnectionById(connectionId)) as Record<
-    string,
-    unknown
-  >;
-  assert.equal(
-    updated.testStatus,
-    "unavailable",
-    "an active cooldown must stay locked even though the quota fetch succeeded"
-  );
-  assert.equal(updated.rateLimitedUntil, stillFutureRateLimitedUntil);
-});
-
 async function createGlmConnectionWithStatus(status: string) {
   return providersDb.createProviderConnection({
     provider: "glm",
@@ -385,52 +334,6 @@ test("Claude subscription quota still exhausted keeps the connection locked (no
   assert.equal(after.rateLimitedUntil, syntheticRateLimitedUntil);
 });
 
-test("rate_limit_exceeded cooldown is not cleared early by an unrelated quota window looking usable (#11277)", async () => {
-  // Reproduces #11277: a connection-scoped cooldown persisted with
-  // lastErrorType "rate_limit_exceeded" (RateLimitReason.RATE_LIMIT_EXCEEDED)
-  // and a long rateLimitedUntil (derived from an upstream reset hint — the
-  // reported production case was ~146h) must NOT be cleared just because the
-  // next scheduled quota sync reports hasUsableQuota()===true from some
-  // unrelated window. Before the fix, only lastErrorType==="quota_exhausted"
-  // reached the rateLimitedUntil guard, so every other reason (including
-  // rate_limit_exceeded) skipped straight to clearRecoveredProviderState(),
-  // producing a self-restart/burn loop on a multi-day cooldown.
-  const farFutureRateLimitedUntil = new Date(Date.now() + 146 * 60 * 60 * 1000).toISOString();
-  const created = await providersDb.createProviderConnection({
-    provider: "opencode",
-    authType: "apikey",
-    name: `OpenCode RateLimitExceeded ${Date.now()}`,
-    apiKey: "opencode-test-key",
-    testStatus: "unavailable",
-    isActive: true,
-    lastError: "Account quota exhausted (opencode)",
-    lastErrorType: "rate_limit_exceeded",
-    errorCode: 429,
-    rateLimitedUntil: farFutureRateLimitedUntil,
-    backoffLevel: 1,
-  });
-  const connectionId = (created as { id: string }).id;
-  const connection = await providersDb.getProviderConnectionById(connectionId);
-
-  // No `quotas` object at all (degraded/partial fetch shape) — this is the
-  // exact shape that, pre-fix, fell straight through to hasTransientState
-  // and cleared the cooldown for any lastErrorType other than quota_exhausted.
-  const result = await providerLimits.maybeClearRecoveredQuotaState(connection, {
-    quotas: { unrelated: { unlimited: true } },
-  });
-
-  assert.equal(
-    result.testStatus,
-    "unavailable",
-    "an active rate_limit_exceeded cooldown must stay locked"
-  );
-
-  const after = await providersDb.getProviderConnectionById(connectionId);
-  assert.equal(after.testStatus, "unavailable");
-  assert.equal(after.lastErrorType, "rate_limit_exceeded");
-  assert.equal(after.rateLimitedUntil, farFutureRateLimitedUntil);
-});
-
 test("CAS primitive clears when expected state matches", async () => {
   const created = await createGlmConnectionWithTransientCooldown();
   const connectionId = (created as { id: string }).id;

tests/unit/provider-patch-ratelimit-protection-11278.test.ts

@@ -1,139 +0,0 @@
-// Regression guard for #11278 — PATCH/PUT /api/providers/[id] silently enabled
-// runtime rate-limit protection (Bottleneck queuing) for ANY connection whose
-// request body included the `rateLimitOverrides` key, even `null`, regardless
-// of whether `rate_limit_protection` was actually persisted as on for that
-// connection in the DB.
-//
-// Root cause: src/app/api/providers/[id]/route.ts unconditionally called
-// enableRateLimitProtection(id) whenever `rateLimitOverrides !== undefined`
-// in the validated body. `EditConnectionModal.tsx` sends `rateLimitOverrides`
-// on every save regardless of whether the operator touched that section, so
-// saving ANY connection silently started queuing its requests through
-// Bottleneck — with the DB (`rate_limit_protection` column) and the dashboard
-// toggle both still showing the feature as off.
-//
-// Fix: only (re)enable the in-memory limiter when the persisted connection
-// (`updated.rateLimitProtection`, mapped from the DB row) is actually `true`;
-// otherwise explicitly disable it so runtime state can't drift ahead of the
-// DB. `rateLimitProtection` is never itself part of updateProviderConnectionSchema,
-// so this route can only read it from the persisted row — never set it.
-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";
-import { makeManagementSessionRequest } from "../helpers/managementSession.ts";
-
-const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-11278-ratelimit-"));
-process.env.DATA_DIR = TEST_DATA_DIR;
-process.env.APP_LOG_TO_FILE = "false";
-process.env.JWT_SECRET = "test-jwt-secret-11278-ratelimit";
-process.env.INITIAL_PASSWORD = "admin-secret";
-
-const core = await import("../../src/lib/db/core.ts");
-const { createProviderConnection, getProviderConnectionById } =
-  await import("../../src/lib/db/providers.ts");
-const providerByIdRoute = await import("../../src/app/api/providers/[id]/route.ts");
-const rateLimitManager = await import("../../open-sse/services/rateLimitManager.ts");
-
-function resetDb() {
-  core.resetDbInstance();
-  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
-  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
-}
-
-test.beforeEach(() => {
-  resetDb();
-});
-
-test.after(() => {
-  core.resetDbInstance();
-  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
-});
-
-async function createConnection(rateLimitProtection: boolean) {
-  return createProviderConnection({
-    provider: "openai",
-    authType: "apikey",
-    name: "OpenAI key",
-    apiKey: "sk-test-key-value",
-    priority: 1,
-    isActive: true,
-    testStatus: "active",
-    rateLimitProtection,
-  });
-}
-
-test(
-  "PUT /api/providers/[id] does NOT enable rate-limit protection just because " +
-    "rateLimitOverrides is present, when protection is off in the DB (#11278 RED->GREEN)",
-  async () => {
-    const connection = (await createConnection(false)) as Record<string, unknown>;
-    assert.equal(connection.rateLimitProtection, false);
-    assert.equal(rateLimitManager.isRateLimitEnabled(connection.id as string), false);
-
-    // Mirrors EditConnectionModal.tsx's handleSubmit(): it always sends
-    // `rateLimitOverrides` on every save, even when the operator never
-    // touched that section of the form.
-    const payload = {
-      name: connection.name,
-      priority: connection.priority,
-      rateLimitOverrides: null,
-    };
-
-    const request = await makeManagementSessionRequest(
-      `http://localhost/api/providers/${connection.id}`,
-      { method: "PUT", body: payload }
-    );
-    const response = await providerByIdRoute.PUT(request, {
-      params: Promise.resolve({ id: connection.id as string }),
-    });
-    assert.equal(response.status, 200, `expected the save to succeed, got ${response.status}`);
-
-    const persisted = (await getProviderConnectionById(connection.id as string)) as Record<
-      string,
-      unknown
-    >;
-    assert.equal(
-      persisted.rateLimitProtection,
-      false,
-      "DB row must still show protection off — this route never sets rateLimitProtection"
-    );
-    assert.equal(
-      rateLimitManager.isRateLimitEnabled(connection.id as string),
-      false,
-      "in-memory limiter must not silently diverge from the persisted DB state"
-    );
-  }
-);
-
-test(
-  "PUT /api/providers/[id] keeps rate-limit protection ENABLED when it is " +
-    "actually persisted as on in the DB",
-  async () => {
-    const connection = (await createConnection(true)) as Record<string, unknown>;
-    assert.equal(connection.rateLimitProtection, true);
-
-    const payload = {
-      name: connection.name,
-      priority: connection.priority,
-      rateLimitOverrides: { rpm: 30 },
-    };
-
-    const request = await makeManagementSessionRequest(
-      `http://localhost/api/providers/${connection.id}`,
-      { method: "PUT", body: payload }
-    );
-    const response = await providerByIdRoute.PUT(request, {
-      params: Promise.resolve({ id: connection.id as string }),
-    });
-    assert.equal(response.status, 200, `expected the save to succeed, got ${response.status}`);
-
-    const persisted = (await getProviderConnectionById(connection.id as string)) as Record<
-      string,
-      unknown
-    >;
-    assert.equal(persisted.rateLimitProtection, true);
-    assert.equal(rateLimitManager.isRateLimitEnabled(connection.id as string), true);
-  }
-);

tests/unit/reasoning-effort-clamp-and-retry.test.ts

@@ -108,7 +108,7 @@ test("a second request for the same provider+model sends the learned value on th
   }
 });
 
-test("400 please use low, high, or max clamps and retries once (nearest-tier: medium -> high, #11295)", async () => {
+test("400 please use low, high, or max clamps and retries once", async () => {
   const executor = new SimpleExecutor();
   const originalFetch = globalThis.fetch;
   const capturedBodies: Record<string, unknown>[] = [];
@@ -140,10 +140,7 @@ test("400 please use low, high, or max clamps and retries once (nearest-tier: me
     });
     assert.equal(capturedBodies.length, 2);
     assert.equal(capturedBodies[0].reasoning_effort, "medium");
-    // #11295: nearest-tier — smallest accepted >= demand — maps medium(3) to
-    // high(4), the smallest accepted rank at or above it (was "low" under the
-    // old downgrade-only direction).
-    assert.equal(capturedBodies[1].reasoning_effort, "high");
+    assert.equal(capturedBodies[1].reasoning_effort, "low");
     const learned = getLearnedReasoningEffort("openai-compatible-chat-eaff6869", "x-preview-f-free") as unknown as Set<string>;
     assert.ok(learned instanceof Set);
     assert.ok(learned.has("low"));
@@ -193,7 +190,7 @@ test("400 please use low, medium with ultra retries to medium", async () => {
   }
 });
 
-test("sub-floor clamp now retries: learned {high,max} with low request clamps up to high (#11295)", async () => {
+test("no-op clamp does not retry: learned {high,max} with low request stays single-fetch", async () => {
   const executor = new SimpleExecutor();
   const originalFetch = globalThis.fetch;
   const capturedBodies: Record<string, unknown>[] = [];
@@ -217,20 +214,17 @@ test("sub-floor clamp now retries: learned {high,max} with low request clamps up
   };
 
   try {
-    // #11295: low is below the learned minimum {high,max}. Pre-#11295 this was
-    // a downgrade-only passthrough (no clamp, no retry, upstream stayed 400
-    // forever). Nearest-tier now clamps up to the accepted floor (high) and
-    // retries once, succeeding.
+    // low is below the learned minimum {high,max}: downgrade-only passthrough,
+    // sanitizer leaves the body unchanged -> no identical-body retry.
     const result = await executor.execute({
       model: "x-preview-f-free-3",
       body: { reasoning_effort: "low" },
       stream: false,
       credentials: {},
     });
-    assert.equal(capturedBodies.length, 2);
+    assert.equal(capturedBodies.length, 1);
     assert.equal(capturedBodies[0].reasoning_effort, "low");
-    assert.equal(capturedBodies[1].reasoning_effort, "high");
-    assert.equal(result.response.status, 200);
+    assert.equal(result.response.status, 400);
   } finally {
     globalThis.fetch = originalFetch;
   }

tests/unit/reasoning-effort-clamp-direction-consistency.test.ts

@@ -1,79 +0,0 @@
-// #11295 — the learned clamp (reactive, from upstream 4xx) and the declared
-// clamp (static registry `supportedThinkingEfforts`) used to disagree on
-// direction for the identical accepted set {low,high,max}: the learned path
-// was downgrade-only (medium -> low) while the declared path was already
-// nearest-tier (medium -> high). Same inputs, opposite outputs, depending only
-// on whether the model happened to have a static registry entry. This test
-// proves the two paths now agree, and that a request below the learned floor
-// (previously silently passed through unmapped, returning null from
-// clampToLearned) is now mapped up to the nearest accepted tier instead.
-import { test, after, beforeEach } from "node:test";
-import assert from "node:assert/strict";
-import { clampToLearned } from "../../open-sse/services/learnedReasoningEffortCaps.ts";
-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("clampToLearned: nearest-tier medium -> high when accepted is {low,high,max} (was low pre-#11295)", () => {
-  assert.equal(clampToLearned("medium", new Set(["low", "high", "max"])), "high");
-});
-
-test("sanitizeReasoningEffortForProvider maps medium identically for a LEARNED-only model and a DECLARED model with the same {low,high,max} accepted set", () => {
-  // Learned side: a custom OpenAI-compatible connection that has no static
-  // registry entry — the only source of truth is the reactively-learned set.
-  recordLearnedReasoningEffort("acme-oai-compatible", "custom-reasoner", [
-    "low",
-    "high",
-    "max",
-  ]);
-  const learnedResult = sanitizeReasoningEffortForProvider(
-    { reasoning_effort: "medium" },
-    "acme-oai-compatible",
-    "custom-reasoner"
-  ) as Record<string, unknown>;
-
-  // Declared side: opencode-go/ox-alpha-free, whose registry entry declares
-  // supportedThinkingEfforts: ["low", "high", "max"] (see reasoningEffort.ts
-  // comment referencing the Console Go 400 case).
-  const declaredResult = sanitizeReasoningEffortForProvider(
-    { reasoning_effort: "medium" },
-    "opencode-go",
-    "ox-alpha-free"
-  ) as Record<string, unknown>;
-
-  assert.equal(learnedResult.reasoning_effort, "high");
-  assert.equal(declaredResult.reasoning_effort, "high");
-  assert.equal(learnedResult.reasoning_effort, declaredResult.reasoning_effort);
-});
-
-test("sub-floor request (none) on a learned-only model with floor {low,high,max} maps to low, not a pass-through null-clamp", () => {
-  recordLearnedReasoningEffort("acme-oai-compatible", "custom-reasoner-2", [
-    "low",
-    "high",
-    "max",
-  ]);
-  const result = sanitizeReasoningEffortForProvider(
-    { reasoning_effort: "none" },
-    "acme-oai-compatible",
-    "custom-reasoner-2"
-  ) as Record<string, unknown>;
-  assert.equal(result.reasoning_effort, "low");
-});
-
-test("clampToLearned: sub-floor demand (none) below accepted {low,high,max} maps to the accepted floor (low), not null", () => {
-  assert.equal(clampToLearned("none", new Set(["low", "high", "max"])), "low");
-});
-
-test("clampToLearned: sub-floor demand (low) below accepted {high,max} maps to the accepted floor (high), not null", () => {
-  assert.equal(clampToLearned("low", new Set(["high", "max"])), "high");
-});

tests/unit/reasoning-effort-learned-capability.test.ts

@@ -90,25 +90,23 @@ test("deepseek's non-ordinal max<->xhigh translation is untouched by the learned
   assert.equal(result.reasoning_effort, "max");
 });
 
-// #11295: nearest-tier — smallest accepted >= demand — replaces the old
-// downgrade-only (greatest accepted <= demand) direction.
-test("proactive clamp: medium→high for learned {low,high,max} (nearest-tier, #11295)", () => {
+test("proactive clamp: medium→low for learned {low,high,max}", () => {
   recordLearnedReasoningEffort("opencode-zen-direct", "x-preview-f-free", ["low", "high", "max"]);
   const out = sanitizeReasoningEffortForProvider(
     { reasoning_effort: "medium", model: "x-preview-f-free" },
     "opencode-zen-direct",
     "x-preview-f-free"
   ) as { reasoning_effort: string };
-  assert.equal(out.reasoning_effort, "high");
+  assert.equal(out.reasoning_effort, "low");
 });
-test("proactive clamp: xhigh→max for learned {low,high,max} (nearest-tier, #11295)", () => {
+test("proactive clamp: xhigh→high for learned {low,high,max}", () => {
   recordLearnedReasoningEffort("opencode-zen-direct", "x-preview-f-free-2", ["low", "high", "max"]);
   const out = sanitizeReasoningEffortForProvider(
     { reasoning_effort: "xhigh", model: "x-preview-f-free-2" },
     "opencode-zen-direct",
     "x-preview-f-free-2"
   ) as { reasoning_effort: string };
-  assert.equal(out.reasoning_effort, "max");
+  assert.equal(out.reasoning_effort, "high");
 });
 test("proactive clamp: ultra→max for learned {low,high,max}", () => {
   recordLearnedReasoningEffort("opencode-zen-direct", "x-preview-f-free-3", ["low", "high", "max"]);
@@ -137,16 +135,14 @@ test("proactive clamp: high→medium for learned {low,medium}", () => {
   ) as { reasoning_effort: string };
   assert.equal(out.reasoning_effort, "medium");
 });
-// #11295: sub-floor demand (low, below the learned floor {high,max}) now
-// clamps up to the floor instead of passing through unchanged.
-test("sub-floor clamp: low→high for learned {high,max} (#11295)", () => {
+test("no upgrade: low stays low for learned {high,max}", () => {
   recordLearnedReasoningEffort("acme", "m3", ["high", "max"]);
   const out = sanitizeReasoningEffortForProvider(
     { reasoning_effort: "low", model: "m3" },
     "acme",
     "m3"
   ) as { reasoning_effort: string };
-  assert.equal(out.reasoning_effort, "high");
+  assert.equal(out.reasoning_effort, "low");
 });
 test("custom model ultra→medium for learned {low,medium}", () => {
   recordLearnedReasoningEffort("openai-compatible-chat-eaff6869", "qwen3-coder-30b-a3b-instruct-2", ["low", "medium"]);