@hiper2d/ai-agents 0.13.1 → 0.14.1

package/dist/index.d.mts

@@ -16,6 +16,7 @@ interface AIMessage {
     googleThoughtSignature?: string;
     grokEncryptedReasoning?: string;
     metaEncryptedReasoning?: string;
+    openaiEncryptedReasoning?: string;
 }
 interface TokenUsage$1 {
     inputTokens: number;
@@ -510,6 +511,7 @@ declare function getProviderSignatureFields(aiType: string, signature?: string):
     googleThoughtSignature?: string;
     grokEncryptedReasoning?: string;
     metaEncryptedReasoning?: string;
+    openaiEncryptedReasoning?: string;
 };
 
 /**
@@ -1407,6 +1409,24 @@ declare class Gpt5Agent extends AbstractAgent {
      * inherited from a default OpenAI can change under us.
      */
     private reasoningParams;
+    /**
+     * 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.
+     */
+    private buildResponsesInput;
+    /** The response's reasoning items, JSON-serialized for the caller to store on the message. */
+    private extractReasoningItems;
     /**
      * Structured output method using Zod with OpenAI's Responses API
      * This provides better schema handling and runtime validation
@@ -1725,6 +1745,13 @@ declare class QwenAgent extends AbstractAgent {
      * this agent stays ignored — deliberately, not because effort is broken.
      */
     private thinkingParams;
+    /**
+     * 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`.
+     */
     private convertToOpenAIMessages;
     private extractThinkingAndUsage;
     /**

package/dist/index.d.ts

@@ -16,6 +16,7 @@ interface AIMessage {
     googleThoughtSignature?: string;
     grokEncryptedReasoning?: string;
     metaEncryptedReasoning?: string;
+    openaiEncryptedReasoning?: string;
 }
 interface TokenUsage$1 {
     inputTokens: number;
@@ -510,6 +511,7 @@ declare function getProviderSignatureFields(aiType: string, signature?: string):
     googleThoughtSignature?: string;
     grokEncryptedReasoning?: string;
     metaEncryptedReasoning?: string;
+    openaiEncryptedReasoning?: string;
 };
 
 /**
@@ -1407,6 +1409,24 @@ declare class Gpt5Agent extends AbstractAgent {
      * inherited from a default OpenAI can change under us.
      */
     private reasoningParams;
+    /**
+     * 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.
+     */
+    private buildResponsesInput;
+    /** The response's reasoning items, JSON-serialized for the caller to store on the message. */
+    private extractReasoningItems;
     /**
      * Structured output method using Zod with OpenAI's Responses API
      * This provides better schema handling and runtime validation
@@ -1725,6 +1745,13 @@ declare class QwenAgent extends AbstractAgent {
      * this agent stays ignored — deliberately, not because effort is broken.
      */
     private thinkingParams;
+    /**
+     * 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`.
+     */
     private convertToOpenAIMessages;
     private extractThinkingAndUsage;
     /**

package/dist/index.js

@@ -1702,6 +1702,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 };
   }
@@ -2526,7 +2529,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
@@ -2538,7 +2588,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 {
@@ -2548,6 +2598,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: (0, import_zod2.zodTextFormat)(schemaToSend, "response_schema")
@@ -2608,7 +2660,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) {
@@ -2627,13 +2679,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;
@@ -2675,7 +2728,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) {
@@ -4767,13 +4820,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) {