@hiper2d/ai-agents 0.5.3 → 0.7.0

package/dist/index.mjs

@@ -798,15 +798,14 @@ 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",
   GLM_FLASH: "glm-flash",
   FUGU_ULTRA: "fugu-ultra",
+  FUGU_MAX: "fugu-max",
   // Qwen (QwenCloud/DashScope). Stable picker ids without the version, matching the gpt/gemini
   // pattern, so future repoints don't orphan persisted ids.
   QWEN_MAX: "qwen-max",
@@ -959,36 +958,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.
@@ -1048,13 +1051,37 @@ var SupportedAiModels = {
   // so the rate is not even guaranteed stable, and its cache hit rate was 9.3% — effectively
   // zero, since every hit came from a duplicate call seconds apart rather than turn-to-turn
   // prefix reuse. Ultra costs the same and is predictable.
+  //
+  // reasoningEffort is PINNED on both entries because the server default differs per model:
+  // fugu-ultra defaults to `xhigh` (console.sakana.ai/models), fugu-max to `high`. Until
+  // 2026-09-20 the agent sent no effort at all, so every Ultra turn ran at xhigh. Measured that
+  // day on a 2k-token three-day game prompt (two samples each, chat completions, json mode):
+  //   ultra xhigh  148s / 265s   $0.34 / $0.50 a turn (orchestration tokens included)
+  //   ultra high    65s /  78s   $0.16 / $0.17
+  //   max   high     6s /  10s   $0.006 / $0.008
+  //   max   xhigh   41s /  47s   $0.02
+  // `max_tokens` is not a latency lever for Ultra: Sakana applies it to the final response only,
+  // the orchestrator "still uses maximum token limit". Effort is the only knob.
   [LLM_CONSTANTS.FUGU_ULTRA]: {
     displayName: "Sakana Fugu Ultra",
     modelApiName: "fugu-ultra",
     apiKeyName: API_KEY_CONSTANTS.FUGU,
     hasThinking: false,
+    reasoningEffort: "high",
     tags: ["extremely-slow", "expensive"]
   },
+  // Fugu Max (2026-09-20, fugu-max → fugu-max-v1.0): Sakana's "largest pool of models on the
+  // cost–performance Pareto frontier" — the everyday Fugu at 5x less than Ultra's output rate
+  // and a fraction of its latency. It reasons (reasoning_tokens 80-500 a turn) but, like
+  // Ultra, never returns reasoning_content, hence hasThinking: false. No orchestration
+  // tokens observed on any call.
+  [LLM_CONSTANTS.FUGU_MAX]: {
+    displayName: "Sakana Fugu Max",
+    modelApiName: "fugu-max",
+    apiKeyName: API_KEY_CONSTANTS.FUGU,
+    hasThinking: false,
+    reasoningEffort: "high"
+  },
   // Qwen models (QwenCloud, OpenAI-compatible endpoint). Added 2026-08-05 straight into the
   // thinking-only catalog: their API has an `enable_thinking` toggle, we always send true, and
   // thinking arrives in `reasoning_content` (verified live against all three, non-streaming).
@@ -1316,13 +1343,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 +1357,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).
@@ -1350,9 +1369,12 @@ var MODEL_PRICING = {
     extendedContextCacheHitPrice: 1,
     extendedContextThresholdTokens: 2e5
   },
-  // Sakana Fugu models. Base `fugu` was retired 2026-08-04 — it had no published price and
-  // measured out at these same ultra rates, so it has no pricing entry.
-  // fugu-ultra has published pricing. Above 272K context the rates roughly double.
+  // Sakana Fugu models (console.sakana.ai/pricing, read 2026-09-20). Base `fugu` was retired
+  // 2026-08-04 — it had no published price and measured out at these same ultra rates, so it
+  // has no pricing entry. fugu-ultra: above 272K context the rates roughly double. Ultra also
+  // reports "orchestration" tokens (its internal expert calls) in prompt_tokens_details /
+  // completion_tokens_details, billed at these same input/output rates — FuguAgent folds them
+  // into the token counts before pricing.
   [SupportedAiModels[LLM_CONSTANTS.FUGU_ULTRA].modelApiName]: {
     inputPrice: 5,
     outputPrice: 30,
@@ -1362,6 +1384,12 @@ var MODEL_PRICING = {
     extendedContextCacheHitPrice: 1,
     extendedContextThresholdTokens: 272e3
   },
+  // fugu-max: flat rates, no context tiers.
+  [SupportedAiModels[LLM_CONSTANTS.FUGU_MAX].modelApiName]: {
+    inputPrice: 2,
+    outputPrice: 6,
+    cacheHitPrice: 0.25
+  },
   // Qwen models. Rates from the official pricing page (qwencloud.com/pricing/api, read
   // 2026-08-30 — the page is client-rendered, so it was read by eye, not WebFetch):
   // qwen3.8-max $2/$6 with implicit-cache hits at $0.25; qwen3.8-flash $0.15/$0.47, hits
@@ -1412,7 +1440,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);
@@ -1474,8 +1506,9 @@ var ANTHROPIC_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 var GEMINI_REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
 var GLM_REASONING_EFFORTS = ["low", "high", "max"];
 var DEEPSEEK_REASONING_EFFORTS = ["low", "high", "max"];
