@warlock.js/ai-mistral 4.6.0

package/esm/known-models.mjs

@@ -0,0 +1,154 @@
+//#region ../@warlock.js/ai-mistral/src/known-models.ts
+/**
+* Model-name fragments identifying Mistral families that accept image
+* input (vision / multimodal).
+*
+* - `pixtral` — Mistral's dedicated multimodal family
+*   (`pixtral-large-latest`, `pixtral-12b`); documents, charts, and
+*   natural images.
+* - `mistral-large` / `mistral-medium` — the recent frontier generations
+*   (Large 3, Medium 3.5) are natively multimodal.
+* - `ministral-3` — the current small open-weight line ships with
+*   best-in-class text + vision.
+*
+* Matched as a **substring** (not a strict prefix) so the date / version
+* suffixes Mistral appends (`pixtral-large-2411`, `mistral-large-2512`)
+* and the `-latest` aliases are all covered without enumerating every
+* release tag. Override per-model via
+* `mistral.model({ name, vision: true | false })` — explicit config
+* always wins over inference.
+*
+* Maintenance: append a fragment when Mistral ships a multimodal family
+* that doesn't already match.
+*/
+const VISION_CAPABLE_SUBSTRINGS = [
+	"pixtral",
+	"mistral-large",
+	"mistral-medium",
+	"ministral-3"
+];
+/**
+* Model-name fragments identifying Mistral families that perform
+* explicit chain-of-thought reasoning.
+*
+* - `magistral` — Mistral's dedicated reasoning family
+*   (`magistral-medium-latest`, `magistral-small-latest`); emits
+*   tokenized thinking chunks.
+* - `mistral-small-4` / `mistral-small` — the current Small generation
+*   is a hybrid model that unifies instruct + reasoning + coding.
+*
+* Matched as a **substring** so version-tagged ids
+* (`magistral-medium-2509`, `mistral-small-2603`) and `-latest` aliases
+* are covered. Override per-model via
+* `mistral.model({ name, reasoning: true | false })` — explicit config
+* always wins over inference.
+*
+* Maintenance: append a fragment when Mistral ships a reasoning family
+* that doesn't already match.
+*/
+const REASONING_CAPABLE_SUBSTRINGS = ["magistral", "mistral-small"];
+/**
+* Infer whether a Mistral model id accepts image input (vision) based on
+* the known multimodal-family fragments. Unknown ids default to `false`
+* so passing an image attachment to a text-only model surfaces a clear,
+* agent-side capability error instead of an opaque Mistral 400.
+*
+* @example
+* inferVisionCapability("pixtral-large-latest");   // → true
+* inferVisionCapability("mistral-large-2512");     // → true
+* inferVisionCapability("magistral-medium-latest");// → false
+* inferVisionCapability("mistral-embed");          // → false
+*/
+function inferVisionCapability(modelName) {
+	const normalized = modelName.toLowerCase();
+	return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+/**
+* Infer whether a Mistral model id is a reasoning model (the `magistral`
+* family plus the hybrid `mistral-small` generation) based on the known
+* fragments. Unknown ids default to `false` so the adapter never forwards
+* an unsupported `reasoning_effort` param to a non-reasoning model.
+*
+* @example
+* inferReasoningCapability("magistral-medium-latest"); // → true
+* inferReasoningCapability("mistral-small-2603");      // → true
+* inferReasoningCapability("mistral-large-latest");    // → false
+* inferReasoningCapability("pixtral-12b");             // → false
+*/
+function inferReasoningCapability(modelName) {
+	const normalized = modelName.toLowerCase();
+	return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+/**
+* Stable `-latest` alias ids for the headline Mistral chat / embeddings
+* models, grouped by role. Convenience constants only — `mistral.model()`
+* accepts any id string, so a version-pinned id
+* (`mistral-large-2512`, `magistral-medium-2509`) works just as well.
+* Capability inference keys off the family fragment, not this list, so a
+* newer alias is recognized the moment its name matches a fragment in
+* {@link inferVisionCapability} / {@link inferReasoningCapability}.
+*/
+const MISTRAL_MODELS = {
+	/** General-purpose multimodal flagship / mid / small chat aliases. */
+	chat: [
+		"mistral-large-latest",
+		"mistral-medium-latest",
+		"mistral-small-latest"
+	],
+	/** Dedicated multimodal (vision) aliases — the `pixtral` family. */
+	vision: ["pixtral-large-latest", "pixtral-12b"],
+	/** Dedicated reasoning aliases — the `magistral` family. */
+	reasoning: ["magistral-medium-latest", "magistral-small-latest"],
+	/** Embeddings model reachable via the OpenAI-compatible `/v1/embeddings`. */
+	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`.
+*
+* 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`.
+*/
+const MISTRAL_DEFAULT_PRICING = {
+	"mistral-large-latest": {
+		input: 2,
+		output: 6
+	},
+	"mistral-medium-latest": {
+		input: .4,
+		output: 2
+	},
+	"mistral-small-latest": {
+		input: .1,
+		output: .3
+	},
+	"pixtral-large-latest": {
+		input: 2,
+		output: 6
+	},
+	"pixtral-12b": {
+		input: .15,
+		output: .15
+	},
+	"magistral-medium-latest": {
+		input: 2,
+		output: 5
+	},
+	"magistral-small-latest": {
+		input: .5,
+		output: 1.5
+	},
+	"mistral-embed": {
+		input: .1,
+		output: 0
+	}
+};
+
+//#endregion
+export { MISTRAL_DEFAULT_PRICING, MISTRAL_MODELS, inferReasoningCapability, inferVisionCapability };
+//# sourceMappingURL=known-models.mjs.map

package/esm/known-models.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-models.mjs","names":[],"sources":["../../../../../../@warlock.js/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"}

package/esm/sdk.d.mts

@@ -0,0 +1,99 @@
+import { MistralModelConfig, MistralSDKConfig } from "./config.type.mjs";
+import { EmbedderConfig, EmbedderContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-mistral/src/sdk.d.ts
+/**
+ * Mistral-backed implementation of `SDKAdapterContract`.
+ *
+ * **Role.** The package entry point for Mistral AI chat + embeddings.
+ * Mistral exposes an **OpenAI-compatible** API (`/v1/chat/completions`,
+ * `/v1/embeddings`), so `MistralSDK` is a *thin wrapper* over the
+ * battle-tested {@link OpenAISDK} — it does NOT re-implement the wire
+ * protocol, streaming loop, tool-call accumulation, structured-output
+ * mapping, error wrapping, or token accounting. It constructs one
+ * internal `OpenAISDK` pointed at Mistral's `baseURL` with
+ * `provider: "mistral"`, and delegates `model()` / `embedder()` /
+ * `count()` straight to it.
+ *
+ * **What this wrapper adds on top of the OpenAI adapter:**
+ * - **Defaults.** Injects Mistral's `baseURL` + `provider` label and a
+ *   default {@link MISTRAL_DEFAULT_PRICING} registry so cost truth works
+ *   out of the box. All are overridable via config.
+ * - **Provider-correct capability inference.** Mistral's model names
+ *   aren't OpenAI names, so the OpenAI prefix lists never match. Before
+ *   delegating `model()`, this wrapper infers `vision` (the `pixtral`
+ *   family + recent multimodal generations) and `reasoning` (the
+ *   `magistral` family + hybrid `mistral-small`) from *this provider's*
+ *   fragment lists and passes them as explicit overrides — which the
+ *   inner `OpenAISDK` honors verbatim. A caller-supplied explicit
+ *   `vision` / `reasoning` still wins.
+ *
+ * Construct one SDK per account and reuse it everywhere; the single
+ * underlying `OpenAI` client (connection pool, auth, rate-limit state)
+ * is shared by every model / embedder produced here.
+ *
+ * **Note — no image generation.** Mistral has no OpenAI-compatible image
+ * endpoint, so `image()` is intentionally NOT exposed. The structural
+ * absence of the method IS the capability guard (see
+ * `SDKAdapterContract.image`): `ai.mistral.image(...)` is a compile-time
+ * error rather than a runtime failure.
+ *
+ * @example
+ * const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });
+ * const model = mistral.model({ name: "mistral-large-latest", temperature: 0.7 });
+ * const embedder = mistral.embedder({ name: "mistral-embed" });
+ *
+ * @example
+ * // Compose into an `ai.mistral` namespace for ergonomic agent wiring.
+ * 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 {
+  /**
+   * The wrapped OpenAI-compatible adapter doing all the real work. Built
+   * once in the constructor with Mistral's `baseURL`, `provider` label,
+   * and merged pricing registry; every public method delegates to it.
+   */
+  private readonly openai;
+  constructor(config: MistralSDKConfig);
+  /**
+   * Build a `ModelContract` for a Mistral chat model.
+   *
+   * Delegates to the inner `OpenAISDK.model()` but first injects
+   * **Mistral-aware capability inference**: when the caller omits
+   * `vision` / `reasoning`, they're inferred from this provider's family
+   * fragments (`pixtral` → vision, `magistral` / `mistral-small` →
+   * reasoning, see `known-models.ts`) and passed down as explicit
+   * overrides. Without this step the wrapped OpenAI adapter would check
+   * Mistral ids against OpenAI prefixes (`gpt-4o`, `o3`, …) and wrongly
+   * report every Mistral model as non-vision / non-reasoning.
+   *
+   * A caller-supplied explicit `vision` / `reasoning` is preserved as-is
+   * (explicit config always wins over inference). Pricing resolution is
+   * handled downstream by `OpenAISDK` against the merged registry:
+   * per-model `pricing` > SDK registry (caller + Mistral defaults) >
+   * `undefined`.
+   */
+  model(config: MistralModelConfig): ModelContract;
+  /**
+   * Rough offline token-count estimate. Delegates to the wrapped
+   * `OpenAISDK.count()` (the shared character-heuristic from the core
+   * package) — good for budgeting / quota guards, not billing. The
+   * optional model id is forwarded but currently ignored.
+   */
+  count(text: string, model?: string): Promise<number>;
+  /**
+   * Build an `EmbedderContract` bound to this SDK's client. Mistral
+   * serves embeddings (`mistral-embed`) through the OpenAI-compatible
+   * `/v1/embeddings` endpoint, so this delegates straight to
+   * `OpenAISDK.embedder()`.
+   *
+   * @example
+   * const embedder = mistral.embedder({ name: "mistral-embed" });
+   * const { vector } = await embedder.embed("Hello world");
+   */
+  embedder(config: EmbedderConfig): EmbedderContract;
+}
+//#endregion
+export { MistralSDK };
+//# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../@warlock.js/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"}

package/esm/sdk.mjs

@@ -0,0 +1,121 @@
+import { MISTRAL_DEFAULT_PRICING, inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
+import { OpenAISDK } from "@warlock.js/ai-openai";
+
+//#region ../@warlock.js/ai-mistral/src/sdk.ts
+/** Default OpenAI-compatible base URL for the Mistral API. */
+const MISTRAL_BASE_URL = "https://api.mistral.ai/v1";
+/** Default provider label stamped onto every model this SDK produces. */
+const MISTRAL_PROVIDER = "mistral";
+/**
+* Mistral-backed implementation of `SDKAdapterContract`.
+*
+* **Role.** The package entry point for Mistral AI chat + embeddings.
+* Mistral exposes an **OpenAI-compatible** API (`/v1/chat/completions`,
+* `/v1/embeddings`), so `MistralSDK` is a *thin wrapper* over the
+* battle-tested {@link OpenAISDK} — it does NOT re-implement the wire
+* protocol, streaming loop, tool-call accumulation, structured-output
+* mapping, error wrapping, or token accounting. It constructs one
+* internal `OpenAISDK` pointed at Mistral's `baseURL` with
+* `provider: "mistral"`, and delegates `model()` / `embedder()` /
+* `count()` straight to it.
+*
+* **What this wrapper adds on top of the OpenAI adapter:**
+* - **Defaults.** Injects Mistral's `baseURL` + `provider` label and a
+*   default {@link MISTRAL_DEFAULT_PRICING} registry so cost truth works
+*   out of the box. All are overridable via config.
+* - **Provider-correct capability inference.** Mistral's model names
+*   aren't OpenAI names, so the OpenAI prefix lists never match. Before
+*   delegating `model()`, this wrapper infers `vision` (the `pixtral`
+*   family + recent multimodal generations) and `reasoning` (the
+*   `magistral` family + hybrid `mistral-small`) from *this provider's*
+*   fragment lists and passes them as explicit overrides — which the
+*   inner `OpenAISDK` honors verbatim. A caller-supplied explicit
+*   `vision` / `reasoning` still wins.
+*
+* Construct one SDK per account and reuse it everywhere; the single
+* underlying `OpenAI` client (connection pool, auth, rate-limit state)
+* is shared by every model / embedder produced here.
+*
+* **Note — no image generation.** Mistral has no OpenAI-compatible image
+* endpoint, so `image()` is intentionally NOT exposed. The structural
+* absence of the method IS the capability guard (see
+* `SDKAdapterContract.image`): `ai.mistral.image(...)` is a compile-time
+* error rather than a runtime failure.
+*
+* @example
+* const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });
+* const model = mistral.model({ name: "mistral-large-latest", temperature: 0.7 });
+* const embedder = mistral.embedder({ name: "mistral-embed" });
+*
+* @example
+* // Compose into an `ai.mistral` namespace for ergonomic agent wiring.
+* const ai = { agent, tool, systemPrompt, mistral: new MistralSDK({ apiKey }) };
+* const reasoner = ai.agent({ model: ai.mistral.model({ name: "magistral-medium-latest" }) });
+*/
+var MistralSDK = class {
+	constructor(config) {
+		const { provider, baseURL, pricing, ...clientOptions } = config;
+		const mergedPricing = {
+			...MISTRAL_DEFAULT_PRICING,
+			...pricing
+		};
+		this.openai = new OpenAISDK({
+			...clientOptions,
+			baseURL: baseURL ?? MISTRAL_BASE_URL,
+			provider: provider ?? MISTRAL_PROVIDER,
+			pricing: mergedPricing
+		});
+	}
+	/**
+	* Build a `ModelContract` for a Mistral chat model.
+	*
+	* Delegates to the inner `OpenAISDK.model()` but first injects
+	* **Mistral-aware capability inference**: when the caller omits
+	* `vision` / `reasoning`, they're inferred from this provider's family
+	* fragments (`pixtral` → vision, `magistral` / `mistral-small` →
+	* reasoning, see `known-models.ts`) and passed down as explicit
+	* overrides. Without this step the wrapped OpenAI adapter would check
+	* Mistral ids against OpenAI prefixes (`gpt-4o`, `o3`, …) and wrongly
+	* report every Mistral model as non-vision / non-reasoning.
+	*
+	* A caller-supplied explicit `vision` / `reasoning` is preserved as-is
+	* (explicit config always wins over inference). Pricing resolution is
+	* handled downstream by `OpenAISDK` against the merged registry:
+	* per-model `pricing` > SDK registry (caller + Mistral defaults) >
+	* `undefined`.
+	*/
+	model(config) {
+		const resolvedConfig = {
+			...config,
+			vision: config.vision ?? inferVisionCapability(config.name),
+			reasoning: config.reasoning ?? inferReasoningCapability(config.name)
+		};
+		return this.openai.model(resolvedConfig);
+	}
+	/**
+	* Rough offline token-count estimate. Delegates to the wrapped
+	* `OpenAISDK.count()` (the shared character-heuristic from the core
+	* package) — good for budgeting / quota guards, not billing. The
+	* optional model id is forwarded but currently ignored.
+	*/
+	async count(text, model) {
+		return this.openai.count(text, model);
+	}
+	/**
+	* Build an `EmbedderContract` bound to this SDK's client. Mistral
+	* serves embeddings (`mistral-embed`) through the OpenAI-compatible
+	* `/v1/embeddings` endpoint, so this delegates straight to
+	* `OpenAISDK.embedder()`.
+	*
+	* @example
+	* const embedder = mistral.embedder({ name: "mistral-embed" });
+	* const { vector } = await embedder.embed("Hello world");
+	*/
+	embedder(config) {
+		return this.openai.embedder(config);
+	}
+};
+
+//#endregion
+export { MistralSDK };
+//# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-mistral/src/sdk.ts"],"sourcesContent":["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":";;;;;AAgBA,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,IAAI,UAAU;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/llms-full.txt

@@ -0,0 +1,105 @@
+# Warlock AI Mistral — full skills
+
+> Package: `@warlock.js/ai-mistral`
+
+> Generated artifact. Concatenates every SKILL.md and reference file under `@warlock.js/ai-mistral/skills/`. Re-run `node scripts/generate-llms.mjs` after any change.
+
+## setup-mistral  `@warlock.js/ai-mistral/setup-mistral/SKILL.md`
+
+---
+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 `@warlock.js/ai/run-ai-agent/SKILL.md`; embedder usage `@warlock.js/ai/embed-text/SKILL.md`; provider picking `@warlock.js/ai/pick-ai-provider/SKILL.md`; 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`
+
+Provider adapter for Mistral AI. Mistral exposes an **OpenAI-compatible** API, so `MistralSDK` is a **thin wrapper** over [`@warlock.js/ai-openai`](@warlock.js/ai-openai/skills/setup-openai/SKILL.md) — it does not re-implement the wire protocol, streaming, tool calls, structured output, error wrapping, or token accounting. It builds one internal `OpenAISDK` pointed at Mistral's `baseURL` with `provider: "mistral"`, then layers on this provider's own capability inference + default pricing. Pair with `@warlock.js/ai` for the agent / tool / system-prompt surface.
+
+## Construction
+
+```ts
+import { MistralSDK } from "@warlock.js/ai-mistral";
+
+const mistral = new MistralSDK({ apiKey: process.env.MISTRAL_API_KEY! });
+```
+
+`baseURL` defaults to `https://api.mistral.ai/v1` (the OpenAI-compatible endpoint serving `/chat/completions` and `/embeddings`). `provider` defaults to `"mistral"` and flows through to `ModelContract.provider`, `AgentReport.model.provider`, and logs. Override `baseURL` only to reach a Mistral-compatible gateway/proxy. Every other upstream OpenAI `ClientOptions` value (`timeout`, `maxRetries`, `defaultHeaders`, `fetch`, …) is forwarded verbatim.
+
+## 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
+```
+
+Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
+
+## Capabilities — what's auto-set
+
+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 }`). |
+
+**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`).
+
+The headline `-latest` aliases are exported as `MISTRAL_MODELS` ({ chat, vision, reasoning, embedding }) for convenience — `mistral.model()` also accepts any version-pinned id (`mistral-large-2512`, `magistral-medium-2509`).
+
+## Uses the OpenAI-compatible endpoint
+
+Because Mistral speaks the OpenAI Chat Completions + Embeddings protocol, everything the OpenAI adapter does applies unchanged: streaming deltas + consolidated tool calls, `response_format: json_schema` structured output (override per model with `responseFormat`), `reasoning_effort` for reasoning models, multipart image input, and the neutral `Usage` breakdown (`input` / `output` / `cachedTokens` / `reasoningTokens`). See [`@warlock.js/ai-openai`](@warlock.js/ai-openai/skills/setup-openai/SKILL.md) for the wire-level detail — it is identical here.
+
+**No image generation.** Mistral has no OpenAI-compatible image endpoint, so `MistralSDK` intentionally does **not** expose `image()` — the structural absence is the capability guard (`ai.mistral.image(...)` is a compile-time error).
+
+## Embeddings
+
+```ts
+const embedder = mistral.embedder({ name: "mistral-embed" });
+
+const { vector, dimensions, usage } = await embedder.embed("Hello world");
+const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
+```
+
+`mistral-embed` is reachable through the OpenAI-compatible `/v1/embeddings`; the embedder delegates to the wrapped OpenAI embedder.
+
+## 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:
+
+```ts
+const mistral = new MistralSDK({
+  apiKey,
+  pricing: {
+    // USD per 1M tokens — billing-grade overrides.
+    "mistral-large-latest":    { input: 2,   output: 6 },
+    "magistral-medium-latest": { input: 2,   output: 5 },
+  },
+});
+```
+
+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.
+
+## 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 [`@warlock.js/ai/handle-ai-errors/SKILL.md`](@warlock.js/ai/handle-ai-errors/SKILL.md).
+
+## When NOT to use this skill
+
+- Image generation — Mistral has no OpenAI-compatible image endpoint; `mistral.image()` does not exist.
+- Other providers — OpenAI `@warlock.js/ai-openai`, Gemini `@warlock.js/ai-google`, Anthropic `@warlock.js/ai-anthropic`, Bedrock `@warlock.js/ai-bedrock`, Ollama `@warlock.js/ai-ollama`.
+- Raw `@mistralai/mistralai` SDK or Vercel `@ai-sdk/mistral` without going through `@warlock.js/ai` agents.
+
+## See also
+
+- [`@warlock.js/ai-openai/skills/setup-openai/SKILL.md`](@warlock.js/ai-openai/skills/setup-openai/SKILL.md) — the wrapped adapter; identical wire behavior.
+- [`@warlock.js/ai/run-ai-agent/SKILL.md`](@warlock.js/ai/run-ai-agent/SKILL.md) — passing the model into `ai.agent({...})`.
+- [`@warlock.js/ai/pick-ai-provider/SKILL.md`](@warlock.js/ai/pick-ai-provider/SKILL.md) — adapter comparison.
+
+

package/llms.txt

@@ -0,0 +1,9 @@
+# Warlock AI Mistral
+
+> Package: `@warlock.js/ai-mistral`
+
+> Mistral AI adapter for @warlock.js/ai (OpenAI-compatible)
+
+## 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 `@warlock.js/ai/run-ai-agent/SKILL.md`; embedder usage `@warlock.js/ai/embed-text/SKILL.md`; provider picking `@warlock.js/ai/pick-ai-provider/SKILL.md`; 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

@@ -0,0 +1,40 @@
+{
+  "name": "@warlock.js/ai-mistral",
+  "description": "Mistral AI adapter for @warlock.js/ai (OpenAI-compatible)",
+  "keywords": [
+    "warlock",
+    "ai",
+    "mistral",
+    "pixtral",
+    "magistral"
+  ],
+  "author": "Hasan Zohdy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/warlockjs/ai-mistral"
+  },
+  "dependencies": {
+    "@warlock.js/ai-openai": "4.6.0",
+    "@warlock.js/logger": "4.6.0"
+  },
+  "peerDependencies": {
+    "@warlock.js/ai": "4.6.0"
+  },
+  "version": "4.6.0",
+  "main": "./cjs/index.cjs",
+  "module": "./esm/index.mjs",
+  "types": "./esm/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.mjs"
+      },
+      "require": {
+        "types": "./esm/index.d.mts",
+        "default": "./cjs/index.cjs"
+      }
+    }
+  }
+}