@hiper2d/ai-agents 0.18.0 → 0.19.1

package/dist/index.mjs

@@ -713,6 +713,14 @@ var ModelInvalidResponseError = class extends ModelError {
     this.truncated = truncated;
   }
 };
+var ModelTimeoutError = class extends ModelError {
+  timeoutMs;
+  constructor(modelType, timeoutMs) {
+    super(`${modelType} did not respond within ${Math.round(timeoutMs / 1e3)}s`, modelType);
+    this.name = "ModelTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
 var ModelRefusalError = class extends ModelError {
   reason;
   constructor(modelType, message = `${modelType} refused to answer (stop_reason: refusal)`, reason) {
@@ -804,7 +812,6 @@ var LLM_CONSTANTS = {
   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.
@@ -816,6 +823,7 @@ var LLM_CONSTANTS = {
   MUSE_SPARK: "muse-spark"
 };
 var DEFAULT_MAX_OUTPUT_TOKENS = 8192;
+var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
 var SupportedAiModels = {
   // Claude Fable 5.1 (2026-09-02, was Fable 5) - frontier reasoning model. Thinking is always on (no non-thinking variant).
   [LLM_CONSTANTS.CLAUDE_FABLE]: {
@@ -976,16 +984,20 @@ var SupportedAiModels = {
   },
   // Always-on reasoning — no non-thinking sibling. Bumped 4.6 → 4.7 on 2026-09-22 (id verified
   // against GET /v1/models). Same price, same 200K extended-context boundary; the context
-  // window is 500K. NOTE 4.7 newly accepts `reasoning_effort` (low | medium | high | xhigh,
-  // default high) where 4.6 had no knob at all. GrokAgent still sends none, so behaviour is
-  // unchanged — but Grok is the app's most expensive model per turn (94% of its output is
-  // reasoning), so a lower pin is the obvious lever to measure before anything else.
+  // window is 500K. 4.7 accepts `reasoning: {effort}` (low | medium | high | xhigh, default
+  // high) where 4.6 had no knob at all; GrokAgent sends the pin below.
+  //
+  // Pinned medium 2026-10-06. At high, production day summaries ran ~2 min and the werewolf
+  // day-2 fixture measured votes 27-55s and summaries 44-55s (1.5-3k output tokens) — too
+  // close to the 60s per-call timeout. At medium the same prompts took votes 5-8s and
+  // summaries 23-25s (3-5x fewer output tokens) with the same vote target and summaries just
+  // as specific.
   [LLM_CONSTANTS.GROK]: {
     displayName: "Grok 4.7",
     modelApiName: "grok-4.7",
     apiKeyName: API_KEY_CONSTANTS.GROK,
     hasThinking: true,
-    reasoningEffort: "high",
+    reasoningEffort: "medium",
     temperature: 0.7
   },
   // Mistral models. Two hybrid entries since 2026-09-18: reasoning is off by default on the
@@ -1004,6 +1016,13 @@ var SupportedAiModels = {
   // 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.
+  //
+  // Mistral Large 4 (`mistral-large-4`, $0.68/$2.09, $0.07 cached) was added in 0.19.0 and
+  // removed in 0.19.1 (2026-10-06/07): too slow to play. Like Small/Medium it accepts only
+  // reasoning_effort high|none, and unlike them it reasons when the field is omitted. At high
+  // a realistic day-2 vote took 25-154s (half past the 60s timeout) and its parallel story
+  // batches finished ~100s apart (Mistral served them one at a time: ~6 min per story). Off,
+  // it answers in ~1s with no trace. Re-test before re-adding.
   [LLM_CONSTANTS.MISTRAL_MEDIUM]: {
     displayName: "Mistral Medium 3.5",
     // The docs' explicit 3.5 id. It was `mistral-medium-3` until 2026-09-18, which Mistral
@@ -1088,9 +1107,9 @@ var SupportedAiModels = {
   // real against $0.85 tracked, a 5.7x undercharge. It is a router with no published price,
   // 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.
+  // prefix reuse.
   //
-  // reasoningEffort is PINNED on both entries because the server default differs per model:
+  // reasoningEffort was 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):
@@ -1100,17 +1119,17 @@ var SupportedAiModels = {
   //   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 Ultra (`fugu-ultra`, $5/$30, $0.50 cached; ×~2 above 272K) was REMOVED in 0.19.1
+  // (2026-10-07): too slow and too expensive for what it played. At `high` a day-2 vote took
+  // 39s and a turn 65-78s (past the 60s request timeout), and as Game Master its four parallel
+  // story batches ran past 240s each. It also billed "orchestration" tokens (its internal expert
+  // calls) on top of the visible counts; FuguAgent still folds those in, in case Max ever
+  // reports them. Consumers map the id to Max.
   // 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
+  // cost–performance Pareto frontier" — 5x less than Ultra's output rate and a fraction of its
+  // latency; the only Fugu since 0.19.1. Live 2026-10-06: day-2 vote 11s, 15-character story
+  // pipeline 100s. 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]: {
@@ -1417,21 +1436,10 @@ var MODEL_PRICING = {
     extendedContextCacheHitPrice: 1,
     extendedContextThresholdTokens: 2e5
   },
-  // 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,
-    cacheHitPrice: 0.5,
-    extendedContextInputPrice: 10,
-    extendedContextOutputPrice: 45,
-    extendedContextCacheHitPrice: 1,
-    extendedContextThresholdTokens: 272e3
-  },
+  // Sakana Fugu (console.sakana.ai/pricing, read 2026-09-20). Base `fugu` (retired 2026-08-04)
+  // and `fugu-ultra` (removed 0.19.1) have no entries. Any "orchestration" tokens reported in
+  // prompt_tokens_details / completion_tokens_details bill at these same rates — FuguAgent
+  // folds them into the token counts before pricing.
   // fugu-max: flat rates, no context tiers.
   [SupportedAiModels[LLM_CONSTANTS.FUGU_MAX].modelApiName]: {
     inputPrice: 2,
@@ -1559,7 +1567,7 @@ var GLM_REASONING_EFFORTS = ["low", "high", "max"];
 var DEEPSEEK_REASONING_EFFORTS = ["low", "high", "max"];
 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"];
+var MISTRAL_REASONING_EFFORTS = ["high"];
 var XAI_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
 var KIMI_REASONING_EFFORTS = ["low", "high", "max"];
 function clampReasoningEffort(effort, allowed) {
@@ -2227,6 +2235,12 @@ var AbstractAgent = class {
    */
   reasoningEffort;
   thinkingBudgetTokens;
+  /**
+   * Wall-clock limit on one ask (DEFAULT_REQUEST_TIMEOUT_MS). Past it the ask throws
+   * ModelTimeoutError; the provider request is abandoned, not cancelled. Raise it per
+   * instance for calls that legitimately run long, like maxOutputTokens.
+   */
+  requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
   instruction;
   /**
    * The instruction split on CACHE_TIER_MARKER: [shared static tier, per-bot tier].
@@ -2261,7 +2275,7 @@ var AbstractAgent = class {
     if (beforeAskHook) await beforeAskHook(this);
     const startedAt = Date.now();
     try {
-      const [result, thinking, usage, signature] = await this.doAskWithZodSchema(zodSchema, messages);
+      const [result, thinking, usage, signature] = await this.withTimeout(this.doAskWithZodSchema(zodSchema, messages));
       return [result, thinking, this.stampDuration(usage, startedAt), signature];
     } catch (error) {
       this.stampErrorDuration(error, startedAt);
@@ -2272,13 +2286,25 @@ var AbstractAgent = class {
     if (beforeAskHook) await beforeAskHook(this);
     const startedAt = Date.now();
     try {
-      const [content, thinking, usage, signature] = await this.doAskText(messages);
+      const [content, thinking, usage, signature] = await this.withTimeout(this.doAskText(messages));
       return [content, thinking, this.stampDuration(usage, startedAt), signature];
     } catch (error) {
       this.stampErrorDuration(error, startedAt);
       throw error;
     }
   }
+  /**
+   * Races the provider call against requestTimeoutMs. A hung provider (accepts the request,
+   * never answers) otherwise runs until the host kills the function with no error to show.
+   */
+  withTimeout(call) {
+    const timeoutMs = this.requestTimeoutMs;
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new ModelTimeoutError(this.model, timeoutMs)), timeoutMs);
+    });
+    return Promise.race([call, timeout]).finally(() => clearTimeout(timer));
+  }
   stampDuration(usage, startedAt) {
     return usage ? { ...usage, durationMs: Date.now() - startedAt } : usage;
   }
@@ -5304,7 +5330,6 @@ var AgentFactory = class {
       case LLM_CONSTANTS.GLM_FLASH:
         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)
@@ -5343,6 +5368,7 @@ export {
   DEEPSEEK_REASONING_EFFORTS,
   DEFAULT_LOGGING_CONFIG,
   DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_REQUEST_TIMEOUT_MS,
   DeepSeekV2Agent,
   FUGU_REASONING_EFFORTS,
   FuguAgent,
@@ -5372,6 +5398,7 @@ export {
   ModelQuotaExceededError,
   ModelRateLimitError,
   ModelRefusalError,
+  ModelTimeoutError,
   ModelUnavailableError,
   OPENAI_REASONING_EFFORTS,
   OpenAiVoiceAgent,