@orxataguy/tyr 1.0.33 → 1.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/lib/AIVendorManager.ts

@@ -43,9 +43,10 @@ export interface AITool {
 
 /**
  * Nivel de "esfuerzo de razonamiento" (extended thinking) pedido al modelo, independiente del
- * vendor concreto. Se traduce a `thinking.budget_tokens` en Anthropic y a `reasoning_effort` en
- * los modelos de OpenAI que lo soportan (serie 'o'); Gemini no tiene un equivalente público en
- * este momento y el valor se ignora silenciosamente para ese vendor.
+ * vendor concreto. Se traduce a `thinking.budget_tokens` en Anthropic, a
+ * `generationConfig.thinkingConfig.thinkingBudget` en Gemini 2.5+ (mismo concepto de presupuesto
+ * de tokens que Anthropic) y a `reasoning_effort` en los modelos de OpenAI que lo soportan (serie
+ * 'o'), que solo acepta un vocabulario fijo (low/medium/high) en lugar de un número de tokens.
  */
 export type ThinkingEffort = 'none' | 'low' | 'medium' | 'high' | 'max';
 
@@ -130,11 +131,6 @@ const RETRY_BASE_DELAY_MS = 500;
 // touching code. 'balanced' matches DEFAULT_MODELS on purpose — it's the vendor's normal default.
 type ModelTier = 'cheap' | 'balanced' | 'flagship';
 
-const MODEL_TIERS: Record<AIVendor, Record<ModelTier, string>> = {
-    anthropic: { cheap: 'claude-haiku-4-5', balanced: 'claude-sonnet-5', flagship: 'claude-opus-4-1' },
-    openai: { cheap: 'gpt-4o-mini', balanced: 'gpt-4o-mini', flagship: 'gpt-4o' },
-    gemini: { cheap: 'gemini-2.5-flash', balanced: 'gemini-2.5-pro', flagship: 'gemini-2.5-pro' },
-};
 
 const MODEL_TIER_ENV: Record<AIVendor, Record<ModelTier, string>> = {
     anthropic: { cheap: 'ANTHROPIC_AI_MODEL_CHEAP', balanced: 'ANTHROPIC_AI_MODEL_BALANCED', flagship: 'ANTHROPIC_AI_MODEL_FLAGSHIP' },
@@ -142,8 +138,36 @@ const MODEL_TIER_ENV: Record<AIVendor, Record<ModelTier, string>> = {
     gemini: { cheap: 'GEMINI_AI_MODEL_CHEAP', balanced: 'GEMINI_AI_MODEL_BALANCED', flagship: 'GEMINI_AI_MODEL_FLAGSHIP' },
 };
 
-/** budget_tokens sent to Anthropic's `thinking` param per effort level. 'none' disables thinking. */
-const THINKING_BUDGETS: Record<ThinkingEffort, number> = {
+
+const MODEL_TIER_DEFAULT: Record<string,string> = {
+    anthropic: 'claude-haiku-4-5-20251001',
+    openai: 'gpt-4o-mini-2024-07-18',
+    gemini: 'gemini-2.5-flash-lite',
+   };
+
+/** budget_tokens sent to Anthropic's `thinking` param per effort level. 'none' disables thinking.
+ *  Each is overridable via env var (see ANTHROPIC_THINKING_BUDGET_ENV); these are the fallback
+ *  values used when the corresponding env var is not set. */
+const ANTHROPIC_THINKING_BUDGETS: Record<ThinkingEffort, number> = {
+    none: 0,
+    low: 1024,
+    medium: 4096,
+    high: 8192,
+    max: 16384,
+};
+
+const ANTHROPIC_THINKING_BUDGET_ENV: Record<ThinkingEffort, string> = {
+    none: 'ANTHROPIC_THINKING_BUDGET_NONE',
+    low: 'ANTHROPIC_THINKING_BUDGET_LOW',
+    medium: 'ANTHROPIC_THINKING_BUDGET_MEDIUM',
+    high: 'ANTHROPIC_THINKING_BUDGET_HIGH',
+    max: 'ANTHROPIC_THINKING_BUDGET_MAX',
+};
+
+/** Gemini 2.5+'s `generationConfig.thinkingConfig.thinkingBudget` is the same token-budget concept
+ *  as Anthropic's, so it reuses the same default magnitudes — overridable independently via its
+ *  own env vars since Gemini's actual valid range differs by model (flash allows 0, pro doesn't). */
+const GEMINI_THINKING_BUDGETS: Record<ThinkingEffort, number> = {
     none: 0,
     low: 1024,
     medium: 4096,
@@ -151,20 +175,92 @@ const THINKING_BUDGETS: Record<ThinkingEffort, number> = {
     max: 16384,
 };
 
+const GEMINI_THINKING_BUDGET_ENV: Record<ThinkingEffort, string> = {
+    none: 'GEMINI_THINKING_BUDGET_NONE',
+    low: 'GEMINI_THINKING_BUDGET_LOW',
+    medium: 'GEMINI_THINKING_BUDGET_MEDIUM',
+    high: 'GEMINI_THINKING_BUDGET_HIGH',
+    max: 'GEMINI_THINKING_BUDGET_MAX',
+};
+
+function resolveThinkingBudget(
+    effort: ThinkingEffort,
+    defaults: Record<ThinkingEffort, number>,
+    env: Record<ThinkingEffort, string>
+): number {
+    return getEnvInt(env[effort], defaults[effort]);
+}
+
+/** OpenAI's reasoning models (serie 'o', gpt-5*) solo aceptan un vocabulario fijo para
+ *  `reasoning_effort` — no un número de tokens — así que aquí se mapea ThinkingEffort a esas
+ *  cadenas en lugar de a un budget. 'none' está ausente a propósito: esos modelos no permiten
+ *  desactivar el razonamiento, así que ThinkingEffort 'none' simplemente omite el parámetro
+ *  (ver openaiReasoningFields). Cada nivel es overridable vía env var por si OpenAI cambia el
+ *  vocabulario aceptado (p.ej. añade 'minimal') sin tener que tocar código. */
+const OPENAI_REASONING_EFFORTS: Partial<Record<ThinkingEffort, string>> = {
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    max: 'high',
+};
+
+const OPENAI_REASONING_EFFORT_ENV: Partial<Record<ThinkingEffort, string>> = {
+    low: 'OPENAI_REASONING_EFFORT_LOW',
+    medium: 'OPENAI_REASONING_EFFORT_MEDIUM',
+    high: 'OPENAI_REASONING_EFFORT_HIGH',
+    max: 'OPENAI_REASONING_EFFORT_MAX',
+};
+
+function resolveOpenAIReasoningEffort(effort: ThinkingEffort): string | undefined {
+    const envVar = OPENAI_REASONING_EFFORT_ENV[effort];
+    const override = envVar ? getEnvString(envVar) : undefined;
+    return override ?? OPENAI_REASONING_EFFORTS[effort];
+}
+
 /**
  * Task-priority → (model tier, thinking effort) matrix. This is the routing table requested by
  * the architecture spec: callers pick a priority by *intent* ("this is a trivial file", "this
  * previous attempt failed"), not by model name, and AIVendorManager decides what that costs.
+ * Each entry is overridable via env var (see PRIORITY_ROUTING_ENV); these are the fallback values
+ * used when the corresponding env var is unset or holds an invalid tier/thinking value.
  */
 const PRIORITY_ROUTING: Record<TaskPriority, { tier: ModelTier; thinking: ThinkingEffort }> = {
     'baja-prioridad': { tier: 'cheap', thinking: 'none' },
-    'baja-media-prioridad': { tier: 'cheap', thinking: 'max' },
+    'baja-media-prioridad': { tier: 'cheap', thinking: 'high' },
     'media-prioridad': { tier: 'balanced', thinking: 'none' },
     'media-alta-prioridad': { tier: 'balanced', thinking: 'high' },
     'alta-prioridad': { tier: 'balanced', thinking: 'max' },
     'muy-alta-prioridad': { tier: 'flagship', thinking: 'max' },
 };
 
+const PRIORITY_ROUTING_ENV: Record<TaskPriority, { tier: string; thinking: string }> = {
+    'baja-prioridad': { tier: 'AI_PRIORITY_BAJA_TIER', thinking: 'AI_PRIORITY_BAJA_THINKING' },
+    'baja-media-prioridad': { tier: 'AI_PRIORITY_BAJA_MEDIA_TIER', thinking: 'AI_PRIORITY_BAJA_MEDIA_THINKING' },
+    'media-prioridad': { tier: 'AI_PRIORITY_MEDIA_TIER', thinking: 'AI_PRIORITY_MEDIA_THINKING' },
+    'media-alta-prioridad': { tier: 'AI_PRIORITY_MEDIA_ALTA_TIER', thinking: 'AI_PRIORITY_MEDIA_ALTA_THINKING' },
+    'alta-prioridad': { tier: 'AI_PRIORITY_ALTA_TIER', thinking: 'AI_PRIORITY_ALTA_THINKING' },
+    'muy-alta-prioridad': { tier: 'AI_PRIORITY_MUY_ALTA_TIER', thinking: 'AI_PRIORITY_MUY_ALTA_THINKING' },
+};
+
+const VALID_MODEL_TIERS: ModelTier[] = ['cheap', 'balanced', 'flagship'];
+const VALID_THINKING_EFFORTS: ThinkingEffort[] = ['none', 'low', 'medium', 'high', 'max'];
+
+/** Resolves the (tier, thinking) route for a priority, letting env vars override either half of
+ *  PRIORITY_ROUTING independently. An env var holding anything other than a valid tier/thinking
+ *  value is ignored in favor of the hardcoded default, rather than passed through to the vendor. */
+function resolvePriorityRoute(priority: TaskPriority): { tier: ModelTier; thinking: ThinkingEffort } {
+    const defaults = PRIORITY_ROUTING[priority];
+    const envVars = PRIORITY_ROUTING_ENV[priority];
+
+    const tierOverride = getEnvString(envVars.tier)?.toLowerCase() as ModelTier | undefined;
+    const thinkingOverride = getEnvString(envVars.thinking)?.toLowerCase() as ThinkingEffort | undefined;
+
+    return {
+        tier: tierOverride && VALID_MODEL_TIERS.includes(tierOverride) ? tierOverride : defaults.tier,
+        thinking: thinkingOverride && VALID_THINKING_EFFORTS.includes(thinkingOverride) ? thinkingOverride : defaults.thinking,
+    };
+}
+
 /** Ordered priority ladder, used by bumpPriority() to escalate one level at a time. */
 const PRIORITY_LADDER: TaskPriority[] = [
     'baja-prioridad',
@@ -255,12 +351,12 @@ export class AIVendorManager {
             .toString()
             .toLowerCase() as AIVendor;
 
-        const route = PRIORITY_ROUTING[priority];
-        if (!route) {
+        if (!PRIORITY_ROUTING[priority]) {
             throw new TyrError(`Unknown task priority: '${priority}'`, null, `Use one of: ${PRIORITY_LADDER.join(', ')}`);
         }
+        const route = resolvePriorityRoute(priority);
 
-        const tierModel = getEnvString(MODEL_TIER_ENV[vendor][route.tier]) ?? MODEL_TIERS[vendor][route.tier];
+        const tierModel = getEnvString(MODEL_TIER_ENV[vendor][route.tier], MODEL_TIER_DEFAULT[vendor]);
 
         return {
             vendor,
@@ -470,7 +566,7 @@ export class AIVendorManager {
     /** Anthropic's extended thinking requires temperature === 1 and max_tokens strictly greater
      *  than budget_tokens; both are enforced here so callers never have to remember it. */
     private anthropicThinkingFields(config: VendorConfig): { thinking?: any; temperature: number; max_tokens: number } {
-        const budget = THINKING_BUDGETS[config.thinking];
+        const budget = resolveThinkingBudget(config.thinking, ANTHROPIC_THINKING_BUDGETS, ANTHROPIC_THINKING_BUDGET_ENV);
         if (!budget) return { temperature: config.temperature, max_tokens: config.maxTokens };
 
         return {
@@ -481,14 +577,23 @@ export class AIVendorManager {
     }
 
     /** OpenAI's `reasoning_effort` only exists on the 'o' reasoning model family and only accepts
-     *  low/medium/high (no 'none'/'max') — mapped from our vendor-agnostic ThinkingEffort. Those
-     *  models also reject a custom `temperature`, so it's omitted whenever reasoning_effort is set. */
+     *  a fixed vocabulary (no 'none') — mapped from our vendor-agnostic ThinkingEffort via
+     *  OPENAI_REASONING_EFFORTS/_ENV. Those models also reject a custom `temperature`, so it's
+     *  omitted whenever reasoning_effort is set. */
     private openaiReasoningFields(config: VendorConfig): { reasoning_effort?: string; temperature?: number } {
         const isReasoningModel = /^o\d/.test(config.model);
         if (!isReasoningModel || config.thinking === 'none') return { temperature: config.temperature };
 
-        const effortMap: Partial<Record<ThinkingEffort, string>> = { low: 'low', medium: 'medium', high: 'high', max: 'high' };
-        return { reasoning_effort: effortMap[config.thinking] };
+        return { reasoning_effort: resolveOpenAIReasoningEffort(config.thinking) };
+    }
+
+    /** Gemini 2.5+'s `thinkingConfig.thinkingBudget` is omitted entirely for 'none' rather than
+     *  sent as 0, because 0 is invalid on Pro models (which can't fully disable thinking) — only
+     *  Flash accepts it. Omitting the field is the safe "off" behavior across both. */
+    private geminiThinkingFields(config: VendorConfig): { thinkingConfig?: { thinkingBudget: number } } {
+        if (config.thinking === 'none') return {};
+        const budget = resolveThinkingBudget(config.thinking, GEMINI_THINKING_BUDGETS, GEMINI_THINKING_BUDGET_ENV);
+        return { thinkingConfig: { thinkingBudget: budget } };
     }
 
     private buildRequest(config: VendorConfig, messages: AIMessage[], stream: boolean, tools?: AITool[]): VendorRequest {
@@ -541,6 +646,7 @@ export class AIVendorManager {
 
             case 'gemini': {
                 const action = stream ? 'streamGenerateContent?alt=sse&' : 'generateContent?';
+                const thinkingFields = this.geminiThinkingFields(config);
                 return {
                     url: `https://generativelanguage.googleapis.com/v1beta/models/${config.model}:${action}key=${config.apiKey}`,
                     headers: { 'content-type': 'application/json' },
@@ -550,6 +656,7 @@ export class AIVendorManager {
                         generationConfig: {
                             temperature: config.temperature,
                             maxOutputTokens: config.maxTokens,
+                            ...thinkingFields,
                         },
                         ...(vendorTools ? { tools: vendorTools } : {}),
                     },