@hiper2d/ai-agents 0.13.0 → 0.14.1

package/dist/index.mjs

@@ -1527,6 +1527,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 +2354,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 +2413,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 +2423,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 +2485,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 +2504,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 +2553,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) {
@@ -4572,24 +4625,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) {