@hiper2d/ai-agents 0.12.0 → 0.13.1

package/dist/index.d.mts

@@ -543,8 +543,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';
@@ -1394,6 +1398,15 @@ declare class Gpt5Agent extends AbstractAgent {
     private readonly logTemplates;
     private readonly errorMessages;
     constructor(name: string, instruction: string, model: string, apiKey: string, temperature: number, enableThinking?: boolean, agentLoggingConfig?: AgentLoggingConfig);
+    /**
+     * `reasoning: {effort}`, sent only when the catalog names a level. Every current OpenAI
+     * model defaults to "medium" when the field is omitted — verified 2026-09-22 by calling
+     * astra/sol/terra/luna with no reasoning param and reading the effort the API echoes back,
+     * since OpenAI documents the default for Sol, Luna and the 5.6 family but not for Astra.
+     * The catalog pins all four to medium so the level is explicit in our request rather than
+     * inherited from a default OpenAI can change under us.
+     */
+    private reasoningParams;
     /**
      * Structured output method using Zod with OpenAI's Responses API
      * This provides better schema handling and runtime validation
@@ -1695,12 +1708,21 @@ 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;
     private convertToOpenAIMessages;

package/dist/index.d.ts

@@ -543,8 +543,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';
@@ -1394,6 +1398,15 @@ declare class Gpt5Agent extends AbstractAgent {
     private readonly logTemplates;
     private readonly errorMessages;
     constructor(name: string, instruction: string, model: string, apiKey: string, temperature: number, enableThinking?: boolean, agentLoggingConfig?: AgentLoggingConfig);
+    /**
+     * `reasoning: {effort}`, sent only when the catalog names a level. Every current OpenAI
+     * model defaults to "medium" when the field is omitted — verified 2026-09-22 by calling
+     * astra/sol/terra/luna with no reasoning param and reading the effort the API echoes back,
+     * since OpenAI documents the default for Sol, Luna and the 5.6 family but not for Astra.
+     * The catalog pins all four to medium so the level is explicit in our request rather than
+     * inherited from a default OpenAI can change under us.
+     */
+    private reasoningParams;
     /**
      * Structured output method using Zod with OpenAI's Responses API
      * This provides better schema handling and runtime validation
@@ -1695,12 +1708,21 @@ 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;
     private convertToOpenAIMessages;

package/dist/index.js

@@ -1061,10 +1061,16 @@ var SupportedAiModels = {
   // GPT-6 Astra (2026-09-03): OpenAI's frontier tier above Sol. No `none` reasoning effort;
   // temperature/top_p are rejected — Gpt5Agent sends neither, so the same agent serves it.
   // The catalog temperature is only carried for the agent constructor signature.
+  // All four OpenAI entries carry reasoningEffort: 'medium' as of 2026-09-22. That is
+  // OpenAI's own current default, established by MEASUREMENT rather than docs: each model was
+  // called with no reasoning param and the effort it echoes back read off the response, since
+  // OpenAI documents the default for Sol, Luna and the 5.6 family but never states Astra's.
+  // Pinning it changes no behaviour today; it stops the default moving under us silently.
   [LLM_CONSTANTS.GPT_ASTRA]: {
     displayName: "GPT-6 Astra",
     modelApiName: "gpt-6-astra",
     apiKeyName: API_KEY_CONSTANTS.OPENAI,
+    reasoningEffort: "medium",
     hasThinking: true,
     temperature: 1,
     tags: ["expensive"]
@@ -1079,6 +1085,7 @@ var SupportedAiModels = {
     displayName: "GPT-6 Sol",
     modelApiName: "gpt-6-sol",
     apiKeyName: API_KEY_CONSTANTS.OPENAI,
+    reasoningEffort: "medium",
     hasThinking: true,
     temperature: 1,
     tags: ["expensive"]
@@ -1087,6 +1094,7 @@ var SupportedAiModels = {
     displayName: "GPT-5.6 Terra",
     modelApiName: "gpt-5.6-terra",
     apiKeyName: API_KEY_CONSTANTS.OPENAI,
+    reasoningEffort: "medium",
     hasThinking: true,
     temperature: 1,
     tags: ["fast", "expensive"]
@@ -1095,6 +1103,7 @@ var SupportedAiModels = {
     displayName: "GPT-6 Luna",
     modelApiName: "gpt-6-luna",
     apiKeyName: API_KEY_CONSTANTS.OPENAI,
+    reasoningEffort: "medium",
     hasThinking: true,
     temperature: 1,
     tags: ["fast", "cheap"]
@@ -2508,6 +2517,17 @@ ${instruction}`);
       apiKey
     });
   }
+  /**
+   * `reasoning: {effort}`, sent only when the catalog names a level. Every current OpenAI
+   * model defaults to "medium" when the field is omitted — verified 2026-09-22 by calling
+   * astra/sol/terra/luna with no reasoning param and reading the effort the API echoes back,
+   * since OpenAI documents the default for Sol, Luna and the 5.6 family but not for Astra.
+   * The catalog pins all four to medium so the level is explicit in our request rather than
+   * inherited from a default OpenAI can change under us.
+   */
+  reasoningParams() {
+    return this.reasoningEffort ? { reasoning: { effort: toOpenAIEffort(this.reasoningEffort) } } : {};
+  }
   /**
    * Structured output method using Zod with OpenAI's Responses API
    * This provides better schema handling and runtime validation
@@ -2528,6 +2548,7 @@ ${instruction}`);
           input,
           max_output_tokens: this.maxOutputTokens,
           prompt_cache_key: this.promptCacheKey,
+          ...this.reasoningParams(),
           text: {
             format: (0, import_zod2.zodTextFormat)(schemaToSend, "response_schema")
           }
@@ -2612,7 +2633,8 @@ ${instruction}`);
         instructions: this.instruction,
         input,
         max_output_tokens: this.maxOutputTokens,
-        prompt_cache_key: this.promptCacheKey
+        prompt_cache_key: this.promptCacheKey,
+        ...this.reasoningParams()
       });
       const content = response.output_text;
       if (!content) {
@@ -4725,12 +4747,21 @@ 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;