@warlock.js/ai-mistral 5.30.0 → 5.32.0

package/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to `@warlock.js/ai-mistral` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.32.0 - 2026-10-18
+
+### Changed
+
+- Pin the package development compiler to TypeScript 7.0.2 and use explicit Node types and source roots with supported module resolution.
+
+## 5.31.0 - 2026-10-18
+
+### Added
+
+- An adapter contract test verifies that aborting `signal` rejects `complete()` and `stream()` on the model and cancels the HTTP request.
+- `MistralModelConfig.promptCacheKey` is sent as `prompt_cache_key`.
+
+### Changed
+
+- Chat calls inherit `providerOptions.openai.body` from the OpenAI adapter, including its protected fields and one-level plain-object merge. Use only this provider's accepted fields when sharing fallback options. Native `countTokens` remains absent; `sdk.count(text)` is an offline estimate.
+
+### Fixed
+
+- `MISTRAL_DEFAULT_PRICING` matches Mistral's current price list (2026-10-17), with cache-read rates and API ids beside the `-latest` aliases. Retired Pixtral and Magistral entries are removed.
+
+### Upgrading
+
+- **BREAKING** `pixtral-*` and `magistral-*` models no longer have built-in prices, so a USD budget on them rejects the run as unpriced. Pass `pricing` for them.
+
 ## 5.30.0 - 2026-10-16
 
 ### Changed
@@ -81,6 +106,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Changed
 
 - Lockstep release maintenance and dependency refresh.
+
 ## 5.20.0 - 2026-09-24
 
 ### Changed

package/README.md