-var FUGU_REASONING_EFFORTS = ["high", "xhigh"];
+var FUGU_REASONING_EFFORTS = ["high", "xhigh", "max"];
 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 +1529,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 +3262,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 +3277,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 +3330,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 +3365,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 +3436,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 {
@@ -4225,13 +4274,15 @@ var FuguAgent = class extends AbstractAgent {
   client;
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
   // initializer would snapshot the default and silently ignore the override.
+  // `reasoning_effort` is re-declared as string: the OpenAI SDK's union lacks Sakana's 'max'.
   get defaultParams() {
     return {
       model: this.model,
       stream: false,
-      // Caps visible output only. Server-side orchestration/reasoning tokens are
-      // separate and unaffected by this.
-      max_tokens: this.maxOutputTokens
+      // Caps the final reply only. Per Sakana's docs the orchestrator "still uses maximum
+      // token limit", so this bounds neither Ultra's latency nor its orchestration spend.
+      max_tokens: this.maxOutputTokens,
+      reasoning_effort: toFuguEffort(this.reasoningEffort ?? "high")
     };
   }
   logTemplates = {
@@ -4256,33 +4307,6 @@ var FuguAgent = class extends AbstractAgent {
       content: msg.content
     }));
   }
-  // ───────────────────────────────────────────────────────────────────────────────────────
-  // TEMPORARY (cost calibration). Base `fugu` is a dynamic router with no published per-token
-  // price and Sakana returns NO cost field in the response — only token counts. Crucially the
-  // response also reports "orchestration tokens" (billed at input/output rates per Sakana's
-  // pricing page) that our standard TokenUsage drops. This logs the full raw breakdown to
-  // BetterStack under a distinctive tag so we can sum real tokens per game and, combined with
-  // the Sakana billing dashboard total, derive the true per-token rate. REMOVE AFTER CALIBRATION.
-  logRawUsageForCalibration(completion) {
-    const usage = completion?.usage;
-    if (!usage) return;
-    logger.info("FUGU_COST_CALIBRATION", {
-      tag: "FUGU_COST_CALIBRATION",
-      model: this.model,
-      agentName: this.name,
-      gameId: this.gameId,
-      userId: this.userId,
-      promptTokens: usage.prompt_tokens ?? 0,
-      completionTokens: usage.completion_tokens ?? 0,
-      totalTokens: usage.total_tokens ?? 0,
-      cachedTokens: usage.prompt_tokens_details?.cached_tokens ?? 0,
-      orchestrationInputTokens: usage.prompt_tokens_details?.orchestration_input_tokens ?? 0,
-      orchestrationInputCachedTokens: usage.prompt_tokens_details?.orchestration_input_cached_tokens ?? 0,
-      reasoningTokens: usage.completion_tokens_details?.reasoning_tokens ?? 0,
-      orchestrationOutputTokens: usage.completion_tokens_details?.orchestration_output_tokens ?? 0,
-      rawUsage: usage
-    });
-  }
   extractThinkingAndUsage(completion) {
     let thinkingContent = "";
     const message = completion.choices[0]?.message;
@@ -4290,21 +4314,14 @@ var FuguAgent = class extends AbstractAgent {
       thinkingContent = message.reasoning_content;
       this.logger(`Captured reasoning_content (${thinkingContent.length} characters)`);
     }
-    let tokenUsage;
-    const usageResult = extractUsageAndCalculateCost(this.model, completion);
-    if (usageResult) {
-      tokenUsage = {
-        inputTokens: usageResult.usage.promptTokens,
-        outputTokens: usageResult.usage.completionTokens,
-        totalTokens: usageResult.usage.totalTokens,
-        costUSD: usageResult.cost,
-        ...usageResult.usage.cacheHitTokens !== void 0 ? { cachedInputTokens: usageResult.usage.cacheHitTokens } : {}
-      };
-      if (usageResult.usage.reasoningTokens) {
-        const reasoningTokens = usageResult.usage.reasoningTokens;
-        const finalAnswerTokens = Math.max(0, tokenUsage.outputTokens - reasoningTokens);
+    const tokenUsage = extractFuguTokenUsage(this.model, completion);
+    if (tokenUsage) {
+      const details = completion.usage ?? {};
+      const orchestrationIn = details.prompt_tokens_details?.orchestration_input_tokens ?? 0;
+      const orchestrationOut = details.completion_tokens_details?.orchestration_output_tokens ?? 0;
+      if (tokenUsage.reasoningTokens || orchestrationIn || orchestrationOut) {
         this.logger(
-          `Output breakdown: ${reasoningTokens} reasoning tokens, ${finalAnswerTokens} final answer tokens`
+          `Usage breakdown: ${tokenUsage.reasoningTokens ?? 0} reasoning tokens; orchestration ${orchestrationIn} in / ${orchestrationOut} out (billed, folded into the totals)`
         );
       }
     }
@@ -4346,7 +4363,6 @@ ${schemaDescription}`;
         this.logger(this.logTemplates.error(this.name, apiError));
         throw new Error(this.errorMessages.apiError(apiError));
       }
-      this.logRawUsageForCalibration(completion);
       const rawReply = completion.choices[0]?.message?.content;
       if (!rawReply) {
         throw new Error(this.errorMessages.emptyResponse);
@@ -4390,7 +4406,6 @@ ${schemaDescription}`;
         this.logger(this.logTemplates.error(this.name, apiError));
         throw new Error(this.errorMessages.apiError(apiError));
       }
-      this.logRawUsageForCalibration(completion);
       const rawReply = completion.choices[0]?.message?.content;
       if (!rawReply) {
         throw new Error(this.errorMessages.emptyResponse);
@@ -4409,6 +4424,31 @@ ${schemaDescription}`;
     }
   }
 };
+function extractFuguTokenUsage(modelApiName, completion) {
+  const usage = completion?.usage;
+  if (!usage) {
+    return void 0;
+  }
+  const promptDetails = usage.prompt_tokens_details ?? {};
+  const completionDetails = usage.completion_tokens_details ?? {};
+  const inputTokens = (usage.prompt_tokens ?? 0) + (promptDetails.orchestration_input_tokens ?? 0);
+  const outputTokens = (usage.completion_tokens ?? 0) + (completionDetails.orchestration_output_tokens ?? 0);
+  const cachedInputTokens = (promptDetails.cached_tokens ?? 0) + (promptDetails.orchestration_input_cached_tokens ?? 0);
+  const reasoningTokens = completionDetails.reasoning_tokens ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    cachedInputTokens,
+    // Omitted rather than 0: consumers persist the object as-is (see TokenUsage).
+    ...reasoningTokens > 0 ? { reasoningTokens } : {},
+    costUSD: calculateModelCost(modelApiName, inputTokens, outputTokens, {
+      cacheHitTokens: cachedInputTokens,
+      // Context-tier selection: the request's own size, not the orchestrator's traffic.
+      contextTokens: usage.total_tokens ?? inputTokens
+    })
+  };
+}
 
 // src/agents/qwen-agent.ts
 import { OpenAI as OpenAI9 } from "openai";
@@ -5060,8 +5100,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);
@@ -5071,6 +5109,7 @@ var AgentFactory = class {
         return new GlmAgent(name, instruction, model.modelApiName, key, model.temperature, shouldEnableThinking);
       // Sakana Fugu models — always-on reasoning, no temperature (ignored by the model)
       case LLM_CONSTANTS.FUGU_ULTRA:
+      case LLM_CONSTANTS.FUGU_MAX:
         return new FuguAgent(name, instruction, model.modelApiName, key, shouldEnableThinking);
       // Qwen models — thinking-only (enable_thinking always sent)
       case LLM_CONSTANTS.QWEN_MAX:
@@ -5124,6 +5163,7 @@ export {
   LLM_CONSTANTS,
   MESSAGE_ROLE,
   META_REASONING_EFFORTS,
+  MISTRAL_REASONING_EFFORTS,
   MODEL_PRICING,
   MetaAgent,
   MiniMaxAgent,
@@ -5225,6 +5265,7 @@ export {
   toGeminiEffort,
   toGlmEffort,
   toMetaEffort,
+  toMistralEffort,
   toOpenAIEffort,
   transcribeWithGemini,
   transcribeWithOpenAi,