@hiper2d/ai-agents 0.13.1 → 0.15.0

package/dist/index.mjs

@@ -1065,10 +1065,15 @@ var SupportedAiModels = {
     // Live 2026-08-30 (one sample each): day-2 vote 11.8s, 15-character story 56.2s.
     tags: ["cheap"]
   },
-  // Sakana Fugu models — OpenAI-compatible. They reason internally (and bill it as
-  // "orchestration" tokens), but never surface reasoning to us: responses come back with
-  // reasoning_tokens: 0 and no reasoning_content. So hasThinking is false — there's no
-  // thinking content to show and no user-facing thinking toggle. Single entry per model.
+  // Sakana Fugu models — OpenAI-compatible. They reason internally, but Chat Completions
+  // (what FuguAgent uses) never returns the text: reasoning_tokens are reported and billed,
+  // there is no reasoning_content. So hasThinking is false. Single entry per model.
+  // The Messages and Responses APIs DO return reasoning (thinking blocks with an empty
+  // signature / reasoning items, some with encrypted_content), but probed 2026-09-24 on
+  // fugu-max it isn't worth switching for, since we keep reasoning only to replay it: the
+  // returned text is often a vague status summary or empty rather than the actual
+  // reasoning, and replayed reasoning reaches the model distorted (a planted "4817" came
+  // back as "4829" on both APIs, presumably rewritten by the orchestrator).
   //
   // Base `fugu` was RETIRED 2026-08-04. It was carried as a cheap everyday option at an
   // assumed $1/$3, but reconciling token logs against the Sakana balance showed it actually
@@ -1527,6 +1532,9 @@ function getProviderSignatureFields(aiType, signature) {
   if (aiType.startsWith("grok")) {
     return { grokEncryptedReasoning: signature };
   }
+  if (aiType.startsWith("gpt")) {
+    return { openaiEncryptedReasoning: signature };
+  }
   if (aiType.startsWith("muse-")) {
     return { metaEncryptedReasoning: signature };
   }
@@ -2351,7 +2359,54 @@ ${instruction}`);
    * inherited from a default OpenAI can change under us.
    */
   reasoningParams() {
-    return this.reasoningEffort ? { reasoning: { effort: toOpenAIEffort(this.reasoningEffort) } } : {};
+    return {
+      reasoning: {
+        ...this.reasoningEffort ? { effort: toOpenAIEffort(this.reasoningEffort) } : {},
+        // Render reasoning from earlier turns into this sample. It is already the
+        // default on all four models we run, but stated explicitly for the same reason
+        // effort is. It only does anything because we replay the items ourselves.
+        context: "all_turns"
+      }
+    };
+  }
+  /**
+   * Responses API input items, with each assistant turn's stored reasoning items replayed
+   * immediately before it. OpenAI attaches `encrypted_content` to reasoning items whenever
+   * `store` is false, which is how we call it: the documented stateless route is to preserve
+   * the output items and replay the history yourself, rather than lean on
+   * `previous_response_id` and OpenAI-side session state.
+   *
+   * This was a single flattened string before ("User: ... / Assistant: ..."), which left
+   * nowhere to put reasoning items. The system prompt still travels ONLY as `instructions`.
+   *
+   * Reasoning is readable only within one model family and the API silently omits items it
+   * cannot read, so a bot moved between GPT-6 and GPT-5.6 Terra loses its reasoning and keeps
+   * working. A bot moved to another provider never reaches this code at all: every agent
+   * reads only its own field, and a missing one falls back to a plain message.
+   */
+  buildResponsesInput(messages) {
+    const input = [];
+    for (const msg of this.prepareMessages(messages)) {
+      if (msg.role === "assistant" && msg.openaiEncryptedReasoning) {
+        try {
+          const items = JSON.parse(msg.openaiEncryptedReasoning);
+          if (Array.isArray(items)) {
+            input.push(...items);
+          }
+        } catch {
+          this.logger("Failed to parse stored encrypted reasoning, replaying message without it");
+        }
+      }
+      input.push({ role: msg.role, content: msg.content });
+    }
+    return input;
+  }
+  /** The response's reasoning items, JSON-serialized for the caller to store on the message. */
+  extractReasoningItems(response) {
+    const items = (response?.output ?? []).filter(
+      (item) => item?.type === "reasoning" && item.encrypted_content
+    );
+    return items.length > 0 ? JSON.stringify(items) : void 0;
   }
   /**
    * Structured output method using Zod with OpenAI's Responses API
@@ -2363,7 +2418,7 @@ ${instruction}`);
     try {
       this.logAsking(messages);
       this.logMessages(messages);
-      const input = this.prepareMessages(messages).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`).join("\n\n");
+      const input = this.buildResponsesInput(messages);
       const schemaToSend = zodSchema;
       let response;
       try {
@@ -2373,6 +2428,8 @@ ${instruction}`);
           input,
           max_output_tokens: this.maxOutputTokens,
           prompt_cache_key: this.promptCacheKey,
