docs(skills): regenerate omni-inference skill for the multi-provider /v1/ocr

The generated agent skill mirrors docs/reference/API_REFERENCE.md; updating the
/v1/ocr section left it stale and tripped the merge-integrity gate.

.env.example

@@ -109,17 +109,6 @@ PORT=20128
 # stay consistent without relying on window.location.origin alone:
 # NEXT_PUBLIC_BASE_URL=https://host/omniroute
 
-# Opt-in iframe embedding of the OmniRoute HTML pages (issue #10273). Off by default:
-# every route ships `frame-ancestors 'none'` + `X-Frame-Options: DENY`, which is why the
-# VS Code Simple Browser (used by the OmniCopilot extension's "Open Dashboard → editor"
-# mode) renders a blank tab. Set this to `vscode` to switch the HTML pages — dashboard,
-# login, docs, landing — to `frame-ancestors 'self' vscode-webview:` and drop
-# X-Frame-Options for them (XFO cannot express a custom scheme). The API surface
-# (/api, /v1, /v1beta, /a2a, /healthz and the root-level aliases) keeps the strict
-# headers regardless. Only `vscode` is recognised; `1`/`true` do NOT enable it.
-# Used by: next.config.mjs via scripts/build/dashboardEmbed.mjs — build-time, rebuild after changing.
-# DASHBOARD_ALLOW_EMBED=vscode
-
 # Split-port mode: serve Dashboard and API on separate ports for network isolation.
 # Used by: src/lib/runtime/ports.ts — overrides PORT for each service.
 # API_PORT=20129

changelog.d/features/10273-dashboard-embed-csp.md

