@hiper2d/ai-agents 0.5.2 → 0.6.0

package/dist/index.d.mts

@@ -363,10 +363,8 @@ declare const LLM_CONSTANTS: {
     GEMINI_PRO: string;
     GEMINI_FLASH: string;
     GEMINI_LITE: string;
-    MISTRAL_LARGE: string;
     MISTRAL_MEDIUM: string;
     MISTRAL_SMALL: string;
-    MISTRAL_MAGISTRAL: string;
     GROK: string;
     KIMI: string;
     GLM: string;
@@ -482,7 +480,7 @@ declare const DEEPSEEK_PEAK_SCHEDULE: PeakPricing;
 declare const MODEL_PRICING: Record<string, ModelPricing>;
 /** True for hybrid thinking-only models — the ones whose effective output price is a known
  *  multiple of the sticker price. Always-on reasoning models (GPT-5, Gemini, Grok, Kimi,
- *  Fable, Magistral) also burn reasoning tokens, but their multiplier hasn't been measured. */
+ *  Fable) also burn reasoning tokens, but their multiplier hasn't been measured. */
 declare function isHybridThinkingModel(modelApiName: string): boolean;
 interface CostCalculationOptions {
     cacheHitTokens?: number;
@@ -532,8 +530,13 @@ declare function getProviderSignatureFields(aiType: string, signature?: string):
  * - Sakana Fugu: high|xhigh
  * - Meta Muse Spark (verified 2026-09-12): minimal|low|medium|high|xhigh|max ("none" → 400; max is
  *   Standard tier only)
- * Qwen accepts reasoning_effort but ignores it (thinking_budget is its knob); MiniMax, Kimi,
- * Grok and Mistral expose no effort parameter.
+ * - Mistral Small 4 / Medium 3.5 (verified 2026-09-18): the API enum is
+ *   none|minimal|low|medium|high|xhigh, with reasoning OFF unless the field is sent. "none" is
+ *   not on the shared scale and means "don't reason", which an agent expresses by omitting the
+ *   field, so the exported slice starts at minimal. Only "high" is documented to return the
+ *   thinking chunk; the intermediate levels are accepted but unverified.
+ * Qwen accepts reasoning_effort but ignores it (thinking_budget is its knob); MiniMax, Kimi and
+ * Grok expose no effort parameter.
  */
 type OpenAIReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 type AnthropicReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
@@ -542,6 +545,7 @@ type GlmReasoningEffort = 'low' | 'high' | 'max';
 type DeepSeekReasoningEffort = 'low' | 'high' | 'max';
 type FuguReasoningEffort = 'high' | 'xhigh';
 type MetaReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type MistralReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 /** The shared scale, lowest first. */
 declare const REASONING_EFFORT_SCALE: readonly ReasoningEffort[];
 declare const OPENAI_REASONING_EFFORTS: readonly OpenAIReasoningEffort[];
@@ -551,6 +555,7 @@ declare const GLM_REASONING_EFFORTS: readonly GlmReasoningEffort[];
 declare const DEEPSEEK_REASONING_EFFORTS: readonly DeepSeekReasoningEffort[];
 declare const FUGU_REASONING_EFFORTS: readonly FuguReasoningEffort[];
 declare const META_REASONING_EFFORTS: readonly MetaReasoningEffort[];
+declare const MISTRAL_REASONING_EFFORTS: readonly MistralReasoningEffort[];
 /** Clamps `effort` to the nearest level in `allowed` (by rank on the shared scale, ties go up). */
 declare function clampReasoningEffort<T extends ReasoningEffort>(effort: ReasoningEffort, allowed: readonly T[]): T;
 declare const toOpenAIEffort: (effort: ReasoningEffort) => OpenAIReasoningEffort;
@@ -560,6 +565,7 @@ declare const toGlmEffort: (effort: ReasoningEffort) => GlmReasoningEffort;
 declare const toDeepSeekEffort: (effort: ReasoningEffort) => DeepSeekReasoningEffort;
 declare const toMetaEffort: (effort: ReasoningEffort) => MetaReasoningEffort;
 declare const toFuguEffort: (effort: ReasoningEffort) => FuguReasoningEffort;
+declare const toMistralEffort: (effort: ReasoningEffort) => MistralReasoningEffort;
 
 /**
  * Unified token usage utilities for all AI providers
@@ -641,8 +647,10 @@ declare function extractAnthropicTokenUsage(response: any): TokenUsage | null;
 declare function extractGoogleTokenUsage(response: any): TokenUsage | null;
 /**
  * Mistral-specific token usage extraction
- * Mistral SDK uses camelCase (promptTokens, completionTokens, totalTokens)
- * and reasoning tokens may be in additionalProperties for Magistral models
+ * Mistral SDK uses camelCase (promptTokens, completionTokens, totalTokens). Reasoning tokens
+ * are not itemised today (they sit inside completionTokens, observed 2026-09-18 on Small 4 and
+ * Medium 3.5 with reasoning_effort: high); the additionalProperties probe below stays in case
+ * a reasoning_tokens field ever appears.
  */
 declare function extractMistralTokenUsage(response: any): TokenUsage | null;
 
@@ -1417,12 +1425,36 @@ declare class GoogleAgent extends AbstractAgent {
     private handleGeminiError;
 }
 
+/**
+ * Mistral agent (Mistral SDK chat.complete) for the hybrid Small 4 / Medium 3.5 models.
+ *
+ * Reasoning is off on the API by default and switched on per request with `reasoning_effort`
+ * (docs.mistral.ai/studio/conversations/reasoning). SDK 1.x has no typed field for it, so it is
+ * injected into the wire body by the same beforeRequest hook that adds `prompt_cache_key`.
+ * With it set, the assistant message comes back as content chunks — a `thinking` chunk (a list
+ * of text chunks holding the trace) followed by the `text` answer — and this works together
+ * with json_schema structured output (verified live 2026-09-18 on both models). Without the
+ * field the reply is a plain string and no trace exists.
+ *
+ * Multi-turn: Mistral asks that the full assistant message, thinking chunk included, be
+ * replayed into history ("stripping reasoning traces degrades performance"). The trace is
+ * plain text, so it rides on `AIMessage.thinking` — no provider signature field — and
+ * convertToMistralMessages rebuilds each prior assistant turn as [thinking, text] chunks.
+ *
+ * Reasoning tokens are counted inside completion_tokens; no separate reasoning_tokens field
+ * arrives, so cost accounting on the output rate already covers the trace.
+ */
 declare class MistralAgent extends AbstractAgent {
     private readonly client;
     private get defaultParams();
     private readonly logTemplates;
     private readonly errorMessages;
     constructor(name: string, instruction: string, model: string, apiKey: string, enableThinking?: boolean, agentLoggingConfig?: AgentLoggingConfig);
+    /**
+     * History in Mistral's shape. A prior assistant turn that carries a stored trace is
+     * replayed as [thinking, text] chunks, as Mistral's multi-turn guidance asks; every other
+     * turn is a plain string.
+     */
     private convertToMistralMessages;
     private processReply;
     private processStructuredReply;
@@ -1438,9 +1470,8 @@ declare class MistralAgent extends AbstractAgent {
      */
     doAskWithZodSchema<T>(zodSchema: z.ZodSchema<T>, messages: AIMessage[]): Promise<[T, string, TokenUsage$1?, string?]>;
     /**
-     * Plain-text ask: no schema appended, no responseFormat. Note that Magistral
-     * reasoning models only return thinking traces when responseFormat is NOT
-     * json_object, so unlike askWithZodSchema this path can surface thinking content.
+     * Plain-text ask: no schema appended, no responseFormat. Reasoning (and the trace) works
+     * the same way as on the schema path.
      */
     doAskText(messages: AIMessage[]): Promise<[string, string, TokenUsage$1?, string?]>;
 }
@@ -1690,4 +1721,4 @@ declare class MiniMaxAgent extends AbstractAgent {
     doAskText(messages: AIMessage[]): Promise<[string, string, TokenUsage$1?, string?]>;
 }
 
-export { type AIMessage, ANTHROPIC_REASONING_EFFORTS, API_KEY_CONSTANTS, AbstractAgent, type AgentActivityData, AgentFactory, type AgentLoggingConfig, type AnthropicReasoningEffort, type AnthropicTokenUsage, type ApiKeyMap, type BeforeAskHook, BotResponseError, BudgetController, type BudgetControllerOptions, BudgetExceededError, type BudgetLimit, type BudgetVerdict, CACHE_TIER_MARKER, ClaudeAgent, type CostCalculationOptions, DEEPSEEK_PEAK_SCHEDULE, DEEPSEEK_REASONING_EFFORTS, DEFAULT_LOGGING_CONFIG, DEFAULT_MAX_OUTPUT_TOKENS, type DeepSeekReasoningEffort, type DeepSeekTokenUsage, DeepSeekV2Agent, FUGU_REASONING_EFFORTS, FuguAgent, type FuguReasoningEffort, GEMINI_AUDIO_TOKENS_PER_SECOND, GEMINI_REASONING_EFFORTS, GLM_REASONING_EFFORTS, type GeminiReasoningEffort, GlmAgent, type GlmReasoningEffort, GoogleAgent, type GoogleSttOptions, type GoogleSttResult, type GoogleTokenUsage, type GoogleTtsAudioOptions, type GoogleTtsResult, GoogleVoiceAgent, Gpt5Agent, GrokAgent, type GrokTokenUsage, InMemorySpendStore, type JsonSchemaOptions, KimiAgent, type KimiTokenUsage, type LLMModel, LLM_CONSTANTS, type LlmLogger, type LoggingConfig, MESSAGE_ROLE, META_REASONING_EFFORTS, MODEL_PRICING, MetaAgent, type MetaReasoningEffort, type MetaTokenUsage, MiniMaxAgent, MistralAgent, type MistralTokenUsage, type Modality, ModelAuthenticationError, type ModelConfig, ModelError, ModelInvalidResponseError, ModelOverloadError, type ModelPricing, ModelQuotaExceededError, ModelRateLimitError, ModelRefusalError, type ModelTag, ModelUnavailableError, OPENAI_REASONING_EFFORTS, type OpenAIReasoningEffort, type OpenAITokenUsage, type OpenAiSttOptions, type OpenAiSttResult, type OpenAiTtsAudioOptions, type OpenAiTtsVoice, OpenAiVoiceAgent, type PeakPricing, type PricingUnit, type ProviderSchema, type TokenUsage as ProviderTokenUsage, type ProviderType, QwenAgent, REASONING_EFFORT_SCALE, type ReasoningEffort, SUPPORTED_VOICE_PROVIDERS, type SpeechRequest, type SpeechResult, type SpeechUsage, type SpendInput, type SpendKind, type SpendLedger, type SpendLedgers, type SpendStore, type SpendWindow, SupportedAiKeyNames, SupportedAiModels, type TokenPairUsage, type TokenUsage$1 as TokenUsage, type TranscriptionRequest, type TranscriptionResult, type TranscriptionUsage, VOICE_MODEL_CONSTANTS, VOICE_MODEL_PRICING, VOICE_PROVIDER_API_KEY, type VoiceAgent, VoiceAgentFactory, type VoiceModelPricing, type VoiceProvider, ZodSchemaConverter, applySpend, buildGoogleTtsPrompt, calculateAnthropicCost, calculateCost, calculateDeepSeekCost, calculateGeminiSttCost, calculateGeminiTtsCost, calculateGoogleCost, calculateGrokCost, calculateKimiCost, calculateMetaCost, calculateMistralCost, calculateModelCost, calculateOpenAICost, calculateOpenAiSttCost, calculateOpenAiTtsCost, clampReasoningEffort, cleanResponse, createCatalog, createVoiceAgent, describeEmptyTtsResponse, evaluateBudget, extractAnthropicTokenUsage, extractTokenUsageFromResponse$2 as extractAnthropicTokenUsageFromResponse, extractDeepSeekTokenUsage, extractTokenUsageFromResponse$6 as extractDeepSeekTokenUsageFromResponse, extractFirstJsonObject, extractGoogleTokenUsage, extractTokenUsageFromResponse$1 as extractGoogleTokenUsageFromResponse, extractGrokTokenUsage, extractTokenUsageFromResponse$4 as extractGrokTokenUsageFromResponse, extractKimiTokenUsage, extractTokenUsageFromResponse$5 as extractKimiTokenUsageFromResponse, extractMetaTokenUsage, extractTokenUsageFromResponse$3 as extractMetaTokenUsageFromResponse, extractMistralTokenUsage, extractTokenUsageFromResponse as extractMistralTokenUsageFromResponse, extractOpenAITokenUsage, extractTokenUsageFromResponse$7 as extractOpenAITokenUsageFromResponse, extractTokenUsage, extractUsageAndCalculateCost, firstRefusal, generateGoogleTtsAudio, generateOpenAiTtsAudio, generateSchemaInstructions, getModelConfigByApiName, getModelDisplayName, getModelProviderName, getModelTags, getProviderSignatureFields, isBudgetExceededError, isHybridThinkingModel, isInPeakWindow, isPeakBilling, isWeekendAt, ledgerSpend, logger, mergeThinking, modelHasTag, modelIsFast, needsPromptBasedSchema, parseAndValidateLlmJson, pcmToWav, periodEnd, periodKey, safeValidateResponse, setBeforeAskHook, setLlmLogger, stableHashHex, stripInlineThinking, supportsNativeJsonSchema, toAnthropicEffort, toDeepSeekEffort, toFuguEffort, toGeminiEffort, toGlmEffort, toMetaEffort, toOpenAIEffort, transcribeWithGemini, transcribeWithOpenAi, validateResponse };
+export { type AIMessage, ANTHROPIC_REASONING_EFFORTS, API_KEY_CONSTANTS, AbstractAgent, type AgentActivityData, AgentFactory, type AgentLoggingConfig, type AnthropicReasoningEffort, type AnthropicTokenUsage, type ApiKeyMap, type BeforeAskHook, BotResponseError, BudgetController, type BudgetControllerOptions, BudgetExceededError, type BudgetLimit, type BudgetVerdict, CACHE_TIER_MARKER, ClaudeAgent, type CostCalculationOptions, DEEPSEEK_PEAK_SCHEDULE, DEEPSEEK_REASONING_EFFORTS, DEFAULT_LOGGING_CONFIG, DEFAULT_MAX_OUTPUT_TOKENS, type DeepSeekReasoningEffort, type DeepSeekTokenUsage, DeepSeekV2Agent, FUGU_REASONING_EFFORTS, FuguAgent, type FuguReasoningEffort, GEMINI_AUDIO_TOKENS_PER_SECOND, GEMINI_REASONING_EFFORTS, GLM_REASONING_EFFORTS, type GeminiReasoningEffort, GlmAgent, type GlmReasoningEffort, GoogleAgent, type GoogleSttOptions, type GoogleSttResult, type GoogleTokenUsage, type GoogleTtsAudioOptions, type GoogleTtsResult, GoogleVoiceAgent, Gpt5Agent, GrokAgent, type GrokTokenUsage, InMemorySpendStore, type JsonSchemaOptions, KimiAgent, type KimiTokenUsage, type LLMModel, LLM_CONSTANTS, type LlmLogger, type LoggingConfig, MESSAGE_ROLE, META_REASONING_EFFORTS, MISTRAL_REASONING_EFFORTS, MODEL_PRICING, MetaAgent, type MetaReasoningEffort, type MetaTokenUsage, MiniMaxAgent, MistralAgent, type MistralReasoningEffort, type MistralTokenUsage, type Modality, ModelAuthenticationError, type ModelConfig, ModelError, ModelInvalidResponseError, ModelOverloadError, type ModelPricing, ModelQuotaExceededError, ModelRateLimitError, ModelRefusalError, type ModelTag, ModelUnavailableError, OPENAI_REASONING_EFFORTS, type OpenAIReasoningEffort, type OpenAITokenUsage, type OpenAiSttOptions, type OpenAiSttResult, type OpenAiTtsAudioOptions, type OpenAiTtsVoice, OpenAiVoiceAgent, type PeakPricing, type PricingUnit, type ProviderSchema, type TokenUsage as ProviderTokenUsage, type ProviderType, QwenAgent, REASONING_EFFORT_SCALE, type ReasoningEffort, SUPPORTED_VOICE_PROVIDERS, type SpeechRequest, type SpeechResult, type SpeechUsage, type SpendInput, type SpendKind, type SpendLedger, type SpendLedgers, type SpendStore, type SpendWindow, SupportedAiKeyNames, SupportedAiModels, type TokenPairUsage, type TokenUsage$1 as TokenUsage, type TranscriptionRequest, type TranscriptionResult, type TranscriptionUsage, VOICE_MODEL_CONSTANTS, VOICE_MODEL_PRICING, VOICE_PROVIDER_API_KEY, type VoiceAgent, VoiceAgentFactory, type VoiceModelPricing, type VoiceProvider, ZodSchemaConverter, applySpend, buildGoogleTtsPrompt, calculateAnthropicCost, calculateCost, calculateDeepSeekCost, calculateGeminiSttCost, calculateGeminiTtsCost, calculateGoogleCost, calculateGrokCost, calculateKimiCost, calculateMetaCost, calculateMistralCost, calculateModelCost, calculateOpenAICost, calculateOpenAiSttCost, calculateOpenAiTtsCost, clampReasoningEffort, cleanResponse, createCatalog, createVoiceAgent, describeEmptyTtsResponse, evaluateBudget, extractAnthropicTokenUsage, extractTokenUsageFromResponse$2 as extractAnthropicTokenUsageFromResponse, extractDeepSeekTokenUsage, extractTokenUsageFromResponse$6 as extractDeepSeekTokenUsageFromResponse, extractFirstJsonObject, extractGoogleTokenUsage, extractTokenUsageFromResponse$1 as extractGoogleTokenUsageFromResponse, extractGrokTokenUsage, extractTokenUsageFromResponse$4 as extractGrokTokenUsageFromResponse, extractKimiTokenUsage, extractTokenUsageFromResponse$5 as extractKimiTokenUsageFromResponse, extractMetaTokenUsage, extractTokenUsageFromResponse$3 as extractMetaTokenUsageFromResponse, extractMistralTokenUsage, extractTokenUsageFromResponse as extractMistralTokenUsageFromResponse, extractOpenAITokenUsage, extractTokenUsageFromResponse$7 as extractOpenAITokenUsageFromResponse, extractTokenUsage, extractUsageAndCalculateCost, firstRefusal, generateGoogleTtsAudio, generateOpenAiTtsAudio, generateSchemaInstructions, getModelConfigByApiName, getModelDisplayName, getModelProviderName, getModelTags, getProviderSignatureFields, isBudgetExceededError, isHybridThinkingModel, isInPeakWindow, isPeakBilling, isWeekendAt, ledgerSpend, logger, mergeThinking, modelHasTag, modelIsFast, needsPromptBasedSchema, parseAndValidateLlmJson, pcmToWav, periodEnd, periodKey, safeValidateResponse, setBeforeAskHook, setLlmLogger, stableHashHex, stripInlineThinking, supportsNativeJsonSchema, toAnthropicEffort, toDeepSeekEffort, toFuguEffort, toGeminiEffort, toGlmEffort, toMetaEffort, toMistralEffort, toOpenAIEffort, transcribeWithGemini, transcribeWithOpenAi, validateResponse };

package/dist/index.d.ts

@@ -363,10 +363,8 @@ declare const LLM_CONSTANTS: {
     GEMINI_PRO: string;
     GEMINI_FLASH: string;
     GEMINI_LITE: string;
-    MISTRAL_LARGE: string;
     MISTRAL_MEDIUM: string;
     MISTRAL_SMALL: string;
-    MISTRAL_MAGISTRAL: string;
     GROK: string;
     KIMI: string;
     GLM: string;
@@ -482,7 +480,7 @@ declare const DEEPSEEK_PEAK_SCHEDULE: PeakPricing;
 declare const MODEL_PRICING: Record<string, ModelPricing>;
 /** True for hybrid thinking-only models — the ones whose effective output price is a known
  *  multiple of the sticker price. Always-on reasoning models (GPT-5, Gemini, Grok, Kimi,
- *  Fable, Magistral) also burn reasoning tokens, but their multiplier hasn't been measured. */
+ *  Fable) also burn reasoning tokens, but their multiplier hasn't been measured. */
 declare function isHybridThinkingModel(modelApiName: string): boolean;
 interface CostCalculationOptions {
     cacheHitTokens?: number;
@@ -532,8 +530,13 @@ declare function getProviderSignatureFields(aiType: string, signature?: string):
  * - Sakana Fugu: high|xhigh
  * - Meta Muse Spark (verified 2026-09-12): minimal|low|medium|high|xhigh|max ("none" → 400; max is
  *   Standard tier only)
- * Qwen accepts reasoning_effort but ignores it (thinking_budget is its knob); MiniMax, Kimi,
- * Grok and Mistral expose no effort parameter.
+ * - Mistral Small 4 / Medium 3.5 (verified 2026-09-18): the API enum is
+ *   none|minimal|low|medium|high|xhigh, with reasoning OFF unless the field is sent. "none" is
+ *   not on the shared scale and means "don't reason", which an agent expresses by omitting the
+ *   field, so the exported slice starts at minimal. Only "high" is documented to return the
+ *   thinking chunk; the intermediate levels are accepted but unverified.
+ * Qwen accepts reasoning_effort but ignores it (thinking_budget is its knob); MiniMax, Kimi and
+ * Grok expose no effort parameter.
  */
 type OpenAIReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 type AnthropicReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
@@ -542,6 +545,7 @@ type GlmReasoningEffort = 'low' | 'high' | 'max';
 type DeepSeekReasoningEffort = 'low' | 'high' | 'max';
 type FuguReasoningEffort = 'high' | 'xhigh';
 type MetaReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type MistralReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 /** The shared scale, lowest first. */
 declare const REASONING_EFFORT_SCALE: readonly ReasoningEffort[];
 declare const OPENAI_REASONING_EFFORTS: readonly OpenAIReasoningEffort[];
@@ -551,6 +555,7 @@ declare const GLM_REASONING_EFFORTS: readonly GlmReasoningEffort[];
 declare const DEEPSEEK_REASONING_EFFORTS: readonly DeepSeekReasoningEffort[];
 declare const FUGU_REASONING_EFFORTS: readonly FuguReasoningEffort[];
 declare const META_REASONING_EFFORTS: readonly MetaReasoningEffort[];
+declare const MISTRAL_REASONING_EFFORTS: readonly MistralReasoningEffort[];
 /** Clamps `effort` to the nearest level in `allowed` (by rank on the shared scale, ties go up). */
 declare function clampReasoningEffort<T extends ReasoningEffort>(effort: ReasoningEffort, allowed: readonly T[]): T;
 declare const toOpenAIEffort: (effort: ReasoningEffort) => OpenAIReasoningEffort;
@@ -560,6 +565,7 @@ declare const toGlmEffort: (effort: ReasoningEffort) => GlmReasoningEffort;
 declare const toDeepSeekEffort: (effort: ReasoningEffort) => DeepSeekReasoningEffort;
 declare const toMetaEffort: (effort: ReasoningEffort) => MetaReasoningEffort;
 declare const toFuguEffort: (effort: ReasoningEffort) => FuguReasoningEffort;
+declare const toMistralEffort: (effort: ReasoningEffort) => MistralReasoningEffort;
 
 /**
  * Unified token usage utilities for all AI providers
@@ -641,8 +647,10 @@ declare function extractAnthropicTokenUsage(response: any): TokenUsage | null;
 declare function extractGoogleTokenUsage(response: any): TokenUsage | null;
 /**
  * Mistral-specific token usage extraction
- * Mistral SDK uses camelCase (promptTokens, completionTokens, totalTokens)
- * and reasoning tokens may be in additionalProperties for Magistral models
+ * Mistral SDK uses camelCase (promptTokens, completionTokens, totalTokens). Reasoning tokens
+ * are not itemised today (they sit inside completionTokens, observed 2026-09-18 on Small 4 and
+ * Medium 3.5 with reasoning_effort: high); the additionalProperties probe below stays in case
+ * a reasoning_tokens field ever appears.
  */
 declare function extractMistralTokenUsage(response: any): TokenUsage | null;
 
@@ -1417,12 +1425,36 @@ declare class GoogleAgent extends AbstractAgent {
     private handleGeminiError;
 }
 
+/**
+ * Mistral agent (Mistral SDK chat.complete) for the hybrid Small 4 / Medium 3.5 models.
+ *
+ * Reasoning is off on the API by default and switched on per request with `reasoning_effort`
+ * (docs.mistral.ai/studio/conversations/reasoning). SDK 1.x has no typed field for it, so it is
+ * injected into the wire body by the same beforeRequest hook that adds `prompt_cache_key`.
+ * With it set, the assistant message comes back as content chunks — a `thinking` chunk (a list
+ * of text chunks holding the trace) followed by the `text` answer — and this works together
+ * with json_schema structured output (verified live 2026-09-18 on both models). Without the
+ * field the reply is a plain string and no trace exists.
+ *
+ * Multi-turn: Mistral asks that the full assistant message, thinking chunk included, be
+ * replayed into history ("stripping reasoning traces degrades performance"). The trace is
+ * plain text, so it rides on `AIMessage.thinking` — no provider signature field — and
+ * convertToMistralMessages rebuilds each prior assistant turn as [thinking, text] chunks.
+ *
+ * Reasoning tokens are counted inside completion_tokens; no separate reasoning_tokens field
+ * arrives, so cost accounting on the output rate already covers the trace.
+ */
 declare class MistralAgent extends AbstractAgent {
     private readonly client;
     private get defaultParams();
     private readonly logTemplates;
     private readonly errorMessages;
     constructor(name: string, instruction: string, model: string, apiKey: string, enableThinking?: boolean, agentLoggingConfig?: AgentLoggingConfig);
+    /**
+     * History in Mistral's shape. A prior assistant turn that carries a stored trace is
+     * replayed as [thinking, text] chunks, as Mistral's multi-turn guidance asks; every other
+     * turn is a plain string.
+     */
     private convertToMistralMessages;
     private processReply;
     private processStructuredReply;
@@ -1438,9 +1470,8 @@ declare class MistralAgent extends AbstractAgent {
      */
     doAskWithZodSchema<T>(zodSchema: z.ZodSchema<T>, messages: AIMessage[]): Promise<[T, string, TokenUsage$1?, string?]>;
     /**
-     * Plain-text ask: no schema appended, no responseFormat. Note that Magistral
-     * reasoning models only return thinking traces when responseFormat is NOT
-     * json_object, so unlike askWithZodSchema this path can surface thinking content.
+     * Plain-text ask: no schema appended, no responseFormat. Reasoning (and the trace) works
+     * the same way as on the schema path.
      */
     doAskText(messages: AIMessage[]): Promise<[string, string, TokenUsage$1?, string?]>;
 }
@@ -1690,4 +1721,4 @@ declare class MiniMaxAgent extends AbstractAgent {
     doAskText(messages: AIMessage[]): Promise<[string, string, TokenUsage$1?, string?]>;
 }
 
-export { type AIMessage, ANTHROPIC_REASONING_EFFORTS, API_KEY_CONSTANTS, AbstractAgent, type AgentActivityData, AgentFactory, type AgentLoggingConfig, type AnthropicReasoningEffort, type AnthropicTokenUsage, type ApiKeyMap, type BeforeAskHook, BotResponseError, BudgetController, type BudgetControllerOptions, BudgetExceededError, type BudgetLimit, type BudgetVerdict, CACHE_TIER_MARKER, ClaudeAgent, type CostCalculationOptions, DEEPSEEK_PEAK_SCHEDULE, DEEPSEEK_REASONING_EFFORTS, DEFAULT_LOGGING_CONFIG, DEFAULT_MAX_OUTPUT_TOKENS, type DeepSeekReasoningEffort, type DeepSeekTokenUsage, DeepSeekV2Agent, FUGU_REASONING_EFFORTS, FuguAgent, type FuguReasoningEffort, GEMINI_AUDIO_TOKENS_PER_SECOND, GEMINI_REASONING_EFFORTS, GLM_REASONING_EFFORTS, type GeminiReasoningEffort, GlmAgent, type GlmReasoningEffort, GoogleAgent, type GoogleSttOptions, type GoogleSttResult, type GoogleTokenUsage, type GoogleTtsAudioOptions, type GoogleTtsResult, GoogleVoiceAgent, Gpt5Agent, GrokAgent, type GrokTokenUsage, InMemorySpendStore, type JsonSchemaOptions, KimiAgent, type KimiTokenUsage, type LLMModel, LLM_CONSTANTS, type LlmLogger, type LoggingConfig, MESSAGE_ROLE, META_REASONING_EFFORTS, MODEL_PRICING, MetaAgent, type MetaReasoningEffort, type MetaTokenUsage, MiniMaxAgent, MistralAgent, type MistralTokenUsage, type Modality, ModelAuthenticationError, type ModelConfig, ModelError, ModelInvalidResponseError, ModelOverloadError, type ModelPricing, ModelQuotaExceededError, ModelRateLimitError, ModelRefusalError, type ModelTag, ModelUnavailableError, OPENAI_REASONING_EFFORTS, type OpenAIReasoningEffort, type OpenAITokenUsage, type OpenAiSttOptions, type OpenAiSttResult, type OpenAiTtsAudioOptions, type OpenAiTtsVoice, OpenAiVoiceAgent, type PeakPricing, type PricingUnit, type ProviderSchema, type TokenUsage as ProviderTokenUsage, type ProviderType, QwenAgent, REASONING_EFFORT_SCALE, type ReasoningEffort, SUPPORTED_VOICE_PROVIDERS, type SpeechRequest, type SpeechResult, type SpeechUsage, type SpendInput, type SpendKind, type SpendLedger, type SpendLedgers, type SpendStore, type SpendWindow, SupportedAiKeyNames, SupportedAiModels, type TokenPairUsage, type TokenUsage$1 as TokenUsage, type TranscriptionRequest, type TranscriptionResult, type TranscriptionUsage, VOICE_MODEL_CONSTANTS, VOICE_MODEL_PRICING, VOICE_PROVIDER_API_KEY, type VoiceAgent, VoiceAgentFactory, type VoiceModelPricing, type VoiceProvider, ZodSchemaConverter, applySpend, buildGoogleTtsPrompt, calculateAnthropicCost, calculateCost, calculateDeepSeekCost, calculateGeminiSttCost, calculateGeminiTtsCost, calculateGoogleCost, calculateGrokCost, calculateKimiCost, calculateMetaCost, calculateMistralCost, calculateModelCost, calculateOpenAICost, calculateOpenAiSttCost, calculateOpenAiTtsCost, clampReasoningEffort, cleanResponse, createCatalog, createVoiceAgent, describeEmptyTtsResponse, evaluateBudget, extractAnthropicTokenUsage, extractTokenUsageFromResponse$2 as extractAnthropicTokenUsageFromResponse, extractDeepSeekTokenUsage, extractTokenUsageFromResponse$6 as extractDeepSeekTokenUsageFromResponse, extractFirstJsonObject, extractGoogleTokenUsage, extractTokenUsageFromResponse$1 as extractGoogleTokenUsageFromResponse, extractGrokTokenUsage, extractTokenUsageFromResponse$4 as extractGrokTokenUsageFromResponse, extractKimiTokenUsage, extractTokenUsageFromResponse$5 as extractKimiTokenUsageFromResponse, extractMetaTokenUsage, extractTokenUsageFromResponse$3 as extractMetaTokenUsageFromResponse, extractMistralTokenUsage, extractTokenUsageFromResponse as extractMistralTokenUsageFromResponse, extractOpenAITokenUsage, extractTokenUsageFromResponse$7 as extractOpenAITokenUsageFromResponse, extractTokenUsage, extractUsageAndCalculateCost, firstRefusal, generateGoogleTtsAudio, generateOpenAiTtsAudio, generateSchemaInstructions, getModelConfigByApiName, getModelDisplayName, getModelProviderName, getModelTags, getProviderSignatureFields, isBudgetExceededError, isHybridThinkingModel, isInPeakWindow, isPeakBilling, isWeekendAt, ledgerSpend, logger, mergeThinking, modelHasTag, modelIsFast, needsPromptBasedSchema, parseAndValidateLlmJson, pcmToWav, periodEnd, periodKey, safeValidateResponse, setBeforeAskHook, setLlmLogger, stableHashHex, stripInlineThinking, supportsNativeJsonSchema, toAnthropicEffort, toDeepSeekEffort, toFuguEffort, toGeminiEffort, toGlmEffort, toMetaEffort, toOpenAIEffort, transcribeWithGemini, transcribeWithOpenAi, validateResponse };
+export { type AIMessage, ANTHROPIC_REASONING_EFFORTS, API_KEY_CONSTANTS, AbstractAgent, type AgentActivityData, AgentFactory, type AgentLoggingConfig, type AnthropicReasoningEffort, type AnthropicTokenUsage, type ApiKeyMap, type BeforeAskHook, BotResponseError, BudgetController, type BudgetControllerOptions, BudgetExceededError, type BudgetLimit, type BudgetVerdict, CACHE_TIER_MARKER, ClaudeAgent, type CostCalculationOptions, DEEPSEEK_PEAK_SCHEDULE, DEEPSEEK_REASONING_EFFORTS, DEFAULT_LOGGING_CONFIG, DEFAULT_MAX_OUTPUT_TOKENS, type DeepSeekReasoningEffort, type DeepSeekTokenUsage, DeepSeekV2Agent, FUGU_REASONING_EFFORTS, FuguAgent, type FuguReasoningEffort, GEMINI_AUDIO_TOKENS_PER_SECOND, GEMINI_REASONING_EFFORTS, GLM_REASONING_EFFORTS, type GeminiReasoningEffort, GlmAgent, type GlmReasoningEffort, GoogleAgent, type GoogleSttOptions, type GoogleSttResult, type GoogleTokenUsage, type GoogleTtsAudioOptions, type GoogleTtsResult, GoogleVoiceAgent, Gpt5Agent, GrokAgent, type GrokTokenUsage, InMemorySpendStore, type JsonSchemaOptions, KimiAgent, type KimiTokenUsage, type LLMModel, LLM_CONSTANTS, type LlmLogger, type LoggingConfig, MESSAGE_ROLE, META_REASONING_EFFORTS, MISTRAL_REASONING_EFFORTS, MODEL_PRICING, MetaAgent, type MetaReasoningEffort, type MetaTokenUsage, MiniMaxAgent, MistralAgent, type MistralReasoningEffort, type MistralTokenUsage, type Modality, ModelAuthenticationError, type ModelConfig, ModelError, ModelInvalidResponseError, ModelOverloadError, type ModelPricing, ModelQuotaExceededError, ModelRateLimitError, ModelRefusalError, type ModelTag, ModelUnavailableError, OPENAI_REASONING_EFFORTS, type OpenAIReasoningEffort, type OpenAITokenUsage, type OpenAiSttOptions, type OpenAiSttResult, type OpenAiTtsAudioOptions, type OpenAiTtsVoice, OpenAiVoiceAgent, type PeakPricing, type PricingUnit, type ProviderSchema, type TokenUsage as ProviderTokenUsage, type ProviderType, QwenAgent, REASONING_EFFORT_SCALE, type ReasoningEffort, SUPPORTED_VOICE_PROVIDERS, type SpeechRequest, type SpeechResult, type SpeechUsage, type SpendInput, type SpendKind, type SpendLedger, type SpendLedgers, type SpendStore, type SpendWindow, SupportedAiKeyNames, SupportedAiModels, type TokenPairUsage, type TokenUsage$1 as TokenUsage, type TranscriptionRequest, type TranscriptionResult, type TranscriptionUsage, VOICE_MODEL_CONSTANTS, VOICE_MODEL_PRICING, VOICE_PROVIDER_API_KEY, type VoiceAgent, VoiceAgentFactory, type VoiceModelPricing, type VoiceProvider, ZodSchemaConverter, applySpend, buildGoogleTtsPrompt, calculateAnthropicCost, calculateCost, calculateDeepSeekCost, calculateGeminiSttCost, calculateGeminiTtsCost, calculateGoogleCost, calculateGrokCost, calculateKimiCost, calculateMetaCost, calculateMistralCost, calculateModelCost, calculateOpenAICost, calculateOpenAiSttCost, calculateOpenAiTtsCost, clampReasoningEffort, cleanResponse, createCatalog, createVoiceAgent, describeEmptyTtsResponse, evaluateBudget, extractAnthropicTokenUsage, extractTokenUsageFromResponse$2 as extractAnthropicTokenUsageFromResponse, extractDeepSeekTokenUsage, extractTokenUsageFromResponse$6 as extractDeepSeekTokenUsageFromResponse, extractFirstJsonObject, extractGoogleTokenUsage, extractTokenUsageFromResponse$1 as extractGoogleTokenUsageFromResponse, extractGrokTokenUsage, extractTokenUsageFromResponse$4 as extractGrokTokenUsageFromResponse, extractKimiTokenUsage, extractTokenUsageFromResponse$5 as extractKimiTokenUsageFromResponse, extractMetaTokenUsage, extractTokenUsageFromResponse$3 as extractMetaTokenUsageFromResponse, extractMistralTokenUsage, extractTokenUsageFromResponse as extractMistralTokenUsageFromResponse, extractOpenAITokenUsage, extractTokenUsageFromResponse$7 as extractOpenAITokenUsageFromResponse, extractTokenUsage, extractUsageAndCalculateCost, firstRefusal, generateGoogleTtsAudio, generateOpenAiTtsAudio, generateSchemaInstructions, getModelConfigByApiName, getModelDisplayName, getModelProviderName, getModelTags, getProviderSignatureFields, isBudgetExceededError, isHybridThinkingModel, isInPeakWindow, isPeakBilling, isWeekendAt, ledgerSpend, logger, mergeThinking, modelHasTag, modelIsFast, needsPromptBasedSchema, parseAndValidateLlmJson, pcmToWav, periodEnd, periodKey, safeValidateResponse, setBeforeAskHook, setLlmLogger, stableHashHex, stripInlineThinking, supportsNativeJsonSchema, toAnthropicEffort, toDeepSeekEffort, toFuguEffort, toGeminiEffort, toGlmEffort, toMetaEffort, toMistralEffort, toOpenAIEffort, transcribeWithGemini, transcribeWithOpenAi, validateResponse };

package/dist/index.js

@@ -59,6 +59,7 @@ __export(src_exports, {
   LLM_CONSTANTS: () => LLM_CONSTANTS,
   MESSAGE_ROLE: () => MESSAGE_ROLE,
   META_REASONING_EFFORTS: () => META_REASONING_EFFORTS,
+  MISTRAL_REASONING_EFFORTS: () => MISTRAL_REASONING_EFFORTS,
   MODEL_PRICING: () => MODEL_PRICING,
   MetaAgent: () => MetaAgent,
   MiniMaxAgent: () => MiniMaxAgent,
@@ -160,6 +161,7 @@ __export(src_exports, {
   toGeminiEffort: () => toGeminiEffort,
   toGlmEffort: () => toGlmEffort,
   toMetaEffort: () => toMetaEffort,
+  toMistralEffort: () => toMistralEffort,
   toOpenAIEffort: () => toOpenAIEffort,
   transcribeWithGemini: () => transcribeWithGemini,
   transcribeWithOpenAi: () => transcribeWithOpenAi,
@@ -967,10 +969,8 @@ var LLM_CONSTANTS = {
   GEMINI_PRO: "gemini-pro",
   GEMINI_FLASH: "gemini-flash",
   GEMINI_LITE: "gemini-lite",
-  MISTRAL_LARGE: "mistral-large",
   MISTRAL_MEDIUM: "mistral-medium",
   MISTRAL_SMALL: "mistral-small",
-  MISTRAL_MAGISTRAL: "mistral-magistral",
   GROK: "grok",
   KIMI: "kimi",
   GLM: "glm",
@@ -1128,36 +1128,40 @@ var SupportedAiModels = {
     hasThinking: true,
     temperature: 0.7
   },
-  // Mistral models
-  [LLM_CONSTANTS.MISTRAL_LARGE]: {
-    displayName: "Mistral Large 3",
-    modelApiName: "mistral-large-latest",
-    apiKeyName: API_KEY_CONSTANTS.MISTRAL,
-    hasThinking: false,
-    tags: ["fast"]
-  },
+  // Mistral models. Two hybrid entries since 2026-09-18: reasoning is off by default on the
+  // API and switched on per request with `reasoning_effort` (see mistral-agent.ts); the trace
+  // comes back as a `thinking` content chunk and works with json_schema structured output
+  // (verified live 2026-09-18 on both). Pinned to 'high' — the only level Mistral's docs
+  // describe ("full thinking chunk before the final answer"); Small is cheap enough that the
+  // extra tokens don't matter, Medium's are priced into its free-tier band via the hybrid
+  // multiplier. Live 2026-09-18 (one short schema ask each): Small 1.7s with a ~600-char
+  // trace, Medium 3.8s with ~2000 chars — Medium's trace ran ~15x its answer length.
+  //
+  // Mistral Large 3 and Magistral Medium 1.2 were dropped 2026-09-18. Large 3 was retired by
+  // Mistral on 2026-08-31 (the `-latest` alias still answered, but its capabilities say
+  // reasoning: false and `reasoning_effort` is a 400 on it). Magistral was retired 2026-07-31
+  // and `magistral-medium-latest` is now literally an alias of Medium 3.5 — the model list
+  // returns `mistral-medium-3-5`, `mistral-medium-3`, `mistral-medium-latest` and
+  // `magistral-medium-latest` as one entry — so Magistral seats had silently become Medium
+  // seats already. Consumers map both retired ids onto the surviving pair.
   [LLM_CONSTANTS.MISTRAL_MEDIUM]: {
     displayName: "Mistral Medium 3.5",
-    modelApiName: "mistral-medium-3",
+    // The docs' explicit 3.5 id. It was `mistral-medium-3` until 2026-09-18, which Mistral
+    // now serves as an alias of the same model (Medium 3 itself retired 2026-08-31).
+    modelApiName: "mistral-medium-3-5",
     apiKeyName: API_KEY_CONSTANTS.MISTRAL,
-    hasThinking: false,
-    tags: ["very-fast", "expensive"]
+    hasThinking: true,
+    reasoningEffort: "high",
+    tags: ["fast", "expensive"]
   },
   [LLM_CONSTANTS.MISTRAL_SMALL]: {
     displayName: "Mistral 4 Small",
+    // Resolves to mistral-small-2603 (Small 4), which also carries the magistral-small alias.
     modelApiName: "mistral-small-latest",
     apiKeyName: API_KEY_CONSTANTS.MISTRAL,
-    hasThinking: false,
-    tags: ["very-fast", "cheap"]
-  },
-  [LLM_CONSTANTS.MISTRAL_MAGISTRAL]: {
-    displayName: "Magistral Medium 1.2",
-    modelApiName: "magistral-medium-latest",
-    apiKeyName: API_KEY_CONSTANTS.MISTRAL,
     hasThinking: true,
-    // Measured very-fast (1.6s) because JSON response mode suppresses its thinking
-    // (see mistral-agent.ts) — it effectively runs as a non-reasoning model here.
-    tags: ["very-fast"]
+    reasoningEffort: "high",
+    tags: ["very-fast", "cheap"]
   },
   // Kimi models. Single always-reasoning entry: K3 reasons by default and the only way to stop
   // it is the undocumented K2-era `thinking: disabled` toggle, which we no longer rely on.
@@ -1485,13 +1489,10 @@ var MODEL_PRICING = {
     outputPrice: 1.5,
     cacheHitPrice: 0.025
   },
-  // Mistral models. Cached tokens bill at 10% of the input price (documented on the
-  // prompt_cache_key param in the API reference; no per-model cached prices published).
-  [SupportedAiModels[LLM_CONSTANTS.MISTRAL_LARGE].modelApiName]: {
-    inputPrice: 0.5,
-    outputPrice: 1.5,
-    cacheHitPrice: 0.05
-  },
+  // Mistral models (mistral.ai/pricing/api, verified 2026-09-18). Cached tokens bill at 10% of
+  // the input price (documented on the prompt_cache_key param; no per-model cached prices
+  // published). Reasoning tokens are counted inside completion_tokens — no separate
+  // reasoning_tokens field — so the output rate already covers the trace.
   [SupportedAiModels[LLM_CONSTANTS.MISTRAL_MEDIUM].modelApiName]: {
     inputPrice: 1.5,
     outputPrice: 7.5,
@@ -1502,11 +1503,6 @@ var MODEL_PRICING = {
     outputPrice: 0.6,
     cacheHitPrice: 0.015
   },
-  [SupportedAiModels[LLM_CONSTANTS.MISTRAL_MAGISTRAL].modelApiName]: {
-    inputPrice: 2,
-    outputPrice: 5,
-    cacheHitPrice: 0.2
-  },
   // Grok models. Cached price is per-model on xAI (not a uniform ratio):
   // grok-4.6 is $0.50/M cached vs $2.00/M input, and all rates double for prompts
   // >= 200K tokens, per docs.x.ai/developers/models (verified 2026-08-12).
@@ -1581,7 +1577,11 @@ var HYBRID_THINKING_API_NAMES = /* @__PURE__ */ new Set([
   // hybrid by the same definition: we force reasoning on, so they carry the multiplier.
   SupportedAiModels[LLM_CONSTANTS.QWEN_MAX].modelApiName,
   SupportedAiModels[LLM_CONSTANTS.QWEN_FLASH].modelApiName,
-  SupportedAiModels[LLM_CONSTANTS.MINIMAX].modelApiName
+  SupportedAiModels[LLM_CONSTANTS.MINIMAX].modelApiName,
+  // Mistral reasons only when asked (`reasoning_effort`), and we always ask — hybrid by the
+  // same definition as Qwen. Added 2026-09-18 when the two entries went thinking-on.
+  SupportedAiModels[LLM_CONSTANTS.MISTRAL_MEDIUM].modelApiName,
+  SupportedAiModels[LLM_CONSTANTS.MISTRAL_SMALL].modelApiName
 ]);
 function isHybridThinkingModel(modelApiName) {
   return HYBRID_THINKING_API_NAMES.has(modelApiName);
@@ -1645,6 +1645,7 @@ var GLM_REASONING_EFFORTS = ["low", "high", "max"];
 var DEEPSEEK_REASONING_EFFORTS = ["low", "high", "max"];
 var FUGU_REASONING_EFFORTS = ["high", "xhigh"];
 var META_REASONING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+var MISTRAL_REASONING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh"];
 function clampReasoningEffort(effort, allowed) {
   const rank = REASONING_EFFORT_SCALE.indexOf(effort);
   let best = allowed[0];
@@ -1665,6 +1666,7 @@ var toGlmEffort = (effort) => clampReasoningEffort(effort, GLM_REASONING_EFFORTS
 var toDeepSeekEffort = (effort) => clampReasoningEffort(effort, DEEPSEEK_REASONING_EFFORTS);
 var toMetaEffort = (effort) => clampReasoningEffort(effort, META_REASONING_EFFORTS);
 var toFuguEffort = (effort) => clampReasoningEffort(effort, FUGU_REASONING_EFFORTS);
+var toMistralEffort = (effort) => clampReasoningEffort(effort, MISTRAL_REASONING_EFFORTS);
 
 // src/pricing/token-usage-utils.ts
 function extractTokenUsage(response) {
@@ -3397,6 +3399,9 @@ ${instruction}`);
           const body = await request.clone().text();
           const json = JSON.parse(body);
           json.prompt_cache_key = promptCacheKey;
+          if (this.enableThinking && this.reasoningEffort) {
+            json.reasoning_effort = toMistralEffort(this.reasoningEffort);
+          }
           return new Request(request.url, {
             method: request.method,
             headers: request.headers,
@@ -3409,11 +3414,25 @@ ${instruction}`);
     });
     this.client = new import_mistralai.Mistral({ apiKey, httpClient });
   }
+  /**
+   * History in Mistral's shape. A prior assistant turn that carries a stored trace is
+   * replayed as [thinking, text] chunks, as Mistral's multi-turn guidance asks; every other
+   * turn is a plain string.
+   */
   convertToMistralMessages(messages) {
-    return this.prepareMessages(messages).map((msg) => ({
-      role: msg.role === "developer" ? "system" : msg.role,
-      content: msg.content
-    }));
+    return this.prepareMessages(messages).map((msg) => {
+      if (msg.role === "assistant" && msg.thinking) {
+        const chunks = [
+          { type: "thinking", thinking: [{ type: "text", text: msg.thinking }] },
+          { type: "text", text: msg.content }
+        ];
+        return { role: "assistant", content: chunks };
+      }
+      return {
+        role: msg.role === "developer" ? "system" : msg.role,
+        content: msg.content
+      };
+    });
   }
   processReply(response) {
     const message = response?.choices?.[0]?.message;
@@ -3448,7 +3467,6 @@ ${instruction}`);
   extractTokenUsage(response) {
     const usage = extractMistralTokenUsage(response);
     if (!usage) return void 0;
-    this.logger(`MISTRAL_CACHE_CALIBRATION raw usage: ${JSON.stringify(response?.usage)}`);
     if (usage.reasoningTokens && usage.reasoningTokens > 0) {
       this.logger(`\u{1F9E0} Reasoning tokens used: ${usage.reasoningTokens}`);
     }
@@ -3484,7 +3502,7 @@ ${instruction}`);
       const convertedMessages = this.convertToMistralMessages(messages);
       if (convertedMessages.length > 0) {
         const lastMessage = convertedMessages[convertedMessages.length - 1];
-        if (lastMessage && lastMessage.content) {
+        if (lastMessage && typeof lastMessage.content === "string" && lastMessage.content) {
           lastMessage.content += `
 
 Your response must be a valid JSON object matching this schema:
@@ -3555,9 +3573,8 @@ ${schemaDescription}`
     }
   }
   /**
-   * Plain-text ask: no schema appended, no responseFormat. Note that Magistral
-   * reasoning models only return thinking traces when responseFormat is NOT
-   * json_object, so unlike askWithZodSchema this path can surface thinking content.
+   * Plain-text ask: no schema appended, no responseFormat. Reasoning (and the trace) works
+   * the same way as on the schema path.
    */
   async doAskText(messages) {
     try {
@@ -4581,6 +4598,18 @@ ${schemaDescription}`;
 
 // src/agents/qwen-agent.ts
 var import_openai9 = require("openai");
+function qwenRefusalFrom(model, apiError) {
+  const message = apiError instanceof Error ? apiError.message : String(apiError);
+  if (!/DataInspectionFailed|inappropriate content/i.test(message)) {
+    return void 0;
+  }
+  const detail = message.replace(/^[\s\S]*DataInspectionFailed:\s*/, "").trim();
+  return new ModelRefusalError(
+    model,
+    `${model} refused the prompt (refusalReason: DataInspectionFailed${detail ? `; ${detail}` : ""})`,
+    "DataInspectionFailed"
+  );
+}
 var QwenAgent = class extends AbstractAgent {
   client;
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
@@ -4705,7 +4734,7 @@ ${schemaDescription}`;
         completion = await this.client.chat.completions.create(params);
       } catch (apiError) {
         this.logger(this.logTemplates.error(this.name, apiError));
-        throw new Error(this.errorMessages.apiError(apiError));
+        throw qwenRefusalFrom(this.model, apiError) ?? new Error(this.errorMessages.apiError(apiError));
       }
       const rawReply = completion.choices[0]?.message?.content;
       if (!rawReply) {
@@ -4725,6 +4754,9 @@ ${schemaDescription}`;
       return [validated, thinkingContent, tokenUsage];
     } catch (error) {
       this.logger(this.logTemplates.error(this.name, error));
+      if (error instanceof ModelError) {
+        throw error;
+      }
       throw new Error(this.errorMessages.apiError(error));
     }
   }
@@ -4758,7 +4790,7 @@ ${openAIMessages[0].content}`;
         completion = await this.client.chat.completions.create(params);
       } catch (apiError) {
         this.logger(this.logTemplates.error(this.name, apiError));
-        throw new Error(this.errorMessages.apiError(apiError));
+        throw qwenRefusalFrom(this.model, apiError) ?? new Error(this.errorMessages.apiError(apiError));
       }
       const rawReply = completion.choices[0]?.message?.content;
       if (!rawReply) {
@@ -4774,6 +4806,9 @@ ${openAIMessages[0].content}`;
       return [reply, thinkingContent, tokenUsage];
     } catch (error) {
       this.logger(this.logTemplates.error(this.name, error));
+      if (error instanceof ModelError) {
+        throw error;
+      }
       throw new Error(this.errorMessages.apiError(error));
     }
   }
@@ -5211,8 +5246,6 @@ var AgentFactory = class {
       // Mistral models
       case LLM_CONSTANTS.MISTRAL_MEDIUM:
       case LLM_CONSTANTS.MISTRAL_SMALL:
-      case LLM_CONSTANTS.MISTRAL_LARGE:
-      case LLM_CONSTANTS.MISTRAL_MAGISTRAL:
         return new MistralAgent(name, instruction, model.modelApiName, key, shouldEnableThinking);
       case LLM_CONSTANTS.KIMI:
         return new KimiAgent(name, instruction, model.modelApiName, key, 0, shouldEnableThinking);
@@ -5276,6 +5309,7 @@ var AgentFactory = class {
   LLM_CONSTANTS,
   MESSAGE_ROLE,
   META_REASONING_EFFORTS,
+  MISTRAL_REASONING_EFFORTS,
   MODEL_PRICING,
   MetaAgent,
   MiniMaxAgent,
@@ -5377,6 +5411,7 @@ var AgentFactory = class {
   toGeminiEffort,
   toGlmEffort,
   toMetaEffort,
+  toMistralEffort,
   toOpenAIEffort,
   transcribeWithGemini,
   transcribeWithOpenAi,