@hiper2d/ai-agents 0.13.0 → 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;
 };
 
 /**
@@ -543,8 +545,12 @@ declare function getProviderSignatureFields(aiType: string, signature?: string):
  * - Moonshot Kimi K3 (platform.kimi.ai/docs/guide/use-reasoning-effort, 2026-09-22):
  *   low|high|max, default max, top-level on Chat Completions. Moonshot shipped the lower
  *   levels after launch; K3 accepted only "max" when this agent was written.
- * Qwen accepts reasoning_effort but ignores it (thinking_budget is its knob); MiniMax exposes
- * no effort parameter.
+ * - Qwen 3.8 max/flash (docs.qwencloud.com, re-probed 2026-09-22): low|medium|xhigh, default
+ *   xhigh, with `high` and `max` aliased onto xhigh and `minimal` onto low. It is a coarse
+ *   alias for thinking_budget (low = 4,096, medium = 16,384, xhigh = 262,144 tokens) and the
+ *   two are mutually exclusive — sending both is a 400. QwenAgent sends the budget instead,
+ *   because 1,024 is tighter than the lowest level effort can express.
+ * MiniMax exposes no effort parameter.
  */
 type OpenAIReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 type AnthropicReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
@@ -1403,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
@@ -1704,14 +1728,30 @@ declare class QwenAgent extends AbstractAgent {
      * generation); without it the model thinks at the provider default, and qwen3.8-max's
      * latency then swings 30–100s.
      *
-     * `reasoning_effort` is deliberately NOT sent. Probed live 2026-08-30 on qwen3.8-flash and
-     * qwen3.8-max: every value low..max is accepted, but reasoning length doesn't track it
-     * (max: low → 1,686 reasoning tokens / 44s, high → 226 / 7s, xhigh → 1,102 / 30s), while
-     * thinking_budget bounds it reliably (≤340 at 1024). The docs also call the two mutually
-     * exclusive on qwen3.8-max. So on Qwen the budget IS the effort knob; `reasoningEffort`
-     * on this agent is ignored.
+     * `reasoning_effort` is NOT sent, and the earlier reason recorded here was wrong. The
+     * 2026-08-30 probe concluded "reasoning length doesn't track effort"; it had tested
+     * low/high/max/xhigh, but Qwen only defines low|medium|xhigh and aliases both `high` and
+     * `max` onto `xhigh`. So that probe compared low against xhigh twice and read the noise as
+     * non-monotonicity.
+     *
+     * Re-probed 2026-09-22 with the documented levels, and effort tracks cleanly:
+     *   qwen3.8-max     budget 1024 → 77 reasoning | low 132 | medium 160 | xhigh 422
+     *   qwen3.8-flash   budget 1024 → 86 reasoning | low  87 | medium 251 | xhigh 417
+     *
+     * We still send the budget, for a better reason: the two are mutually exclusive (sending
+     * both is a 400), Qwen documents effort as a coarse alias for a budget (low = 4,096,
+     * medium = 16,384, xhigh = 262,144 tokens), and our 1,024 is tighter than the lowest level
+     * it can express. The budget is the finer AND cheaper knob here, so `reasoningEffort` on
+     * 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;
 };
 
 /**
@@ -543,8 +545,12 @@ declare function getProviderSignatureFields(aiType: string, signature?: string):
  * - Moonshot Kimi K3 (platform.kimi.ai/docs/guide/use-reasoning-effort, 2026-09-22):
  *   low|high|max, default max, top-level on Chat Completions. Moonshot shipped the lower
  *   levels after launch; K3 accepted only "max" when this agent was written.
- * Qwen accepts reasoning_effort but ignores it (thinking_budget is its knob); MiniMax exposes
- * no effort parameter.
+ * - Qwen 3.8 max/flash (docs.qwencloud.com, re-probed 2026-09-22): low|medium|xhigh, default
+ *   xhigh, with `high` and `max` aliased onto xhigh and `minimal` onto low. It is a coarse
+ *   alias for thinking_budget (low = 4,096, medium = 16,384, xhigh = 262,144 tokens) and the
+ *   two are mutually exclusive — sending both is a 400. QwenAgent sends the budget instead,
+ *   because 1,024 is tighter than the lowest level effort can express.
+ * MiniMax exposes no effort parameter.
  */
 type OpenAIReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 type AnthropicReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
