@hiper2d/ai-agents 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -805,6 +805,7 @@ var LLM_CONSTANTS = {
   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",
@@ -826,9 +827,13 @@ var SupportedAiModels = {
     tags: ["expensive"]
   },
   // Claude models — thinking-only entries (non-thinking variants retired 2026-08-05)
+  // Opus moved 5 → 5.5 on 2026-09-22 (`claude-opus-5-5`, verified against GET /v1/models).
+  // Cheaper than Opus 5 ($4/$20 vs $5/$25) and the same 1M context / 128K output. Thinking is
+  // always on, as on Opus 5. Its API default effort is `medium`, but we keep the catalog-wide
+  // `high` pin so bot answers don't get shallower than every other model in the lobby.
   [LLM_CONSTANTS.CLAUDE_OPUS]: {
-    displayName: "Claude 5 Opus",
-    modelApiName: "claude-opus-5",
+    displayName: "Claude 5.5 Opus",
+    modelApiName: "claude-opus-5-5",
     apiKeyName: API_KEY_CONSTANTS.ANTHROPIC,
     hasThinking: true,
     reasoningEffort: "high",
@@ -1050,13 +1055,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).
@@ -1277,9 +1306,13 @@ var MODEL_PRICING = {
     cacheHitPrice: 0.25
   },
   [SupportedAiModels[LLM_CONSTANTS.CLAUDE_OPUS].modelApiName]: {
-    inputPrice: 5,
-    outputPrice: 25,
-    cacheHitPrice: 0.5
+    // Opus 5.5 (2026-09-22): $4/$20, down from Opus 5's $5/$25. Cache reads are 5% of input
+    // here, not the usual 10% — $0.20, not $0.40. Cache WRITES ($5 at 5m, $8 at 1h) are not
+    // modelled: calculateCost bills every uncached prompt token at inputPrice, so a write is
+    // under-billed by the 1.25x/2x premium. Pre-existing for every Anthropic model.
+    inputPrice: 4,
+    outputPrice: 20,
+    cacheHitPrice: 0.2
   },
   [SupportedAiModels[LLM_CONSTANTS.CLAUDE_SONNET].modelApiName]: {
     inputPrice: 2,
@@ -1344,9 +1377,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,
@@ -1356,6 +1392,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
@@ -1472,7 +1514,7 @@ 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) {
@@ -2428,6 +2470,7 @@ ${instruction}`);
 
 // src/agents/anthropic-agent.ts
 import { Anthropic } from "@anthropic-ai/sdk";
+var rejectsDisabledThinking = (model) => model.includes("fable") || model.includes("opus-5-5");
 var ClaudeAgent = class extends AbstractAgent {
   client;
   /**
@@ -2644,7 +2687,9 @@ ${schemaDescription}`;
           params.temperature = 1;
         }
       } else if (usesAdaptiveThinking) {
-        params.thinking = { type: "disabled" };
+        if (!rejectsDisabledThinking(this.model)) {
+          params.thinking = { type: "disabled" };
+        }
       } else {
         params.temperature = this.temperature;
       }
@@ -2738,7 +2783,9 @@ ${schemaDescription}`;
           params.temperature = 1;
         }
       } else if (usesAdaptiveThinking) {
-        params.thinking = { type: "disabled" };
+        if (!rejectsDisabledThinking(this.model)) {
+          params.thinking = { type: "disabled" };
+        }
       } else {
         params.temperature = this.temperature;
       }
@@ -4240,13 +4287,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 = {
@@ -4271,33 +4320,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;
@@ -4305,21 +4327,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)`
         );
       }
     }
@@ -4361,7 +4376,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);
@@ -4405,7 +4419,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);
@@ -4424,6 +4437,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";
@@ -5084,6 +5122,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: