modelrig 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -10,6 +10,275 @@ published package diverge.
 This project adheres to [Semantic Versioning](https://semver.org/). Dates are
 UTC.
 
+## [0.5.0] — 2026-08-22
+
+Released with the docs/registry mirror in one R-A ceremony. Headline for router
+codebases: `rig.runRaw` inside a run context now records a step (the `/runs`
+tree fills in), raw-lane timeouts are tier-aware and teach, the `trial:`
+candidate flag + console picker ship (deploy the server before any YAML uses
+`trial:`), and the console rollups show cost and quality together by route or
+tag. `modelrig-oracle` 0.2.0 ships alongside (`propose_candidates`).
+
+Raw-lane defaults (#245) — the raw lane teaches its own timeouts. The `timeoutMs`
+default becomes tier-aware, a `timeout` failure carries a teaching `fixHint`, an
+empty no-tools gemini response carries a hint naming grounding, and the raw-lane
+defaults are published as a generated table that cannot drift from the runtime.
+
+Declare-first experiment ergonomics (routing-console R3, #239) — a `trial:`
+candidate you declare but never serve live, a console challenger picker, and a
+one-command bake-off that measures it on real captured traffic before you
+promote it.
+
+### Changed
+
+- **Raw-lane `timeoutMs` default is now tier-aware** (was a flat 120 s):
+  `standard`/`priority` default to 300 s and `flex` to 900 s (the 15-minute budget
+  ModelRig advertises) — a passthrough should not be shorter-fused than the tier it
+  advertises, and grounded/large prompts routinely exceed 120 s even at standard.
+  An explicit `timeoutMs` **always wins** (no pre-dispatch rejection — a short
+  deadline is a choice), and a `timeout` failure on the raw lane now carries a
+  `fixHint` naming the elapsed time, the tier, that tier's budget, and the two
+  fixes (raise `timeoutMs`, or drop to `serviceTier: "standard"`). The routed
+  lane's required `policy.timeout_ms` is unchanged. Callers who relied on a fast
+  120 s failure should set `timeoutMs` explicitly.
+
+### Added — declare-first experiment (routing-console R3)
+
+- **`candidates[].trial: true`** (route bundle) — a DECLARED candidate that is
+  NEVER served live. The loader parses and validates it, marks an all-trial
+  variant `trialOnly`, and warns on a trial candidate no variant references;
+  `resolveCandidates` drops trial candidates on every live path (`rig.run`,
+  `runStream`, `runBundle`, the hosted gateway slug lane) and keeps them only in
+  bake-off replay. Selecting a trial variant on a live call is a
+  `RouteConfigError` that names the bake-off. This lets a customer measure a new
+  model on real captured traffic before promoting it. Additive: a route with no
+  trial candidate is byte-identical to before.
+  - CAVEAT — **deploy the server before any customer YAML carries `trial:`.** An
+    SDK/server older than 0.5.0 IGNORES `trial:` (the loader has always been
+    tolerant of unknown candidate keys) and its resolver has no trial-mode filter,
+    so it would serve the candidate LIVE — including an older hosted-gateway build
+    reading the flag through the mirror. Roll the server first, then let routes
+    start declaring `trial:`. The console's declare-YAML says so inline.
+- **`requirementPredicates(route)` / `evaluateChallengerEligibility(...)`** (new
+  exports) — decompose a route's `require` + json rung into capability-flag
+  requirements and answer "can this model be a trial challenger?", pinned in
+  agreement with the live resolver's `satisfiesRequirements`.
+- **`buildDeclareTrialChange(bundle, challenger)` / `trialVariantName(...)`** and
+  a trial-winner branch of **`buildSwapChange`** (new exports) — the paste-ready
+  declare-YAML (challenger appended `trial: true`, a `trial-<provider>-<model>`
+  variant, `version: n+1`) and the promote-YAML that drops the winner's trial
+  flag, moves it to position 0, and removes the trial variant. No filesystem, no
+  git — the human applies the PR (F6).
+- **`ManualChallengerTrigger` + `manualChallengerTriggerHash`**, and
+  **`proposalsClient.createManualChallenger`** — a console/oracle-initiated
+  declare-first proposal (`kind:"bakeoff"`, idempotent per `(route, challenger)`).
+- **`RunMeta`/`Rig` additions:** `rig.capabilities` and `rig.searchAvailable` are
+  exposed so the challenger picker answers eligibility with the exact live flags;
+  `modelrig bakeoff --from-proposal <id>` reads the trial variant from a
+  manual_challenger proposal (default vs that one variant).
+- **`resolveRouteBundle` / `hashResolvedBundle`** (new exports) — the canonical
+  `bundle_sha` helpers, used by the hosted-lane bake-off to prove the caller org's
+  mirrored bundle is the SAME bundle the deployment holds locally (a route-name
+  collision on a multi-tenant mirror otherwise baked off a foreign org's route).
+
+### Added
+
+- **A grounding-naming `fixHint` on an empty no-tools gemini response.** When a
+  call that declared no tools comes back with no text parts (a grounding turn
+  that produced only `functionCall` parts, for example), the `content_invalid`
+  "empty response" failure now names grounding as the likely cause. Note: the
+  text extraction itself is unchanged in effect — the SDK already concatenated
+  mixed `functionCall` + text parts — so the customer-zero empty-response report
+  (#245 secondary) remains an OPEN investigation pending a captured response.
+
+### Docs
+
+- **Raw-lane defaults table** — a generated table (`RAW_DEFAULTS`, rendered at the
+  `<!-- RAW_DEFAULTS -->` marker in `route-bundles.md` and in `llms.txt`) lists
+  every raw-lane knob and its default, with the tier-aware `timeoutMs` read from
+  the same constant the runtime resolves from — so the published defaults cannot
+  drift from what `rig.runRaw` sends. README / quickstart / migration-playbook
+  gain the "flex ⇒ set `timeoutMs` in minutes" one-liner.
+
+Raw-lane artifact graph + tags parity (G1). A `rig.runRaw` / `rig.runRawStream`
+call inside a `rig.artifacts.run.start` context now records a ground-truth step,
+so a router or report pipeline that wraps raw (BYOK) calls in a run context gets
+a real per-run tree at `/runs/[id]` instead of an empty one. ZERO DDL.
+
+### Added — raw-lane graph
+
+- **Raw calls record a ground-truth step.** Inside a run context,
+  `runRaw`/`runRawStream` emit a step (on success AND failure, buffered AND
+  streaming) whose `inference_id` joins the metered `lane=raw` row — parity with
+  the routed lane's auto-step. Fail-open: a buffer error there never affects the
+  returned result. Outside a run context the dispatch is byte-identical to 0.4.0
+  (no step row). Raw steps are **metadata only** — no artifact content is written
+  on the raw lane.
+- **`stepKey` on BOTH lanes.** `RunOptions.stepKey` (routed) and
+  `RawRunInput.stepKey` (raw) name the step. Resolution is `stepKey ?? tags.step
+  ?? auto` (`route#n` / `provider/model#n`), validated `[A-Za-z0-9_.:#-]{1,128}`;
+  an invalid value is warned once and dropped to the auto key (never thrown). A
+  raw row's step **task** is `tags.step ?? provider/model`.
+- **Ambient artifact step.** `artifact.save` without a `stepKey` now attaches to
+  the ambient step (the most recent step in the run context), so the two grouping
+  mechanisms compose — a raw/routed call and the artifacts saved around it land in
+  one group.
+- **Required-dimension hygiene on the raw lane.** `runRaw`/`runRawStream` run the
+  same once-per-process "required dimension missing from tags" warning the routed
+  lane does.
+
+### Added — docs
+
+- **instrumentation.md** gains "Tags, dimensions, and the graph": tags = flat
+  filter/rollup (`/costs`), the graph = the per-run tree (`/runs/[id]`), how
+  `stepKey` + ambient artifacts compose, and the raw-lane behavior.
+- **The per-service key rule** is now stated in the quickstart, the migration
+  playbook (F-6), and llms.txt: `MODELRIG_API_KEY` gates the exporter *per
+  process* — set it on EVERY service, worker, and cron, or a keyless process
+  buffers to its own local SQLite and ships nothing.
+- **route-bundles.md** points at where `rig.yaml` `dimensions` are declared; the
+  **README** documents `stepKey` on the raw lane.
+
+## [0.4.0] — 2026-08-22
+
+Released with the docs/registry mirror in one R-A ceremony. NOT in this tag:
+the R3 declare-first `trial:` candidate flag (#239) and raw-lane artifact
+steps (G1) — both land in 0.5.0.
+
+CE-9 raw-lane multi-provider parity — the `reasoning` and native-grounding knobs
+generalize beyond gemini, a `responseFormat` knob joins the raw lane, and the
+provider×knob support set becomes ONE table (`RAW_KNOB_SUPPORT`) that the runtime
+guard AND the published docs matrix both read, so they can never disagree. Every
+knob stays ADDITIVE: absent ⇒ byte-identical to the 0.3.0 request shape.
+
+### Added — docs
+
+- **Routing & reliability page** (`https://modelrig.dev/routing-reliability.html`) —
+  the runtime model in one concept page: resolve -> candidate ladder -> validate ->
+  repair -> fall-through -> exhaust, what is stored per attempt, and a **code-anchored
+  boundary** (`ROUTING_BOUNDARY`, one tripwire test per entry) that lists what does not
+  trigger fall-through and what is not built — the build fails if a listed feature ships
+  without the entry being updated.
+
+### Fixed
+
+- **Failure-teaching links resolve.** `RigFailureError.docsUrl` (and the CLI/console
+  error render) now point at `routing-reliability.html#<class>` — one stable heading per
+  failure class — instead of the never-built `/docs/failures` path, which 404'd on
+  every typed failure.
+
+### Added — `rig.runRaw` / `rig.runRawStream`
+
+- **`reasoning` generalizes beyond gemini WITHOUT a per-model allowlist (R1).**
+  openai / deepinfra / fireworks forward `level` → `reasoning_effort` verbatim
+  and let the provider enforce — a model that does not accept it surfaces a
+  CLASSIFIED, teaching failure ("this model does not accept reasoning_effort —
+  remove reasoning or pick a reasoning model"), never a cryptic 400 or a silent
+  drop. grok forwards a DISCLOSED coarsening (`minimal,low → "low"`;
+  `medium,high → "high"`; xAI accepts `low|high` only). gemini stays
+  model-gated (thinking-capable models only). deepseek + anthropic FAIL CLOSED
+  pre-dispatch with a provider-specific fixHint (deepseek → select the
+  `deepseek-reasoner` model; anthropic → extended thinking unwired).
+- **Grok native grounding (R2) — WITHDRAWN before release.** The CE-9 live gate hit xAI's `410 Live search is deprecated`; the replacement `web_search` tool is Responses-API-only, which the grok adapter does not speak yet. grok grounding FAILS CLOSED (matrix `supported: false`, teaching note) until CE-9b lands that path. Original entry, kept for the record: `grounding: { mode: "native" }` on grok →
+  xAI Live Search (`search_parameters: { mode: "on" }`). Citations are not
+  surfaced on `meta` in v1 (same documented limitation as gemini).
+- **`responseFormat?: "json_object"` (R4).** MIME-shaping on the OpenAI-dialect
+  providers (openai/deepseek/grok/deepinfra/fireworks → `response_format: { type:
+  "json_object" }`) and gemini (`responseMimeType: "application/json"`, no
+  schema). This is syntactic-JSON forcing, NOT schema enforcement — F4 stands:
+  no validation, no repair, `meta.validated` stays false. anthropic has no
+  equivalent and FAILS CLOSED. DeepSeek's word-"JSON" prompt wrinkle is the
+  caller's responsibility on the raw lane (documented, never injected).
+- **DeepInfra/Fireworks prompt-cache hint (R3).** `cache.key` now maps to
+  `prompt_cache_key` on the openai-compatible adapter, closing the DeepInfra cost
+  gap. (openai and grok already mapped `cache.key → prompt_cache_key` on 0.3.0 —
+  that was a docs gap, not a code gap; it is now documented as plain fact.)
+
+### Added — exports (R5/R6)
+
+- **`RAW_KNOB_SUPPORT`** (the provider×knob matrix) + **`rawKnobSupport(provider)`**
+  (a pure lookup) — a multi-provider dispatcher ASKS which knobs a provider
+  honors instead of duplicating our lists. The guard (`assertRawKnobsSupported`)
+  and the docs generator both import this table.
+- **`GEMINI_THINKING_CAPABLE_MODELS`** — the thinking-capable set (previously
+  un-exported), so customers stop duplicating it (the §3.1 drift complaint).
+- **`coarsenGrokReasoningEffort`** + **`renderRawKnobMatrix`** — the disclosed
+  grok coarsening and the docs matrix renderer.
+
+### Docs
+
+- A generated provider×knob matrix on the modelrig.dev route-bundles page and in
+  `llms.txt`, rendered FROM `RAW_KNOB_SUPPORT` (never a hand-written twin).
+- `caching-lifecycle.md`: the cache directive is provider-neutral — a resource
+  HANDLE on gemini, a routing HINT (`prompt_cache_key`, retention on openai) on
+  the OpenAI-dialect providers.
+
+CE-8 — first-class **runRaw-only construction**. A Lane-B customer who only calls
+`rig.runRaw`/`runRawStream` can now build a rig with no routes at all, so a stray
+route file it never serves cannot down construction — retiring the empty-temp-dir
+workaround.
+
+### Added
+
+- **`RigConfig.routesDir` now accepts `null`** (was `string`). With `null`,
+  `createRig` SKIPS route loading, the `rig.yaml` manifest, and the
+  serveable-candidate gate; `runRaw`/`runRawStream` work exactly as before. The
+  `string` path is byte-identical to 0.3.0 (the existing serveability hard-error
+  on a zero-serveable route is unchanged and regression-pinned).
+- **`requireRoutesDir(config, surface)`** exported — narrows `routesDir` to a
+  string for route-required contexts, throwing the teaching failure on `null`.
+  Used by `modelrig-server` and `modelrig-oracle` (both always serve routes).
+
+### Behaviour
+
+- On a `routesDir: null` rig, `run`/`runStream`/`runBundle`/`runBundleStream`/
+  `replay`/`bakeoff`/`bakeoffFromEvalCases`/`verifySwap` throw `RigFailureError`
+  class `invariant_violation` (no new failure class) with the fixHint
+  *"this rig was constructed runRaw-only (routesDir: null); give createRig a
+  routesDir to serve routes"*. `rig.serveability` is `[]`.
+- `loadConfigFromEnv` stays string-only (no env var disables routes, by design);
+  opt out in code: `createRig({ ...loadConfigFromEnv(), routesDir: null })`.
+
+### Docs
+
+- README, `docs/migration-playbook.md` (Lane-B seam + C4 checkpoint), and the
+  generated `llms.txt` gain the runRaw-only construction snippet, the `apiKey`
+  BYOK line on every `runRaw` example, the combined-prompt → `userPrompt` note,
+  and the note that the cache-ratio-vs-baseline metric is a REAL-run measurement
+  (deferred-to-first-run at the checkpoint), not a probe.
+
+R0 — the **per-call telemetry ladder key** (routing-console spec §2.1). Every
+inference row now records which call it belongs to and its position in the
+routing ladder, so a dashboard can reconstruct the exact sequence one `rig.run`
+walked and compute fallback / repair rates.
+
+### Added — telemetry ladder key
+
+- **`RunMeta.callId`** — the `call_id` shared by every telemetry row a single
+  `run` / `runStream` / `runBundle` / `runRaw` invocation writes (primary, retry,
+  repair, grounding-search, tool-call), so a caller can correlate a `RunResult`
+  with its ladder in the console. Additive & OPTIONAL — a pre-0.4.0 caller's meta
+  omits it.
+- Telemetry rows gain **`call_id`**, **`attempt_seq`** (1-based, monotonic across
+  every row of the call), and **`candidate_index`** (position of the dispatched
+  candidate in the call's EFFECTIVE declared list — after variant narrowing and
+  per-run filters; a repair row carries the repaired candidate's index; the raw
+  lane is seq 1 / index 0). All three are OPTIONAL on the wire and nullable in
+  storage: an older SDK OMITS them and the payload is byte-identical to before
+  R0; a reader treats null as *"recorded by an SDK older than 0.4.0."*
+- OTLP spans gain `modelrig.call_id` / `modelrig.attempt_seq` /
+  `modelrig.candidate_index`, emitted only when present.
+- **`CandidateIterator.index`** (read-only getter, public type) — the index of the
+  candidate the last `next()` returned (−1 before the first call). Additive for
+  callers; an external IMPLEMENTER of the interface must add the member.
+- **`tags.rung`** on every telemetry row (R1 review, F1) — one of `primary` |
+  `retry` | `repair` | `search` | `tool_call` | `predispatch_fail`, so the routing
+  dashboard and ladder view can tell a real candidate dispatch from a tool-call
+  turn or a pre-dispatch failure without column heuristics. Additive (rides
+  `tags_json`, no schema change); a pre-0.4.0 row omits it and the rollup falls
+  back to `repaired_by` / `provider = "search"`. Public type `TelemetryRung` is
+  exported.
+
 ## [0.3.0] — 2026-08-21
 
 The `modelrig-oracle` MCP server ships to npm alongside this release (its own

package/README.md

@@ -99,27 +99,88 @@ over the route's `cache: auto` stamp, and a non-matching fallback dispatches
 without it. ModelRig carries the handle and prices the hits — it never creates,
 refreshes, or deletes the resource, so a long job needs your own TTL heartbeat
 (see the [caching lifecycle](https://modelrig.dev/caching-lifecycle.html) doc).
-The Lane-B `rig.runRaw({ provider, model, …, cache: { key } })` seam takes the
-same field.
+The Lane-B `rig.runRaw({ provider, model, apiKey, …, cache: { key } })` seam takes
+the same field.
 
 `rig.runRaw` also accepts
-three provider knobs, each additive — absent ⇒ byte-identical dispatch:
-`grounding: { mode: "native" }` (native provider web grounding, gemini-only in
-v1), `serviceTier: "standard" | "flex" | "priority"`, and
-`reasoning: { level: "minimal" | "low" | "medium" | "high" }` (gemini-only in
-v1, mapped to the thinking level). A declared directive a provider cannot honor
-FAILS CLOSED — a thrown `RigFailureError` with class `invariant_violation`,
-pre-dispatch (no meter, no provider call) — never a silent drop. A grounded step
-that also passes a `cache.key` keeps its cached-token ratio: bake the
-`googleSearch` tool into the cache resource at creation (ModelRig sends
-`cachedContent` without tools, which the provider requires).
+provider knobs, each additive — absent ⇒ byte-identical dispatch:
+`grounding: { mode: "native" }` (native provider web grounding —
+gemini; grok fail-closed until CE-9b), `serviceTier: "standard" | "flex" | "priority"`,
+`reasoning: { level: "minimal" | "low" | "medium" | "high" }` (reasoning effort¹),
+and `responseFormat: "json_object"` (syntactic-JSON forcing¹ — MIME-shaping, NOT
+schema enforcement, so `meta.validated` stays `false`). A declared directive a
+provider cannot honor FAILS CLOSED — a thrown `RigFailureError` with class
+`invariant_violation`, pre-dispatch (no meter, no provider call) — never a silent
+drop. **Which provider honors which knob is one table** — the runtime guard and
+the published
+[provider × knob matrix](https://modelrig.dev/route-bundles.html#raw-lane-provider-knob-support-rigrunraw)
+are generated from the same `RAW_KNOB_SUPPORT`; ask it in code with
+`rawKnobSupport(provider)` (and `GEMINI_THINKING_CAPABLE_MODELS` is exported so
+you don't duplicate the thinking-model set). A grounded step that also passes a
+`cache.key` keeps its cached-token ratio: bake the `googleSearch` tool into the
+cache resource at creation (ModelRig sends `cachedContent` without tools, which
+the provider requires).
+
+_¹ Multi-provider `reasoning` and `responseFormat` ship in
+0.4.0; on the published package `reasoning`/`grounding` are gemini-only._
+
+**runRaw — a BYOK passthrough (Lane B).** When you don't need a route — no
+schema, no validation, no retries — call a `provider/model` directly with your
+own provider key:
+
+```ts
+const rig = createRig(loadConfigFromEnv());
+const result = await rig.runRaw({
+  provider: "gemini",
+  model: "gemini-3.1-pro",
+  apiKey: process.env.GEMINI_API_KEY!,   // runRaw is BYOK — pass your provider key
+  systemPrompt: "",                       // one combined prompt? put it ALL in userPrompt, leave systemPrompt empty
+  userPrompt: buildPrompt(input),
+});
+```
+
+`runRaw` is BYOK — pass your provider key; ModelRig holds it for the one call and
+never stores it. It records one metered `lane=raw` telemetry row at the
+provider's list price (zero ModelRig margin) and throws a typed `RigFailureError`
+on failure, exactly like `rig.run`.
+
+Called inside a `rig.artifacts.run.start` context, `runRaw`/`runRawStream` also
+records a ground-truth **step** in the run's graph (`/runs/[id]`) — since
+modelrig 0.5.0, on success and on failure. Name it with `stepKey` (the same field
+`RunOptions` exposes on the routed lane; precedence `stepKey` > `tags.step` > an
+auto `provider/model#n` key), so a raw call and the artifacts you `save` around it
+group under one step.
+
+The raw-lane `timeoutMs` default is **tier-aware** since 0.5.0 — `standard`/
+`priority` 300 s, `flex` 900 s; an explicit `timeoutMs` always wins, and a
+`timeout` failure teaches the tier + budget in its `fixHint`. **flex ⇒ set
+`timeoutMs` in minutes** (default 900 s since 0.5.0). See the generated
+[raw-lane defaults table](https://modelrig.dev/route-bundles.html#raw-lane-defaults-rigrunraw).
+
+**runRaw-only construction (`routesDir: null`) — 0.4.0+.** A
+Lane-B deployment that ONLY calls `runRaw`/`runRawStream` has no routes. Build it
+with `routesDir: null` and `createRig` skips route loading, the `rig.yaml`
+manifest, and the serveability gate entirely — so a stray route file it never
+calls (or a route whose provider key is absent in this deployment) can no longer
+down construction:
+
+```ts
+const rig = createRig({ ...loadConfigFromEnv(), routesDir: null });
+await rig.runRaw({ provider, model, apiKey, systemPrompt, userPrompt });
+```
+
+`loadConfigFromEnv()` always yields a string `routesDir`, so the opt-out is a
+deliberate code-level choice — override it as above; there is no env var that
+disables routes, by design. On such a rig, `rig.run` and every other
+route-dependent surface (`runStream`, `runBundle`, bake-offs, watch, replay,
+`verifySwap`) throws a terminal `invariant_violation` naming the fix.
 
 Every attempt is recorded in a local SQLite file (`.modelrig/telemetry.db`)
 tagged with your `tags`. Failures are typed —
 `RigFailureError.failure.class` is one of `content_invalid`, `capacity_shed`,
-`network`, `refusal`, `cache_invalid`, `timeout`, `budget_exhausted`,
+`network`, `refusal`, `cache_invalid`, `timeout`, `config_auth`, `budget_exhausted`,
 `invariant_violation` — with a separate retry budget per class, so a flaky
-network never spends your content-validation retries.
+network never spends your content-validation retries. What each class means, whether it retries, and how it backs off is on [Routing & reliability](https://modelrig.dev/routing-reliability.html#5-failure-classes).
 
 ## CLI
 
@@ -155,6 +216,10 @@ on the quickstart:
   stable enough to build on, not frozen.
 - **`modelrig serve` needs the `modelrig-server` package** — it is not bundled
   here.
+- **What the ladder does and does not do.** Fall-through is structural and
+  infrastructural, never a quality judgment; the full boundary (quality gate,
+  raw-lane structure, latency ordering…) is generated and tripwire-tested on
+  [Routing & reliability](https://modelrig.dev/routing-reliability.html#10-not-yet-implemented-the-boundary).
 
 ## License
 

package/dist/adapters/deepseek.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepseek.d.ts","sourceRoot":"","sources":["../../src/adapters/deepseek.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMhE,OAAO,KAAK,EAAuB,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAMhG,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAMhF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAiB1E;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;KAAE,CAAC;IAC1D,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,eAAe,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAOD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,oBAAoB,CA2B1F;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CA8JpF"}
+{"version":3,"file":"deepseek.d.ts","sourceRoot":"","sources":["../../src/adapters/deepseek.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMhE,OAAO,KAAK,EAAuB,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAMhG,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAMhF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAiB1E;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;KAAE,CAAC;IAC1D,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,eAAe,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAOD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,oBAAoB,CAkC1F;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CA8JpF"}

package/dist/adapters/deepseek.js

@@ -62,6 +62,13 @@ function classifyDeepSeekFailure(message) {
 const JSON_GUARD = "Respond with a single valid JSON object.";
 function buildDeepSeekParams(model, req) {
     const wantJson = req.outputSchema !== null;
+    // CE-9 R4: the raw lane's `responseFormat: "json_object"` also drives DeepSeek's
+    // json_object mode (the flag previously fired ONLY on the routed outputSchema
+    // path, which is always null on the raw lane). Absent both ⇒ no key
+    // (byte-identical). The JSON_GUARD below stays keyed on the ROUTED path only:
+    // on the raw lane the word-"JSON" wrinkle is the caller's prompt responsibility
+    // (spec R4), not silently intercepted here.
+    const jsonObject = wantJson || req.responseFormat === "json_object";
     let systemPrompt = req.systemPrompt;
     if (wantJson && !req.systemPrompt.includes("JSON") && !req.userPrompt.includes("JSON")) {
         systemPrompt = systemPrompt === "" ? JSON_GUARD : `${systemPrompt}\n\n${JSON_GUARD}`;
@@ -77,7 +84,7 @@ function buildDeepSeekParams(model, req) {
         stream: true,
         stream_options: { include_usage: true },
         ...(0, sampling_1.openAISamplingFields)(req),
-        ...(wantJson ? { response_format: { type: "json_object" } } : {}),
+        ...(jsonObject ? { response_format: { type: "json_object" } } : {}),
         ...(req.tools !== undefined && req.tools.length > 0
             ? {
                 tools: (0, tool_mapping_1.toOpenAITools)(req.tools),

package/dist/adapters/gemini.d.ts

@@ -18,6 +18,12 @@ import type { FailureClass } from "../types/failures";
 export interface GeminiAdapterConfig {
     readonly apiKey: string;
 }
+/** Models that accept thinkingConfig — passing it to 2.x models 400s.
+ * Ported from the production THINKING_CAPABLE_MODELS set. EXPORTED (CE-9 R6) so
+ * a multi-provider customer's dispatcher reads THIS set instead of duplicating
+ * it (the §3.1 drift complaint) — the same fact the raw-lane guard uses to keep
+ * gemini reasoning model-gated. */
+export declare const GEMINI_THINKING_CAPABLE_MODELS: ReadonlySet<string>;
 export declare function geminiSupports(feature: CapabilityFlag, model: string): boolean;
 export interface ClassifiedFailure {
     readonly cls: FailureClass;
@@ -50,5 +56,44 @@ export interface GeminiShapedRequest {
 }
 /** Pure request shaping — everything except the abort signal. */
 export declare function buildGeminiRequest(model: string, req: ShapingInput): GeminiShapedRequest;
+/** A candidate's parts as we read them post-response — `functionCall`, `text`,
+ * and (if `includeThoughts` were ever set) a `thought`-flagged text part may all
+ * appear on the same candidate (a grounded / thinking turn). */
+type GeminiCandidatePart = {
+    readonly functionCall?: unknown;
+    readonly text?: string;
+    readonly thought?: boolean;
+};
+type GeminiCandidateShape = {
+    readonly content?: {
+        readonly parts?: readonly GeminiCandidatePart[];
+    };
+};
+/**
+ * #245 secondary — concatenate the answer `text` parts of a Gemini candidate's
+ * content. On the raw / no-tools lane a grounding-originated `functionCall` part
+ * (googleSearch) is NOT a tool-call turn, and the SDK's `response.text` getter
+ * returns empty (and logs a warning) on a response that mixes `functionCall` +
+ * `text` parts — so read the text parts directly. `thought`-flagged parts are
+ * skipped to match `response.text` semantics (they are the reasoning summary, not
+ * the answer). Pure + exported for the fixture regression test (no network).
+ * (spec §2 Secondary — the SNPS bug.)
+ */
+export declare function extractGeminiCandidateText(candidate: GeminiCandidateShape | undefined): string;
+/** #245 secondary — whether a candidate carries a `functionCall` part. On the
+ * no-tools lane this means grounding produced only a googleSearch invocation with
+ * no text answer, which the empty-response `fixHint` should name. */
+export declare function geminiCandidateHasFunctionCall(candidate: GeminiCandidateShape | undefined): boolean;
+/**
+ * #245 secondary — pick the answer text from a Gemini response. The branch the
+ * `call()` path uses, extracted pure so it is unit-testable without a network:
+ *  - tools declared: trust the SDK `response.text` getter, byte-identical to
+ *    pre-#245 (a functionCall turn is handled earlier as a tool-call).
+ *  - no tools declared: read the candidate's text parts directly, because
+ *    `response.text` returns empty on a grounding-originated functionCall+text
+ *    response; fall back to `response.text` only if there is no text part.
+ */
+export declare function resolveGeminiText(candidate: GeminiCandidateShape | undefined, responseText: string | undefined, hasTools: boolean): string;
 export declare function createGeminiAdapter(config: GeminiAdapterConfig): ProviderAdapter;
+export {};
 //# sourceMappingURL=gemini.d.ts.map

package/dist/adapters/gemini.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../src/adapters/gemini.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,cAAc,EAGd,cAAc,EACd,eAAe,EAEhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,mBAAmB,CAAC;AAKlE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAkCD,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG9E;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAyCxE;AAED;6EAC6E;AAC7E,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;AAE7D;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,iBAAiB,GAAG,IAAI,CAQrG;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAgDxF;AA0BD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,eAAe,CA+JhF"}
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../src/adapters/gemini.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,cAAc,EAGd,cAAc,EACd,eAAe,EAEhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,mBAAmB,CAAC;AAKlE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;mCAImC;AACnC,eAAO,MAAM,8BAA8B,EAAE,WAAW,CAAC,MAAM,CAI7D,CAAC;AA0BH,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG9E;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAyCxE;AAED;6EAC6E;AAC7E,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;AAE7D;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,iBAAiB,GAAG,IAAI,CAQrG;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAqDxF;AA0BD;;gEAEgE;AAChE,KAAK,mBAAmB,GAAG;IACzB,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AACF,KAAK,oBAAoB,GAAG;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;KAAE,CAAA;CAAE,CAAC;AAEvG;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,oBAAoB,GAAG,SAAS,GAAG,MAAM,CAM9F;AAED;;qEAEqE;AACrE,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,oBAAoB,GAAG,SAAS,GAAG,OAAO,CAInG;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,oBAAoB,GAAG,SAAS,EAC3C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,QAAQ,EAAE,OAAO,GAChB,MAAM,CAGR;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,eAAe,CA+KhF"}

package/dist/adapters/gemini.js

@@ -15,17 +15,24 @@
  * gemini transformation logic is consulted during the port.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_THINKING_CAPABLE_MODELS = void 0;
 exports.geminiSupports = geminiSupports;
 exports.classifyGeminiFailure = classifyGeminiFailure;
 exports.geminiReasoningUnsupported = geminiReasoningUnsupported;
 exports.buildGeminiRequest = buildGeminiRequest;
+exports.extractGeminiCandidateText = extractGeminiCandidateText;
+exports.geminiCandidateHasFunctionCall = geminiCandidateHasFunctionCall;
+exports.resolveGeminiText = resolveGeminiText;
 exports.createGeminiAdapter = createGeminiAdapter;
 const genai_1 = require("@google/genai");
 const tool_mapping_1 = require("./tool-mapping");
 const sampling_1 = require("./sampling");
 /** Models that accept thinkingConfig — passing it to 2.x models 400s.
- * Ported from the production THINKING_CAPABLE_MODELS set. */
-const THINKING_CAPABLE_MODELS = new Set([
+ * Ported from the production THINKING_CAPABLE_MODELS set. EXPORTED (CE-9 R6) so
+ * a multi-provider customer's dispatcher reads THIS set instead of duplicating
+ * it (the §3.1 drift complaint) — the same fact the raw-lane guard uses to keep
+ * gemini reasoning model-gated. */
+exports.GEMINI_THINKING_CAPABLE_MODELS = new Set([
     "gemini-3.1-pro-preview",
     "gemini-3.0-pro-preview",
     "gemini-3.1-flash-preview",
@@ -110,7 +117,7 @@ function classifyGeminiFailure(message) {
  * reasoning declared, or a thinking-capable model). Pure — unit-tested directly.
  */
 function geminiReasoningUnsupported(model, req) {
-    if (req.reasoning !== undefined && !THINKING_CAPABLE_MODELS.has(model)) {
+    if (req.reasoning !== undefined && !exports.GEMINI_THINKING_CAPABLE_MODELS.has(model)) {
         return {
             cls: "invariant_violation",
             fixHint: `reasoning control requires a thinking-capable Gemini model; "${model}" is not one — remove reasoning or choose a thinking-capable model`,
@@ -134,12 +141,18 @@ function buildGeminiRequest(model, req) {
         maxOutputTokens: (0, sampling_1.effectiveMaxOutputTokens)(req, DEFAULT_MAX_OUTPUT_TOKENS),
         topP: req.sampling?.topP ?? TOP_P,
         topK: TOP_K,
-        ...(THINKING_CAPABLE_MODELS.has(model) ? { thinkingConfig: { thinkingLevel } } : {}),
+        ...(exports.GEMINI_THINKING_CAPABLE_MODELS.has(model) ? { thinkingConfig: { thinkingLevel } } : {}),
     };
     if (req.outputSchema !== null) {
         config.responseMimeType = "application/json";
         config.responseJsonSchema = req.outputSchema;
     }
+    else if (req.responseFormat === "json_object") {
+        // CE-9 R4: mime-shaping ONLY — force a JSON mime type WITHOUT a schema. This
+        // is the raw lane, so F4 stands: no responseJsonSchema, no validation, no
+        // repair, `validated` stays false. Absent ⇒ no key (byte-identical).
+        config.responseMimeType = "application/json";
+    }
     // cachedContent excludes systemInstruction and tools — the API rejects
     // requests setting both (they are baked into the cache at creation time,
     // including the googleSearch tool for cached grounded steps).
@@ -180,6 +193,43 @@ function extractServedTier(rawServiceTier, trafficType, requested) {
         return "priority";
     return requested;
 }
+/**
+ * #245 secondary — concatenate the answer `text` parts of a Gemini candidate's
+ * content. On the raw / no-tools lane a grounding-originated `functionCall` part
+ * (googleSearch) is NOT a tool-call turn, and the SDK's `response.text` getter
+ * returns empty (and logs a warning) on a response that mixes `functionCall` +
+ * `text` parts — so read the text parts directly. `thought`-flagged parts are
+ * skipped to match `response.text` semantics (they are the reasoning summary, not
+ * the answer). Pure + exported for the fixture regression test (no network).
+ * (spec §2 Secondary — the SNPS bug.)
+ */
+function extractGeminiCandidateText(candidate) {
+    return (candidate?.content?.parts ?? [])
+        .filter((p) => p.thought !== true)
+        .map((p) => p.text)
+        .filter((t) => typeof t === "string")
+        .join("");
+}
+/** #245 secondary — whether a candidate carries a `functionCall` part. On the
+ * no-tools lane this means grounding produced only a googleSearch invocation with
+ * no text answer, which the empty-response `fixHint` should name. */
+function geminiCandidateHasFunctionCall(candidate) {
+    return (candidate?.content?.parts ?? []).some((p) => p.functionCall !== undefined && p.functionCall !== null);
+}
+/**
+ * #245 secondary — pick the answer text from a Gemini response. The branch the
+ * `call()` path uses, extracted pure so it is unit-testable without a network:
+ *  - tools declared: trust the SDK `response.text` getter, byte-identical to
+ *    pre-#245 (a functionCall turn is handled earlier as a tool-call).
+ *  - no tools declared: read the candidate's text parts directly, because
+ *    `response.text` returns empty on a grounding-originated functionCall+text
+ *    response; fall back to `response.text` only if there is no text part.
+ */
+function resolveGeminiText(candidate, responseText, hasTools) {
+    if (hasTools)
+        return responseText ?? "";
+    return extractGeminiCandidateText(candidate) || (responseText ?? "");
+}
 function createGeminiAdapter(config) {
     const ai = new genai_1.GoogleGenAI({ apiKey: config.apiKey });
     return {
@@ -256,9 +306,20 @@ function createGeminiAdapter(config) {
                 if (finishReason === "RECITATION") {
                     return fail("refusal", "Gemini blocked output via recitation filter (finishReason=RECITATION)", undefined, usage);
                 }
-                const text = response.text ?? "";
+                // #245 secondary: when the caller declared NO tools, a `functionCall`
+                // part is grounding-originated (googleSearch), NOT a tool-call turn — and
+                // `response.text` returns empty on a mixed functionCall+text response, so
+                // read the text parts directly. When tools WERE declared this path is
+                // reached only for a no-functionCall response, so `response.text` is
+                // byte-identical to before.
+                const noTools = req.tools === undefined || req.tools.length === 0;
+                const text = resolveGeminiText(candidates?.[0], response.text, !noTools);
                 if (text.trim().length === 0) {
-                    return fail("content_invalid", `empty response from Gemini (finishReason=${finishReason ?? "none"})`, undefined, usage);
+                    const groundedNoText = noTools &&
+                        geminiCandidateHasFunctionCall(candidates?.[0]);
+                    return fail("content_invalid", `empty response from Gemini (finishReason=${finishReason ?? "none"})`, groundedNoText
+                        ? "the grounded response returned only a googleSearch functionCall part with no text — refine the grounding query, or remove grounding if the model can answer directly"
+                        : undefined, usage);
                 }
                 if (finishReason === "MAX_TOKENS" && req.outputSchema !== null) {
                     // A truncated structured emission is mid-object and unparseable.

package/dist/adapters/grok.d.ts

@@ -36,7 +36,14 @@ export interface GrokShapedParams {
     /** Prompt-cache routing hint (WS-C) — the stable-prefix fingerprint the run
      * loop stamps; xAI keeps a warm cache keyed to it (writes free today). */
     readonly prompt_cache_key?: string;
+    /** CE-9 R1 — xAI accepts `reasoning_effort: "low" | "high"` ONLY, so the
+     * neutral four-level `level` is coarsened by `coarsenGrokReasoningEffort`
+     * (a DISCLOSED, lossy mapping: `minimal,low → "low"`; `medium,high → "high"`).
+     * Present only when the caller declared `reasoning`. */
+    readonly reasoning_effort?: "low" | "high";
     readonly response_format?: {
+        readonly type: "json_object";
+    } | {
         readonly type: "json_schema";
         readonly json_schema: {
             readonly name: string;

package/dist/adapters/grok.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grok.d.ts","sourceRoot":"","sources":["../../src/adapters/grok.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMhE,OAAO,KAAK,EAAuB,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAMhG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAsBtE;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;KAAE,CAAC;IAC1D,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;8EAC0E;IAC1E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE;QACzB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,WAAW,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;SAAE,CAAC;KACjG,CAAC;IACF,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,gBAAgB,CAsClF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAgK5E"}
+{"version":3,"file":"grok.d.ts","sourceRoot":"","sources":["../../src/adapters/grok.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMhE,OAAO,KAAK,EAAuB,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAOhG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CA+BtE;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;KAAE,CAAC;IAC1D,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;8EAC0E;IAC1E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC;;;4DAGwD;IACxD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,eAAe,CAAC,EACrB;QAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;KAAE,GAChC;QACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,WAAW,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;SAAE,CAAC;KACjG,CAAC;IACN,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,gBAAgB,CAmDlF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAgK5E"}