@@ -1403,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
@@ -1704,14 +1728,30 @@ declare class QwenAgent extends AbstractAgent {
      * generation); without it the model thinks at the provider default, and qwen3.8-max's
      * latency then swings 30–100s.
      *
-     * `reasoning_effort` is deliberately NOT sent. Probed live 2026-08-30 on qwen3.8-flash and
-     * qwen3.8-max: every value low..max is accepted, but reasoning length doesn't track it
-     * (max: low → 1,686 reasoning tokens / 44s, high → 226 / 7s, xhigh → 1,102 / 30s), while
-     * thinking_budget bounds it reliably (≤340 at 1024). The docs also call the two mutually
-     * exclusive on qwen3.8-max. So on Qwen the budget IS the effort knob; `reasoningEffort`
-     * on this agent is ignored.
+     * `reasoning_effort` is NOT sent, and the earlier reason recorded here was wrong. The
+     * 2026-08-30 probe concluded "reasoning length doesn't track effort"; it had tested
+     * low/high/max/xhigh, but Qwen only defines low|medium|xhigh and aliases both `high` and
+     * `max` onto `xhigh`. So that probe compared low against xhigh twice and read the noise as
+     * non-monotonicity.
+     *
+     * Re-probed 2026-09-22 with the documented levels, and effort tracks cleanly:
+     *   qwen3.8-max     budget 1024 → 77 reasoning | low 132 | medium 160 | xhigh 422
+     *   qwen3.8-flash   budget 1024 → 86 reasoning | low  87 | medium 251 | xhigh 417
+     *
+     * We still send the budget, for a better reason: the two are mutually exclusive (sending
+     * both is a 400), Qwen documents effort as a coarse alias for a budget (low = 4,096,
+     * medium = 16,384, xhigh = 262,144 tokens), and our 1,024 is tighter than the lowest level
+     * it can express. The budget is the finer AND cheaper knob here, so `reasoningEffort` on
+     * 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) {
@@ -4747,24 +4800,49 @@ var QwenAgent = class extends AbstractAgent {
    * generation); without it the model thinks at the provider default, and qwen3.8-max's
    * latency then swings 30–100s.
    *
-   * `reasoning_effort` is deliberately NOT sent. Probed live 2026-08-30 on qwen3.8-flash and
-   * qwen3.8-max: every value low..max is accepted, but reasoning length doesn't track it
-   * (max: low → 1,686 reasoning tokens / 44s, high → 226 / 7s, xhigh → 1,102 / 30s), while
-   * thinking_budget bounds it reliably (≤340 at 1024). The docs also call the two mutually
-   * exclusive on qwen3.8-max. So on Qwen the budget IS the effort knob; `reasoningEffort`
-   * on this agent is ignored.
+   * `reasoning_effort` is NOT sent, and the earlier reason recorded here was wrong. The
+   * 2026-08-30 probe concluded "reasoning length doesn't track effort"; it had tested
+   * low/high/max/xhigh, but Qwen only defines low|medium|xhigh and aliases both `high` and
+   * `max` onto `xhigh`. So that probe compared low against xhigh twice and read the noise as
+   * non-monotonicity.
+   *
+   * Re-probed 2026-09-22 with the documented levels, and effort tracks cleanly:
+   *   qwen3.8-max     budget 1024 → 77 reasoning | low 132 | medium 160 | xhigh 422
+   *   qwen3.8-flash   budget 1024 → 86 reasoning | low  87 | medium 251 | xhigh 417
+   *
+   * We still send the budget, for a better reason: the two are mutually exclusive (sending
+   * both is a 400), Qwen documents effort as a coarse alias for a budget (low = 4,096,
+   * medium = 16,384, xhigh = 262,144 tokens), and our 1,024 is tighter than the lowest level
+   * it can express. The budget is the finer AND cheaper knob here, so `reasoningEffort` on
+   * this agent stays ignored — deliberately, not because effort is broken.
    */
   thinkingParams() {
     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) {