@hiper2d/ai-agents 0.5.2 → 0.6.0

package/dist/index.mjs

@@ -798,10 +798,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",
@@ -959,36 +957,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.
@@ -1316,13 +1318,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,
@@ -1333,11 +1332,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).
@@ -1412,7 +1406,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);
@@ -1476,6 +1474,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];
@@ -1496,6 +1495,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) {
@@ -3228,6 +3228,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,
@@ -3240,11 +3243,25 @@ ${instruction}`);
     });
     this.client = new 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;
@@ -3279,7 +3296,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}`);
     }
@@ -3315,7 +3331,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:
@@ -3386,9 +3402,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 {
@@ -4412,6 +4427,18 @@ ${schemaDescription}`;
 
 // src/agents/qwen-agent.ts
 import { OpenAI as OpenAI9 } from "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
@@ -4536,7 +4563,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) {
@@ -4556,6 +4583,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));
     }
   }
@@ -4589,7 +4619,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) {
@@ -4605,6 +4635,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));
     }
   }
@@ -5042,8 +5075,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);
@@ -5106,6 +5137,7 @@ export {
   LLM_CONSTANTS,
   MESSAGE_ROLE,
   META_REASONING_EFFORTS,
+  MISTRAL_REASONING_EFFORTS,
   MODEL_PRICING,
   MetaAgent,
   MiniMaxAgent,
@@ -5207,6 +5239,7 @@ export {
   toGeminiEffort,
   toGlmEffort,
   toMetaEffort,
+  toMistralEffort,
   toOpenAIEffort,
   transcribeWithGemini,
   transcribeWithOpenAi,