+          // Stateless: encrypted reasoning is only returned for unstored responses.
+          store: false,
           ...this.reasoningParams(),
           text: {
             format: zodTextFormat(schemaToSend, "response_schema")
@@ -2433,7 +2490,7 @@ ${instruction}`);
         this.logReply(response.output_parsed, reasoningContent, tokenUsage);
       }
       this.logger(`\u2705 Response validated successfully with Zod schema`);
-      return [response.output_parsed, reasoningContent, tokenUsage];
+      return [response.output_parsed, reasoningContent, tokenUsage, this.extractReasoningItems(response)];
     } catch (error) {
       this.logger(this.logTemplates.error(this.name, error));
       if (error instanceof ModelError) {
@@ -2452,13 +2509,14 @@ ${instruction}`);
     try {
       this.logAsking(messages);
       this.logMessages(messages);
-      const input = this.prepareMessages(messages).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`).join("\n\n");
+      const input = this.buildResponsesInput(messages);
       const response = await this.client.responses.create({
         model: this.model,
         instructions: this.instruction,
         input,
         max_output_tokens: this.maxOutputTokens,
         prompt_cache_key: this.promptCacheKey,
+        store: false,
         ...this.reasoningParams()
       });
       const content = response.output_text;
@@ -2500,7 +2558,7 @@ ${instruction}`);
         }
       }
       this.logReply(content, "", tokenUsage);
-      return [content, "", tokenUsage];
+      return [content, "", tokenUsage, this.extractReasoningItems(response)];
     } catch (error) {
       this.logger(this.logTemplates.error(this.name, error));
       if (error instanceof ModelError) {
@@ -4592,13 +4650,29 @@ var QwenAgent = class extends AbstractAgent {
     const budget = this.thinkingBudgetTokens;
     return {
       enable_thinking: this.enableThinking,
-      ...this.enableThinking && budget !== void 0 ? { thinking_budget: budget } : {}
+      ...this.enableThinking && budget !== void 0 ? { thinking_budget: budget } : {},
+      // Lets the model read the `reasoning_content` we replay on assistant messages, so a
+      // bot keeps its own train of thought across turns. Qwen documents models as NOT
+      // reading replayed reasoning unless this is set (qwen3.8-max and qwen3.8-flash are
+      // both on the supported list). Measured 2026-09-22: qwen3.8-max actually used the
+      // replayed reasoning with the flag off too, but we follow the documented contract
+      // rather than rely on that. Stateless — the reasoning comes from our payload, not
+      // from any server-side session.
+      ...this.enableThinking ? { preserve_thinking: true } : {}
     };
   }
+  /**
+   * Assistant turns carry their own `reasoning_content` back so the model can reference what
+   * it was thinking on earlier turns (paired with `preserve_thinking` in thinkingParams).
+   * Qwen's reasoning is PLAIN TEXT, not a signed or encrypted blob, so there is nothing for
+   * another provider to reject: a bot whose model changes mid-game simply stops sending it
+   * and keeps working. The text is the same one the caller already stores as `thinking`.
+   */
   convertToOpenAIMessages(messages) {
     return messages.map((msg) => ({
       role: msg.role,
-      content: msg.content
+      content: msg.content,
+      ...msg.role === "assistant" && msg.thinking ? { reasoning_content: msg.thinking } : {}
     }));
   }
   extractThinkingAndUsage(completion) {
@@ -4665,7 +4739,11 @@ ${schemaDescription}`;
         const params = {
           ...this.defaultParams,
           messages: openAIMessages,
-          ...this.thinkingParams()
+          ...this.thinkingParams(),
+          response_format: {
+            type: "json_schema",
+            json_schema: ZodSchemaConverter.toOpenAIJsonSchema(zodSchema, "response_schema")
+          }
         };
         completion = await this.client.chat.completions.create(params);
       } catch (apiError) {