@@ -1 +0,0 @@
-- feat(dashboard): opt-in `DASHBOARD_ALLOW_EMBED=vscode` relaxes CSP `frame-ancestors` to `'self' vscode-webview:` and drops `X-Frame-Options` for HTML pages only, so the dashboard renders inside the VS Code Simple Browser (OmniCopilot). Default posture unchanged — API routes stay unframable (#10273)

config/quality/quality-baseline.json

@@ -102,7 +102,7 @@
       "_rebaseline_2026_07_28_v3849_release": "75.5 -> 99 (+23.5). Aperto EXIGIDO pelo modo --require-tighten do ratchet: a métrica melhorou de verdade no ciclo v3.8.49. A causa é o workflow assíncrono de tradução, que finalmente alcançou o denominador em EN — as rebaselines anteriores (v3.8.39/.44/.47) foram todas afrouxamentos registrando o atraso das traduções, e agora ele foi pago. O coletor SUBTRAI os placeholders (present - placeholder em scripts/quality/collect-metrics.mjs), então os 317 marcadores __MISSING__ que esta release introduziu para o drift de valor já estão descontados dos 99 — o número é honesto, não inflado por placeholder. Medido pelo collect-metrics do CI no run 30404226939."
     },
     "deadExports": {
-      "value": 409,
+      "value": 415,
       "direction": "down",
       "_rebaseline_2026_08_09_v3850_post_sweep": "227 -> 230. Measured by npm run check:dead-code on the unmodified release/v3.8.50 tip 382449d593 during the mandatory --full-ci pre-flight. The +3 is inherited cycle drift from the authorized merge sweep; this repair adds no production exports. Rebaseline records the actual tip so ci.yml quality-gate can run, while structural cleanup remains separate debt.",
       "_rebaseline_2026_07_01_v3843_release": "225->227 (+2). v3.8.43 cycle drift, surfaced in the Quality Ratchet job after eslintWarnings was rebaselined (check:dead-code runs there). 227 = measured by check:dead-code (knip) on the release tip 4635076eb. The 5 CI fixes add 0 dead exports: safeHttpHref in linkify.ts is module-local AND used (called by linkifyText); no new exports; test files are not scanned. Tighten via --update next cycle.",
@@ -111,7 +111,8 @@
       "_rebaseline_2026_06_27_v3838_release": "345->346 (+1). v3.8.38 cycle drift surfaced by the release-green pre-flight (Quality Ratchet does NOT run on PR->release fast-gates). Net +1 inherited from this cycle's feature/fix merges (new executors/providers, compression fidelity-gate module) minus #5138's removal of dead legacy store modules. Release-finalize working tree touches ONLY CHANGELOG.md + i18n mirrors + README + baselines — 0 production-code change. Structural cleanup tracked as debt.",
       "_rebaseline_2026_06_26_v3837_release": "343->345. v3.8.37 cycle drift surfaced by the release-green pre-flight (the Quality Ratchet does NOT run on PR->release fast-gates, so warnings/complexity accrued unmeasured across this cycle's 76 commits — provider adds DGrid/Pioneer/xAI, headroom proxy lifecycle #4649, ~50 SSE/translator fixes, Engine Combos #5062). Trust-but-verify: this release-finalize working tree touches ONLY CHANGELOG.md, docs/i18n/*/CHANGELOG.md mirrors, and these baselines — 0 production-code change, so all drift is inherited cycle drift (`any` warn-allowed in open-sse/ + tests/). Tighten via --require-tighten next cycle.",
       "_rebaseline_2026_08_11_v3850_merge_storm": "230 -> 248. Own drift from the 2026-08-11 merge storm (99 PRs into release/v3.8.50 via authorized sweep): new providers/executors/handlers added dead exports that knip cannot see as used. Measured on the base-fix tip (7ca73697b0 + this repair PR). Owner authorized rebaseline (2026-08-11) — structural cleanup remains separate debt.",
-      "_rebaseline_2026_08_13_v3850_knip_bump": "248 -> 409. NOT code-added dead exports: dependabot bump #10043 (2026-08-13) upgraded knip 6.27.0 -> 6.32.x, and the new knip detects 162 MORE genuinely-unused exports (331 vs 169 deadExports) that 6.27 missed. DEAD_FILES unchanged (78). Reproduced identically on the clean release/v3.8.50 tip 266e39d3 with a fresh knip 6.32 node_modules — so every PR is born red on this gate until the tool change is absorbed. Owner authorized rebaseline (2026-08-13, via base-reds PR #10260). Structural cleanup of the 162 newly-surfaced dead exports remains separate debt."
+      "_rebaseline_2026_08_13_v3850_knip_bump": "248 -> 409. NOT code-added dead exports: dependabot bump #10043 (2026-08-13) upgraded knip 6.27.0 -> 6.32.x, and the new knip detects 162 MORE genuinely-unused exports (331 vs 169 deadExports) that 6.27 missed. DEAD_FILES unchanged (78). Reproduced identically on the clean release/v3.8.50 tip 266e39d3 with a fresh knip 6.32 node_modules — so every PR is born red on this gate until the tool change is absorbed. Owner authorized rebaseline (2026-08-13, via base-reds PR #10260). Structural cleanup of the 162 newly-surfaced dead exports remains separate debt.",
+      "_rebaseline_2026_08_14_ocr_imagetotext_series": "OCR/image-to-text series (#10275/#10283/#10287/#10289/#10291): deadExports 409 -> 415. Each PR in the series adds public util/registry exports that are exercised by their unit tests but not yet by a second production caller — normalizeImageBuffer (imageNormalize), MISTRAL_PASSTHROUGH / AZURE_DI_TRANSFORMATION / getOcrTransformation (ocrRegistry), resolveOcrCredentials (v1/ocr route). They are the documented public surface of the new modules and are covered by tests; structural cleanup stays tracked in #3501."
     },
     "cognitiveComplexity": {
       "value": 1223,

docs/architecture/RESILIENCE_GUIDE.md

@@ -289,123 +289,6 @@ single-shot, so usage accounting and semaphore release are not duplicated.
 
 ---
 
-## 7. Upstream Status Restatement (misstated quota errors)
-
-**Scope:** one upstream gateway that reports temporary quota exhaustion with the wrong HTTP status.
-
-**Purpose:** correct a misleading status BEFORE classification, so downstream consumers (fallback engine, combo aggregation, the client-facing response) see the true retryable nature of the failure.
-
-Some gateways signal TEMPORARY quota exhaustion with a non-retryable HTTP
-status. `agentrouter.org` returns `403` (sometimes `400`) with a Chinese body
-(`用户额度不足` / `额度不足`) instead of the standard `429`. Clients like Claude
-Code treat `403` as permanent and abort the session, and without correction
-the fallback engine would classify it as `AUTH_ERROR` instead of a quota
-event.
-
-**Implementation:**
-
-- Registry + matcher: `open-sse/config/upstreamStatusRestatement.ts` — a
-  per-provider list of rules (`{id, fromStatuses, toStatus, textMarkers,
-excludeMarkers, defaultRetryAfterMs}`), matched via `applyStatusRestatement()`.
-- Call site: the `providerFailure:` block in `open-sse/handlers/chatCore.ts`
-  (around line 3654), right after `parseUpstreamError()` parses an upstream
-  response with an error HTTP status (`!providerResponse.ok`), and before any
-  classification runs, so every downstream consumer sees the corrected
-  status. Errors embedded inside a `200` SSE stream follow a separate,
-  later stream-parsing path and are **not** covered by this hook today — a
-  known limitation, not yet needed for agentrouter's misstatus (which
-  surfaces as an error HTTP status).
-- Retry eligibility: `429` is in `RETRY_AFTER_ELIGIBLE_STATUSES`
-  (`open-sse/services/combo/unavailableRetryGate.ts`), so a restated error
-  carries a real retry window instead of surfacing as a dead `403`.
-- The synthetic `60s` `defaultRetryAfterMs` (`upstreamStatusRestatement.ts`)
-  is only what the restated response tells the **client**; it is not itself
-  the connection's internal cooldown/lockout duration — that is governed
-  separately by whichever mechanism actually handles the restated error
-  (Connection Cooldown's escalating backoff, §2, base `3s` for API-key
-  providers; or Model Lockout, §3, for per-model-quota providers like
-  agentrouter). The router can become eligible to retry internally sooner
-  than the 60s window it advertises to the client — intentional headroom,
-  not a bug.
-
-Permanent errors (agentrouter's `无权访问模型` — no access to this model) are
-NEVER restated: `excludeMarkers` vetoes the rule even when `textMarkers` hit,
-so the error keeps its original status and nothing retries it forever. A
-separate provider classification rule
-(`agentrouter-model-access-denied` in `open-sse/config/providerErrorRules.ts`)
-declares an `auth_error`/scope-`model` match for this text, but it does not
-fire on the live production path today: the rule only matches `status ===
-403`, and `checkFallbackError`'s apikey-category `FORBIDDEN` branch
-(`open-sse/services/accountFallback.ts`) returns early for a plain 403
-*before* the provider-rule lookup ever runs. In practice a `无权访问模型` 403
-is handled the same way as the base apikey-provider 403 path (see Connection
-Cooldown, §2), not as a 6h model lockout. The rule still exists as a
-declarative classification consumable by future callers of `classifyError`
-with context — wiring it into the production `checkFallbackError` path is
-tracked as a follow-up, not yet done.
-
-Restated quota errors (`额度不足`) do reach a provider rule in production
-(`agentrouter-user-quota-exhausted`, scope `"connection"`), but `scope` on
-`ProviderErrorRuleMatch` is currently informational — the persistence path
-(`checkFallbackError` → `combo.ts`) only consumes `reason` and `cooldownMs`,
-never `scope`. What actually happens for agentrouter (`passthroughModels:
-true` → `hasPerModelQuota()` returns `true`) is a **per-model** lockout via
-`recordModelLockoutFailure()`: the connection itself is never cooled down for
-this error (`combo.ts` skips `recordProviderCooldown` for 429 when
-`hasPerModelQuota` is true), so other models on the same account keep being
-tried — each one burns one call and its own lockout before combo routing
-moves on. Honoring `scope` end-to-end (so a `"connection"` match actually
-locks the connection) is tracked as a follow-up.
-
-### Two-stage design: status restatement, then classification
-
-Status restatement (`upstreamStatusRestatement.ts`) and provider
-classification rules (`open-sse/config/providerErrorRules.ts`,
-`providerRuleRegistry`) are separate registries that both key on provider id
-and text markers, but they run in different places and serve different
-purposes: restatement rewrites the HTTP status early in `chatCore.ts`;
-classification rules pick the fallback `reason` and lock `scope`
-(`model` / `provider` / `connection`) inside `checkFallbackError()`
-(`open-sse/services/accountFallback.ts`).
-
-Classification rules only see full error **text** (needed to match body
-markers like `额度不足`) for providers listed in the `FULL_TEXT_RULE_PROVIDERS`
-allowlist in `providerErrorRules.ts` — currently only `"agentrouter"`. For
-every other provider, `checkFallbackError` hands `getProviderErrorRuleMatch`
-only the structured error (`{code, type}`), which is enough for
-header/status/code-based rules but blind to body-text markers. The helper
-`resolveRuleMatchBody()` performs this selection: full error text for
-allowlisted providers, the structured error otherwise. Adding a provider to
-`FULL_TEXT_RULE_PROVIDERS` is an explicit per-provider opt-in — it exists so
-that the default path for every provider not on the list stays
-byte-for-byte unchanged.
-
-### Adding a new quota-misstating gateway
-
-1. Register one rule array in `statusRestatementRegistry`
-   (`open-sse/config/upstreamStatusRestatement.ts`). Keep `textMarkers`
-   provider-specific; never reuse generic English phrases that collide with
-   `CREDITS_EXHAUSTED_SIGNALS` (`open-sse/services/accountFallback.ts`).
-2. Optionally register classification rules in
-   `open-sse/config/providerErrorRules.ts` (`providerRuleRegistry`) to pick
-   the right lock scope (`connection` for account-wide quota, `model` for
-   per-model errors). This step only takes effect in production for
-   providers whose rules need the full error text (body markers): add the
-   provider id to `FULL_TEXT_RULE_PROVIDERS` in the same file — otherwise
-   `checkFallbackError` only ever hands the rule the structured
-   `{code, type}` error and a body-text rule will never match live traffic.
-   Rules that match purely on `status`/`headers` (like Opencode's or
-   Minimax's) do not need this opt-in.
-3. Add unit tests mirroring `tests/unit/upstream-status-restatement.test.ts`
-   and `tests/unit/agentrouter-error-rules.test.ts` (including the
-   not-permanent / not-creditsExhausted guards, and — if the provider needs
-   the allowlist — a test asserting `resolveRuleMatchBody()` returns the
-   full text only for that provider).
-
-No changes to `chatCore.ts`, `classifyError`, or combo are needed.
-
----
-
 ## Other Resilience Features
 
 - **19 routing strategies** (priority, weighted, round-robin, context-relay, fill-first, p2c, random, least-used, cost-optimized, reset-aware, reset-window, headroom, strict-random, auto, lkgp, context-optimized, cache-optimized, fusion, pipeline) — see [AUTO-COMBO.md](../routing/AUTO-COMBO.md).

docs/openapi.yaml

@@ -6840,9 +6840,17 @@ paths:
         - Images
       summary: Document OCR
       description: >-
-        Mistral OCR–compatible document OCR endpoint. Accepts a JSON body
-        referencing a document/image and returns extracted text. Success
-        responses carry the `X-OmniRoute-*` cost-telemetry headers.
+        Multi-provider document OCR endpoint (Mistral OCR–compatible request
+        and response shape). Accepts a JSON body referencing a document/image
+        and returns extracted text. `model` selects the provider via a
+        `provider/model` prefix (e.g. `mistral/mistral-ocr-latest`,
+        `azure-document-intelligence/prebuilt-read`); a bare model id (e.g.
+        `mistral-ocr-latest`) resolves to its registered provider, and an
+        omitted `model` defaults to Mistral. Azure Document Intelligence is
+        asynchronous upstream — the handler polls the returned operation
+        until it succeeds or fails before responding, so this endpoint can
+        take longer to return for that provider. Success responses carry the
+        `X-OmniRoute-*` cost-telemetry headers.
       security:
         - BearerAuth: []
       requestBody:
@@ -6854,6 +6862,11 @@ paths:
               properties:
                 model:
                   type: string
+                  description: >-
+                    `provider/model` id or bare model id. Registered ids:
+                    `mistral/mistral-ocr-latest`,
+                    `azure-document-intelligence/prebuilt-read`. Defaults to
+                    `mistral-ocr-latest` when omitted.
                 document:
                   type: object
       responses:

docs/reference/API_REFERENCE.md

@@ -17,6 +17,7 @@ Complete reference for all OmniRoute API endpoints.
 - [Chat Completions](#chat-completions)
 - [Embeddings](#embeddings)
 - [Image Generation](#image-generation)
+- [Document OCR](#document-ocr)
 - [List Models](#list-models)
 - [Provider Plugin Manifest](#provider-plugin-manifest)
 - [Compatibility Endpoints](#compatibility-endpoints)
@@ -199,6 +200,53 @@ GET /v1/images/generations
 
 ---
 
+## Document OCR
+
+```bash
+POST /v1/ocr
+Authorization: Bearer your-api-key
+Content-Type: application/json
+
+{
+  "model": "mistral/mistral-ocr-latest",
+  "document": {
+    "type": "document_url",
+    "document_url": "https://example.com/invoice.pdf"
+  }
+}
+```
+
+`model` selects the OCR provider via a `provider/model` prefix; a bare model id (e.g.
+`mistral-ocr-latest`) resolves to its registered provider, and an omitted `model` defaults to
+Mistral (`mistral-ocr-latest`). Registered providers (`open-sse/config/ocrRegistry.ts`):
+
+| Provider id                   | Model id             | `model` value                                               | Notes                                                                          |
+| ----------------------------- | -------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| `mistral`                     | `mistral-ocr-latest` | `mistral/mistral-ocr-latest` (or bare `mistral-ocr-latest`) | Synchronous — the response is returned directly from the single upstream call. |
+| `azure-document-intelligence` | `prebuilt-read`      | `azure-document-intelligence/prebuilt-read`                 | Asynchronous upstream (`analyze` + poll) — see below.                          |
+
+Both providers respond in the same Mistral-shaped body:
+
+```json
+{
+  "pages": [{ "index": 0, "markdown": "# Extracted text..." }],
+  "model": "mistral-ocr-latest",
+  "usage_info": { "pages_processed": 1 }
+}
+```
+
+### Azure Document Intelligence poll flow
+
+Azure Document Intelligence's `analyze` API is asynchronous: the initial request returns an
+`Operation-Location` header instead of a body, and the result must be polled for. The handler
+(`open-sse/handlers/ocr.ts`) polls that URL every second for up to 30 attempts, fails fast (does
+not keep polling) on a non-`ok` poll response or a `"failed"` status, and returns `504` if the
+operation is still running after the attempt budget is exhausted. The final Azure response is
+normalized into the same `pages`/`markdown` shape used by Mistral before being returned to the
+caller, so client code does not need to special-case the provider.
+
+---
+
 ## List Models
 
 ```bash
@@ -489,18 +537,18 @@ call**, so the reported `X-OmniRoute-Response-Latency` is near-zero
 (benchmarking, p50/p99 monitoring) should check the
 `X-OmniRoute-Cache-Latency` response header:
 
-| Value | Meaning |
-|-------|---------|
+| Value       | Meaning                                                       |
+| ----------- | ------------------------------------------------------------- |
 | `synthetic` | Response served from cache; latency is not real upstream time |
-| *(absent)* | Response from real upstream call |
+| _(absent)_  | Response from real upstream call                              |
 
 ### Per-key cache bypass
 
 API keys can opt out of semantic cache reads via `cacheDefaultMode`:
 
-| Value | Behavior |
-|-------|----------|
-| `legacy` | Normal cache behavior (default) |
+| Value    | Behavior                                        |
+| -------- | ----------------------------------------------- |
+| `legacy` | Normal cache behavior (default)                 |
 | `bypass` | Skip cache lookup entirely; always hit upstream |
 
 Set at key creation (`POST /api/keys`) or update (`PATCH /api/keys/[id]`):
@@ -603,13 +651,13 @@ X-OmniRoute-No-Cache: true
 
 ### Monitoring
 
-| Endpoint                 | Method     | Description                                                                                          |
-| ------------------------ | ---------- | ---------------------------------------------------------------------------------------------------- |
-| `/api/sessions`          | GET        | Active session tracking                                                                              |
-| `/api/rate-limits`       | GET        | Per-account rate limits                                                                              |
-| `/api/monitoring/health` | GET        | Health check + provider summary (`catalogCount`, `configuredCount`, `activeCount`, `monitoredCount`) |
-| `/api/cache/stats`       | GET/DELETE | Cache stats / clear                                                                                  |
-| `/api/modality-bridge/stats` | GET    | In-memory Modality Bridge telemetry — per-modality `bridged`/`cacheHits`/`failures`/`lastUsedAt` counters (reset on restart; management auth) |
+| Endpoint                     | Method     | Description                                                                                                                                   |
+| ---------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `/api/sessions`              | GET        | Active session tracking                                                                                                                       |
+| `/api/rate-limits`           | GET        | Per-account rate limits                                                                                                                       |
+| `/api/monitoring/health`     | GET        | Health check + provider summary (`catalogCount`, `configuredCount`, `activeCount`, `monitoredCount`)                                          |
+| `/api/cache/stats`           | GET/DELETE | Cache stats / clear                                                                                                                           |
+| `/api/modality-bridge/stats` | GET        | In-memory Modality Bridge telemetry — per-modality `bridged`/`cacheHits`/`failures`/`lastUsedAt` counters (reset on restart; management auth) |
 
 ### Backup & Export/Import
 

docs/reference/ENVIRONMENT.md

@@ -123,7 +123,6 @@ OmniRoute uses **SQLite** (via `better-sqlite3`) for all persistence. These vari
 | `PORT`                                      | `20128`                        | `src/lib/runtime/ports.ts`                                               | Primary port for both Dashboard UI and API endpoints (single-port mode).                                                                                                                                                                                                                                                       |
 | `OMNIROUTE_BASE_PATH`                       | _(empty = root)_               | `next.config.mjs`, `scripts/docker/ensure-docker-base-path.mjs`          | URL subpath for serving OmniRoute behind a reverse proxy (sets Next.js `basePath`; auth redirects are basePath-aware). E.g. `/omniroute`. In Docker the value is baked during `docker build` (`ARG OMNIROUTE_BASE_PATH`); pre-built root images can apply a different runtime value once at container start before Next.js boots. Set `NEXT_PUBLIC_BASE_URL` to the public origin including the same subpath. |
 | `NEXT_PUBLIC_OMNIROUTE_BASE_PATH`           | _(empty = root)_               | `src/shared/hooks/useDisplayBaseUrl.ts`                                  | Browser-visible mirror of `OMNIROUTE_BASE_PATH`, inlined at build time so the dashboard endpoint display shows `https://host/omniroute/v1` instead of `https://host/v1`. Falls back to `OMNIROUTE_BASE_PATH` when unset. Rebuild after changing (Next `basePath` is build-time).                                               |
-| `DASHBOARD_ALLOW_EMBED`                     | _(unset = never framable)_     | `next.config.mjs`, `scripts/build/dashboardEmbed.mjs`                    | Opt-in iframe embedding of the HTML pages. Unset, every route ships `frame-ancestors 'none'` + `X-Frame-Options: DENY`. Set to `vscode` to serve the pages (dashboard, login, docs, landing) with `frame-ancestors 'self' vscode-webview:` and no `X-Frame-Options`, so the VS Code Simple Browser can render them (OmniCopilot's `dashboardOpen: "editor"` mode). The API surface (`/api`, `/v1`, `/v1beta`, `/a2a`, `/healthz`, root-level aliases) keeps the strict headers either way. Only `vscode` is recognised — `1`/`true` do not enable it. Build-time: rebuild after changing.                     |
 | `API_PORT`                                  | _(unset)_                      | `src/lib/runtime/ports.ts`                                               | When set, serves the `/v1/*` proxy API on this separate port.                                                                                                                                                                                                                                                                  |
 | `API_HOST`                                  | `0.0.0.0`                      | `src/lib/runtime/ports.ts`                                               | Bind address for the API port.                                                                                                                                                                                                                                                                                                 |
 | `DASHBOARD_PORT`                            | _(unset)_                      | `src/lib/runtime/ports.ts`                                               | When set, serves the Dashboard UI on this separate port.                                                                                                                                                                                                                                                                       |

next.config.mjs

@@ -4,11 +4,6 @@ import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { mitmManagerAliasFor } from "./scripts/build/mitm-stub-flag.mjs";
 import { normalizeBasePath } from "./scripts/build/normalizeBasePath.mjs";
-import {
-  buildSecurityHeaderRules,
-  nonPageRoutePrefixes,
-  resolveDashboardEmbedMode,
-} from "./scripts/build/dashboardEmbed.mjs";
 
 const withNextIntl = createNextIntlPlugin("./src/i18n/request.ts");
 const distDir = process.env.NEXT_DIST_DIR || ".build/next";
@@ -80,11 +75,6 @@ function isNextIntlExtractorDynamicImportWarning(warning) {
 // for security-sensitive environments. See docs/security/SOCKET_DEV_FINDINGS.md.
 const isMinimalBuild = process.env.OMNIROUTE_BUILD_PROFILE === "minimal";
 
-// #10273: `null` unless the operator opts in with DASHBOARD_ALLOW_EMBED=vscode. Read at build
-// time like every other knob in this file (OMNIROUTE_BASE_PATH, OMNIROUTE_BUILD_PROFILE, …),
-// so changing it requires a rebuild. See scripts/build/dashboardEmbed.mjs.
-const dashboardEmbedMode = resolveDashboardEmbedMode(process.env);
-
 const minimalBuildAliases = isMinimalBuild
   ? {
       "@/mitm/cert/install": "./src/mitm/cert/install.stub.ts",
@@ -399,21 +389,11 @@ const nextConfig = {
   },
 
   async headers() {
-    // #10273: opt-in embedding for the VS Code Simple Browser (OmniCopilot). Off by default —
-    // `securityHeaders` then applies to `/:path*` exactly as it always has. When the operator
-    // sets DASHBOARD_ALLOW_EMBED=vscode, buildSecurityHeaderRules() splits that catch-all into
-    // two complementary rules: the API surface keeps `frame-ancestors 'none'` + X-Frame-Options,
-    // the HTML pages get `frame-ancestors 'self' vscode-webview:` and no X-Frame-Options.
-    // The exclusion list is DERIVED from the rewrite table below (self-reference is safe — the
-    // config object is fully built by the time Next calls headers()), so a future root-level API
-    // alias is excluded automatically instead of silently becoming framable.
-    const embedRules = buildSecurityHeaderRules({
-      mode: dashboardEmbedMode,
-      securityHeaders,
-      prefixes: dashboardEmbedMode ? nonPageRoutePrefixes(await nextConfig.rewrites()) : [],
-    });
     return [
-      ...embedRules,
+      {
+        source: "/:path*",
+        headers: securityHeaders,
+      },
       // G-10: allow OmniRoute's own dashboard to embed the 9Router UI via our reverse proxy.
       // `frame-ancestors 'self'` overrides the global `frame-ancestors 'none'` only for this
       // path. The route is already LOCAL_ONLY (routeGuard.ts) so remote origins cannot reach it.

open-sse/config/ocrRegistry.ts

@@ -16,6 +16,7 @@ export interface OcrProvider {
   authType: string;
   authHeader: string;
   models: OcrModel[];
+  transformation?: OcrTransformation;
 }
 
 export interface ParsedOcrModel {
@@ -23,6 +24,86 @@ export interface ParsedOcrModel {
   model: string | null;
 }
 
+export interface OcrResponseShape {
+  pages: Array<{ index: number; markdown: string }>;
+  model: string;
+  usage_info?: Record<string, unknown>;
+}
+
+export interface OcrTransformation {
+  buildRequest(args: {
+    baseUrl: string;
+    token: string;
+    body: Record<string, unknown>;
+    modelId: string;
+  }): { url: string; init: RequestInit };
+  parseResponse(raw: unknown): OcrResponseShape;
+  /** Async providers (Azure DI): return the poll URL from the first response, else null. */
+  pollUrl?(res: Response): string | null;
+}
+
+export const MISTRAL_PASSTHROUGH: OcrTransformation = {
+  buildRequest({ baseUrl, token, body, modelId }) {
+    return {
+      url: baseUrl,
+      init: {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ ...body, model: modelId }),
+      },
+    };
+  },
+  parseResponse(raw) {
+    return raw as OcrResponseShape;
+  },
+};
+
+export function getOcrTransformation(providerId: string): OcrTransformation {
+  return OCR_PROVIDERS[providerId]?.transformation ?? MISTRAL_PASSTHROUGH;
+}
+
+const AZURE_DI_API_VERSION = "2024-11-30";
+
+function azureDiSource(document: Record<string, unknown> | undefined): Record<string, string> {
+  if (!document) return {};
+  const url = String(document.document_url ?? document.image_url ?? "");
+  if (url.startsWith("data:")) {
+    const comma = url.indexOf(",");
+    return { base64Source: comma >= 0 ? url.slice(comma + 1) : "" };
+  }
+  return url ? { urlSource: url } : {};
+}
+
+export const AZURE_DI_TRANSFORMATION: OcrTransformation = {
+  buildRequest({ baseUrl, token, body, modelId }) {
+    const root = baseUrl.replace(/\/+$/, "");
+    return {
+      url: `${root}/documentintelligence/documentModels/${modelId}:analyze?api-version=${AZURE_DI_API_VERSION}&outputContentFormat=markdown`,
+      init: {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Ocp-Apim-Subscription-Key": token },
+        body: JSON.stringify(azureDiSource(body.document as Record<string, unknown>)),
+      },
+    };
+  },
+  pollUrl(res) {
+    return res.headers.get("Operation-Location");
+  },
+  parseResponse(raw) {
+    const r = raw as {
+      analyzeResult?: { content?: string; pages?: unknown[] };
+    };
+    const pageCount = r.analyzeResult?.pages?.length ?? 1;
+    // Azure returns the whole-document markdown in `content`; we mirror it into the
+    // Mistral shape as a single aggregated "page" (index 0), preserving pageCount.
+    return {
+      pages: [{ index: 0, markdown: r.analyzeResult?.content ?? "" }],
+      model: "prebuilt-read",
+      usage_info: { pages_processed: pageCount },
+    };
+  },
+};
+
 export const OCR_PROVIDERS: Record<string, OcrProvider> = {
   mistral: {
     id: "mistral",
@@ -31,6 +112,14 @@ export const OCR_PROVIDERS: Record<string, OcrProvider> = {
     authHeader: "bearer",
     models: [{ id: "mistral-ocr-latest", name: "Mistral OCR" }],
   },
+  "azure-document-intelligence": {
+    id: "azure-document-intelligence",
+    baseUrl: "",
+    authType: "apikey",
+    authHeader: "Ocp-Apim-Subscription-Key",
+    models: [{ id: "prebuilt-read", name: "Azure Document Intelligence (Read)" }],
+    transformation: AZURE_DI_TRANSFORMATION,
+  },
 };
 
 /**

open-sse/config/providerErrorRules.ts

@@ -29,15 +29,7 @@ export type ProviderErrorRule = {
 
 export type ProviderErrorRuleMatch = {
   reason: ConfiguredErrorReason;
-  /**
-   * Intended lock scope. NOTE: this field is currently INFORMATIONAL — no
-   * consumer of `getProviderErrorRuleMatch` (checkFallbackError, combo.ts)
-   * reads `scope` today; only `reason` and `cooldownMs` are consulted. The
-   * actual lock scope applied at runtime is decided independently by each
-   * call site (e.g. `hasPerModelQuota()` deciding model- vs connection-level
-   * lockout). Honoring this field end-to-end is tracked as a follow-up —
-   * see `docs/architecture/RESILIENCE_GUIDE.md` §7.
-   */
+  /** Default "provider" — lock the whole connection so other providers take over. */
   scope: "model" | "provider" | "connection";
   /** Optional explicit cooldown; falls back to the existing per-reason defaults. */
   cooldownMs?: number;
@@ -184,61 +176,6 @@ function buildOpenrouterRules(): ProviderErrorRule[] {
   ];
 }
 
-// ─── AgentRouter ────────────────────────────────────────────────────────────
-// agentrouter.org misstates temporary quota exhaustion as 403/400 with a
-// Chinese body. upstreamStatusRestatement.ts rewrites the status to 429
-// BEFORE classification, so rules here accept both the raw 403/400 and the
-// restated 429 (text is the real discriminator either way). In production,
-// the raw 403 path is what actually matters here: checkFallbackError's
-// apikey-category FORBIDDEN branch (~line 1699) returns EARLY for a plain
-// 403, before these rules are ever consulted — these rules fire on the
-// RESTATED 429 (chatCore's upstreamStatusRestatement hook runs first) via
-// resolveRuleMatchBody, which is the only path in checkFallbackError that
-// hands these rules the full error text instead of just {code, type}.
-//  - "额度不足": account-wide temporary quota → quota_exhausted, scope
-//    "connection" (mirror of the Opencode account-wide rationale above).
-//    NOTE: `scope` on ProviderErrorRuleMatch is currently informational —
-//    checkFallbackError/combo.ts only consume `reason` and `cooldownMs`, not
-//    `scope`. For agentrouter specifically (passthroughModels: true →
-//    hasPerModelQuota() is true), this quota_exhausted match actually
-//    resolves to a PER-MODEL lockout (recordModelLockoutFailure), not a
-//    connection-wide lock — other models on the same account keep being
-//    tried by combo routing (each burning one call) until they lock out
-//    individually. Honoring `scope` end-to-end is tracked as a follow-up.
-//  - "无权访问模型": declares auth_error/scope "model" (intent: lock only the
-//    model so the connection keeps serving the rest — Model Lockout tier).
-//    This rule does NOT fire on the production path today: it only matches
-//    `status === 403`, but checkFallbackError's apikey FORBIDDEN branch
-//    returns early for a plain 403 before this rule is ever consulted (see
-//    the note above). A live `无权访问模型` 403 is handled like the base
-//    apikey-provider 403 today. Wiring this rule into that path is tracked
-//    as a follow-up.
-function buildAgentrouterRules(): ProviderErrorRule[] {
-  const AGENTROUTER_ERROR_STATUSES = new Set([400, 403, 429]);
-  return [
-    {
-      id: "agentrouter-user-quota-exhausted",
-      match: ({ status, body }) => {
-        if (!AGENTROUTER_ERROR_STATUSES.has(status)) return null;
-        const text = JSON.stringify(body ?? "").toLowerCase();
-        if (!text.includes("额度不足")) return null;
-        return { reason: "quota_exhausted", scope: "connection" };
-      },
-    },
-    {
-      id: "agentrouter-model-access-denied",
-      match: ({ status, body }) => {
-        if (status !== 403) return null;
-        const text = JSON.stringify(body ?? "").toLowerCase();
-        if (!text.includes("无权访问模型")) return null;
-        // 6h: effectively "until the operator fixes the key's model grants",
-        // without being an unrecoverable terminal state.
-        return { reason: "auth_error", scope: "model", cooldownMs: 6 * 60 * 60 * 1000 };
-      },
-    },
-  ];
-}
-
 /**
  * Global registry. Provider name → ordered list of rules (first match wins).
  * Add new providers here; the matcher in classifyError will pick them up
@@ -252,37 +189,8 @@ export const providerRuleRegistry = new Map<string, ProviderErrorRule[]>([
   ["minimax-passthrough", buildMinimaxRules()],
   ["cloudflare-ai", buildCloudflareAiRules()],
   ["openrouter", buildOpenrouterRules()],
-  ["agentrouter", buildAgentrouterRules()],
 ]);
 
-/**
- * Providers whose rules match on the FULL upstream error text.
- * checkFallbackError's rule lookup normally passes only the structured
- * error ({code, type} — message stripped by the combo callers), which is
- * enough for header/status/code rules but blind to body-text markers like
- * agentrouter's "额度不足". Providers in this set get the raw error text as
- * the match body instead. EXCLUSIVE allowlist by owner decision (2026-08-13):
- * adding a provider here is an explicit opt-in — the default path for every
- * other provider must remain byte-for-byte unchanged.
- */
-const FULL_TEXT_RULE_PROVIDERS = new Set(["agentrouter"]);
-
-/**
- * Resolve the body handed to getProviderErrorRuleMatch inside
- * checkFallbackError: full error text for FULL_TEXT_RULE_PROVIDERS,
- * the structured error for everyone else.
- */
-export function resolveRuleMatchBody(
-  provider: string | null | undefined,
-  structuredError: unknown,
-  errorText: string | null | undefined
-): unknown {
-  if (provider && FULL_TEXT_RULE_PROVIDERS.has(provider.toLowerCase()) && errorText) {
-    return errorText;
-  }
-  return structuredError ?? null;
-}
-
 /**
  * Returns the first matching rule for a provider, or null if none match.
  * Callers use this to (a) classify the reason and (b) decide whether to

open-sse/config/upstreamStatusRestatement.ts

@@ -1,129 +0,0 @@
-/**
- * Upstream status restatement — registry of gateways that MISSTATE temporary
- * quota exhaustion as a non-retryable HTTP status.
- *
- * agentrouter.org signals "user quota exhausted" with 403 (sometimes 400) and
- * a Chinese body ("用户额度不足") instead of the standard 429. Clients like
- * Claude Code treat 403 as permanent and abort the whole session, and our own
- * fallback engine classifies it as AUTH_ERROR instead of a quota event.
- *
- * applyStatusRestatement() is called from exactly ONE place — the
- * `providerFailure:` block in open-sse/handlers/chatCore.ts, right after
- * parseUpstreamError() parses an upstream response with an error HTTP status
- * (!providerResponse.ok), and before any classification runs — so every
- * downstream consumer (checkFallbackError, combo aggregation, the client
- * response) sees the corrected status. Errors embedded inside a 200 SSE
- * stream follow a separate, later stream-parsing path and are NOT covered by
- * this hook today (known limitation; not yet needed for agentrouter's
- * misstatus, which surfaces as an error HTTP status). 429 is
- * Retry-After-eligible in
- * open-sse/services/combo/unavailableRetryGate.ts, so the client also gets a
- * retry window instead of a dead 403.
- *
- * Adding a future gateway with the same defect = register ONE rule array
- * below (and, for cooldown-scope refinement, one entry in
- * providerErrorRules.ts). No pipeline changes.
- *
- * Marker discipline: keep textMarkers provider-specific (the Chinese strings
- * are upstream error literals, not UI copy). Generic English phrases like
- * "insufficient_quota" are in CREDITS_EXHAUSTED_SIGNALS
- * (accountFallback.ts) and would flip the connection into a terminal
- * credits_exhausted state — never use them as markers here.
- *
- * Accepted trade-off: matching only on response body text means a
- * legitimate 400 whose body ECHOES user-supplied content containing a
- * marker (e.g. a prompt that itself contains "额度不足") would be restated to
- * 429 and lose the combo's 400 stop-guard. This is treated as an acceptable
- * risk because these markers are rare outside a genuine upstream error;
- * keeping markers short, provider-specific, and non-generic (as above)
- * minimizes false-positive restatement.
- */
-
-export type UpstreamStatusRestatementRule = {
-  id: string;
-  fromStatuses: ReadonlySet<number>;
-  toStatus: number;
-  /** Lowercase markers matched against lowercased `message` + JSON(body). Any hit → restate. */
-  textMarkers: readonly string[];
-  /** Lowercase markers that VETO the rule even when textMarkers hit (permanent errors). */
-  excludeMarkers?: readonly string[];
-  /** Synthetic Retry-After used ONLY when the upstream provided none. */
-  defaultRetryAfterMs?: number;
-};
-
-export type StatusRestatementInput = {
-  provider: string | null | undefined;
-  status: number;
-  message: string | null | undefined;
-  body?: unknown;
-  retryAfterMs?: number | null;
-};
-
-export type StatusRestatementResult = {
-  status: number;
-  retryAfterMs: number | null;
-  ruleId: string | null;
-  fromStatus: number;
-};
-
-// ─── agentrouter ────────────────────────────────────────────────────────────
-// Observed misstatus (ClaudeShield field reports + upstream behavior):
-//   403 "用户额度不足" / "额度不足"  → temporary user-quota exhaustion → 429
-//   400 variants carrying the same quota text                        → 429
-//   403 "无权访问模型" (no access to this model) → genuinely permanent, NEVER
-//   restated — it must keep flowing as 403 so nothing retries it forever.
-const AGENTROUTER_RULES: UpstreamStatusRestatementRule[] = [
-  {
-    id: "agentrouter-quota-misstatus",
-    fromStatuses: new Set([403, 400]),
-    toStatus: 429,
-    textMarkers: ["额度不足"],
-    excludeMarkers: ["无权访问"],
-    defaultRetryAfterMs: 60_000,
-  },
-];
-
-/** Provider id (lowercase) → ordered rules; first match wins. */
-export const statusRestatementRegistry = new Map<string, UpstreamStatusRestatementRule[]>([
-  ["agentrouter", AGENTROUTER_RULES],
-]);
-
-function stringifyBody(body: unknown): string {
-  if (body === null || body === undefined) return "";
-  if (typeof body === "string") return body;
-  try {
-    return JSON.stringify(body);
-  } catch {
-    return "";
-  }
-}
-
-export function applyStatusRestatement(input: StatusRestatementInput): StatusRestatementResult {
-  const passthrough: StatusRestatementResult = {
-    status: input.status,
-    retryAfterMs: input.retryAfterMs ?? null,
-    ruleId: null,
-    fromStatus: input.status,
-  };
-  if (!input.provider) return passthrough;
-  const rules = statusRestatementRegistry.get(input.provider.toLowerCase());
-  if (!rules) return passthrough;
-
-  const haystack = `${input.message ?? ""} ${stringifyBody(input.body)}`.toLowerCase();
-  if (!haystack.trim()) return passthrough;
-
-  for (const rule of rules) {
-    if (!rule.fromStatuses.has(input.status)) continue;
-    if (!rule.textMarkers.some((marker) => haystack.includes(marker))) continue;
-    if (rule.excludeMarkers?.some((marker) => haystack.includes(marker))) continue;
-    const upstreamRetryAfterMs =
-      typeof input.retryAfterMs === "number" && input.retryAfterMs > 0 ? input.retryAfterMs : null;
-    return {
-      status: rule.toStatus,
-      retryAfterMs: upstreamRetryAfterMs ?? rule.defaultRetryAfterMs ?? null,
-      ruleId: rule.id,
-      fromStatus: input.status,
-    };
-  }
-  return passthrough;
-}

open-sse/handlers/chatCore.ts

@@ -190,7 +190,6 @@ import {
   DEFAULT_MAX_TOKENS,
   STREAM_DISCONNECT_GRACE_PERIOD_MS,
 } from "../config/constants.ts";
-import { applyStatusRestatement } from "../config/upstreamStatusRestatement.ts";
 import { createRecoverableStream, makeContinuationBody } from "../services/streamRecovery.ts";
 import {
   resolveResilienceSettings,
@@ -3668,27 +3667,6 @@ export async function handleChatCore({
       upstreamErrorType = details.errorType as string | undefined;
     }
 
-    // Gateways like agentrouter misstate temporary quota exhaustion as 403/400,
-    // which downstream classification treats as AUTH_ERROR and clients like
-    // Claude Code treat as permanent. Restate to 429 (+ synthetic Retry-After)
-    // BEFORE any classification so both the fallback engine and the surfaced
-    // client status see a retryable error. Registry-scoped per provider.
-    const restatement = applyStatusRestatement({
-      provider,
-      status: statusCode,
-      message,
-      body: upstreamErrorBody,
-      retryAfterMs,
-    });
-    if (restatement.ruleId) {
-      statusCode = restatement.status;
-      retryAfterMs = restatement.retryAfterMs;
-      log?.info?.(
-        "STATUS_RESTATE",
-        `${provider} ${restatement.fromStatus}→${statusCode} (${restatement.ruleId})`
-      );
-    }
-
     const signatureRecovery = await recoverAnthropicThinkingSignature({
       provider,
       statusCode,

open-sse/handlers/ocr.ts

@@ -5,21 +5,43 @@ import { CORS_HEADERS } from "../utils/cors.ts";
  * Handles POST /v1/ocr (Mistral OCR API format).
  */
 
-import { getOcrProvider, parseOcrModel } from "../config/ocrRegistry.ts";
+import {
+  getOcrProvider,
+  getOcrTransformation,
+  parseOcrModel,
+  OCR_PROVIDERS,
+} from "../config/ocrRegistry.ts";
 import { errorResponse } from "../utils/error.ts";
 import { attachOmniRouteMetaHeaders } from "@/domain/omnirouteResponseMeta";
 import { generateRequestId } from "@/shared/utils/requestId";
 
+const OCR_POLL_MAX_ATTEMPTS = 30;
+const OCR_POLL_INTERVAL_MS = 1000;
+
+const defaultSleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
 /**
  * Handle OCR request
  *
+ * Dispatches to the per-provider transformation (see `open-sse/config/ocrRegistry.ts`)
+ * to build the upstream request, then (for async providers like Azure Document
+ * Intelligence) polls the returned operation URL until it succeeds or fails,
+ * before normalizing the response into the Mistral OCR shape.
+ *
  * @param {Object} options
  * @param {Object} options.body - JSON body { model, document }
- * @param {Object} options.credentials - Provider credentials { apiKey }
+ * @param {Object} options.credentials - Provider credentials { apiKey, accessToken, baseUrl }
+ * @param {Function} [options.fetchImpl] - DI hook for tests; defaults to global fetch
+ * @param {Function} [options.sleepImpl] - DI hook for tests; defaults to a real setTimeout-based sleep
  * @returns {Response}
  */
 /** @returns {Promise<unknown>} */
-export async function handleOcr({ body, credentials }) {
+export async function handleOcr({
+  body,
+  credentials,
+  fetchImpl = fetch,
+  sleepImpl = defaultSleep,
+}) {
   const startTime = Date.now();
   if (!body.document) {
     return errorResponse(400, "document is required");
@@ -31,7 +53,10 @@ export async function handleOcr({ body, credentials }) {
   const providerConfig = providerId ? getOcrProvider(providerId) : null;
 
   if (!providerConfig) {
-    return errorResponse(400, `No OCR provider found for model "${model}". Available: mistral`);
+    return errorResponse(
+      400,
+      `No OCR provider found for model "${model}". Available: ${Object.keys(OCR_PROVIDERS).join(", ")}`
+    );
   }
 
   const token = credentials?.apiKey || credentials?.accessToken;
@@ -39,18 +64,15 @@ export async function handleOcr({ body, credentials }) {
     return errorResponse(401, `No credentials for OCR provider: ${providerId}`);
   }
 
+  const baseUrl = credentials?.baseUrl || providerConfig.baseUrl;
+  if (!baseUrl) {
+    return errorResponse(400, `No base URL configured for OCR provider: ${providerId}`);
+  }
+
   try {
-    const res = await fetch(providerConfig.baseUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-      },
-      body: JSON.stringify({
-        ...body,
-        model: modelId,
-      }),
-    });
+    const transformation = getOcrTransformation(providerId);
+    const { url, init } = transformation.buildRequest({ baseUrl, token, body, modelId });
+    const res = await fetchImpl(url, init);
 
     if (!res.ok) {
       const errText = await res.text();
@@ -63,7 +85,17 @@ export async function handleOcr({ body, credentials }) {
       });
     }
 
-    const data = await res.json();
+    const pollUrl = transformation.pollUrl?.(res) ?? null;
+    let data: unknown;
+    if (pollUrl) {
+      const authHeader = buildAuthHeader(providerConfig.authHeader, token);
+      data = await pollOcrOperation({ pollUrl, authHeader, fetchImpl, sleepImpl });
+      if (data instanceof Response) return data;
+    } else {
+      data = await res.json();
+    }
+
+    const parsed = transformation.parseResponse(data);
     const headers = new Headers({ ...CORS_HEADERS, "Content-Type": "application/json" });
     attachOmniRouteMetaHeaders(headers, {
       provider: providerId,
@@ -72,8 +104,48 @@ export async function handleOcr({ body, credentials }) {
       latencyMs: Date.now() - startTime,
       requestId: generateRequestId(),
     });
-    return new Response(JSON.stringify(data), { status: 200, headers });
+    return new Response(JSON.stringify(parsed), { status: 200, headers });
   } catch (err) {
-    return errorResponse(500, `OCR request failed: ${err.message}`);
+    console.error("[OCR]", err);
+    return errorResponse(500, "OCR request failed");
   }
 }
+
+/**
+ * Build the same auth header used for the initial upstream request, so the
+ * poll GET (e.g. Azure Document Intelligence's Operation-Location) authenticates
+ * identically.
+ */
+function buildAuthHeader(authHeader: string, token: string): Record<string, string> {
+  if (authHeader === "bearer") {
+    return { Authorization: `Bearer ${token}` };
+  }
+  return { [authHeader]: token };
+}
+
+/**
+ * Poll an async OCR operation (Azure Document Intelligence) until it succeeds or fails.
+ *
+ * @returns {Promise<unknown|Response>} the parsed JSON body on success, or an error Response
+ */
+async function pollOcrOperation({ pollUrl, authHeader, fetchImpl, sleepImpl }) {
+  for (let attempt = 0; attempt < OCR_POLL_MAX_ATTEMPTS; attempt++) {
+    await sleepImpl(OCR_POLL_INTERVAL_MS);
+    const pollRes = await fetchImpl(pollUrl, {
+      method: "GET",
+      headers: authHeader,
+    });
+    if (!pollRes.ok) {
+      console.error("[OCR] poll error", pollRes.status);
+      return errorResponse(502, "OCR analysis failed");
+    }
+    const json = await pollRes.json();
+    if (json.status === "succeeded") {
+      return json;
+    }
+    if (json.status === "failed") {
+      return errorResponse(502, "OCR analysis failed");
+    }
+  }
+  return errorResponse(504, "OCR analysis timed out");
+}

open-sse/services/accountFallback.ts

@@ -15,7 +15,7 @@ import {
   serviceSupervisorCooldown,
   isNimFunctionDegraded,
 } from "../config/errorConfig.ts";
-import { getProviderErrorRuleMatch, resolveRuleMatchBody } from "../config/providerErrorRules.ts";
+import { getProviderErrorRuleMatch } from "../config/providerErrorRules.ts";
 import * as rot from "./rotationConfig.ts";
 import { getPassthroughProviders, getProviderCategory } from "../config/providerRegistry.ts";
 import {
@@ -1743,12 +1743,7 @@ export function checkFallbackError(
       // specific configured reasons (e.g. 503 → SERVER_ERROR would be
       // shadowed by 503 → MODEL_CAPACITY).
       const providerMatch = provider
-        ? getProviderErrorRuleMatch(
-            provider,
-            status,
-            headers,
-            resolveRuleMatchBody(provider, structuredError ?? null, errorStr)
-          )
+        ? getProviderErrorRuleMatch(provider, status, headers, structuredError ?? null)
         : null;
       const reason = providerMatch
         ? providerMatch.reason
@@ -1781,12 +1776,7 @@ export function checkFallbackError(
     // generic zero-cooldown default. Mirror the backoff branch above so
     // provider rules win on cooldown/reason regardless of `backoff`.
     const providerMatch = provider
-      ? getProviderErrorRuleMatch(
-          provider,
-          status,
-          headers,
-          resolveRuleMatchBody(provider, structuredError ?? null, errorStr)
-        )
+      ? getProviderErrorRuleMatch(provider, status, headers, structuredError ?? null)
       : null;
     const cooldownMs = providerMatch?.cooldownMs ?? configuredRule.cooldownMs ?? 0;
     return {

open-sse/services/compression/outputStyles/catalog.ts

@@ -95,30 +95,6 @@ export const OUTPUT_STYLE_CATALOG: Record<string, OutputStyle> = {
       },
     },
   },
-  // i-have-adhd (action-first output) — integrated into the output-style registry
-  // so it rides the existing production injector, like ponytail.
-  // Source: https://github.com/ayghri/i-have-adhd (MIT). The upstream skill's 10
-  // ADHD-friendly rules, adapted for proxy injection: agent-harness-specific rules
-  // (restate plan state, time estimates) reworded as conditionals so they hold for
-  // plain chat clients too.
-  "i-have-adhd": {
-    id: "i-have-adhd",
-    label: "I have ADHD (action-first)",
-    description:
-      "Action-first output: next action leads, steps numbered, one concrete next step, no preamble.",
-    levels: {
-      lite: `# I have ADHD (lite)\nLead with the action: command, path, or snippet first, prose after. Number multi-step work; each step one bounded action. End with ONE concrete next step. No preamble, no recap, no closing pleasantries. ${SHARED_BOUNDARIES}`,
-      full: `# I have ADHD — action-first output\n\nThe reader has ADHD. Shape output so an ADHD brain can act on it:\n1. Lead with the next action — command, path, or snippet first; context after, if at all.\n2. Number multi-step work; each step is one bounded action; use the fewest steps that work.\n3. End with ONE concrete next step doable in under two minutes.\n4. Suppress tangents: finish the first issue, offer the second as a separate question.\n5. In multi-turn work, restate where things stand ("step 3 of 5 done") — the reader cannot hold state between messages.\n6. When human effort is involved, estimate it in concrete units (minutes, an afternoon), never "some work".\n7. Make wins visible: state what now works and how to try it.\n8. Errors matter-of-fact: cause and fix; never "Uh oh".\n9. Cap lists at 5 items; split into "do now" vs "later" beyond that.\n10. No preamble, no recap, no closers ("Hope this helps").\nExceptions: an explicit "explain" request gets a full body (still no preamble/closer); destructive actions get confirmation first; real ambiguity gets one short clarifying question. ${SHARED_BOUNDARIES}`,
-      ultra: `# I have ADHD (ultra)\nAction first: command/path/snippet, then prose if needed. Numbered bounded steps, fewest that work. One <2-min next step at the end. No tangents — separate question. Multi-turn: restate state. Human effort: concrete time units. Wins visible. Errors: cause + fix. Lists ≤5. Zero preamble/recap/closers. Explain-requests get full body; destructive actions get confirmation; real ambiguity gets one question. ${SHARED_BOUNDARIES}`,
-    },
-    i18n: {
-      "pt-BR": {
-        lite: `# Eu tenho TDAH (lite)\nComece pela ação: comando, path ou snippet primeiro, prosa depois. Numere trabalho multi-passo; cada passo é uma ação delimitada. Termine com UMA próxima ação concreta. Sem preâmbulo, sem recap, sem despedidas. ${SHARED_BOUNDARIES}`,
-        full: `# Eu tenho TDAH — saída action-first\n\nO leitor tem TDAH. Molde a saída para que um cérebro TDAH consiga agir sobre ela:\n1. Comece pela próxima ação — comando, path ou snippet primeiro; contexto depois, se necessário.\n2. Numere trabalho multi-passo; cada passo é uma ação delimitada; use o menor número de passos que funcione.\n3. Termine com UMA próxima ação concreta executável em menos de dois minutos.\n4. Suprima tangentes: termine a primeira questão, ofereça a segunda como pergunta separada.\n5. Em trabalho multi-turno, reafirme onde as coisas estão ("passo 3 de 5 feito") — o leitor não guarda estado entre mensagens.\n6. Quando houver esforço humano, estime em unidades concretas (minutos, uma tarde), nunca "um pouco de trabalho".\n7. Torne vitórias visíveis: diga o que funciona agora e como testar.\n8. Erros de forma direta: causa e fix; nunca "Opa!".\n9. Listas com no máximo 5 itens; acima disso, divida em "agora" vs "depois".\n10. Sem preâmbulo, sem recap, sem despedidas ("Espero ter ajudado").\nExceções: pedido explícito de "explique" recebe corpo completo (ainda sem preâmbulo/despedida); ações destrutivas recebem confirmação antes; ambiguidade real recebe uma pergunta curta de esclarecimento. ${SHARED_BOUNDARIES}`,
-        ultra: `# Eu tenho TDAH (ultra)\nAção primeiro: comando/path/snippet, prosa depois se precisar. Passos numerados e delimitados, o mínimo que funcione. UMA próxima ação <2 min no fim. Sem tangentes — pergunta separada. Multi-turno: reafirme o estado. Esforço humano: unidades concretas de tempo. Vitórias visíveis. Erros: causa + fix. Listas ≤5. Zero preâmbulo/recap/despedidas. "Explique" recebe corpo completo; ação destrutiva recebe confirmação; ambiguidade real recebe uma pergunta. ${SHARED_BOUNDARIES}`,
-      },
-    },
-  },
   "terse-cjk": {
     id: "terse-cjk",
     label: "Terse CJK (文言)",

scripts/build/dashboardEmbed.mjs

@@ -1,142 +0,0 @@
-/**
- * Opt-in iframe embedding for OmniRoute's HTML pages (#10273).
- *
- * OmniRoute ships `frame-ancestors 'none'` + `X-Frame-Options: DENY` on every route, which
- * is the right default for a proxy that holds provider credentials. The OmniCopilot VS Code
- * extension, however, renders the dashboard inside the built-in Simple Browser — an iframe
- * whose ancestor is a `vscode-webview:` document — so the strict default paints a blank tab.
- *
- * Setting `DASHBOARD_ALLOW_EMBED=vscode` at build time swaps the page surface to
- * `frame-ancestors 'self' vscode-webview:` and drops `X-Frame-Options` for those pages.
- * XFO has no syntax for a custom scheme, and keeping `DENY` alongside a permissive
- * `frame-ancestors` would still block the frame in engines that honour XFO first — dropping
- * it is required, not cosmetic. (Modern engines ignore XFO entirely once `frame-ancestors`
- * is present, so nothing is lost where CSP is supported.)
- *
- * The API surface is deliberately left out: `/api/*`, `/v1*`, `/a2a`, `/healthz` and every
- * root-level rewrite alias keep the strict headers even in embed mode. Those are the
- * Hard-Rule-15/17 process-spawning and proxy surfaces and never need framing.
- *
- * Build-time by design: Next.js resolves `headers()` when the config loads, matching the
- * existing env-driven knobs in `next.config.mjs` (`OMNIROUTE_BASE_PATH`,
- * `OMNIROUTE_BUILD_PROFILE`, …). Changing the value requires a rebuild.
- */
-
-export const DASHBOARD_EMBED_ENV = "DASHBOARD_ALLOW_EMBED";
-
-/** Ancestor allow-list per supported embed mode. Adding a mode here is the only extension point. */
-export const EMBED_FRAME_ANCESTORS = Object.freeze({
-  // `vscode-webview:` is the scheme VS Code assigns to webview/Simple Browser documents.
-  // `'self'` keeps OmniRoute's own same-origin frames (e.g. the G-10 9Router embed) working.
-  vscode: "'self' vscode-webview:",
-});
-
-/** The strict `frame-ancestors` token the CSP carries by default. */
-export const STRICT_FRAME_ANCESTORS = "frame-ancestors 'none'";
-
-/**
- * App-router surfaces that are not HTML pages and have no `rewrites()` alias to derive them
- * from. Everything else in the exclusion list comes from the rewrite table, so a future API
- * alias is excluded automatically instead of silently becoming framable.
- */
-export const STATIC_NON_PAGE_PREFIXES = Object.freeze(["api", "a2a", "healthz"]);
-
-/**
- * Resolve the opt-in embed mode from the environment.
- * Unknown / truthy-looking values (`1`, `true`, `on`) intentionally do NOT enable embedding:
- * the operator must name the ancestor family they are opening up.
- *
- * @param {Record<string, string | undefined>} env
- * @returns {"vscode" | null}
- */
-export function resolveDashboardEmbedMode(env = process.env) {
-  const raw = env?.[DASHBOARD_EMBED_ENV];
-  if (typeof raw !== "string") return null;
-  const normalized = raw.trim().toLowerCase();
-  return Object.hasOwn(EMBED_FRAME_ANCESTORS, normalized) ? normalized : null;
-}
-
-/**
- * The first path segment of every route that must stay unframable, derived from the
- * `rewrites()` table plus the static app-router API surfaces.
- *
- * @param {{ source: string }[]} rewriteRules
- * @returns {string[]} sorted, de-duplicated prefixes
- */
-export function nonPageRoutePrefixes(rewriteRules = []) {
-  const prefixes = new Set(STATIC_NON_PAGE_PREFIXES);
-  for (const { source } of rewriteRules) {
-    const first = source.replace(/^\//, "").split("/")[0];
-    // Skip parameterised first segments (`/:path*`) — they would exclude the whole site.
-    if (first && !first.startsWith(":")) prefixes.add(first);
-  }
-  return [...prefixes].sort();
-}
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * Two complementary Next.js `source` patterns built from the same prefix list, so the union
- * covers every pathname exactly once — no gap (a page with no security headers) and no
- * overlap (an order-dependent merge).
- *
- * @param {string[]} prefixes
- * @returns {{ nonPageSource: string, pageSource: string }}
- */
-export function complementarySources(prefixes) {
-  const alternation = prefixes.map(escapeRegExp).join("|");
-  const boundary = `(?:${alternation})(?:/|$)`;
-  return {
-    nonPageSource: `/((?=${boundary}).*)`,
-    pageSource: `/((?!${boundary}).*)`,
-  };
-}
-
-/**
- * Swap only the `frame-ancestors` token of an existing CSP, leaving every other directive
- * byte-identical.
- *
- * @param {string} contentSecurityPolicy
- * @param {"vscode"} mode
- */
-export function relaxFrameAncestors(contentSecurityPolicy, mode) {
-  return contentSecurityPolicy.replace(
-    STRICT_FRAME_ANCESTORS,
-    `frame-ancestors ${EMBED_FRAME_ANCESTORS[mode]}`
-  );
-}
-
-/**
- * Build the `headers()` rules carrying OmniRoute's baseline security headers.
- *
- * With embedding off this returns the single catch-all rule the config has always had, so a
- * default build is unchanged. With embedding on it returns two complementary rules: the API
- * surface keeps the strict headers, the page surface gets the relaxed CSP and no XFO.
- *
- * @param {{
- *   mode: "vscode" | null,
- *   securityHeaders: { key: string, value: string }[],
- *   prefixes?: string[],
- * }} options
- * @returns {{ source: string, headers: { key: string, value: string }[] }[]}
- */
-export function buildSecurityHeaderRules({ mode, securityHeaders, prefixes = [] }) {
-  if (!mode) return [{ source: "/:path*", headers: securityHeaders }];
-
-  const { nonPageSource, pageSource } = complementarySources(prefixes);
-  const pageHeaders = securityHeaders
-    // X-Frame-Options cannot express `vscode-webview:` and would veto the relaxed CSP.
-    .filter((header) => header.key !== "X-Frame-Options")
-    .map((header) =>
-      header.key === "Content-Security-Policy"
-        ? { key: header.key, value: relaxFrameAncestors(header.value, mode) }
-        : header
-    );
-
-  return [
-    { source: nonPageSource, headers: securityHeaders },
-    { source: pageSource, headers: pageHeaders },
-  ];
-}

skills/omni-inference/SKILL.md

@@ -304,7 +304,7 @@ curl -X POST https://localhost:20128/api/v1/management/proxy-subscriptions/{id}/
 
 Document OCR
 
-Mistral OCR–compatible document OCR endpoint. Accepts a JSON body referencing a document/image and returns extracted text. Success responses carry the `X-OmniRoute-*` cost-telemetry headers.
+Multi-provider document OCR endpoint (Mistral OCR–compatible request and response shape). Accepts a JSON body referencing a document/image and returns extracted text. `model` selects the provider via a `provider/model` prefix (e.g. `mistral/mistral-ocr-latest`, `azure-document-intelligence/prebuilt-read`); a bare model id (e.g. `mistral-ocr-latest`) resolves to its registered provider, and an omitted `model` defaults to Mistral. Azure Document Intelligence is asynchronous upstream — the handler polls the returned operation until it succeeds or fails before responding, so this endpoint can take longer to return for that provider. Success responses carry the `X-OmniRoute-*` cost-telemetry headers.
 
 ```bash
 curl -X POST https://localhost:20128/api/v1/ocr \

src/app/api/v1/ocr/route.ts

@@ -15,6 +15,25 @@ import {
   rateLimitedProviderResponse,
 } from "@/app/api/v1/_shared/rateLimit";
 
+/**
+ * Custom-endpoint providers (e.g. azure-document-intelligence) store the
+ * connection's resource endpoint under providerSpecificData.baseUrl, not as
+ * a top-level credentials field — mirror the convention used across
+ * src/lib/providers/validation/* (see e.g. urlHelpers.ts). handleOcr reads
+ * credentials.baseUrl, so surface it here. An existing top-level baseUrl
+ * always wins (kept for tests/callers that pass it directly).
+ */
+export function resolveOcrCredentials<
+  T extends { baseUrl?: string; providerSpecificData?: Record<string, unknown> },
+>(credentials: T): T {
+  if (credentials?.baseUrl) return credentials;
+  const providerSpecificBaseUrl = credentials?.providerSpecificData?.baseUrl;
+  if (typeof providerSpecificBaseUrl === "string" && providerSpecificBaseUrl.trim()) {
+    return { ...credentials, baseUrl: providerSpecificBaseUrl };
+  }
+  return credentials;
+}
+
 /**
  * Handle CORS preflight
  */
@@ -66,7 +85,9 @@ async function postHandler(request, context) {
     return rateLimitedProviderResponse(resolvedProvider, credentials);
   }
 
-  const response = await handleOcr({ body: { ...body, model }, credentials });
+  const ocrCredentials = resolveOcrCredentials(credentials);
+
+  const response = await handleOcr({ body: { ...body, model }, credentials: ocrCredentials });
   if (response?.ok) {
     await clearRecoveredProviderState(credentials);
   }

stryker.conf.json

@@ -63,7 +63,6 @@
       "tests/unit/adaptive-admission-route-matrix.test.ts",
       "tests/unit/adaptive-admission-runtime.test.ts",
       "tests/unit/adobe-firefly.test.ts",
-      "tests/unit/agentrouter-error-rules.test.ts",
       "tests/unit/alibaba-free-tier-exhaustion.test.ts",
       "tests/unit/anthropic-thinking-signature-recovery.test.ts",
       "tests/unit/antigravity-429-quota-tdd.test.ts",

tests/unit/agentrouter-error-rules.test.ts

@@ -1,141 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-/**
- * agentrouter.org quota model, as declared by the `providerErrorRules.ts`
- * classification layer:
- *  - "额度不足" (quota insufficient) is ACCOUNT-wide and temporary → the rule
- *    declares scope "connection".
- *  - "无权访问模型" (no access to this model) is permanent PER MODEL → the rule
- *    declares scope "model".
- * Status matching accepts both the raw upstream 403 AND the restated 429
- * (upstreamStatusRestatement.ts rewrites 403→429 before classification).
- *
- * IMPORTANT — `scope` above is what the rule DECLARES, not what production
- * enforces: `ProviderErrorRuleMatch.scope` is not consumed by
- * checkFallbackError/combo.ts today (only `reason`/`cooldownMs` are). For
- * agentrouter (passthroughModels: true → hasPerModelQuota() true), the
- * quota_exhausted match actually resolves to a PER-MODEL lockout in
- * production, not a connection-wide lock — other models on the same account
- * keep being tried by combo routing until they lock out individually. And
- * the "无权访问模型" rule never reaches production traffic at all today: it
- * only matches raw `status === 403`, but checkFallbackError's apikey
- * FORBIDDEN branch returns early for a plain 403 before any provider rule is
- * consulted (see A7). See `docs/architecture/RESILIENCE_GUIDE.md` §7 for the
- * full writeup and the tracked follow-up to honor `scope`.
- */
-
-const { providerRuleRegistry, getProviderErrorRuleMatch } = await import(
-  "../../open-sse/config/providerErrorRules.ts"
-);
-const { classifyError, checkFallbackError } = await import(
-  "../../open-sse/services/accountFallback.ts"
-);
-const { RateLimitReason } = await import("../../open-sse/config/constants.ts");
-
-test("A1: agentrouter is registered in providerRuleRegistry", () => {
-  const rules = providerRuleRegistry.get("agentrouter");
-  assert.ok(rules && rules.length > 0);
-});
-
-test("A2: quota body → quota_exhausted scope connection (restated 429)", () => {
-  const match = getProviderErrorRuleMatch("agentrouter", 429, {}, {
-    error: { message: "用户额度不足，请充值" },
-  });
-  assert.ok(match, "quota body must match");
-  assert.equal(match.reason, "quota_exhausted");
-  assert.equal(match.scope, "connection");
-});
-
-test("A3: quota body also matches the raw (pre-restatement) 403", () => {
-  const match = getProviderErrorRuleMatch("agentrouter", 403, {}, "用户额度不足");
-  assert.ok(match);
-  assert.equal(match.reason, "quota_exhausted");
-});
-
-test("A4: 无权访问模型 → auth_error scope model, at the RULE layer only (getProviderErrorRuleMatch directly) — this rule never receives production traffic (see A7): checkFallbackError's apikey FORBIDDEN branch returns early for a plain 403 before reaching this rule", () => {
-  const match = getProviderErrorRuleMatch("agentrouter", 403, {}, {
-    error: { message: "无权访问模型 claude-sonnet-4" },
-  });
-  assert.ok(match);
-  assert.equal(match.reason, "auth_error");
-  assert.equal(match.scope, "model");
-});
-
-test("A5: classifyError layer guard — quota text wins over the 403→AUTH_ERROR status fallback (classifyError itself has no production caller today; the production guard is A6/checkFallbackError)", () => {
-  const reason = classifyError(403, "用户额度不足", {
-    provider: "agentrouter",
-    headers: {},
-    body: { error: { message: "用户额度不足" } },
-  });
-  assert.equal(reason, RateLimitReason.QUOTA_EXHAUSTED);
-});
-
-test("A6: guard — restated quota error is retryable, never terminal, and now actually classified as quota_exhausted", () => {
-  // Status 429 (post-restatement) reaches checkFallbackError's provider-rule
-  // lookup. resolveRuleMatchBody() hands agentrouter the full error text
-  // (instead of just the stripped {code, type} structuredError every other
-  // provider gets), so the "额度不足" rule actually fires here — this is the
-  // production path the restatement hook (Task 2) feeds into.
-  const result = checkFallbackError(429, "用户额度不足", 0, null, "agentrouter", null);
-  assert.equal(result.shouldFallback, true);
-  assert.equal(result.reason, "quota_exhausted");
-  assert.ok(!result.permanent, "quota misstatus must never be permanent");
-  assert.ok(!result.creditsExhausted, "must not trip CREDITS_EXHAUSTED_SIGNALS");
-  assert.ok(result.cooldownMs > 0, "must carry a real cooldown");
-});
-
-test("A7: guard — raw 403 quota (hook bypassed) is still not account-deactivation", () => {
-  // A raw (pre-restatement) 403 never actually reaches the agentrouter provider
-  // rules in production: checkFallbackError's apikey-category FORBIDDEN branch
-  // (status === 403 && getProviderCategory(provider) === "apikey") returns
-  // EARLY via resolveApiKeyForbiddenFallback before the provider-rule lookup
-  // is ever consulted. In the real pipeline, chatCore's upstreamStatusRestatement
-  // hook (Task 2) already converts 403→429 before checkFallbackError ever sees
-  // it, so this early-return path is what a hook-bypassed raw 403 hits — and it
-  // must still not be misclassified as permanent account deactivation.
-  const result = checkFallbackError(403, "用户额度不足", 0, null, "agentrouter", null);
-  assert.equal(result.shouldFallback, true);
-  assert.ok(!result.permanent);
-});
-
-test("A8: plain agentrouter 403 (no quota text) keeps the default apikey auth path", () => {
-  const match = getProviderErrorRuleMatch("agentrouter", 403, {}, "Invalid API key");
-  assert.equal(match, null);
-});
-
-test("A9: resolveRuleMatchBody hands full text ONLY to allowlisted providers", async () => {
-  const { resolveRuleMatchBody } = await import(
-    "../../open-sse/config/providerErrorRules.ts"
-  );
-  const structured = { code: "rate_limited", type: "requests" };
-  assert.equal(resolveRuleMatchBody("agentrouter", structured, "用户额度不足"), "用户额度不足");
-  assert.equal(resolveRuleMatchBody("opencode", structured, "monthly usage limit reached"), structured);
-  assert.equal(resolveRuleMatchBody("openrouter", null, "some error text"), null);
-  assert.equal(resolveRuleMatchBody("agentrouter", structured, ""), structured);
-});
-
-test("A10: other providers' checkFallbackError behavior is unchanged (exclusivity)", () => {
-  // opencode's body-text rule ("organization_quota_exceeded") must still NOT
-  // fire through checkFallbackError — the allowlist is agentrouter-only, so
-  // opencode keeps getting only the stripped structuredError as the match
-  // body (null here, since no structuredError arg is passed), same as before
-  // this fix. Baseline captured on the pre-fix code with this exact input:
-  //   { shouldFallback: true, cooldownMs: 3000, baseCooldownMs: 3000,
-  //     newBackoffLevel: 1, usedUpstreamRetryHint: false,
-  //     reason: "rate_limit_exceeded" }
-  // i.e. it falls through to the generic 429 configured rule, NOT the
-  // opencode-quota-exhausted-body provider rule — asserting `reason` here is
-  // exactly what proves the allowlist didn't leak to opencode.
-  const result = checkFallbackError(
-    429,
-    '{"error":{"message":"organization_quota_exceeded"}}',
-    0,
-    null,
-    "opencode",
-    null
-  );
-  assert.ok(result.shouldFallback);
-  assert.equal(result.reason, "rate_limit_exceeded");
-  assert.equal(result.cooldownMs, 3000);
-});

tests/unit/compression/i-have-adhd-catalog.test.ts

@@ -1,76 +0,0 @@
-/**
- * Tests for the i-have-adhd output style — action-first prompt injection.
- *
- * Verifies:
- *   - i-have-adhd is registered with lite/full/ultra levels
- *   - i18n map exists for pt-BR with all three levels
- *   - Each level (en and pt-BR) contains the SHARED_BOUNDARIES suffix
- *   - Core concepts present: action-first, numbered steps, no preamble
- *   - No locale gate (style valid under every language)
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import {
-  OUTPUT_STYLE_CATALOG,
-  outputStyleMeta,
-} from "../../../open-sse/services/compression/outputStyles/catalog.ts";
-
-const ADHD = OUTPUT_STYLE_CATALOG["i-have-adhd"];
-
-function assertString(v: unknown, label: string): asserts v is string {
-  assert.equal(typeof v, "string", `${label} must be a string`);
-}
-
-describe("i-have-adhd output style", () => {
-  it("is registered in the catalog with lite/full/ultra levels", () => {
-    assert.ok(ADHD, "i-have-adhd must be in catalog");
-    assert.equal(ADHD.id, "i-have-adhd");
-    assert.ok(ADHD.label.includes("ADHD"));
-    assertString(ADHD.levels.lite, "lite");
-    assertString(ADHD.levels.full, "full");
-    assertString(ADHD.levels.ultra, "ultra");
-  });
-
-  it("every level ends with the shared boundaries suffix", () => {
-    const shared = "Code blocks, file paths";
-    assert.ok(ADHD.levels.lite.includes(shared));
-    assert.ok(ADHD.levels.full.includes(shared));
-    assert.ok(ADHD.levels.ultra.includes(shared));
-  });
-
-  it("the full level contains the action-first core concepts", () => {
-    assert.ok(ADHD.levels.full.includes("Lead with the next action"));
-    assert.ok(/[Nn]umber/.test(ADHD.levels.full), "full mentions numbered steps");
-    assert.ok(ADHD.levels.full.includes("No preamble"));
-  });
-
-  it("has an i18n map for pt-BR with all three intensity levels", () => {
-    assert.ok(ADHD.i18n, "i18n must be defined");
-    const pt = ADHD.i18n["pt-BR"];
-    assert.ok(pt, "pt-BR must exist");
-    assertString(pt.lite, "pt-BR.lite");
-    assertString(pt.full, "pt-BR.full");
-    assertString(pt.ultra, "pt-BR.ultra");
-  });
-
-  it("each pt-BR level ends with shared boundaries", () => {
-    const shared = "Code blocks";
-    const pt = ADHD.i18n?.["pt-BR"];
-    assert.ok(pt, "pt-BR i18n must exist");
-    assert.ok(pt.lite.includes(shared), "pt-BR.lite contains shared boundaries");
-    assert.ok(pt.full.includes(shared), "pt-BR.full contains shared boundaries");
-    assert.ok(pt.ultra.includes(shared), "pt-BR.ultra contains shared boundaries");
-  });
-
-  it("pt-BR full contains Portuguese action-first terminology", () => {
-    const pt = ADHD.i18n?.["pt-BR"];
-    assert.ok(pt, "pt-BR i18n must exist");
-    assert.ok(/ação/.test(pt.full), "pt-BR.full mentions ação");
-    assert.ok(/preâmbulo/.test(pt.full), "pt-BR.full mentions preâmbulo");
-  });
-
-  it("carries no locale gate", () => {
-    assert.equal(outputStyleMeta("i-have-adhd").locale, undefined);
-  });
-});

tests/unit/dashboard-embed-csp-10273.test.ts

@@ -1,324 +0,0 @@
-// Regression guard for #10273: opt-in CSP relaxation so OmniRoute's HTML pages can be
-// embedded in the VS Code Simple Browser (the OmniCopilot extension's `dashboardOpen:
-// "editor"` mode renders them inside a `vscode-webview:` iframe).
-//
-// The default posture is UNCHANGED and must stay that way: `frame-ancestors 'none'` +
-// `X-Frame-Options: DENY` on every route. Only when the operator explicitly sets
-// DASHBOARD_ALLOW_EMBED=vscode do the HTML pages switch to
-// `frame-ancestors 'self' vscode-webview:` and drop `X-Frame-Options` (XFO has no syntax
-// for a custom scheme, and CSP frame-ancestors supersedes it in modern engines).
-//
-// The API surface (`/api`, `/v1`, `/v1beta`, the root-level rewrite aliases, `/a2a`,
-// `/healthz`) must keep the strict headers even in embed mode — those are the
-// Hard-Rule-15/17 surfaces and never need framing.
-//
-// These tests assert EFFECTIVE headers, not config shape: `effectiveHeaders()` replays
-// Next.js's own matching + last-wins merge (see
-// node_modules/next/dist/server/lib/router-utils/resolve-routes.js, `resHeaders[key] = value`)
-// so a rule that silently stops matching, or an ordering regression, fails here.
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { getPathMatch } from "next/dist/shared/lib/router/utils/path-match.js";
-
-import {
-  DASHBOARD_EMBED_ENV,
-  EMBED_FRAME_ANCESTORS,
-  resolveDashboardEmbedMode,
-  nonPageRoutePrefixes,
-  buildSecurityHeaderRules,
-} from "../../scripts/build/dashboardEmbed.mjs";
-
-const modulePath = path.join(process.cwd(), "next.config.mjs");
-const originalEmbed = process.env[DASHBOARD_EMBED_ENV];
-
-interface HeaderEntry {
-  key: string;
-  value: string;
-}
-interface HeaderRule {
-  source: string;
-  headers: HeaderEntry[];
-}
-
-async function loadHeaders(label: string): Promise<HeaderRule[]> {
-  const mod = await import(`${pathToFileURL(modulePath).href}?case=${label}-${Date.now()}`);
-  return mod.default.headers();
-}
-
-/** Replay Next.js's header matching + last-wins merge for one pathname. */
-function effectiveHeaders(rules: HeaderRule[], pathname: string): Record<string, string> {
-  const merged: Record<string, string> = {};
-  for (const rule of rules) {
-    if (getPathMatch(rule.source, { removeUnnamedParams: true })(pathname) === false) continue;
-    for (const { key, value } of rule.headers) merged[key] = value;
-  }
-  return merged;
-}
-
-// Pages an operator expects to reach inside the VS Code Simple Browser. `/login` is on the
-// list on purpose: the webview has its own cookie jar, so an embedded session ALWAYS starts
-// unauthenticated and `/dashboard` redirects there (src/server/authz/pipeline.ts).
-const PAGE_PATHS = [
-  "/",
-  "/dashboard",
-  "/dashboard/providers",
-  "/dashboard/combos/editor",
-  "/login",
-  "/forgot-password",
-  "/docs/guides/i18n",
-  "/landing",
-  "/status",
-];
-
-// Never framable — the process-spawning / proxy surfaces plus every root-level API alias
-// declared in next.config.mjs `rewrites()`.
-const API_PATHS = [
-  "/api",
-  "/api/v1/chat/completions",
-  "/api/services/ninerouter/start",
-  "/v1",
-  "/v1/models",
-  "/v1beta/models",
-  "/chat/completions",
-  "/responses",
-  "/responses/abc/cancel",
-  "/models",
-  "/codex/responses",
-  "/anthropic/v1/messages",
-  "/openai/v1/models",
-  "/metrics",
-  "/debug",
-  "/.env",
-  "/a2a",
-  "/healthz",
-];
-
-function restoreEnv(): void {
-  if (originalEmbed === undefined) delete process.env[DASHBOARD_EMBED_ENV];
-  else process.env[DASHBOARD_EMBED_ENV] = originalEmbed;
-}
-
-test.afterEach(restoreEnv);
-
-// ── the opt-in switch itself ───────────────────────────────────────────────
-
-test("#10273 embed mode is OFF unless DASHBOARD_ALLOW_EMBED names a known mode", () => {
-  for (const raw of [undefined, "", "  ", "0", "1", "true", "yes", "on", "browser", "vscode-web"]) {
-    assert.equal(
-      resolveDashboardEmbedMode(raw === undefined ? {} : { [DASHBOARD_EMBED_ENV]: raw }),
-      null,
-      `DASHBOARD_ALLOW_EMBED=${JSON.stringify(raw)} must not enable embedding`
-    );
-  }
-});
-
-test("#10273 DASHBOARD_ALLOW_EMBED=vscode enables the vscode mode, case/space tolerant", () => {
-  for (const raw of ["vscode", "VSCode", "  vscode  ", "VSCODE"]) {
-    assert.equal(resolveDashboardEmbedMode({ [DASHBOARD_EMBED_ENV]: raw }), "vscode");
-  }
-  assert.equal(EMBED_FRAME_ANCESTORS.vscode, "'self' vscode-webview:");
-});
-
-// ── default posture must not move ──────────────────────────────────────────
-
-test("#10273 default build keeps frame-ancestors 'none' + X-Frame-Options: DENY everywhere", async () => {
-  delete process.env[DASHBOARD_EMBED_ENV];
-  const rules = await loadHeaders("embed-off");
-
-  assert.equal(
-    rules[0].source,
-    "/:path*",
-    "the global rule must stay a plain catch-all by default"
-  );
-
-  for (const pathname of [...PAGE_PATHS, ...API_PATHS]) {
-    const headers = effectiveHeaders(rules, pathname);
-    assert.match(
-      headers["Content-Security-Policy"],
-      /frame-ancestors 'none'/,
-      `${pathname} must keep frame-ancestors 'none' when the opt-in is off`
-    );
-    assert.equal(
-      headers["X-Frame-Options"],
-      "DENY",
-      `${pathname} must keep X-Frame-Options: DENY when the opt-in is off`
-    );
-  }
-});
-
-test("#10273 default build emits no extra header rules (byte-identical to pre-feature config)", async () => {
-  delete process.env[DASHBOARD_EMBED_ENV];
-  const rules = await loadHeaders("embed-off-shape");
-  assert.deepEqual(
-    rules.map((rule) => rule.source),
-    ["/:path*", "/dashboard/providers/services/:name/embed/:path*"]
-  );
-});
-
-// ── embed mode ─────────────────────────────────────────────────────────────
-
-test("#10273 embed mode lets vscode-webview: frame the HTML pages and drops X-Frame-Options", async () => {
-  process.env[DASHBOARD_EMBED_ENV] = "vscode";
-  const rules = await loadHeaders("embed-on-pages");
-
-  for (const pathname of PAGE_PATHS) {
-    const headers = effectiveHeaders(rules, pathname);
-    assert.ok(
-      headers["Content-Security-Policy"],
-      `${pathname} must still receive a Content-Security-Policy`
-    );
-    assert.match(
-      headers["Content-Security-Policy"],
-      /frame-ancestors 'self' vscode-webview:/,
-      `${pathname} must allow the vscode-webview: ancestor in embed mode`
-    );
-    assert.equal(
-      headers["X-Frame-Options"],
-      undefined,
-      `${pathname} must NOT carry X-Frame-Options in embed mode (it would still block the iframe)`
-    );
-  }
-});
-
-test("#10273 embed mode keeps the API surface strictly unframable", async () => {
-  process.env[DASHBOARD_EMBED_ENV] = "vscode";
-  const rules = await loadHeaders("embed-on-api");
-
-  for (const pathname of API_PATHS) {
-    const headers = effectiveHeaders(rules, pathname);
-    assert.match(
-      headers["Content-Security-Policy"],
-      /frame-ancestors 'none'/,
-      `${pathname} is an API surface and must keep frame-ancestors 'none' even in embed mode`
-    );
-    assert.equal(
-      headers["X-Frame-Options"],
-      "DENY",
-      `${pathname} is an API surface and must keep X-Frame-Options: DENY even in embed mode`
-    );
-    assert.ok(
-      !headers["Content-Security-Policy"].includes("vscode-webview:"),
-      `${pathname} must never allow the vscode-webview: ancestor`
-    );
-  }
-});
-
-test("#10273 embed mode relaxes ONLY frame-ancestors — every other directive/header survives", async () => {
-  process.env[DASHBOARD_EMBED_ENV] = "vscode";
-  const relaxed = effectiveHeaders(await loadHeaders("embed-on-intact"), "/dashboard");
-
-  delete process.env[DASHBOARD_EMBED_ENV];
-  const strict = effectiveHeaders(await loadHeaders("embed-off-intact"), "/dashboard");
-
-  assert.equal(
-    relaxed["Content-Security-Policy"],
-    strict["Content-Security-Policy"].replace(
-      "frame-ancestors 'none'",
-      `frame-ancestors ${EMBED_FRAME_ANCESTORS.vscode}`
-    ),
-    "embed mode must swap the frame-ancestors token and change nothing else in the CSP"
-  );
-
-  for (const key of [
-    "X-Content-Type-Options",
-    "Referrer-Policy",
-    "Permissions-Policy",
-    "Strict-Transport-Security",
-  ]) {
-    assert.equal(relaxed[key], strict[key], `${key} must be identical in embed mode`);
-  }
-});
-
-test("#10273 embed mode preserves the G-10 9Router embed override (last rule still wins)", async () => {
-  process.env[DASHBOARD_EMBED_ENV] = "vscode";
-  const rules = await loadHeaders("embed-on-g10");
-  const headers = effectiveHeaders(rules, "/dashboard/providers/services/ninerouter/embed/ui");
-
-  assert.equal(
-    headers["Content-Security-Policy"],
-    "frame-ancestors 'self'",
-    "the G-10 same-origin override must keep the last word for the 9Router embed route"
-  );
-});
-
-// ── the API prefix list must stay derived from the config, not hand-maintained ──
-
-test("#10273 every root-level rewrite alias is excluded from the embeddable page surface", async () => {
-  const modUrl = `${pathToFileURL(modulePath).href}?case=prefixes-${Date.now()}`;
-  const nextConfig = (await import(modUrl)).default;
-  const rewrites = await nextConfig.rewrites();
-  const prefixes = new Set(nonPageRoutePrefixes(rewrites));
-
-  for (const { source } of rewrites) {
-    const first = source.replace(/^\//, "").split("/")[0];
-    assert.ok(
-      prefixes.has(first),
-      `rewrite alias "${source}" must be excluded from the embeddable page surface — ` +
-        `it proxies an API route and must never be framable`
-    );
-  }
-  // The app-router API surfaces that have no rewrite alias.
-  for (const literal of ["api", "a2a", "healthz"]) {
-    assert.ok(prefixes.has(literal), `"${literal}" must be excluded from the page surface`);
-  }
-});
-
-test("#10273 Next.js accepts the generated header sources in BOTH modes (startup guard)", async () => {
-  // `loadCustomRoutes` is the validation Next runs when the config loads: a `source` it
-  // rejects aborts the build. The embed-mode sources are regexes, and CI never builds with
-  // DASHBOARD_ALLOW_EMBED set — without this guard a malformed source would only blow up on
-  // the operator's machine, at build time, with the feature already shipped.
-  const require = createRequire(import.meta.url);
-  const loadCustomRoutes = require("next/dist/lib/load-custom-routes.js").default;
-
-  for (const mode of [undefined, "vscode"]) {
-    if (mode) process.env[DASHBOARD_EMBED_ENV] = mode;
-    else delete process.env[DASHBOARD_EMBED_ENV];
-
-    const nextConfig = (
-      await import(`${pathToFileURL(modulePath).href}?case=validate-${mode}-${Date.now()}`)
-    ).default;
-    const routes = await loadCustomRoutes({
-      ...nextConfig,
-      trailingSlash: false,
-      skipTrailingSlashRedirect: false,
-      basePath: "",
-      i18n: undefined,
-    });
-
-    assert.equal(
-      routes.headers.length,
-      mode ? 3 : 2,
-      `mode=${mode ?? "off"} should produce ${mode ? 3 : 2} header routes`
-    );
-  }
-});
-
-test("#10273 buildSecurityHeaderRules produces complementary sources with no gap", () => {
-  const securityHeaders = [
-    { key: "Content-Security-Policy", value: "frame-ancestors 'none'; default-src 'self'" },
-    { key: "X-Frame-Options", value: "DENY" },
-  ];
-  const rules = buildSecurityHeaderRules({
-    mode: "vscode",
-    securityHeaders,
-    prefixes: ["api", "v1"],
-  });
-
-  // Every pathname must be covered by exactly one of the two rules — a gap would ship a
-  // page with NO security headers at all, an overlap would make the merge order-dependent.
-  for (const pathname of ["/", "/dashboard", "/login", "/api/v1/models", "/v1/models", "/apifoo"]) {
-    const matched = rules.filter(
-      (rule) => getPathMatch(rule.source, { removeUnnamedParams: true })(pathname) !== false
-    );
-    assert.equal(
-      matched.length,
-      1,
-      `${pathname} must match exactly one rule, got ${matched.length}`
-    );
-  }
-});

tests/unit/ocr-handler-dispatch.test.ts

@@ -0,0 +1,133 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { handleOcr } from "../../open-sse/handlers/ocr.ts";
+
+function fetchStub(
+  script: Array<{ status: number; headers?: Record<string, string>; json?: unknown }>
+) {
+  const calls: Array<{ url: string; init: RequestInit }> = [];
+  const impl = async (url: string, init: RequestInit) => {
+    calls.push({ url, init });
+    const step = script.shift()!;
+    return new Response(step.json !== undefined ? JSON.stringify(step.json) : null, {
+      status: step.status,
+      headers: { "Content-Type": "application/json", ...(step.headers ?? {}) },
+    });
+  };
+  return { impl, calls };
+}
+
+const noSleep = async () => {};
+
+test("mistral path posts once and returns the upstream body", async () => {
+  const { impl, calls } = fetchStub([
+    { status: 200, json: { pages: [{ index: 0, markdown: "ok" }], model: "mistral-ocr-latest" } },
+  ]);
+  const res = await handleOcr({
+    body: {
+      model: "mistral/mistral-ocr-latest",
+      document: { type: "image_url", image_url: "https://x/y.png" },
+    },
+    credentials: { apiKey: "sk" },
+    fetchImpl: impl,
+    sleepImpl: noSleep,
+  });
+  assert.equal(res.status, 200);
+  assert.equal(calls.length, 1);
+  const data = await res.json();
+  assert.equal(data.pages[0].markdown, "ok");
+});
+
+test("azure DI path polls Operation-Location until succeeded", async () => {
+  const { impl, calls } = fetchStub([
+    { status: 202, headers: { "Operation-Location": "https://poll/op/1" } },
+    { status: 200, json: { status: "running" } },
+    { status: 200, json: { status: "succeeded", analyzeResult: { content: "# md", pages: [{}] } } },
+  ]);
+  const res = await handleOcr({
+    body: {
+      model: "azure-document-intelligence/prebuilt-read",
+      document: { type: "document_url", document_url: "https://x/d.pdf" },
+    },
+    credentials: { apiKey: "azkey", baseUrl: "https://r.cognitiveservices.azure.com" },
+    fetchImpl: impl,
+    sleepImpl: noSleep,
+  });
+  assert.equal(res.status, 200);
+  assert.ok(calls.length >= 3);
+  const data = await res.json();
+  assert.equal(data.pages[0].markdown, "# md");
+});
+
+test("unknown model lists available providers dynamically and errors do not leak internals", async () => {
+  const res = await handleOcr({
+    body: { model: "nope/none", document: { type: "image_url", image_url: "https://x" } },
+    credentials: { apiKey: "k" },
+    fetchImpl: async () => new Response("{}", { status: 200 }),
+    sleepImpl: noSleep,
+  });
+  assert.equal(res.status, 400);
+  const body = await res.json();
+  assert.ok(body.error.message.includes("azure-document-intelligence"));
+  assert.ok(!body.error.message.includes("at /"));
+});
+
+test("azure DI poll returns failed status maps to 502", async () => {
+  const { impl } = fetchStub([
+    { status: 202, headers: { "Operation-Location": "https://poll/op/1" } },
+    { status: 200, json: { status: "failed" } },
+  ]);
+  const res = await handleOcr({
+    body: {
+      model: "azure-document-intelligence/prebuilt-read",
+      document: { type: "document_url", document_url: "https://x/d.pdf" },
+    },
+    credentials: { apiKey: "azkey", baseUrl: "https://r.cognitiveservices.azure.com" },
+    fetchImpl: impl,
+    sleepImpl: noSleep,
+  });
+  assert.equal(res.status, 502);
+  const body = await res.json();
+  assert.ok(!body.error.message.includes("at /"));
+});
+
+test("azure DI poll returns a non-ok response (401) and fails fast without exhausting the loop", async () => {
+  const { impl, calls } = fetchStub([
+    { status: 202, headers: { "Operation-Location": "https://poll/op/1" } },
+    { status: 401, json: { error: "unauthorized" } },
+  ]);
+  const res = await handleOcr({
+    body: {
+      model: "azure-document-intelligence/prebuilt-read",
+      document: { type: "document_url", document_url: "https://x/d.pdf" },
+    },
+    credentials: { apiKey: "azkey", baseUrl: "https://r.cognitiveservices.azure.com" },
+    fetchImpl: impl,
+    sleepImpl: noSleep,
+  });
+  assert.equal(res.status, 502);
+  // 1 initial POST + 1 poll: the loop stopped immediately, it did not run all 30 attempts.
+  assert.equal(calls.length, 2);
+  const body = await res.json();
+  assert.ok(!body.error.message.includes("at /"));
+});
+
+test("azure DI poll never resolves and times out after 30 attempts with a 504", async () => {
+  const script = [{ status: 202, headers: { "Operation-Location": "https://poll/op/1" } }];
+  for (let i = 0; i < 30; i++) {
+    script.push({ status: 200, json: { status: "running" } });
+  }
+  const { impl, calls } = fetchStub(script);
+  const res = await handleOcr({
+    body: {
+      model: "azure-document-intelligence/prebuilt-read",
+      document: { type: "document_url", document_url: "https://x/d.pdf" },
+    },
+    credentials: { apiKey: "azkey", baseUrl: "https://r.cognitiveservices.azure.com" },
+    fetchImpl: impl,
+    sleepImpl: noSleep,
+  });
+  assert.equal(res.status, 504);
+  // 1 initial POST + 30 poll attempts (the max cap), no more.
+  assert.equal(calls.length, 31);
+});

tests/unit/ocr-registry-transformations.test.ts

@@ -0,0 +1,74 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  OCR_PROVIDERS,
+  getOcrTransformation,
+  MISTRAL_PASSTHROUGH,
+} from "../../open-sse/config/ocrRegistry.ts";
+
+test("mistral resolves the passthrough transformation by default", () => {
+  const t = getOcrTransformation("mistral");
+  assert.equal(t, MISTRAL_PASSTHROUGH);
+  const { url, init } = t.buildRequest({
+    baseUrl: OCR_PROVIDERS.mistral.baseUrl,
+    token: "sk-test",
+    body: { document: { type: "image_url", image_url: "https://x/y.png" } },
+    modelId: "mistral-ocr-latest",
+  });
+  assert.equal(url, "https://api.mistral.ai/v1/ocr");
+  assert.equal(init.method, "POST");
+  assert.equal((init.headers as Record<string, string>).Authorization, "Bearer sk-test");
+  const sent = JSON.parse(String(init.body));
+  assert.equal(sent.model, "mistral-ocr-latest");
+});
+
+test("passthrough parseResponse returns the body unchanged (Mistral is the canonical shape)", () => {
+  const raw = { pages: [{ index: 0, markdown: "hello" }], model: "mistral-ocr-latest" };
+  assert.deepEqual(MISTRAL_PASSTHROUGH.parseResponse(raw), raw);
+});
+
+test("azure-document-intelligence builds the prebuilt-read:analyze request", () => {
+  const t = getOcrTransformation("azure-document-intelligence");
+  const { url, init } = t.buildRequest({
+    baseUrl: "https://myres.cognitiveservices.azure.com",
+    token: "azkey",
+    body: { document: { type: "document_url", document_url: "https://x/d.pdf" } },
+    modelId: "prebuilt-read",
+  });
+  assert.equal(
+    url,
+    "https://myres.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-read:analyze?api-version=2024-11-30&outputContentFormat=markdown"
+  );
+  assert.equal((init.headers as Record<string, string>)["Ocp-Apim-Subscription-Key"], "azkey");
+  const sent = JSON.parse(String(init.body));
+  assert.equal(sent.urlSource, "https://x/d.pdf");
+});
+
+test("azure-document-intelligence extracts poll URL and parses analyzeResult into Mistral shape", () => {
+  const t = getOcrTransformation("azure-document-intelligence");
+  const res = new Response(null, {
+    status: 202,
+    headers: { "Operation-Location": "https://poll/op/1" },
+  });
+  assert.equal(t.pollUrl?.(res), "https://poll/op/1");
+  const parsed = t.parseResponse({
+    status: "succeeded",
+    analyzeResult: { content: "# doc text", pages: [{ pageNumber: 1 }] },
+  });
+  assert.equal(parsed.pages.length, 1);
+  assert.equal(parsed.pages[0].index, 0);
+  assert.equal(parsed.pages[0].markdown, "# doc text");
+  assert.equal(parsed.model, "prebuilt-read");
+});
+
+test("azure DI maps base64/image_url documents to base64Source/urlSource", () => {
+  const t = getOcrTransformation("azure-document-intelligence");
+  const { init } = t.buildRequest({
+    baseUrl: "https://r.example.com",
+    token: "k",
+    body: { document: { type: "image_url", image_url: "data:image/png;base64,AAAA" } },
+    modelId: "prebuilt-read",
+  });
+  const sent = JSON.parse(String(init.body));
+  assert.equal(sent.base64Source, "AAAA");
+});

tests/unit/ocr-route-contract.test.ts

@@ -0,0 +1,48 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { getAllOcrModels, parseOcrModel } from "../../open-sse/config/ocrRegistry.ts";
+import { resolveOcrCredentials } from "../../src/app/api/v1/ocr/route.ts";
+
+test("getAllOcrModels exposes both the mistral and azure-document-intelligence OCR models", () => {
+  const ids = getAllOcrModels().map((m) => m.id);
+  assert.ok(ids.includes("mistral/mistral-ocr-latest"));
+  assert.ok(ids.includes("azure-document-intelligence/prebuilt-read"));
+});
+
+test("parseOcrModel resolves the azure-document-intelligence provider prefix", () => {
+  assert.deepEqual(parseOcrModel("azure-document-intelligence/prebuilt-read"), {
+    provider: "azure-document-intelligence",
+    model: "prebuilt-read",
+  });
+});
+
+// ── resolveOcrCredentials — maps the connection's custom endpoint (stored
+// under providerSpecificData.baseUrl per the src/lib/providers/validation/*
+// convention) onto the top-level credentials.baseUrl field that handleOcr
+// reads, so azure-document-intelligence connections resolve their endpoint. ──
+
+test("resolveOcrCredentials surfaces providerSpecificData.baseUrl to the top level", () => {
+  const credentials = {
+    apiKey: "azkey",
+    providerSpecificData: { baseUrl: "https://r.cognitiveservices.azure.com" },
+  };
+  assert.deepEqual(resolveOcrCredentials(credentials), {
+    apiKey: "azkey",
+    providerSpecificData: { baseUrl: "https://r.cognitiveservices.azure.com" },
+    baseUrl: "https://r.cognitiveservices.azure.com",
+  });
+});
+
+test("resolveOcrCredentials keeps an existing top-level baseUrl untouched", () => {
+  const credentials = {
+    apiKey: "azkey",
+    baseUrl: "https://explicit.example.com",
+    providerSpecificData: { baseUrl: "https://ignored.example.com" },
+  };
+  assert.equal(resolveOcrCredentials(credentials).baseUrl, "https://explicit.example.com");
+});
+
+test("resolveOcrCredentials is a no-op when there is no providerSpecificData.baseUrl (mistral)", () => {
+  const credentials = { apiKey: "sk-mistral" };
+  assert.deepEqual(resolveOcrCredentials(credentials), credentials);
+});

tests/unit/ocr-route.test.ts

@@ -183,6 +183,7 @@ test("handleOcr returns a sanitized 500 when the upstream request throws", async
   const payload = (await response.json()) as any;
 
   assert.equal(response.status, 500);
-  assert.match(payload.error.message, /OCR request failed: socket closed/);
+  assert.ok(payload.error.message.includes("OCR request failed"));
+  assert.ok(!payload.error.message.includes("socket closed"));
   assert.ok(!payload.error.message.includes("at /"));
 });

tests/unit/upstream-status-restatement.test.ts

@@ -1,126 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-/**
- * Gateways like agentrouter.org misstate TEMPORARY quota exhaustion as 403/400
- * (Chinese body "用户额度不足"), which Claude Code treats as permanent and dies.
- * applyStatusRestatement() rewrites such statuses to 429 (+ synthetic
- * Retry-After) in ONE place, before fallback classification and before the
- * status ever reaches the client. Registry-driven: future gateways with the
- * same defect register one rule array — no pipeline changes.
- */
-
-const { applyStatusRestatement, statusRestatementRegistry } = await import(
-  "../../open-sse/config/upstreamStatusRestatement.ts"
-);
-
-test("R1: agentrouter 403 + 用户额度不足 → 429 with synthetic Retry-After", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 403,
-    message: '{"error":{"message":"用户额度不足","type":"insufficient_user_quota"}}',
-    retryAfterMs: null,
-  });
-  assert.equal(out.status, 429);
-  assert.equal(out.fromStatus, 403);
-  assert.equal(out.ruleId, "agentrouter-quota-misstatus");
-  assert.equal(out.retryAfterMs, 60_000);
-});
-
-test("R2: agentrouter 403 + 无权访问模型 (no model access) is NOT restated", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 403,
-    message: "无权访问模型 claude-sonnet-4",
-    retryAfterMs: null,
-  });
-  assert.equal(out.status, 403);
-  assert.equal(out.ruleId, null);
-});
-
-test("R3: quota marker in body (not message) still restates", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 403,
-    message: "Forbidden",
-    body: { error: { message: "用户额度不足，请充值" } },
-    retryAfterMs: null,
-  });
-  assert.equal(out.status, 429);
-});
-
-test("R4: upstream-provided retryAfterMs wins over the synthetic default", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 403,
-    message: "用户额度不足",
-    retryAfterMs: 5_000,
-  });
-  assert.equal(out.status, 429);
-  assert.equal(out.retryAfterMs, 5_000);
-});
-
-test("R5: agentrouter 400 with quota marker also restates (gateway variant)", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 400,
-    message: "额度不足",
-    retryAfterMs: null,
-  });
-  assert.equal(out.status, 429);
-});
-
-test("R6: agentrouter 403 without quota markers is untouched (real auth error)", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 403,
-    message: "Invalid API key",
-    retryAfterMs: null,
-  });
-  assert.equal(out.status, 403);
-  assert.equal(out.ruleId, null);
-});
-
-test("R7: other providers never match agentrouter rules (registry-scoped)", () => {
-  const out = applyStatusRestatement({
-    provider: "openai",
-    status: 403,
-    message: "用户额度不足",
-    retryAfterMs: null,
-  });
-  assert.equal(out.status, 403);
-});
-
-test("R8: statuses a rule does not list pass through (already-correct 429)", () => {
-  const out = applyStatusRestatement({
-    provider: "agentrouter",
-    status: 429,
-    message: "用户额度不足",
-    retryAfterMs: 1_000,
-  });
-  assert.equal(out.status, 429);
-  assert.equal(out.ruleId, null);
-  assert.equal(out.retryAfterMs, 1_000);
-});
-
-test("R9: registry exposes agentrouter so future gateways copy the one-line recipe", () => {
-  const rules = statusRestatementRegistry.get("agentrouter");
-  assert.ok(rules && rules.length > 0);
-});
-
-test("R10: chatCore wires applyStatusRestatement into the providerFailure block", async () => {
-  // chatCore is a god-file that cannot be imported standalone in unit tests
-  // (side-effectful DB/env wiring), so the wiring contract is asserted at the
-  // source level: the hook must exist, run against the parsed error, and
-  // reassign both statusCode and retryAfterMs BEFORE classification.
-  const { readFile } = await import("node:fs/promises");
-  const src = await readFile(
-    new URL("../../open-sse/handlers/chatCore.ts", import.meta.url),
-    "utf8"
-  );
-  assert.match(src, /applyStatusRestatement\(/, "chatCore must call applyStatusRestatement");
-  const hookIndex = src.indexOf("applyStatusRestatement(");
-  const classifyIndex = src.indexOf("classifyProviderError(statusCode");
-  assert.ok(hookIndex > -1 && classifyIndex > -1 && hookIndex < classifyIndex,
-    "restatement must run BEFORE classifyProviderError so fallback sees the corrected status");
-});