@@ -54,12 +54,12 @@ MistralModelConfig {
 
 The headline `-latest` aliases are exported as `MISTRAL_MODELS`, grouped by role:
 
-| Family | Aliases | Notes |
-| --- | --- | --- |
-| `chat` | `mistral-large-latest`, `mistral-medium-latest`, `mistral-small-latest` | General-purpose multimodal flagship / mid / small |
-| `vision` | `pixtral-large-latest`, `pixtral-12b` | Dedicated multimodal (image input) |
-| `reasoning` | `magistral-medium-latest`, `magistral-small-latest` | Chain-of-thought reasoning |
-| `embedding` | `mistral-embed` | Via the OpenAI-compatible `/v1/embeddings` |
+| Family      | Aliases                                                                 | Notes                                             |
+| ----------- | ----------------------------------------------------------------------- | ------------------------------------------------- |
+| `chat`      | `mistral-large-latest`, `mistral-medium-latest`, `mistral-small-latest` | General-purpose multimodal flagship / mid / small |
+| `vision`    | `pixtral-large-latest`, `pixtral-12b`                                   | Dedicated multimodal (image input)                |
+| `reasoning` | `magistral-medium-latest`, `magistral-small-latest`                     | Chain-of-thought reasoning                        |
+| `embedding` | `mistral-embed`                                                         | Via the OpenAI-compatible `/v1/embeddings`        |
 
 `mistral.model()` accepts any id string, so version-pinned ids (`mistral-large-2512`, `magistral-medium-2509`) work just as well — capability inference keys off the family fragment, not the alias list.
 
@@ -67,16 +67,16 @@ The headline `-latest` aliases are exported as `MISTRAL_MODELS`, grouped by role
 
 The wrapper injects **Mistral-aware** capability inference before delegating to the OpenAI adapter, because the OpenAI prefix lists (`gpt-4o`, `o3`, …) never match Mistral names. An explicit value always wins over inference.
 
-| Capability | Default |
-| --- | --- |
-| `vision` | Inferred from the model name — `true` for the `pixtral` family and the recent multimodal generations (`mistral-large`, `mistral-medium`, `ministral-3`); `false` otherwise. |
-| `reasoning` | Inferred from the model name — `true` for the `magistral` family and the hybrid `mistral-small` generation; `false` otherwise. Drives whether `reasoning.effort` maps to `reasoning_effort` on the wire. |
-| `structuredOutput` | `true`, unless `responseFormat` is forced to `"json_object"` / `"text"`. |
+| Capability         | Default                                                                                                                                                                                                  |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vision`           | Inferred from the model name — `true` for the `pixtral` family and the recent multimodal generations (`mistral-large`, `mistral-medium`, `ministral-3`); `false` otherwise.                              |
+| `reasoning`        | Inferred from the model name — `true` for the `magistral` family and the hybrid `mistral-small` generation; `false` otherwise. Drives whether `reasoning.effort` maps to `reasoning_effort` on the wire. |
+| `structuredOutput` | `true`, unless `responseFormat` is forced to `"json_object"` / `"text"`.                                                                                                                                 |
 
 ```ts
-mistral.model({ name: "pixtral-large-latest" });            // vision auto-true
-mistral.model({ name: "magistral-medium-latest" });         // reasoning auto-true
-mistral.model({ name: "some-fine-tune", vision: true });    // explicit override
+mistral.model({ name: "pixtral-large-latest" }); // vision auto-true
+mistral.model({ name: "magistral-medium-latest" }); // reasoning auto-true
+mistral.model({ name: "some-fine-tune", vision: true }); // explicit override
 ```
 
 ## Embeddings

package/cjs/index.cjs

@@ -106,49 +106,76 @@ const MISTRAL_MODELS = {
 	embedding: ["mistral-embed"]
 };
 /**
-* Conservative default USD pricing registry (per 1,000,000 tokens),
-* keyed by stable `-latest` alias, surfaced onto every model unless the
-* caller overrides it via SDK-level or per-model `pricing`.
+* Default USD pricing registry (per 1,000,000 tokens), keyed by API id
+* and alias, surfaced onto every model unless the caller overrides it via
+* SDK-level or per-model `pricing`. `cachedInput` is the prompt-cache
+* rate (10% of input).
 *
-* These are sane published-list approximations for budgeting / cost-truth
-* out of the box — Mistral revises rates and ships new generations, so
-* pass an explicit `pricing` registry to `new MistralSDK({ pricing })`
-* for billing-grade numbers. Resolution at `model()` time always lets a
-* caller-supplied rate win: per-model `pricing` > SDK `pricing` > these
-* defaults > `undefined`.
+* Source: https://docs.mistral.ai/inference/pricing and the model pages
+* under https://docs.mistral.ai/models (API ids and aliases), fetched
+* 2026-10-17. Mistral Large 4 (public preview, sale price) and the
+* retired Pixtral / Magistral models are not included. Resolution at
+* `model()` time always lets a caller-supplied rate win: per-model
+* `pricing` > SDK `pricing` > these defaults > `undefined`.
 */
 const MISTRAL_DEFAULT_PRICING = {
 	"mistral-large-latest": {
-		input: 2,
-		output: 6
+		input: .5,
+		output: 1.5,
+		cachedInput: .05
+	},
+	"mistral-large-2512": {
+		input: .5,
+		output: 1.5,
+		cachedInput: .05
 	},
 	"mistral-medium-latest": {
-		input: .4,
-		output: 2
+		input: 1.5,
+		output: 7.5,
+		cachedInput: .15
 	},
-	"mistral-small-latest": {
-		input: .1,
-		output: .3
+	"mistral-medium-3-5": {
+		input: 1.5,
+		output: 7.5,
+		cachedInput: .15
 	},
-	"pixtral-large-latest": {
-		input: 2,
-		output: 6
+	"mistral-small-latest": {
+		input: .15,
+		output: .6,
+		cachedInput: .015
 	},
-	"pixtral-12b": {
+	"mistral-small-2603": {
 		input: .15,
-		output: .15
+		output: .6,
+		cachedInput: .015
 	},
-	"magistral-medium-latest": {
-		input: 2,
-		output: 5
+	"ministral-14b-latest": {
+		input: .2,
+		output: .2,
+		cachedInput: .02
 	},
-	"magistral-small-latest": {
-		input: .5,
-		output: 1.5
+	"ministral-14b-2512": {
+		input: .2,
+		output: .2,
+		cachedInput: .02
+	},
+	"codestral-latest": {
+		input: .3,
+		output: .9,
+		cachedInput: .03
+	},
+	"codestral-2508": {
+		input: .3,
+		output: .9,
+		cachedInput: .03
 	},
 	"mistral-embed": {
 		input: .1,
 		output: 0
+	},
+	"mistral-embed-2312": {
+		input: .1,
+		output: 0
 	}
 };
 

package/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../../packages/ai-mistral/src/known-models.ts","../../../../../../../packages/ai-mistral/src/sdk.ts"],"sourcesContent":["import type { ModelPricing } from \"@warlock.js/ai\";\n\n/**\n * Model-name fragments identifying Mistral families that accept image\n * input (vision / multimodal).\n *\n * - `pixtral` — Mistral's dedicated multimodal family\n *   (`pixtral-large-latest`, `pixtral-12b`); documents, charts, and\n *   natural images.\n * - `mistral-large` / `mistral-medium` — the recent frontier generations\n *   (Large 3, Medium 3.5) are natively multimodal.\n * - `ministral-3` — the current small open-weight line ships with\n *   best-in-class text + vision.\n *\n * Matched as a **substring** (not a strict prefix) so the date / version\n * suffixes Mistral appends (`pixtral-large-2411`, `mistral-large-2512`)\n * and the `-latest` aliases are all covered without enumerating every\n * release tag. Override per-model via\n * `mistral.model({ name, vision: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a multimodal family\n * that doesn't already match.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"pixtral\",\n  \"mistral-large\",\n  \"mistral-medium\",\n  \"ministral-3\",\n] as const;\n\n/**\n * Model-name fragments identifying Mistral families that perform\n * explicit chain-of-thought reasoning.\n *\n * - `magistral` — Mistral's dedicated reasoning family\n *   (`magistral-medium-latest`, `magistral-small-latest`); emits\n *   tokenized thinking chunks.\n * - `mistral-small-4` / `mistral-small` — the current Small generation\n *   is a hybrid model that unifies instruct + reasoning + coding.\n *\n * Matched as a **substring** so version-tagged ids\n * (`magistral-medium-2509`, `mistral-small-2603`) and `-latest` aliases\n * are covered. Override per-model via\n * `mistral.model({ name, reasoning: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a reasoning family\n * that doesn't already match.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"magistral\", \"mistral-small\"] as const;\n\n/**\n * Infer whether a Mistral model id accepts image input (vision) based on\n * the known multimodal-family fragments. Unknown ids default to `false`\n * so passing an image attachment to a text-only model surfaces a clear,\n * agent-side capability error instead of an opaque Mistral 400.\n *\n * @example\n * inferVisionCapability(\"pixtral-large-latest\");   // → true\n * inferVisionCapability(\"mistral-large-2512\");     // → true\n * inferVisionCapability(\"magistral-medium-latest\");// → false\n * inferVisionCapability(\"mistral-embed\");          // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Mistral model id is a reasoning model (the `magistral`\n * family plus the hybrid `mistral-small` generation) based on the known\n * fragments. Unknown ids default to `false` so the adapter never forwards\n * an unsupported `reasoning_effort` param to a non-reasoning model.\n *\n * @example\n * inferReasoningCapability(\"magistral-medium-latest\"); // → true\n * inferReasoningCapability(\"mistral-small-2603\");      // → true\n * inferReasoningCapability(\"mistral-large-latest\");    // → false\n * inferReasoningCapability(\"pixtral-12b\");             // → false\n */\nexport function inferReasoningCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Stable `-latest` alias ids for the headline Mistral chat / embeddings\n * models, grouped by role. Convenience constants only — `mistral.model()`\n * accepts any id string, so a version-pinned id\n * (`mistral-large-2512`, `magistral-medium-2509`) works just as well.\n * Capability inference keys off the family fragment, not this list, so a\n * newer alias is recognized the moment its name matches a fragment in\n * {@link inferVisionCapability} / {@link inferReasoningCapability}.\n */\nexport const MISTRAL_MODELS = {\n  /** General-purpose multimodal flagship / mid / small chat aliases. */\n  chat: [\"mistral-large-latest\", \"mistral-medium-latest\", \"mistral-small-latest\"],\n  /** Dedicated multimodal (vision) aliases — the `pixtral` family. */\n  vision: [\"pixtral-large-latest\", \"pixtral-12b\"],\n  /** Dedicated reasoning aliases — the `magistral` family. */\n  reasoning: [\"magistral-medium-latest\", \"magistral-small-latest\"],\n  /** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */\n  embedding: [\"mistral-embed\"],\n} as const;\n\n/**\n * Conservative default USD pricing registry (per 1,000,000 tokens),\n * keyed by stable `-latest` alias, surfaced onto every model unless the\n * caller overrides it via SDK-level or per-model `pricing`.\n *\n * These are sane published-list approximations for budgeting / cost-truth\n * out of the box — Mistral revises rates and ships new generations, so\n * pass an explicit `pricing` registry to `new MistralSDK({ pricing })`\n * for billing-grade numbers. Resolution at `model()` time always lets a\n * caller-supplied rate win: per-model `pricing` > SDK `pricing` > these\n * defaults > `undefined`.\n */\nexport const MISTRAL_DEFAULT_PRICING: Record<string, ModelPricing> = {\n  \"mistral-large-latest\": { input: 2, output: 6 },\n  \"mistral-medium-latest\": { input: 0.4, output: 2 },\n  \"mistral-small-latest\": { input: 0.1, output: 0.3 },\n  \"pixtral-large-latest\": { input: 2, output: 6 },\n  \"pixtral-12b\": { input: 0.15, output: 0.15 },\n  \"magistral-medium-latest\": { input: 2, output: 5 },\n  \"magistral-small-latest\": { input: 0.5, output: 1.5 },\n  \"mistral-embed\": { input: 0.1, output: 0 },\n};\n","import type {\n  EmbedderConfig,\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type { MistralModelConfig, MistralSDKConfig } from \"./config.type\";\nimport {\n  inferReasoningCapability,\n  inferVisionCapability,\n  MISTRAL_DEFAULT_PRICING,\n} from \"./known-models\";\n\n/** Default OpenAI-compatible base URL for the Mistral API. */\nconst MISTRAL_BASE_URL = \"https://api.mistral.ai/v1\";\n\n/** Default provider label stamped onto every model this SDK produces. */\nconst MISTRAL_PROVIDER = \"mistral\";\n\n/**\n * Mistral-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Mistral AI chat + embeddings.\n * Mistral exposes an **OpenAI-compatible** API (`/v1/chat/completions`,\n * `/v1/embeddings`), so `MistralSDK` is a *thin wrapper* over the\n * battle-tested {@link OpenAISDK} — it does NOT re-implement the wire\n * protocol, streaming loop, tool-call accumulation, structured-output\n * mapping, error wrapping, or token accounting. It constructs one\n * internal `OpenAISDK` pointed at Mistral's `baseURL` with\n * `provider: \"mistral\"`, and delegates `model()` / `embedder()` /\n * `count()` straight to it.\n *\n * **What this wrapper adds on top of the OpenAI adapter:**\n * - **Defaults.** Injects Mistral's `baseURL` + `provider` label and a\n *   default {@link MISTRAL_DEFAULT_PRICING} registry so cost truth works\n *   out of the box. All are overridable via config.\n * - **Provider-correct capability inference.** Mistral's model names\n *   aren't OpenAI names, so the OpenAI prefix lists never match. Before\n *   delegating `model()`, this wrapper infers `vision` (the `pixtral`\n *   family + recent multimodal generations) and `reasoning` (the\n *   `magistral` family + hybrid `mistral-small`) from *this provider's*\n *   fragment lists and passes them as explicit overrides — which the\n *   inner `OpenAISDK` honors verbatim. A caller-supplied explicit\n *   `vision` / `reasoning` still wins.\n *\n * Construct one SDK per account and reuse it everywhere; the single\n * underlying `OpenAI` client (connection pool, auth, rate-limit state)\n * is shared by every model / embedder produced here.\n *\n * **Note — no image generation.** Mistral has no OpenAI-compatible image\n * endpoint, so `image()` is intentionally NOT exposed. The structural\n * absence of the method IS the capability guard (see\n * `SDKAdapterContract.image`): `ai.mistral.image(...)` is a compile-time\n * error rather than a runtime failure.\n *\n * @example\n * const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });\n * const model = mistral.model({ name: \"mistral-large-latest\", temperature: 0.7 });\n * const embedder = mistral.embedder({ name: \"mistral-embed\" });\n *\n * @example\n * // Compose into an `ai.mistral` namespace for ergonomic agent wiring.\n * const ai = { agent, tool, systemPrompt, mistral: new MistralSDK({ apiKey }) };\n * const reasoner = ai.agent({ model: ai.mistral.model({ name: \"magistral-medium-latest\" }) });\n */\nexport class MistralSDK implements SDKAdapterContract {\n  /**\n   * The wrapped OpenAI-compatible adapter doing all the real work. Built\n   * once in the constructor with Mistral's `baseURL`, `provider` label,\n   * and merged pricing registry; every public method delegates to it.\n   */\n  private readonly openai: OpenAISDK;\n\n  public constructor(config: MistralSDKConfig) {\n    const { provider, baseURL, pricing, ...clientOptions } = config;\n\n    // Caller pricing wins per model id; otherwise fall back to this\n    // provider's published-list defaults so cost truth works out of the box.\n    const mergedPricing: Record<string, ModelPricing> = {\n      ...MISTRAL_DEFAULT_PRICING,\n      ...pricing,\n    };\n\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? MISTRAL_BASE_URL,\n      provider: provider ?? MISTRAL_PROVIDER,\n      pricing: mergedPricing,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` for a Mistral chat model.\n   *\n   * Delegates to the inner `OpenAISDK.model()` but first injects\n   * **Mistral-aware capability inference**: when the caller omits\n   * `vision` / `reasoning`, they're inferred from this provider's family\n   * fragments (`pixtral` → vision, `magistral` / `mistral-small` →\n   * reasoning, see `known-models.ts`) and passed down as explicit\n   * overrides. Without this step the wrapped OpenAI adapter would check\n   * Mistral ids against OpenAI prefixes (`gpt-4o`, `o3`, …) and wrongly\n   * report every Mistral model as non-vision / non-reasoning.\n   *\n   * A caller-supplied explicit `vision` / `reasoning` is preserved as-is\n   * (explicit config always wins over inference). Pricing resolution is\n   * handled downstream by `OpenAISDK` against the merged registry:\n   * per-model `pricing` > SDK registry (caller + Mistral defaults) >\n   * `undefined`.\n   */\n  public model(config: MistralModelConfig): ModelContract {\n    const resolvedConfig: MistralModelConfig = {\n      ...config,\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n    };\n\n    return this.openai.model(resolvedConfig);\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegates to the wrapped\n   * `OpenAISDK.count()` (the shared character-heuristic from the core\n   * package) — good for budgeting / quota guards, not billing. The\n   * optional model id is forwarded but currently ignored.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an `EmbedderContract` bound to this SDK's client. Mistral\n   * serves embeddings (`mistral-embed`) through the OpenAI-compatible\n   * `/v1/embeddings` endpoint, so this delegates straight to\n   * `OpenAISDK.embedder()`.\n   *\n   * @example\n   * const embedder = mistral.embedder({ name: \"mistral-embed\" });\n   * const { vector } = await embedder.embed(\"Hello world\");\n   */\n  public embedder(config: EmbedderConfig): EmbedderContract {\n    // `embedder` is optional on the contract but always present on the\n    // wrapped OpenAI adapter — assert it for the delegation.\n    return this.openai.embedder!(config);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,+BAA+B,CAAC,aAAa,eAAe;;;;;;;;;;;;;AAclE,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;;;;;;AAcA,SAAgB,yBAAyB,WAA4B;CACnE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;AAWA,MAAa,iBAAiB;;CAE5B,MAAM;EAAC;EAAwB;EAAyB;CAAsB;;CAE9E,QAAQ,CAAC,wBAAwB,aAAa;;CAE9C,WAAW,CAAC,2BAA2B,wBAAwB;;CAE/D,WAAW,CAAC,eAAe;AAC7B;;;;;;;;;;;;;AAcA,MAAa,0BAAwD;CACnE,wBAAwB;EAAE,OAAO;EAAG,QAAQ;CAAE;CAC9C,yBAAyB;EAAE,OAAO;EAAK,QAAQ;CAAE;CACjD,wBAAwB;EAAE,OAAO;EAAK,QAAQ;CAAI;CAClD,wBAAwB;EAAE,OAAO;EAAG,QAAQ;CAAE;CAC9C,eAAe;EAAE,OAAO;EAAM,QAAQ;CAAK;CAC3C,2BAA2B;EAAE,OAAO;EAAG,QAAQ;CAAE;CACjD,0BAA0B;EAAE,OAAO;EAAK,QAAQ;CAAI;CACpD,iBAAiB;EAAE,OAAO;EAAK,QAAQ;CAAE;AAC3C;;;;;ACjHA,MAAM,mBAAmB;;AAGzB,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDzB,IAAa,aAAb,MAAsD;CAQpD,AAAO,YAAY,QAA0B;EAC3C,MAAM,EAAE,UAAU,SAAS,SAAS,GAAG,kBAAkB;EAIzD,MAAM,gBAA8C;GAClD,GAAG;GACH,GAAG;EACL;EAEA,KAAK,SAAS,IAAIA,gCAAU;GAC1B,GAAG;GACH,SAAS,WAAW;GACpB,UAAU,YAAY;GACtB,SAAS;EACX,CAAC;CACH;;;;;;;;;;;;;;;;;;;CAoBA,AAAO,MAAM,QAA2C;EACtD,MAAM,iBAAqC;GACzC,GAAG;GACH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;EACrE;EAEA,OAAO,KAAK,OAAO,MAAM,cAAc;CACzC;;;;;;;CAQA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAA0C;EAGxD,OAAO,KAAK,OAAO,SAAU,MAAM;CACrC;AACF"}
+{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../../packages/ai-mistral/src/known-models.ts","../../../../../../../packages/ai-mistral/src/sdk.ts"],"sourcesContent":["import type { ModelPricing } from \"@warlock.js/ai\";\n\n/**\n * Model-name fragments identifying Mistral families that accept image\n * input (vision / multimodal).\n *\n * - `pixtral` — Mistral's dedicated multimodal family\n *   (`pixtral-large-latest`, `pixtral-12b`); documents, charts, and\n *   natural images.\n * - `mistral-large` / `mistral-medium` — the recent frontier generations\n *   (Large 3, Medium 3.5) are natively multimodal.\n * - `ministral-3` — the current small open-weight line ships with\n *   best-in-class text + vision.\n *\n * Matched as a **substring** (not a strict prefix) so the date / version\n * suffixes Mistral appends (`pixtral-large-2411`, `mistral-large-2512`)\n * and the `-latest` aliases are all covered without enumerating every\n * release tag. Override per-model via\n * `mistral.model({ name, vision: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a multimodal family\n * that doesn't already match.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"pixtral\",\n  \"mistral-large\",\n  \"mistral-medium\",\n  \"ministral-3\",\n] as const;\n\n/**\n * Model-name fragments identifying Mistral families that perform\n * explicit chain-of-thought reasoning.\n *\n * - `magistral` — Mistral's dedicated reasoning family\n *   (`magistral-medium-latest`, `magistral-small-latest`); emits\n *   tokenized thinking chunks.\n * - `mistral-small-4` / `mistral-small` — the current Small generation\n *   is a hybrid model that unifies instruct + reasoning + coding.\n *\n * Matched as a **substring** so version-tagged ids\n * (`magistral-medium-2509`, `mistral-small-2603`) and `-latest` aliases\n * are covered. Override per-model via\n * `mistral.model({ name, reasoning: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a reasoning family\n * that doesn't already match.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"magistral\", \"mistral-small\"] as const;\n\n/**\n * Infer whether a Mistral model id accepts image input (vision) based on\n * the known multimodal-family fragments. Unknown ids default to `false`\n * so passing an image attachment to a text-only model surfaces a clear,\n * agent-side capability error instead of an opaque Mistral 400.\n *\n * @example\n * inferVisionCapability(\"pixtral-large-latest\");   // → true\n * inferVisionCapability(\"mistral-large-2512\");     // → true\n * inferVisionCapability(\"magistral-medium-latest\");// → false\n * inferVisionCapability(\"mistral-embed\");          // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Mistral model id is a reasoning model (the `magistral`\n * family plus the hybrid `mistral-small` generation) based on the known\n * fragments. Unknown ids default to `false` so the adapter never forwards\n * an unsupported `reasoning_effort` param to a non-reasoning model.\n *\n * @example\n * inferReasoningCapability(\"magistral-medium-latest\"); // → true\n * inferReasoningCapability(\"mistral-small-2603\");      // → true\n * inferReasoningCapability(\"mistral-large-latest\");    // → false\n * inferReasoningCapability(\"pixtral-12b\");             // → false\n */\nexport function inferReasoningCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Stable `-latest` alias ids for the headline Mistral chat / embeddings\n * models, grouped by role. Convenience constants only — `mistral.model()`\n * accepts any id string, so a version-pinned id\n * (`mistral-large-2512`, `magistral-medium-2509`) works just as well.\n * Capability inference keys off the family fragment, not this list, so a\n * newer alias is recognized the moment its name matches a fragment in\n * {@link inferVisionCapability} / {@link inferReasoningCapability}.\n */\nexport const MISTRAL_MODELS = {\n  /** General-purpose multimodal flagship / mid / small chat aliases. */\n  chat: [\"mistral-large-latest\", \"mistral-medium-latest\", \"mistral-small-latest\"],\n  /** Dedicated multimodal (vision) aliases — the `pixtral` family. */\n  vision: [\"pixtral-large-latest\", \"pixtral-12b\"],\n  /** Dedicated reasoning aliases — the `magistral` family. */\n  reasoning: [\"magistral-medium-latest\", \"magistral-small-latest\"],\n  /** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */\n  embedding: [\"mistral-embed\"],\n} as const;\n\n/**\n * Default USD pricing registry (per 1,000,000 tokens), keyed by API id\n * and alias, surfaced onto every model unless the caller overrides it via\n * SDK-level or per-model `pricing`. `cachedInput` is the prompt-cache\n * rate (10% of input).\n *\n * Source: https://docs.mistral.ai/inference/pricing and the model pages\n * under https://docs.mistral.ai/models (API ids and aliases), fetched\n * 2026-10-17. Mistral Large 4 (public preview, sale price) and the\n * retired Pixtral / Magistral models are not included. Resolution at\n * `model()` time always lets a caller-supplied rate win: per-model\n * `pricing` > SDK `pricing` > these defaults > `undefined`.\n */\nexport const MISTRAL_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"mistral-large-latest\": { input: 0.5, output: 1.5, cachedInput: 0.05 },\n  \"mistral-large-2512\": { input: 0.5, output: 1.5, cachedInput: 0.05 },\n  \"mistral-medium-latest\": { input: 1.5, output: 7.5, cachedInput: 0.15 },\n  \"mistral-medium-3-5\": { input: 1.5, output: 7.5, cachedInput: 0.15 },\n  \"mistral-small-latest\": { input: 0.15, output: 0.6, cachedInput: 0.015 },\n  \"mistral-small-2603\": { input: 0.15, output: 0.6, cachedInput: 0.015 },\n  \"ministral-14b-latest\": { input: 0.2, output: 0.2, cachedInput: 0.02 },\n  \"ministral-14b-2512\": { input: 0.2, output: 0.2, cachedInput: 0.02 },\n  \"codestral-latest\": { input: 0.3, output: 0.9, cachedInput: 0.03 },\n  \"codestral-2508\": { input: 0.3, output: 0.9, cachedInput: 0.03 },\n  \"mistral-embed\": { input: 0.1, output: 0 },\n  \"mistral-embed-2312\": { input: 0.1, output: 0 },\n};\n","import type {\n  EmbedderConfig,\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type { MistralModelConfig, MistralSDKConfig } from \"./config.type\";\nimport {\n  inferReasoningCapability,\n  inferVisionCapability,\n  MISTRAL_DEFAULT_PRICING,\n} from \"./known-models\";\n\n/** Default OpenAI-compatible base URL for the Mistral API. */\nconst MISTRAL_BASE_URL = \"https://api.mistral.ai/v1\";\n\n/** Default provider label stamped onto every model this SDK produces. */\nconst MISTRAL_PROVIDER = \"mistral\";\n\n/**\n * Mistral-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Mistral AI chat + embeddings.\n * Mistral exposes an **OpenAI-compatible** API (`/v1/chat/completions`,\n * `/v1/embeddings`), so `MistralSDK` is a *thin wrapper* over the\n * battle-tested {@link OpenAISDK} — it does NOT re-implement the wire\n * protocol, streaming loop, tool-call accumulation, structured-output\n * mapping, error wrapping, or token accounting. It constructs one\n * internal `OpenAISDK` pointed at Mistral's `baseURL` with\n * `provider: \"mistral\"`, and delegates `model()` / `embedder()` /\n * `count()` straight to it.\n *\n * **What this wrapper adds on top of the OpenAI adapter:**\n * - **Defaults.** Injects Mistral's `baseURL` + `provider` label and a\n *   default {@link MISTRAL_DEFAULT_PRICING} registry so cost truth works\n *   out of the box. All are overridable via config.\n * - **Provider-correct capability inference.** Mistral's model names\n *   aren't OpenAI names, so the OpenAI prefix lists never match. Before\n *   delegating `model()`, this wrapper infers `vision` (the `pixtral`\n *   family + recent multimodal generations) and `reasoning` (the\n *   `magistral` family + hybrid `mistral-small`) from *this provider's*\n *   fragment lists and passes them as explicit overrides — which the\n *   inner `OpenAISDK` honors verbatim. A caller-supplied explicit\n *   `vision` / `reasoning` still wins.\n *\n * Construct one SDK per account and reuse it everywhere; the single\n * underlying `OpenAI` client (connection pool, auth, rate-limit state)\n * is shared by every model / embedder produced here.\n *\n * **Note — no image generation.** Mistral has no OpenAI-compatible image\n * endpoint, so `image()` is intentionally NOT exposed. The structural\n * absence of the method IS the capability guard (see\n * `SDKAdapterContract.image`): `ai.mistral.image(...)` is a compile-time\n * error rather than a runtime failure.\n *\n * @example\n * const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });\n * const model = mistral.model({ name: \"mistral-large-latest\", temperature: 0.7 });\n * const embedder = mistral.embedder({ name: \"mistral-embed\" });\n *\n * @example\n * // Compose into an `ai.mistral` namespace for ergonomic agent wiring.\n * const ai = { agent, tool, systemPrompt, mistral: new MistralSDK({ apiKey }) };\n * const reasoner = ai.agent({ model: ai.mistral.model({ name: \"magistral-medium-latest\" }) });\n */\nexport class MistralSDK implements SDKAdapterContract {\n  /**\n   * The wrapped OpenAI-compatible adapter doing all the real work. Built\n   * once in the constructor with Mistral's `baseURL`, `provider` label,\n   * and merged pricing registry; every public method delegates to it.\n   */\n  private readonly openai: OpenAISDK;\n\n  public constructor(config: MistralSDKConfig) {\n    const { provider, baseURL, pricing, ...clientOptions } = config;\n\n    // Caller pricing wins per model id; otherwise fall back to this\n    // provider's published-list defaults so cost truth works out of the box.\n    const mergedPricing: Record<string, ModelPricing> = {\n      ...MISTRAL_DEFAULT_PRICING,\n      ...pricing,\n    };\n\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? MISTRAL_BASE_URL,\n      provider: provider ?? MISTRAL_PROVIDER,\n      pricing: mergedPricing,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` for a Mistral chat model.\n   *\n   * Delegates to the inner `OpenAISDK.model()` but first injects\n   * **Mistral-aware capability inference**: when the caller omits\n   * `vision` / `reasoning`, they're inferred from this provider's family\n   * fragments (`pixtral` → vision, `magistral` / `mistral-small` →\n   * reasoning, see `known-models.ts`) and passed down as explicit\n   * overrides. Without this step the wrapped OpenAI adapter would check\n   * Mistral ids against OpenAI prefixes (`gpt-4o`, `o3`, …) and wrongly\n   * report every Mistral model as non-vision / non-reasoning.\n   *\n   * A caller-supplied explicit `vision` / `reasoning` is preserved as-is\n   * (explicit config always wins over inference). Pricing resolution is\n   * handled downstream by `OpenAISDK` against the merged registry:\n   * per-model `pricing` > SDK registry (caller + Mistral defaults) >\n   * `undefined`.\n   */\n  public model(config: MistralModelConfig): ModelContract {\n    const resolvedConfig: MistralModelConfig = {\n      ...config,\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n    };\n\n    return this.openai.model(resolvedConfig);\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegates to the wrapped\n   * `OpenAISDK.count()` (the shared character-heuristic from the core\n   * package) — good for budgeting / quota guards, not billing. The\n   * optional model id is forwarded but currently ignored.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an `EmbedderContract` bound to this SDK's client. Mistral\n   * serves embeddings (`mistral-embed`) through the OpenAI-compatible\n   * `/v1/embeddings` endpoint, so this delegates straight to\n   * `OpenAISDK.embedder()`.\n   *\n   * @example\n   * const embedder = mistral.embedder({ name: \"mistral-embed\" });\n   * const { vector } = await embedder.embed(\"Hello world\");\n   */\n  public embedder(config: EmbedderConfig): EmbedderContract {\n    // `embedder` is optional on the contract but always present on the\n    // wrapped OpenAI adapter — assert it for the delegation.\n    return this.openai.embedder!(config);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,+BAA+B,CAAC,aAAa,eAAe;;;;;;;;;;;;;AAclE,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;;;;;;AAcA,SAAgB,yBAAyB,WAA4B;CACnE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;AAWA,MAAa,iBAAiB;;CAE5B,MAAM;EAAC;EAAwB;EAAyB;CAAsB;;CAE9E,QAAQ,CAAC,wBAAwB,aAAa;;CAE9C,WAAW,CAAC,2BAA2B,wBAAwB;;CAE/D,WAAW,CAAC,eAAe;AAC7B;;;;;;;;;;;;;;AAeA,MAAa,0BAAkE;CAC7E,wBAAwB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACrE,sBAAsB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACnE,yBAAyB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACtE,sBAAsB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACnE,wBAAwB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACvE,sBAAsB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACrE,wBAAwB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACrE,sBAAsB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACnE,oBAAoB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACjE,kBAAkB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CAC/D,iBAAiB;EAAE,OAAO;EAAK,QAAQ;CAAE;CACzC,sBAAsB;EAAE,OAAO;EAAK,QAAQ;CAAE;AAChD;;;;;ACtHA,MAAM,mBAAmB;;AAGzB,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDzB,IAAa,aAAb,MAAsD;CAQpD,AAAO,YAAY,QAA0B;EAC3C,MAAM,EAAE,UAAU,SAAS,SAAS,GAAG,kBAAkB;EAIzD,MAAM,gBAA8C;GAClD,GAAG;GACH,GAAG;EACL;EAEA,KAAK,SAAS,IAAIA,gCAAU;GAC1B,GAAG;GACH,SAAS,WAAW;GACpB,UAAU,YAAY;GACtB,SAAS;EACX,CAAC;CACH;;;;;;;;;;;;;;;;;;;CAoBA,AAAO,MAAM,QAA2C;EACtD,MAAM,iBAAqC;GACzC,GAAG;GACH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;EACrE;EAEA,OAAO,KAAK,OAAO,MAAM,cAAc;CACzC;;;;;;;CAQA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAA0C;EAGxD,OAAO,KAAK,OAAO,SAAU,MAAM;CACrC;AACF"}

package/esm/config.type.d.mts

@@ -1,6 +1,5 @@
 import { OpenAISDKConfig } from "@warlock.js/ai-openai";
 import { ModelConfig } from "@warlock.js/ai";
-
 //#region ../../packages/ai-mistral/src/config.type.d.ts
 /**
  * Configuration for the Mistral SDK adapter.
@@ -34,7 +33,7 @@ import { ModelConfig } from "@warlock.js/ai";
  *   pricing: { "mistral-large-latest": { input: 2, output: 6 } },
  * });
  */
-type MistralSDKConfig = OpenAISDKConfig;
+export type MistralSDKConfig = OpenAISDKConfig;
 /**
  * Per-model configuration for `MistralSDK.model()`. Extends the neutral
  * {@link ModelConfig} with the same capability overrides the wrapped
@@ -52,7 +51,7 @@ type MistralSDKConfig = OpenAISDKConfig;
  * mistral.model({ name: "magistral-medium-latest" });        // reasoning auto-true
  * mistral.model({ name: "some-fine-tune", vision: true });   // explicit override
  */
-type MistralModelConfig = ModelConfig & {
+export type MistralModelConfig = ModelConfig & {
   /**
    * Override the auto-inferred vision capability. When omitted, the
    * adapter checks the model id against this provider's multimodal
@@ -76,6 +75,16 @@ type MistralModelConfig = ModelConfig & {
    * `responseFormat` forces a loose mode (`"json_object"` / `"text"`).
    */
   structuredOutput?: boolean;
+  /**
+   * Prompt-cache routing key, sent as `prompt_cache_key` so requests that
+   * share a prefix land on the same Mistral cache. Use a stable value per
+   * conversation or tenant. Sent only while the SDK keeps its default
+   * provider label.
+   *
+   * @example
+   * model({ name: "mistral-large-latest", promptCacheKey: `conversation:${conversationId}` });
+   */
+  promptCacheKey?: string;
   /**
    * Override the wire-level `response_format` the adapter emits when the
    * caller supplies a response schema (`"json_schema"` | `"json_object"`
@@ -97,5 +106,4 @@ type MistralModelConfig = ModelConfig & {
   audio?: boolean;
 };
 //#endregion
-export { MistralModelConfig, MistralSDKConfig };
 //# sourceMappingURL=config.type.d.mts.map

package/esm/config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-mistral/src/config.type.ts"],"mappings":";;;;;;AAmCA;;;;AAA8C;AAmB9C;;;;;;;;;;;;AA0CO;;;;;;;;;;;;;KA7DK,gBAAA,GAAmB,eAAe;;;;;;;;;;;;;;;;;;KAmBlC,kBAAA,GAAqB,WAAW;;;;;;;;EAQ1C,MAAA;;;;;;;;;EASA,SAAA;;;;;;EAMA,gBAAA;;;;;;;EAOA,cAAA;;;;;;EAMA,GAAA;;;;;;EAMA,KAAA;AAAA"}
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-mistral/src/config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAmCY,mBAAmB;;;;;;;;;;;;;;;;;;YAmBnB,qBAAqB;;;;;;;;EAQ/B;;;;;;;;;EASA;;;;;;EAMA;;;;;;;;;;EAUA;;;;;;;EAOA;;;;;;EAMA;;;;;;EAMA"}

package/esm/known-models.d.mts

@@ -1,5 +1,4 @@
 import { ModelPricing } from "@warlock.js/ai";
-
 //#region ../../packages/ai-mistral/src/known-models.d.ts
 /**
  * Infer whether a Mistral model id accepts image input (vision) based on
@@ -13,7 +12,7 @@ import { ModelPricing } from "@warlock.js/ai";
  * inferVisionCapability("magistral-medium-latest");// → false
  * inferVisionCapability("mistral-embed");          // → false
  */
-declare function inferVisionCapability(modelName: string): boolean;
+export declare function inferVisionCapability(modelName: string): boolean;
 /**
  * Infer whether a Mistral model id is a reasoning model (the `magistral`
  * family plus the hybrid `mistral-small` generation) based on the known
@@ -26,7 +25,7 @@ declare function inferVisionCapability(modelName: string): boolean;
  * inferReasoningCapability("mistral-large-latest");    // → false
  * inferReasoningCapability("pixtral-12b");             // → false
  */
-declare function inferReasoningCapability(modelName: string): boolean;
+export declare function inferReasoningCapability(modelName: string): boolean;
 /**
  * Stable `-latest` alias ids for the headline Mistral chat / embeddings
  * models, grouped by role. Convenience constants only — `mistral.model()`
@@ -36,25 +35,29 @@ declare function inferReasoningCapability(modelName: string): boolean;
  * newer alias is recognized the moment its name matches a fragment in
  * {@link inferVisionCapability} / {@link inferReasoningCapability}.
  */
-declare const MISTRAL_MODELS: {
-  /** General-purpose multimodal flagship / mid / small chat aliases. */readonly chat: readonly ["mistral-large-latest", "mistral-medium-latest", "mistral-small-latest"]; /** Dedicated multimodal (vision) aliases — the `pixtral` family. */
-  readonly vision: readonly ["pixtral-large-latest", "pixtral-12b"]; /** Dedicated reasoning aliases — the `magistral` family. */
-  readonly reasoning: readonly ["magistral-medium-latest", "magistral-small-latest"]; /** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */
+export declare const MISTRAL_MODELS: {
+  /** General-purpose multimodal flagship / mid / small chat aliases. */
+  readonly chat: readonly ["mistral-large-latest", "mistral-medium-latest", "mistral-small-latest"];
+  /** Dedicated multimodal (vision) aliases — the `pixtral` family. */
+  readonly vision: readonly ["pixtral-large-latest", "pixtral-12b"];
+  /** Dedicated reasoning aliases — the `magistral` family. */
+  readonly reasoning: readonly ["magistral-medium-latest", "magistral-small-latest"];
+  /** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */
   readonly embedding: readonly ["mistral-embed"];
 };
 /**
- * Conservative default USD pricing registry (per 1,000,000 tokens),
- * keyed by stable `-latest` alias, surfaced onto every model unless the
- * caller overrides it via SDK-level or per-model `pricing`.
+ * Default USD pricing registry (per 1,000,000 tokens), keyed by API id
+ * and alias, surfaced onto every model unless the caller overrides it via
+ * SDK-level or per-model `pricing`. `cachedInput` is the prompt-cache
+ * rate (10% of input).
  *
- * These are sane published-list approximations for budgeting / cost-truth
- * out of the box — Mistral revises rates and ships new generations, so
- * pass an explicit `pricing` registry to `new MistralSDK({ pricing })`
- * for billing-grade numbers. Resolution at `model()` time always lets a
- * caller-supplied rate win: per-model `pricing` > SDK `pricing` > these
- * defaults > `undefined`.
+ * Source: https://docs.mistral.ai/inference/pricing and the model pages
+ * under https://docs.mistral.ai/models (API ids and aliases), fetched
+ * 2026-10-17. Mistral Large 4 (public preview, sale price) and the
+ * retired Pixtral / Magistral models are not included. Resolution at
+ * `model()` time always lets a caller-supplied rate win: per-model
+ * `pricing` > SDK `pricing` > these defaults > `undefined`.
  */
-declare const MISTRAL_DEFAULT_PRICING: Record<string, ModelPricing>;
+export declare const MISTRAL_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>>;
 //#endregion
-export { MISTRAL_DEFAULT_PRICING, MISTRAL_MODELS, inferReasoningCapability, inferVisionCapability };
 //# sourceMappingURL=known-models.d.mts.map

package/esm/known-models.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"known-models.d.mts","names":[],"sources":["../../../../../../../packages/ai-mistral/src/known-models.ts"],"mappings":";;;;;AAgEA;;;;AAAuD;AAkBvD;;;;AAA0D;iBAlB1C,qBAAA,CAAsB,SAAiB;;;;;;;;;;AAwDvD;;;iBAtCgB,wBAAA,CAAyB,SAAiB;AAsCO;;;;;;;;;AAAA,cAvBpD,cAAA;;;;;;;;;;;;;;;;;;cAuBA,uBAAA,EAAyB,MAAM,SAAS,YAAA"}
+{"version":3,"file":"known-models.d.mts","names":[],"sources":["../../../../../../../packages/ai-mistral/src/known-models.ts"],"mappings":";;;;;;;;;;;;;;wBAgEgB,sBAAsB;;;;;;;;;;;;;wBAkBtB,yBAAyB;;;;;;;;;;qBAe5B;;WAEX;;WAEA;;WAEA;;WAEA;;;;;;;;;;;;;;;qBAgBW,yBAAyB,SAAS,eAAe"}

package/esm/known-models.mjs

@@ -103,49 +103,76 @@ const MISTRAL_MODELS = {
 	embedding: ["mistral-embed"]
 };
 /**
-* Conservative default USD pricing registry (per 1,000,000 tokens),
-* keyed by stable `-latest` alias, surfaced onto every model unless the
-* caller overrides it via SDK-level or per-model `pricing`.
+* Default USD pricing registry (per 1,000,000 tokens), keyed by API id
+* and alias, surfaced onto every model unless the caller overrides it via
+* SDK-level or per-model `pricing`. `cachedInput` is the prompt-cache
+* rate (10% of input).
 *
-* These are sane published-list approximations for budgeting / cost-truth
-* out of the box — Mistral revises rates and ships new generations, so
-* pass an explicit `pricing` registry to `new MistralSDK({ pricing })`
-* for billing-grade numbers. Resolution at `model()` time always lets a
-* caller-supplied rate win: per-model `pricing` > SDK `pricing` > these
-* defaults > `undefined`.
+* Source: https://docs.mistral.ai/inference/pricing and the model pages
+* under https://docs.mistral.ai/models (API ids and aliases), fetched
+* 2026-10-17. Mistral Large 4 (public preview, sale price) and the
+* retired Pixtral / Magistral models are not included. Resolution at
+* `model()` time always lets a caller-supplied rate win: per-model
+* `pricing` > SDK `pricing` > these defaults > `undefined`.
 */
 const MISTRAL_DEFAULT_PRICING = {
 	"mistral-large-latest": {
-		input: 2,
-		output: 6
+		input: .5,
+		output: 1.5,
+		cachedInput: .05
+	},
+	"mistral-large-2512": {
+		input: .5,
+		output: 1.5,
+		cachedInput: .05
 	},
 	"mistral-medium-latest": {
-		input: .4,
-		output: 2
+		input: 1.5,
+		output: 7.5,
+		cachedInput: .15
 	},
-	"mistral-small-latest": {
-		input: .1,
-		output: .3
+	"mistral-medium-3-5": {
+		input: 1.5,
+		output: 7.5,
+		cachedInput: .15
 	},
-	"pixtral-large-latest": {
-		input: 2,
-		output: 6
+	"mistral-small-latest": {
+		input: .15,
+		output: .6,
+		cachedInput: .015
 	},
-	"pixtral-12b": {
+	"mistral-small-2603": {
 		input: .15,
-		output: .15
+		output: .6,
+		cachedInput: .015
 	},
-	"magistral-medium-latest": {
-		input: 2,
-		output: 5
+	"ministral-14b-latest": {
+		input: .2,
+		output: .2,
+		cachedInput: .02
 	},
-	"magistral-small-latest": {
-		input: .5,
-		output: 1.5
+	"ministral-14b-2512": {
+		input: .2,
+		output: .2,
+		cachedInput: .02
+	},
+	"codestral-latest": {
+		input: .3,
+		output: .9,
+		cachedInput: .03
+	},
+	"codestral-2508": {
+		input: .3,
+		output: .9,
+		cachedInput: .03
 	},
 	"mistral-embed": {
 		input: .1,
 		output: 0
+	},
+	"mistral-embed-2312": {
+		input: .1,
+		output: 0
 	}
 };
 

package/esm/known-models.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-models.mjs","names":[],"sources":["../../../../../../../packages/ai-mistral/src/known-models.ts"],"sourcesContent":["import type { ModelPricing } from \"@warlock.js/ai\";\n\n/**\n * Model-name fragments identifying Mistral families that accept image\n * input (vision / multimodal).\n *\n * - `pixtral` — Mistral's dedicated multimodal family\n *   (`pixtral-large-latest`, `pixtral-12b`); documents, charts, and\n *   natural images.\n * - `mistral-large` / `mistral-medium` — the recent frontier generations\n *   (Large 3, Medium 3.5) are natively multimodal.\n * - `ministral-3` — the current small open-weight line ships with\n *   best-in-class text + vision.\n *\n * Matched as a **substring** (not a strict prefix) so the date / version\n * suffixes Mistral appends (`pixtral-large-2411`, `mistral-large-2512`)\n * and the `-latest` aliases are all covered without enumerating every\n * release tag. Override per-model via\n * `mistral.model({ name, vision: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a multimodal family\n * that doesn't already match.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"pixtral\",\n  \"mistral-large\",\n  \"mistral-medium\",\n  \"ministral-3\",\n] as const;\n\n/**\n * Model-name fragments identifying Mistral families that perform\n * explicit chain-of-thought reasoning.\n *\n * - `magistral` — Mistral's dedicated reasoning family\n *   (`magistral-medium-latest`, `magistral-small-latest`); emits\n *   tokenized thinking chunks.\n * - `mistral-small-4` / `mistral-small` — the current Small generation\n *   is a hybrid model that unifies instruct + reasoning + coding.\n *\n * Matched as a **substring** so version-tagged ids\n * (`magistral-medium-2509`, `mistral-small-2603`) and `-latest` aliases\n * are covered. Override per-model via\n * `mistral.model({ name, reasoning: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a reasoning family\n * that doesn't already match.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"magistral\", \"mistral-small\"] as const;\n\n/**\n * Infer whether a Mistral model id accepts image input (vision) based on\n * the known multimodal-family fragments. Unknown ids default to `false`\n * so passing an image attachment to a text-only model surfaces a clear,\n * agent-side capability error instead of an opaque Mistral 400.\n *\n * @example\n * inferVisionCapability(\"pixtral-large-latest\");   // → true\n * inferVisionCapability(\"mistral-large-2512\");     // → true\n * inferVisionCapability(\"magistral-medium-latest\");// → false\n * inferVisionCapability(\"mistral-embed\");          // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Mistral model id is a reasoning model (the `magistral`\n * family plus the hybrid `mistral-small` generation) based on the known\n * fragments. Unknown ids default to `false` so the adapter never forwards\n * an unsupported `reasoning_effort` param to a non-reasoning model.\n *\n * @example\n * inferReasoningCapability(\"magistral-medium-latest\"); // → true\n * inferReasoningCapability(\"mistral-small-2603\");      // → true\n * inferReasoningCapability(\"mistral-large-latest\");    // → false\n * inferReasoningCapability(\"pixtral-12b\");             // → false\n */\nexport function inferReasoningCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Stable `-latest` alias ids for the headline Mistral chat / embeddings\n * models, grouped by role. Convenience constants only — `mistral.model()`\n * accepts any id string, so a version-pinned id\n * (`mistral-large-2512`, `magistral-medium-2509`) works just as well.\n * Capability inference keys off the family fragment, not this list, so a\n * newer alias is recognized the moment its name matches a fragment in\n * {@link inferVisionCapability} / {@link inferReasoningCapability}.\n */\nexport const MISTRAL_MODELS = {\n  /** General-purpose multimodal flagship / mid / small chat aliases. */\n  chat: [\"mistral-large-latest\", \"mistral-medium-latest\", \"mistral-small-latest\"],\n  /** Dedicated multimodal (vision) aliases — the `pixtral` family. */\n  vision: [\"pixtral-large-latest\", \"pixtral-12b\"],\n  /** Dedicated reasoning aliases — the `magistral` family. */\n  reasoning: [\"magistral-medium-latest\", \"magistral-small-latest\"],\n  /** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */\n  embedding: [\"mistral-embed\"],\n} as const;\n\n/**\n * Conservative default USD pricing registry (per 1,000,000 tokens),\n * keyed by stable `-latest` alias, surfaced onto every model unless the\n * caller overrides it via SDK-level or per-model `pricing`.\n *\n * These are sane published-list approximations for budgeting / cost-truth\n * out of the box — Mistral revises rates and ships new generations, so\n * pass an explicit `pricing` registry to `new MistralSDK({ pricing })`\n * for billing-grade numbers. Resolution at `model()` time always lets a\n * caller-supplied rate win: per-model `pricing` > SDK `pricing` > these\n * defaults > `undefined`.\n */\nexport const MISTRAL_DEFAULT_PRICING: Record<string, ModelPricing> = {\n  \"mistral-large-latest\": { input: 2, output: 6 },\n  \"mistral-medium-latest\": { input: 0.4, output: 2 },\n  \"mistral-small-latest\": { input: 0.1, output: 0.3 },\n  \"pixtral-large-latest\": { input: 2, output: 6 },\n  \"pixtral-12b\": { input: 0.15, output: 0.15 },\n  \"magistral-medium-latest\": { input: 2, output: 5 },\n  \"magistral-small-latest\": { input: 0.5, output: 1.5 },\n  \"mistral-embed\": { input: 0.1, output: 0 },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,+BAA+B,CAAC,aAAa,eAAe;;;;;;;;;;;;;AAclE,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;;;;;;AAcA,SAAgB,yBAAyB,WAA4B;CACnE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;AAWA,MAAa,iBAAiB;;CAE5B,MAAM;EAAC;EAAwB;EAAyB;CAAsB;;CAE9E,QAAQ,CAAC,wBAAwB,aAAa;;CAE9C,WAAW,CAAC,2BAA2B,wBAAwB;;CAE/D,WAAW,CAAC,eAAe;AAC7B;;;;;;;;;;;;;AAcA,MAAa,0BAAwD;CACnE,wBAAwB;EAAE,OAAO;EAAG,QAAQ;CAAE;CAC9C,yBAAyB;EAAE,OAAO;EAAK,QAAQ;CAAE;CACjD,wBAAwB;EAAE,OAAO;EAAK,QAAQ;CAAI;CAClD,wBAAwB;EAAE,OAAO;EAAG,QAAQ;CAAE;CAC9C,eAAe;EAAE,OAAO;EAAM,QAAQ;CAAK;CAC3C,2BAA2B;EAAE,OAAO;EAAG,QAAQ;CAAE;CACjD,0BAA0B;EAAE,OAAO;EAAK,QAAQ;CAAI;CACpD,iBAAiB;EAAE,OAAO;EAAK,QAAQ;CAAE;AAC3C"}
+{"version":3,"file":"known-models.mjs","names":[],"sources":["../../../../../../../packages/ai-mistral/src/known-models.ts"],"sourcesContent":["import type { ModelPricing } from \"@warlock.js/ai\";\n\n/**\n * Model-name fragments identifying Mistral families that accept image\n * input (vision / multimodal).\n *\n * - `pixtral` — Mistral's dedicated multimodal family\n *   (`pixtral-large-latest`, `pixtral-12b`); documents, charts, and\n *   natural images.\n * - `mistral-large` / `mistral-medium` — the recent frontier generations\n *   (Large 3, Medium 3.5) are natively multimodal.\n * - `ministral-3` — the current small open-weight line ships with\n *   best-in-class text + vision.\n *\n * Matched as a **substring** (not a strict prefix) so the date / version\n * suffixes Mistral appends (`pixtral-large-2411`, `mistral-large-2512`)\n * and the `-latest` aliases are all covered without enumerating every\n * release tag. Override per-model via\n * `mistral.model({ name, vision: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a multimodal family\n * that doesn't already match.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"pixtral\",\n  \"mistral-large\",\n  \"mistral-medium\",\n  \"ministral-3\",\n] as const;\n\n/**\n * Model-name fragments identifying Mistral families that perform\n * explicit chain-of-thought reasoning.\n *\n * - `magistral` — Mistral's dedicated reasoning family\n *   (`magistral-medium-latest`, `magistral-small-latest`); emits\n *   tokenized thinking chunks.\n * - `mistral-small-4` / `mistral-small` — the current Small generation\n *   is a hybrid model that unifies instruct + reasoning + coding.\n *\n * Matched as a **substring** so version-tagged ids\n * (`magistral-medium-2509`, `mistral-small-2603`) and `-latest` aliases\n * are covered. Override per-model via\n * `mistral.model({ name, reasoning: true | false })` — explicit config\n * always wins over inference.\n *\n * Maintenance: append a fragment when Mistral ships a reasoning family\n * that doesn't already match.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"magistral\", \"mistral-small\"] as const;\n\n/**\n * Infer whether a Mistral model id accepts image input (vision) based on\n * the known multimodal-family fragments. Unknown ids default to `false`\n * so passing an image attachment to a text-only model surfaces a clear,\n * agent-side capability error instead of an opaque Mistral 400.\n *\n * @example\n * inferVisionCapability(\"pixtral-large-latest\");   // → true\n * inferVisionCapability(\"mistral-large-2512\");     // → true\n * inferVisionCapability(\"magistral-medium-latest\");// → false\n * inferVisionCapability(\"mistral-embed\");          // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Mistral model id is a reasoning model (the `magistral`\n * family plus the hybrid `mistral-small` generation) based on the known\n * fragments. Unknown ids default to `false` so the adapter never forwards\n * an unsupported `reasoning_effort` param to a non-reasoning model.\n *\n * @example\n * inferReasoningCapability(\"magistral-medium-latest\"); // → true\n * inferReasoningCapability(\"mistral-small-2603\");      // → true\n * inferReasoningCapability(\"mistral-large-latest\");    // → false\n * inferReasoningCapability(\"pixtral-12b\");             // → false\n */\nexport function inferReasoningCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Stable `-latest` alias ids for the headline Mistral chat / embeddings\n * models, grouped by role. Convenience constants only — `mistral.model()`\n * accepts any id string, so a version-pinned id\n * (`mistral-large-2512`, `magistral-medium-2509`) works just as well.\n * Capability inference keys off the family fragment, not this list, so a\n * newer alias is recognized the moment its name matches a fragment in\n * {@link inferVisionCapability} / {@link inferReasoningCapability}.\n */\nexport const MISTRAL_MODELS = {\n  /** General-purpose multimodal flagship / mid / small chat aliases. */\n  chat: [\"mistral-large-latest\", \"mistral-medium-latest\", \"mistral-small-latest\"],\n  /** Dedicated multimodal (vision) aliases — the `pixtral` family. */\n  vision: [\"pixtral-large-latest\", \"pixtral-12b\"],\n  /** Dedicated reasoning aliases — the `magistral` family. */\n  reasoning: [\"magistral-medium-latest\", \"magistral-small-latest\"],\n  /** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */\n  embedding: [\"mistral-embed\"],\n} as const;\n\n/**\n * Default USD pricing registry (per 1,000,000 tokens), keyed by API id\n * and alias, surfaced onto every model unless the caller overrides it via\n * SDK-level or per-model `pricing`. `cachedInput` is the prompt-cache\n * rate (10% of input).\n *\n * Source: https://docs.mistral.ai/inference/pricing and the model pages\n * under https://docs.mistral.ai/models (API ids and aliases), fetched\n * 2026-10-17. Mistral Large 4 (public preview, sale price) and the\n * retired Pixtral / Magistral models are not included. Resolution at\n * `model()` time always lets a caller-supplied rate win: per-model\n * `pricing` > SDK `pricing` > these defaults > `undefined`.\n */\nexport const MISTRAL_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"mistral-large-latest\": { input: 0.5, output: 1.5, cachedInput: 0.05 },\n  \"mistral-large-2512\": { input: 0.5, output: 1.5, cachedInput: 0.05 },\n  \"mistral-medium-latest\": { input: 1.5, output: 7.5, cachedInput: 0.15 },\n  \"mistral-medium-3-5\": { input: 1.5, output: 7.5, cachedInput: 0.15 },\n  \"mistral-small-latest\": { input: 0.15, output: 0.6, cachedInput: 0.015 },\n  \"mistral-small-2603\": { input: 0.15, output: 0.6, cachedInput: 0.015 },\n  \"ministral-14b-latest\": { input: 0.2, output: 0.2, cachedInput: 0.02 },\n  \"ministral-14b-2512\": { input: 0.2, output: 0.2, cachedInput: 0.02 },\n  \"codestral-latest\": { input: 0.3, output: 0.9, cachedInput: 0.03 },\n  \"codestral-2508\": { input: 0.3, output: 0.9, cachedInput: 0.03 },\n  \"mistral-embed\": { input: 0.1, output: 0 },\n  \"mistral-embed-2312\": { input: 0.1, output: 0 },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,+BAA+B,CAAC,aAAa,eAAe;;;;;;;;;;;;;AAclE,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;;;;;;AAcA,SAAgB,yBAAyB,WAA4B;CACnE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;AAWA,MAAa,iBAAiB;;CAE5B,MAAM;EAAC;EAAwB;EAAyB;CAAsB;;CAE9E,QAAQ,CAAC,wBAAwB,aAAa;;CAE9C,WAAW,CAAC,2BAA2B,wBAAwB;;CAE/D,WAAW,CAAC,eAAe;AAC7B;;;;;;;;;;;;;;AAeA,MAAa,0BAAkE;CAC7E,wBAAwB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACrE,sBAAsB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACnE,yBAAyB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACtE,sBAAsB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACnE,wBAAwB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACvE,sBAAsB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACrE,wBAAwB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACrE,sBAAsB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACnE,oBAAoB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CACjE,kBAAkB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAK;CAC/D,iBAAiB;EAAE,OAAO;EAAK,QAAQ;CAAE;CACzC,sBAAsB;EAAE,OAAO;EAAK,QAAQ;CAAE;AAChD"}

package/esm/sdk.d.mts

@@ -1,6 +1,5 @@
 import { MistralModelConfig, MistralSDKConfig } from "./config.type.mjs";
 import { EmbedderConfig, EmbedderContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
-
 //#region ../../packages/ai-mistral/src/sdk.d.ts
 /**
  * Mistral-backed implementation of `SDKAdapterContract`.
@@ -48,7 +47,7 @@ import { EmbedderConfig, EmbedderContract, ModelContract, SDKAdapterContract } f
  * const ai = { agent, tool, systemPrompt, mistral: new MistralSDK({ apiKey }) };
  * const reasoner = ai.agent({ model: ai.mistral.model({ name: "magistral-medium-latest" }) });
  */
-declare class MistralSDK implements SDKAdapterContract {
+export declare class MistralSDK implements SDKAdapterContract {
   /**
    * The wrapped OpenAI-compatible adapter doing all the real work. Built
    * once in the constructor with Mistral's `baseURL`, `provider` label,
@@ -95,5 +94,4 @@ declare class MistralSDK implements SDKAdapterContract {
   embedder(config: EmbedderConfig): EmbedderContract;
 }
 //#endregion
-export { MistralSDK };
 //# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../../packages/ai-mistral/src/sdk.ts"],"mappings":";;;;;;AAmEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0E2D;;;;;;;;;;;;;;cA1E9C,UAAA,YAAsB,kBAAA;;;;;;mBAMhB,MAAA;cAEE,MAAA,EAAQ,gBAAA;;;;;;;;;;;;;;;;;;;EAoCpB,KAAA,CAAM,MAAA,EAAQ,kBAAA,GAAqB,aAAA;;;;;;;EAgB7B,KAAA,CAAM,IAAA,UAAc,KAAA,YAAiB,OAAA;;;;;;;;;;;EAc3C,QAAA,CAAS,MAAA,EAAQ,cAAA,GAAiB,gBAAA;AAAA"}
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../../packages/ai-mistral/src/sdk.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEa,sBAAsB;;;;;;mBAMhB;EAEjB,YAAmB,QAAQ;;;;;;;;;;;;;;;;;;;EAoCpB,MAAM,QAAQ,qBAAqB;;;;;;;EAgB7B,MAAM,cAAc,iBAAiB;;;;;;;;;;;EAc3C,SAAS,QAAQ,iBAAiB"}

package/llms-full.txt

@@ -8,7 +8,7 @@
 
 ---
 name: setup-mistral
-description: 'Wire @warlock.js/ai-mistral — new MistralSDK({apiKey, baseURL?, provider?, pricing?}) for Mistral AI, a thin wrapper over the OpenAI adapter that uses Mistral''s OpenAI-compatible endpoint (https://api.mistral.ai/v1). .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for a ModelContract with Mistral-aware capabilities (vision auto-inferred for the pixtral family, reasoning for the magistral family + hybrid mistral-small), .embedder({name, dimensions?}) for mistral-embed via /v1/embeddings. Triggers: `MistralSDK`, `mistral.model`, `mistral.embedder`, `pixtral`, `magistral`, `mistral-large`, `mistral-small`, `mistral-medium`, `ministral`, `mistral-embed`, `api.mistral.ai`, OpenAI-compatible Mistral, `reasoning_effort`, `responseFormat`, `pricing`; "use mistral", "wire mistral into a warlock agent", "configure mistral-large", "use magistral reasoning", "pixtral vision", "mistral embeddings with warlock". Skip: image generation (Mistral has no OpenAI-compatible image endpoint — `mistral.image()` does not exist); the wrapped adapter internals `@warlock.js/ai-openai`; agent wiring the `run-ai-agent` topic of the `warlock-js-ai` skill; embedder usage the `embed-text` topic of the `warlock-js-ai` skill; provider picking the `pick-ai-provider` topic of the `warlock-js-ai` skill; siblings `@warlock.js/ai-google`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-ollama`; raw `@mistralai/mistralai`, Vercel `@ai-sdk/mistral`.'
+description: 'Wire @warlock.js/ai-mistral — new MistralSDK({apiKey, baseURL?, provider?, pricing?}) for Mistral AI, a thin wrapper over the OpenAI adapter that uses Mistral''s OpenAI-compatible endpoint (https://api.mistral.ai/v1). .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for a ModelContract with Mistral-aware capabilities (vision auto-inferred for the pixtral family, reasoning for the magistral family + hybrid mistral-small), .embedder({name, dimensions?}) for mistral-embed via /v1/embeddings. Triggers: `MistralSDK`, `mistral.model`, `mistral.embedder`, `pixtral`, `magistral`, `mistral-large`, `mistral-small`, `mistral-medium`, `ministral`, `mistral-embed`, `api.mistral.ai`, `MISTRAL_DEFAULT_PRICING`, `promptCacheKey`, OpenAI-compatible Mistral, `reasoning_effort`, `responseFormat`, `pricing`; "use mistral", "wire mistral into a warlock agent", "configure mistral-large", "use magistral reasoning", "pixtral vision", "mistral embeddings with warlock". Skip: image generation (Mistral has no OpenAI-compatible image endpoint — `mistral.image()` does not exist); the wrapped adapter internals `@warlock.js/ai-openai`; agent wiring the `run-ai-agent` topic of the `warlock-js-ai` skill; embedder usage the `embed-text` topic of the `warlock-js-ai` skill; provider picking the `pick-ai-provider` topic of the `warlock-js-ai` skill; siblings `@warlock.js/ai-google`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-ollama`; raw `@mistralai/mistralai`, Vercel `@ai-sdk/mistral`.'
 ---
 
 # `@warlock.js/ai-mistral`
@@ -28,10 +28,10 @@ const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });
 ## Producing a model
 
 ```ts
-mistral.model({ name: "mistral-large-latest" })             // multimodal flagship
-mistral.model({ name: "magistral-medium-latest" })          // reasoning
-mistral.model({ name: "pixtral-large-latest" })             // vision
-mistral.model({ name: "some-fine-tune", vision: true })     // explicit capability override
+mistral.model({ name: "mistral-large-latest" }); // multimodal flagship
+mistral.model({ name: "magistral-medium-latest" }); // reasoning
+mistral.model({ name: "pixtral-large-latest" }); // vision
+mistral.model({ name: "some-fine-tune", vision: true }); // explicit capability override
 ```
 
 Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
@@ -40,13 +40,13 @@ Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
 
 The wrapper injects **Mistral-aware** inference before delegating to the OpenAI adapter (the OpenAI prefix lists never match Mistral names):
 
-| Flag | Default |
-| --- | --- |
-| `vision` | Inferred from the model name. `true` for the `pixtral` family and the recent multimodal generations (`mistral-large`, `mistral-medium`, `ministral-3`); `false` otherwise. |
-| `reasoning` | Inferred from the model name. `true` for the `magistral` family and the hybrid `mistral-small` generation; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
-| `structuredOutput` | `true`, unless `responseFormat` is forced to `"json_object"` / `"text"` (loose modes). |
-| `promptCaching` | `true` (inherited from the OpenAI adapter — read-side `cachedTokens` accounting). |
-| `pdf` / `audio` | `false` by default (opt-in `.model({ pdf: true })` / `{ audio: true }`). |
+| Flag               | Default                                                                                                                                                                       |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vision`           | Inferred from the model name. `true` for the `pixtral` family and the recent multimodal generations (`mistral-large`, `mistral-medium`, `ministral-3`); `false` otherwise.    |
+| `reasoning`        | Inferred from the model name. `true` for the `magistral` family and the hybrid `mistral-small` generation; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
+| `structuredOutput` | `true`, unless `responseFormat` is forced to `"json_object"` / `"text"` (loose modes).                                                                                        |
+| `promptCaching`    | `true` (inherited from the OpenAI adapter — read-side `cachedTokens` accounting).                                                                                             |
+| `pdf` / `audio`    | `false` by default (opt-in `.model({ pdf: true })` / `{ audio: true }`).                                                                                                      |
 
 **Override any flag explicitly** via `.model({ name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio? })` — an explicit value always wins over inference. The known-family fragments live in `known-models.ts` (`inferVisionCapability`, `inferReasoningCapability`).
 
@@ -71,24 +71,47 @@ const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
 
 ## Pricing — per-model registry
 
-The adapter ships a conservative default registry (`MISTRAL_DEFAULT_PRICING`, USD per 1,000,000 tokens) so cost truth works out of the box. Pass your own `pricing` to win per model id:
+The adapter ships a default registry (`MISTRAL_DEFAULT_PRICING`, USD per 1,000,000 tokens, with the 10%-of-input cache rate as `cachedInput`) so cost truth works out of the box, on agent reports and on each `model.complete()` / streaming `done` usage. Pass your own `pricing` to win per model id:
 
 ```ts
+import { totalCost } from "@warlock.js/ai";
+import { MISTRAL_DEFAULT_PRICING, MistralSDK } from "@warlock.js/ai-mistral";
+
 const mistral = new MistralSDK({
-  apiKey,
+  apiKey: process.env.MISTRAL_API_KEY ?? "",
   pricing: {
-    // USD per 1M tokens — billing-grade overrides.
-    "mistral-large-latest":    { input: 2,   output: 6 },
-    "magistral-medium-latest": { input: 2,   output: 5 },
+    // USD per 1M tokens — contract rates win over the defaults.
+    "mistral-large-latest": { input: 0.45, output: 1.35, cachedInput: 0.045 },
   },
 });
+
+MISTRAL_DEFAULT_PRICING["mistral-small-latest"]; // { input: 0.15, output: 0.6, cachedInput: 0.015 }
+
+const { usage } = await mistral
+  .model({ name: "mistral-medium-latest" })
+  .complete([{ role: "user", content: "hi" }]);
+console.log(totalCost(usage.cost));
 ```
 
-Resolution at `model()` time: per-model `pricing` (`mistral.model({ name, pricing })`) > SDK-level `pricing` > `MISTRAL_DEFAULT_PRICING` > `undefined`. The defaults are list-price approximations — pass explicit rates for billing.
+Resolution at `model()` time: per-model `pricing` (`mistral.model({ name, pricing })`) > SDK-level `pricing` > `MISTRAL_DEFAULT_PRICING` > `undefined`.
+
+- **Source.** https://docs.mistral.ai/inference/pricing plus the model pages under https://docs.mistral.ai/models (API ids and aliases), fetched 2026-10-17. Covered: `mistral-large-latest` / `mistral-large-2512`, `mistral-medium-latest` / `mistral-medium-3-5`, `mistral-small-latest` / `mistral-small-2603`, `ministral-14b-latest` / `ministral-14b-2512`, `codestral-latest` / `codestral-2508`, `mistral-embed` / `mistral-embed-2312`.
+- **Not included:** Mistral Large 4 (public preview at a temporary sale price) and the retired Pixtral / Magistral models (no longer on the price list) — pass `pricing` if you still call them.
+
+## Prompt caching
+
+Mistral's Chat Completions accepts `prompt_cache_key` (https://docs.mistral.ai/studio/conversations/advanced/prompt-caching). Set `promptCacheKey` on the model to route related requests to the same cache; it is sent while the SDK keeps its default `"mistral"` provider label. Cached tokens come back as `usage.cachedTokens` (inside `prompt_tokens`, so `inputIncludesCache: true`) and bill at `cachedInput`.
+
+```ts
+import { MistralSDK } from "@warlock.js/ai-mistral";
+
+const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY ?? "" });
+const model = mistral.model({ name: "mistral-large-latest", promptCacheKey: "conversation:42" });
+```
 
 ## Errors
 
-Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the wrapped OpenAI adapter (dispatch keys on `APIError.status + code`) — see the `handle-ai-errors` topic of the `warlock-js-ai` skill.
+Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the wrapped OpenAI adapter (dispatch keys on `APIError.status + code`) — see the `handle-ai-errors` topic of the `warlock-js-ai` skill. HTTP 503 (and OpenAI's `server_is_overloaded` code) maps to `ProviderOverloadedError` (`code: "PROVIDER_OVERLOADED"`, `retryable: true`); every wrapped error carries `status`, `retryable` and `billed` (`false` for 401 / 402 / 403, otherwise `"unknown"`).
 
 ## When NOT to use this skill
 
@@ -102,4 +125,18 @@ Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by th
 - The `run-ai-agent` topic of the `warlock-js-ai` skill — passing the model into `ai.agent({...})`.
 - The `pick-ai-provider` topic of the `warlock-js-ai` skill — adapter comparison.
 
+## Provider body options and token estimates
+
+This adapter delegates Chat Completions to the OpenAI adapter, so
+`providerOptions.openai.body` adds native Chat request fields. Other provider
+keys are ignored. Plain-object fields merge one level deep with neutral options;
+caller-provided keys win, while arrays, scalars and `null` replace the field.
+The OpenAI adapter's protected conversation, tool and transport fields remain
+protected here too. Send only fields supported by this provider; do not reuse
+OpenAI-only bodies across a mixed-provider fallback chain.
+
+Models from this adapter have no native `countTokens` method. Check
+`model.countTokens` before using an optional native counting capability;
+`sdk.count(text)` is a separate offline estimate.
+
 

package/llms.txt

@@ -6,4 +6,4 @@
 
 ## Skills
 
-- [setup-mistral](@warlock.js/ai-mistral/setup-mistral/SKILL.md): Wire @warlock.js/ai-mistral — new MistralSDK({apiKey, baseURL?, provider?, pricing?}) for Mistral AI, a thin wrapper over the OpenAI adapter that uses Mistral's OpenAI-compatible endpoint (https://api.mistral.ai/v1). .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for a ModelContract with Mistral-aware capabilities (vision auto-inferred for the pixtral family, reasoning for the magistral family + hybrid mistral-small), .embedder({name, dimensions?}) for mistral-embed via /v1/embeddings. Triggers: `MistralSDK`, `mistral.model`, `mistral.embedder`, `pixtral`, `magistral`, `mistral-large`, `mistral-small`, `mistral-medium`, `ministral`, `mistral-embed`, `api.mistral.ai`, OpenAI-compatible Mistral, `reasoning_effort`, `responseFormat`, `pricing`; "use mistral", "wire mistral into a warlock agent", "configure mistral-large", "use magistral reasoning", "pixtral vision", "mistral embeddings with warlock". Skip: image generation (Mistral has no OpenAI-compatible image endpoint — `mistral.image()` does not exist); the wrapped adapter internals `@warlock.js/ai-openai`; agent wiring the `run-ai-agent` topic of the `warlock-js-ai` skill; embedder usage the `embed-text` topic of the `warlock-js-ai` skill; provider picking the `pick-ai-provider` topic of the `warlock-js-ai` skill; siblings `@warlock.js/ai-google`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-ollama`; raw `@mistralai/mistralai`, Vercel `@ai-sdk/mistral`.
+- [setup-mistral](@warlock.js/ai-mistral/setup-mistral/SKILL.md): Wire @warlock.js/ai-mistral — new MistralSDK({apiKey, baseURL?, provider?, pricing?}) for Mistral AI, a thin wrapper over the OpenAI adapter that uses Mistral's OpenAI-compatible endpoint (https://api.mistral.ai/v1). .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for a ModelContract with Mistral-aware capabilities (vision auto-inferred for the pixtral family, reasoning for the magistral family + hybrid mistral-small), .embedder({name, dimensions?}) for mistral-embed via /v1/embeddings. Triggers: `MistralSDK`, `mistral.model`, `mistral.embedder`, `pixtral`, `magistral`, `mistral-large`, `mistral-small`, `mistral-medium`, `ministral`, `mistral-embed`, `api.mistral.ai`, `MISTRAL_DEFAULT_PRICING`, `promptCacheKey`, OpenAI-compatible Mistral, `reasoning_effort`, `responseFormat`, `pricing`; "use mistral", "wire mistral into a warlock agent", "configure mistral-large", "use magistral reasoning", "pixtral vision", "mistral embeddings with warlock". Skip: image generation (Mistral has no OpenAI-compatible image endpoint — `mistral.image()` does not exist); the wrapped adapter internals `@warlock.js/ai-openai`; agent wiring the `run-ai-agent` topic of the `warlock-js-ai` skill; embedder usage the `embed-text` topic of the `warlock-js-ai` skill; provider picking the `pick-ai-provider` topic of the `warlock-js-ai` skill; siblings `@warlock.js/ai-google`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-ollama`; raw `@mistralai/mistralai`, Vercel `@ai-sdk/mistral`.

package/package.json

@@ -16,13 +16,13 @@
     "directory": "packages/ai-mistral"
   },
   "dependencies": {
-    "@warlock.js/ai-openai": "5.30.0",
-    "@warlock.js/logger": "5.30.0"
+    "@warlock.js/ai-openai": "5.32.0",
+    "@warlock.js/logger": "5.32.0"
   },
   "peerDependencies": {
-    "@warlock.js/ai": "5.30.0"
+    "@warlock.js/ai": "5.32.0"
   },
-  "version": "5.30.0",
+  "version": "5.32.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",

package/skills/setup-mistral/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-mistral
-description: 'Wire @warlock.js/ai-mistral — new MistralSDK({apiKey, baseURL?, provider?, pricing?}) for Mistral AI, a thin wrapper over the OpenAI adapter that uses Mistral''s OpenAI-compatible endpoint (https://api.mistral.ai/v1). .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for a ModelContract with Mistral-aware capabilities (vision auto-inferred for the pixtral family, reasoning for the magistral family + hybrid mistral-small), .embedder({name, dimensions?}) for mistral-embed via /v1/embeddings. Triggers: `MistralSDK`, `mistral.model`, `mistral.embedder`, `pixtral`, `magistral`, `mistral-large`, `mistral-small`, `mistral-medium`, `ministral`, `mistral-embed`, `api.mistral.ai`, OpenAI-compatible Mistral, `reasoning_effort`, `responseFormat`, `pricing`; "use mistral", "wire mistral into a warlock agent", "configure mistral-large", "use magistral reasoning", "pixtral vision", "mistral embeddings with warlock". Skip: image generation (Mistral has no OpenAI-compatible image endpoint — `mistral.image()` does not exist); the wrapped adapter internals `@warlock.js/ai-openai`; agent wiring the `run-ai-agent` topic of the `warlock-js-ai` skill; embedder usage the `embed-text` topic of the `warlock-js-ai` skill; provider picking the `pick-ai-provider` topic of the `warlock-js-ai` skill; siblings `@warlock.js/ai-google`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-ollama`; raw `@mistralai/mistralai`, Vercel `@ai-sdk/mistral`.'
+description: 'Wire @warlock.js/ai-mistral — new MistralSDK({apiKey, baseURL?, provider?, pricing?}) for Mistral AI, a thin wrapper over the OpenAI adapter that uses Mistral''s OpenAI-compatible endpoint (https://api.mistral.ai/v1). .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for a ModelContract with Mistral-aware capabilities (vision auto-inferred for the pixtral family, reasoning for the magistral family + hybrid mistral-small), .embedder({name, dimensions?}) for mistral-embed via /v1/embeddings. Triggers: `MistralSDK`, `mistral.model`, `mistral.embedder`, `pixtral`, `magistral`, `mistral-large`, `mistral-small`, `mistral-medium`, `ministral`, `mistral-embed`, `api.mistral.ai`, `MISTRAL_DEFAULT_PRICING`, `promptCacheKey`, OpenAI-compatible Mistral, `reasoning_effort`, `responseFormat`, `pricing`; "use mistral", "wire mistral into a warlock agent", "configure mistral-large", "use magistral reasoning", "pixtral vision", "mistral embeddings with warlock". Skip: image generation (Mistral has no OpenAI-compatible image endpoint — `mistral.image()` does not exist); the wrapped adapter internals `@warlock.js/ai-openai`; agent wiring the `run-ai-agent` topic of the `warlock-js-ai` skill; embedder usage the `embed-text` topic of the `warlock-js-ai` skill; provider picking the `pick-ai-provider` topic of the `warlock-js-ai` skill; siblings `@warlock.js/ai-google`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-ollama`; raw `@mistralai/mistralai`, Vercel `@ai-sdk/mistral`.'
 ---
 
 # `@warlock.js/ai-mistral`
@@ -20,10 +20,10 @@ const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });
 ## Producing a model
 
 ```ts
-mistral.model({ name: "mistral-large-latest" })             // multimodal flagship
-mistral.model({ name: "magistral-medium-latest" })          // reasoning
-mistral.model({ name: "pixtral-large-latest" })             // vision
-mistral.model({ name: "some-fine-tune", vision: true })     // explicit capability override
+mistral.model({ name: "mistral-large-latest" }); // multimodal flagship
+mistral.model({ name: "magistral-medium-latest" }); // reasoning
+mistral.model({ name: "pixtral-large-latest" }); // vision
+mistral.model({ name: "some-fine-tune", vision: true }); // explicit capability override
 ```
 
 Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
@@ -32,13 +32,13 @@ Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
 
 The wrapper injects **Mistral-aware** inference before delegating to the OpenAI adapter (the OpenAI prefix lists never match Mistral names):
 
-| Flag | Default |
-| --- | --- |
-| `vision` | Inferred from the model name. `true` for the `pixtral` family and the recent multimodal generations (`mistral-large`, `mistral-medium`, `ministral-3`); `false` otherwise. |
-| `reasoning` | Inferred from the model name. `true` for the `magistral` family and the hybrid `mistral-small` generation; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
-| `structuredOutput` | `true`, unless `responseFormat` is forced to `"json_object"` / `"text"` (loose modes). |
-| `promptCaching` | `true` (inherited from the OpenAI adapter — read-side `cachedTokens` accounting). |
-| `pdf` / `audio` | `false` by default (opt-in `.model({ pdf: true })` / `{ audio: true }`). |
+| Flag               | Default                                                                                                                                                                       |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vision`           | Inferred from the model name. `true` for the `pixtral` family and the recent multimodal generations (`mistral-large`, `mistral-medium`, `ministral-3`); `false` otherwise.    |
+| `reasoning`        | Inferred from the model name. `true` for the `magistral` family and the hybrid `mistral-small` generation; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
+| `structuredOutput` | `true`, unless `responseFormat` is forced to `"json_object"` / `"text"` (loose modes).                                                                                        |
+| `promptCaching`    | `true` (inherited from the OpenAI adapter — read-side `cachedTokens` accounting).                                                                                             |
+| `pdf` / `audio`    | `false` by default (opt-in `.model({ pdf: true })` / `{ audio: true }`).                                                                                                      |
 
 **Override any flag explicitly** via `.model({ name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio? })` — an explicit value always wins over inference. The known-family fragments live in `known-models.ts` (`inferVisionCapability`, `inferReasoningCapability`).
 
@@ -63,24 +63,47 @@ const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
 
 ## Pricing — per-model registry
 
-The adapter ships a conservative default registry (`MISTRAL_DEFAULT_PRICING`, USD per 1,000,000 tokens) so cost truth works out of the box. Pass your own `pricing` to win per model id:
+The adapter ships a default registry (`MISTRAL_DEFAULT_PRICING`, USD per 1,000,000 tokens, with the 10%-of-input cache rate as `cachedInput`) so cost truth works out of the box, on agent reports and on each `model.complete()` / streaming `done` usage. Pass your own `pricing` to win per model id:
 
 ```ts
+import { totalCost } from "@warlock.js/ai";
+import { MISTRAL_DEFAULT_PRICING, MistralSDK } from "@warlock.js/ai-mistral";
+
 const mistral = new MistralSDK({
-  apiKey,
+  apiKey: process.env.MISTRAL_API_KEY ?? "",
   pricing: {
-    // USD per 1M tokens — billing-grade overrides.
-    "mistral-large-latest":    { input: 2,   output: 6 },
-    "magistral-medium-latest": { input: 2,   output: 5 },
+    // USD per 1M tokens — contract rates win over the defaults.
+    "mistral-large-latest": { input: 0.45, output: 1.35, cachedInput: 0.045 },
   },
 });
+
+MISTRAL_DEFAULT_PRICING["mistral-small-latest"]; // { input: 0.15, output: 0.6, cachedInput: 0.015 }
+
+const { usage } = await mistral
+  .model({ name: "mistral-medium-latest" })
+  .complete([{ role: "user", content: "hi" }]);
+console.log(totalCost(usage.cost));
 ```
 
-Resolution at `model()` time: per-model `pricing` (`mistral.model({ name, pricing })`) > SDK-level `pricing` > `MISTRAL_DEFAULT_PRICING` > `undefined`. The defaults are list-price approximations — pass explicit rates for billing.
+Resolution at `model()` time: per-model `pricing` (`mistral.model({ name, pricing })`) > SDK-level `pricing` > `MISTRAL_DEFAULT_PRICING` > `undefined`.
+
+- **Source.** https://docs.mistral.ai/inference/pricing plus the model pages under https://docs.mistral.ai/models (API ids and aliases), fetched 2026-10-17. Covered: `mistral-large-latest` / `mistral-large-2512`, `mistral-medium-latest` / `mistral-medium-3-5`, `mistral-small-latest` / `mistral-small-2603`, `ministral-14b-latest` / `ministral-14b-2512`, `codestral-latest` / `codestral-2508`, `mistral-embed` / `mistral-embed-2312`.
+- **Not included:** Mistral Large 4 (public preview at a temporary sale price) and the retired Pixtral / Magistral models (no longer on the price list) — pass `pricing` if you still call them.
+
+## Prompt caching
+
+Mistral's Chat Completions accepts `prompt_cache_key` (https://docs.mistral.ai/studio/conversations/advanced/prompt-caching). Set `promptCacheKey` on the model to route related requests to the same cache; it is sent while the SDK keeps its default `"mistral"` provider label. Cached tokens come back as `usage.cachedTokens` (inside `prompt_tokens`, so `inputIncludesCache: true`) and bill at `cachedInput`.
+
+```ts
+import { MistralSDK } from "@warlock.js/ai-mistral";
+
+const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY ?? "" });
+const model = mistral.model({ name: "mistral-large-latest", promptCacheKey: "conversation:42" });
+```
 
 ## Errors
 
-Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the wrapped OpenAI adapter (dispatch keys on `APIError.status + code`) — see the `handle-ai-errors` topic of the `warlock-js-ai` skill.
+Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the wrapped OpenAI adapter (dispatch keys on `APIError.status + code`) — see the `handle-ai-errors` topic of the `warlock-js-ai` skill. HTTP 503 (and OpenAI's `server_is_overloaded` code) maps to `ProviderOverloadedError` (`code: "PROVIDER_OVERLOADED"`, `retryable: true`); every wrapped error carries `status`, `retryable` and `billed` (`false` for 401 / 402 / 403, otherwise `"unknown"`).
 
 ## When NOT to use this skill
 
@@ -93,3 +116,17 @@ Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by th
 - The `setup-openai` topic of the `warlock-js-ai-openai` skill — the wrapped adapter; identical wire behavior.
 - The `run-ai-agent` topic of the `warlock-js-ai` skill — passing the model into `ai.agent({...})`.
 - The `pick-ai-provider` topic of the `warlock-js-ai` skill — adapter comparison.
+
+## Provider body options and token estimates
+
+This adapter delegates Chat Completions to the OpenAI adapter, so
+`providerOptions.openai.body` adds native Chat request fields. Other provider
+keys are ignored. Plain-object fields merge one level deep with neutral options;
+caller-provided keys win, while arrays, scalars and `null` replace the field.
+The OpenAI adapter's protected conversation, tool and transport fields remain
+protected here too. Send only fields supported by this provider; do not reuse
+OpenAI-only bodies across a mixed-provider fallback chain.
+
+Models from this adapter have no native `countTokens` method. Check
+`model.countTokens` before using an optional native counting capability;
+`sdk.count(text)` is a separate offline estimate.