@jaypie/llm 1.3.8 → 1.3.10

package/dist/esm/index.js

@@ -11,61 +11,61 @@ import { resolve } from 'path';
 import { getS3FileBuffer, getEnvSecret } from '@jaypie/aws';
 import { fetchWeatherApi } from 'openmeteo';
 
-const FIRST_CLASS_PROVIDER = {
-    // https://docs.anthropic.com/en/docs/about-claude/models/overview
-    ANTHROPIC: {
-        DEFAULT: "claude-sonnet-4-6",
-        LARGE: "claude-opus-4-8",
-        SMALL: "claude-sonnet-4-6",
-        TINY: "claude-haiku-4-5",
-    },
-    // https://ai.google.dev/gemini-api/docs/models
-    GOOGLE: {
-        DEFAULT: "gemini-3.1-pro-preview",
-        LARGE: "gemini-3.1-pro-preview",
-        SMALL: "gemini-3.5-flash",
-        TINY: "gemini-3.1-flash-lite",
-    },
-    // https://developers.openai.com/api/docs/models
-    OPENAI: {
-        DEFAULT: "gpt-5.4",
-        LARGE: "gpt-5.5",
-        SMALL: "gpt-5.4-mini",
-        TINY: "gpt-5.4-nano",
-    },
-    // https://docs.x.ai/developers/models
-    XAI: {
-        DEFAULT: "grok-latest",
-        LARGE: "grok-4.3-latest",
-        SMALL: "grok-4-1-fast-reasoning",
-        TINY: "grok-4-1-fast-non-reasoning",
-    },
+/**
+ * Provider-neutral reasoning-effort levels — a five-point relative scale that
+ * deliberately borrows no provider's vocabulary. Each adapter translates these
+ * to its provider's native control (OpenAI `reasoning.effort`, Anthropic
+ * `output_config.effort`, Gemini `thinkingLevel`/`thinkingBudget`, Grok
+ * `reasoning_effort`, OpenRouter `reasoning.effort`), spreading the scale across
+ * the provider's available range. Omitting `effort` leaves the provider default
+ * untouched, so it is safe to set across a fallback chain.
+ */
+const EFFORT = {
+    LOWEST: "lowest",
+    LOW: "low",
+    MEDIUM: "medium",
+    HIGH: "high",
+    HIGHEST: "highest",
 };
 const MODEL = {
     // Anthropic
+    FABLE: "claude-fable-5",
     OPUS: "claude-opus-4-8",
-    SONNET: "claude-sonnet-4-6",
+    SONNET: "claude-sonnet-5",
     HAIKU: "claude-haiku-4-5",
-    FABLE: "claude-fable-5",
     MYTHOS: "claude-mythos-5",
     // Google
     GEMINI_FLASH: "gemini-3.5-flash",
     GEMINI_FLASH_LITE: "gemini-3.1-flash-lite",
     GEMINI_PRO: "gemini-3.1-pro-preview",
     // OpenAI
+    SOL: "gpt-5.6-sol",
+    TERRA: "gpt-5.6-terra",
+    LUNA: "gpt-5.6-luna",
+    /** @deprecated use MODEL.SOL (gpt-5.6-sol) */
     GPT: "gpt-5.5",
+    /** @deprecated use MODEL.TERRA (gpt-5.6-terra) */
     GPT_MINI: "gpt-5.4-mini",
+    /** @deprecated use MODEL.LUNA (gpt-5.6-luna) */
     GPT_NANO: "gpt-5.4-nano",
     // xAI
     GROK: "grok-latest",
+    // OpenRouter (provider-prefixed routes; traversed by the OpenRouter hot test)
+    OPENROUTER: {
+        GLM: "z-ai/glm-5.2",
+        LUNA: "openai/gpt-5.6-luna",
+        SONNET: "anthropic/claude-sonnet-5",
+    },
 };
 const GOOGLE_PROVIDER = {
     // https://ai.google.dev/gemini-api/docs/models
+    DEFAULT: MODEL.GEMINI_FLASH,
+    /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.GOOGLE.DEFAULT, or pick a specific model from MODEL.*. */
     MODEL: {
-        DEFAULT: FIRST_CLASS_PROVIDER.GOOGLE.DEFAULT,
-        LARGE: FIRST_CLASS_PROVIDER.GOOGLE.LARGE,
-        SMALL: FIRST_CLASS_PROVIDER.GOOGLE.SMALL,
-        TINY: FIRST_CLASS_PROVIDER.GOOGLE.TINY,
+        DEFAULT: "gemini-3.1-pro-preview",
+        LARGE: "gemini-3.1-pro-preview",
+        SMALL: "gemini-3.5-flash",
+        TINY: "gemini-3.1-flash-lite",
     },
     MODEL_MATCH_WORDS: ["gemini", "google"],
     NAME: "google",
@@ -77,6 +77,10 @@ const GOOGLE_PROVIDER = {
 const PROVIDER = {
     // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
     BEDROCK: {
+        // Bedrock has no MODEL.* catalog entry yet; keep the literal default id.
+        // nova-pro is the Amazon-native model that reliably does tools+structured.
+        DEFAULT: "amazon.nova-pro-v1:0",
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.BEDROCK.DEFAULT. */
         MODEL: {
             DEFAULT: "amazon.nova-lite-v1:0",
             LARGE: "amazon.nova-pro-v1:0",
@@ -97,22 +101,26 @@ const PROVIDER = {
     },
     ANTHROPIC: {
         // https://docs.anthropic.com/en/docs/about-claude/models/overview
+        DEFAULT: MODEL.SONNET,
         MAX_TOKENS: {
             // Non-streaming ceiling: responses above ~16K output tokens risk HTTP
             // timeouts; streaming requests resolve to the model maximum instead
             // (see util/maxOutputTokens.ts)
             DEFAULT: 16384,
         },
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.ANTHROPIC.DEFAULT, or pick a specific model from MODEL.*. */
         MODEL: {
-            DEFAULT: FIRST_CLASS_PROVIDER.ANTHROPIC.DEFAULT,
-            LARGE: FIRST_CLASS_PROVIDER.ANTHROPIC.LARGE,
-            SMALL: FIRST_CLASS_PROVIDER.ANTHROPIC.SMALL,
-            TINY: FIRST_CLASS_PROVIDER.ANTHROPIC.TINY,
+            DEFAULT: "claude-sonnet-4-6",
+            LARGE: "claude-opus-4-8",
+            SMALL: "claude-sonnet-4-6",
+            TINY: "claude-haiku-4-5",
         },
         MODEL_MATCH_WORDS: [
             "anthropic",
             "claude",
+            "fable",
             "haiku",
+            "mythos",
             "opus",
             "sonnet",
         ],
@@ -135,21 +143,25 @@ const PROVIDER = {
     GOOGLE: GOOGLE_PROVIDER,
     OPENAI: {
         // https://platform.openai.com/docs/models
+        DEFAULT: MODEL.SOL,
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.OPENAI.DEFAULT, or pick a specific model from MODEL.*. */
         MODEL: {
-            DEFAULT: FIRST_CLASS_PROVIDER.OPENAI.DEFAULT,
-            LARGE: FIRST_CLASS_PROVIDER.OPENAI.LARGE,
-            SMALL: FIRST_CLASS_PROVIDER.OPENAI.SMALL,
-            TINY: FIRST_CLASS_PROVIDER.OPENAI.TINY,
+            DEFAULT: "gpt-5.4",
+            LARGE: "gpt-5.5",
+            SMALL: "gpt-5.4-mini",
+            TINY: "gpt-5.4-nano",
         },
-        MODEL_MATCH_WORDS: ["openai", "gpt", /^o\d/],
+        MODEL_MATCH_WORDS: ["gpt", "luna", "openai", "sol", "terra", /^o\d/],
         NAME: "openai",
     },
     OPENROUTER: {
+        DEFAULT: MODEL.OPENROUTER.SONNET,
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.OPENROUTER.DEFAULT, or pick a specific route from MODEL.OPENROUTER.*. */
         MODEL: {
-            DEFAULT: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.DEFAULT}`,
-            LARGE: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.LARGE}`,
-            SMALL: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.SMALL}`,
-            TINY: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.TINY}`,
+            DEFAULT: "anthropic/claude-sonnet-4-6",
+            LARGE: "anthropic/claude-opus-4-8",
+            SMALL: "anthropic/claude-sonnet-4-6",
+            TINY: "anthropic/claude-haiku-4-5",
         },
         MODEL_MATCH_WORDS: ["openrouter"],
         NAME: "openrouter",
@@ -164,11 +176,13 @@ const PROVIDER = {
         // https://docs.x.ai/docs/models
         API_KEY: "XAI_API_KEY",
         BASE_URL: "https://api.x.ai/v1",
+        DEFAULT: MODEL.GROK,
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.XAI.DEFAULT, or pick a specific model from MODEL.*. */
         MODEL: {
-            DEFAULT: FIRST_CLASS_PROVIDER.XAI.DEFAULT,
-            LARGE: FIRST_CLASS_PROVIDER.XAI.LARGE,
-            SMALL: FIRST_CLASS_PROVIDER.XAI.SMALL,
-            TINY: FIRST_CLASS_PROVIDER.XAI.TINY,
+            DEFAULT: "grok-latest",
+            LARGE: "grok-latest",
+            SMALL: "grok-4-1-fast-reasoning",
+            TINY: "grok-4-1-fast-non-reasoning",
         },
         MODEL_MATCH_WORDS: ["grok", "xai"],
         NAME: "xai",
@@ -176,6 +190,7 @@ const PROVIDER = {
 };
 // Last: Defaults
 const DEFAULT = {
+    /** @deprecated Size tiers are retired in 2.0. Use DEFAULT.PROVIDER.DEFAULT, or pick a specific model from MODEL.*. */
     MODEL: {
         BASE: PROVIDER.OPENAI.MODEL.DEFAULT,
         LARGE: PROVIDER.OPENAI.MODEL.LARGE,
@@ -184,6 +199,10 @@ const DEFAULT = {
     },
     PROVIDER: PROVIDER.OPENAI,
 };
+/**
+ * @deprecated Size-tier catalogs are retired in 2.0. Pick specific models from
+ * MODEL.* (grouped by provider via MODEL_MATCH_WORDS / determineModelProvider).
+ */
 // Only include "first class" models, not OpenRouter or other proxy services
 const ALL = {
     BASE: [
@@ -236,6 +255,7 @@ var constants = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ALL: ALL,
     DEFAULT: DEFAULT,
+    EFFORT: EFFORT,
     MODEL: MODEL,
     PROVIDER: PROVIDER
 });
@@ -243,7 +263,7 @@ var constants = /*#__PURE__*/Object.freeze({
 function determineModelProvider(input) {
     if (!input) {
         return {
-            model: DEFAULT.PROVIDER.MODEL.DEFAULT,
+            model: DEFAULT.PROVIDER.DEFAULT,
             provider: DEFAULT.PROVIDER.NAME,
         };
     }
@@ -266,85 +286,42 @@ function determineModelProvider(input) {
     // Check if input is a provider name
     if (input === PROVIDER.BEDROCK.NAME) {
         return {
-            model: PROVIDER.BEDROCK.MODEL.DEFAULT,
+            model: PROVIDER.BEDROCK.DEFAULT,
             provider: PROVIDER.BEDROCK.NAME,
         };
     }
     if (input === PROVIDER.ANTHROPIC.NAME) {
         return {
-            model: PROVIDER.ANTHROPIC.MODEL.DEFAULT,
+            model: PROVIDER.ANTHROPIC.DEFAULT,
             provider: PROVIDER.ANTHROPIC.NAME,
         };
     }
     if (input === PROVIDER.GOOGLE.NAME || input === "gemini") {
         return {
-            model: PROVIDER.GOOGLE.MODEL.DEFAULT,
+            model: PROVIDER.GOOGLE.DEFAULT,
             provider: PROVIDER.GOOGLE.NAME,
         };
     }
     if (input === PROVIDER.OPENAI.NAME) {
         return {
-            model: PROVIDER.OPENAI.MODEL.DEFAULT,
+            model: PROVIDER.OPENAI.DEFAULT,
             provider: PROVIDER.OPENAI.NAME,
         };
     }
     if (input === PROVIDER.OPENROUTER.NAME) {
         return {
-            model: PROVIDER.OPENROUTER.MODEL.DEFAULT,
+            model: PROVIDER.OPENROUTER.DEFAULT,
             provider: PROVIDER.OPENROUTER.NAME,
         };
     }
     if (input === PROVIDER.XAI.NAME) {
         return {
-            model: PROVIDER.XAI.MODEL.DEFAULT,
+            model: PROVIDER.XAI.DEFAULT,
             provider: PROVIDER.XAI.NAME,
         };
     }
-    // Check if input matches an Anthropic model exactly
-    for (const [, modelValue] of Object.entries(PROVIDER.ANTHROPIC.MODEL)) {
-        if (input === modelValue) {
-            return {
-                model: input,
-                provider: PROVIDER.ANTHROPIC.NAME,
-            };
-        }
-    }
-    // Check if input matches a Gemini model exactly
-    for (const [, modelValue] of Object.entries(PROVIDER.GOOGLE.MODEL)) {
-        if (input === modelValue) {
-            return {
-                model: input,
-                provider: PROVIDER.GOOGLE.NAME,
-            };
-        }
-    }
-    // Check if input matches an OpenAI model exactly
-    for (const [, modelValue] of Object.entries(PROVIDER.OPENAI.MODEL)) {
-        if (input === modelValue) {
-            return {
-                model: input,
-                provider: PROVIDER.OPENAI.NAME,
-            };
-        }
-    }
-    // Check if input matches an OpenRouter model exactly
-    for (const [, modelValue] of Object.entries(PROVIDER.OPENROUTER.MODEL)) {
-        if (input === modelValue) {
-            return {
-                model: input,
-                provider: PROVIDER.OPENROUTER.NAME,
-            };
-        }
-    }
-    // Check if input matches an xAI model exactly
-    for (const [, modelValue] of Object.entries(PROVIDER.XAI.MODEL)) {
-        if (input === modelValue) {
-            return {
-                model: input,
-                provider: PROVIDER.XAI.NAME,
-            };
-        }
-    }
+    // Exact model ids are classified by the "/" rule and MODEL_MATCH_WORDS below,
+    // so no per-provider id catalog is consulted here.
     // Assume OpenRouter for models containing "/" (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
     // This check must come before match words so that "openai/gpt-4" is not matched by "openai" keyword
     if (input.includes("/")) {
@@ -461,6 +438,125 @@ class BaseProviderAdapter {
     }
 }
 
+/**
+ * Per-provider translation of the provider-neutral {@link LlmEffort} scale.
+ *
+ * The neutral enum (lowest → low → medium → high → highest) is a relative
+ * five-point scale. Each table below maps it onto the target provider's native
+ * effort control, keeping `medium`/`high` semantically aligned across providers
+ * and using each provider's extra bottom (`minimal`) or top (`xhigh`/`max`)
+ * rung where one exists. Providers with fewer levels collapse the ends and mark
+ * the result `papered`. A single `effort` value is therefore safe to reuse
+ * across providers and fallback chains.
+ */
+/** Consistent debug message for a papered-over effort level. */
+function paperedEffortMessage({ model, provider, requested, value, }) {
+    return `[llm] effort '${requested}' has no distinct tier on ${provider} model '${model}'; using '${value}'`;
+}
+// OpenAI Responses API `reasoning.effort`.
+// Full ladder: minimal | low | medium | high | xhigh (plus `none`). Availability
+// is not uniform across the gpt-5 line:
+//   - `xhigh` was introduced at gpt-5.2 and has been continuous since, so it is
+//     safe for our gpt-5.4 default and everything newer.
+//   - `minimal` shipped on gpt-5/5.1, was dropped at gpt-5.2, and returned on
+//     the current line; because that history is non-monotonic we only trust it
+//     from gpt-5.4 (our default floor) onward.
+// Outside those windows (older gpt-5, o-series) the extreme rung is clamped and
+// the mapping reports `papered: true`.
+const OPENAI_EFFORT = {
+    [EFFORT.LOWEST]: "minimal",
+    [EFFORT.LOW]: "low",
+    [EFFORT.MEDIUM]: "medium",
+    [EFFORT.HIGH]: "high",
+    [EFFORT.HIGHEST]: "xhigh",
+};
+function openAiGptVersion(model) {
+    const match = model.match(/^gpt-(\d+)(?:\.(\d+))?/);
+    if (!match)
+        return null;
+    return { major: Number(match[1]), minor: match[2] ? Number(match[2]) : 0 };
+}
+function atLeast(version, major, minor) {
+    if (!version)
+        return false;
+    return (version.major > major || (version.major === major && version.minor >= minor));
+}
+function toOpenAiEffort(effort, { model }) {
+    const native = OPENAI_EFFORT[effort];
+    const version = openAiGptVersion(model);
+    // `minimal` only from gpt-5.4 (non-monotonic history; absent on o-series)
+    if (native === "minimal" && !atLeast(version, 5, 4)) {
+        return { papered: true, value: "low" };
+    }
+    // `xhigh` from gpt-5.2 onward (absent on older gpt-5 and o-series)
+    if (native === "xhigh" && !atLeast(version, 5, 2)) {
+        return { papered: true, value: "high" };
+    }
+    return { papered: false, value: native };
+}
+// xAI Grok `reasoning_effort` — low | medium | high. No sub-low or top rung, so
+// `lowest` collapses onto `low` and `highest` onto `high`.
+const XAI_EFFORT = {
+    [EFFORT.LOWEST]: { papered: true, value: "low" },
+    [EFFORT.LOW]: { papered: false, value: "low" },
+    [EFFORT.MEDIUM]: { papered: false, value: "medium" },
+    [EFFORT.HIGH]: { papered: false, value: "high" },
+    [EFFORT.HIGHEST]: { papered: true, value: "high" },
+};
+function toXaiEffort(effort) {
+    return XAI_EFFORT[effort];
+}
+// Anthropic `output_config.effort` — low | medium | high | xhigh | max. No
+// sub-low rung, so `lowest` collapses onto `low`; `highest` reaches `max`.
+const ANTHROPIC_EFFORT = {
+    [EFFORT.LOWEST]: { papered: true, value: "low" },
+    [EFFORT.LOW]: { papered: false, value: "low" },
+    [EFFORT.MEDIUM]: { papered: false, value: "medium" },
+    [EFFORT.HIGH]: { papered: false, value: "high" },
+    [EFFORT.HIGHEST]: { papered: false, value: "max" },
+};
+function toAnthropicEffort(effort) {
+    return ANTHROPIC_EFFORT[effort];
+}
+// Gemini 3.x `thinkingConfig.thinkingLevel` — MINIMAL | LOW | MEDIUM | HIGH. No
+// top rung above HIGH, so `highest` collapses onto HIGH.
+const GEMINI_THINKING_LEVEL = {
+    [EFFORT.LOWEST]: { papered: false, value: "MINIMAL" },
+    [EFFORT.LOW]: { papered: false, value: "LOW" },
+    [EFFORT.MEDIUM]: { papered: false, value: "MEDIUM" },
+    [EFFORT.HIGH]: { papered: false, value: "HIGH" },
+    [EFFORT.HIGHEST]: { papered: true, value: "HIGH" },
+};
+function toGeminiThinkingLevel(effort) {
+    return GEMINI_THINKING_LEVEL[effort];
+}
+// Gemini 2.5 `thinkingConfig.thinkingBudget` — every tier is a distinct token
+// budget, so nothing is papered over. Floor (512) clears every 2.5 minimum;
+// ceiling (24,576) is valid across 2.5 Pro (max 32,768) and Flash (max 24,576).
+const GEMINI_THINKING_BUDGET = {
+    [EFFORT.LOWEST]: 512,
+    [EFFORT.LOW]: 4096,
+    [EFFORT.MEDIUM]: 8192,
+    [EFFORT.HIGH]: 16384,
+    [EFFORT.HIGHEST]: 24576,
+};
+function toGeminiThinkingBudget(effort) {
+    return { papered: false, value: GEMINI_THINKING_BUDGET[effort] };
+}
+// OpenRouter `reasoning.effort` — accepts the full minimal..xhigh ladder and
+// maps to the routed provider's nearest supported level itself, so nothing is
+// papered here.
+const OPENROUTER_EFFORT = {
+    [EFFORT.LOWEST]: "minimal",
+    [EFFORT.LOW]: "low",
+    [EFFORT.MEDIUM]: "medium",
+    [EFFORT.HIGH]: "high",
+    [EFFORT.HIGHEST]: "xhigh",
+};
+function toOpenRouterEffort(effort) {
+    return { papered: false, value: OPENROUTER_EFFORT[effort] };
+}
+
 // Enums
 var LlmMessageRole;
 (function (LlmMessageRole) {
@@ -1294,6 +1390,43 @@ async function* parseSseStream(body, { doneSentinel = DEFAULT_DONE_SENTINEL } =
     }
 }
 
+const UNKNOWN = "unknown";
+/**
+ * Tally loop totals onto the root logger's report session so handlers
+ * (express, lambda) include llm activity in the report emitted at teardown.
+ * Silently no-ops outside an active session or when the logger predates
+ * tally support.
+ */
+function tallyOperate({ toolCallNames = [], turns, usage = [], }) {
+    if (typeof log$2.tally !== "function")
+        return;
+    const llm = {
+        operates: 1,
+        toolCalls: toolCallNames.length,
+        turns,
+    };
+    if (toolCallNames.length > 0) {
+        const tools = {};
+        for (const name of toolCallNames) {
+            tools[name] = (tools[name] ?? 0) + 1;
+        }
+        llm.tools = tools;
+    }
+    if (usage.length > 0) {
+        const usageByModel = {};
+        for (const item of usage) {
+            const key = [item.provider, item.model].filter(Boolean).join(":") || UNKNOWN;
+            usageByModel[key] ?? (usageByModel[key] = { input: 0, output: 0, reasoning: 0, total: 0 });
+            usageByModel[key].input += item.input;
+            usageByModel[key].output += item.output;
+            usageByModel[key].reasoning += item.reasoning;
+            usageByModel[key].total += item.total;
+        }
+        llm.usage = usageByModel;
+    }
+    log$2.tally({ llm });
+}
+
 /**
  * Helper function to safely call a function that might throw
  * @param fn Function to call safely
@@ -1454,6 +1587,22 @@ function isTransientNetworkError(error) {
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME$3 = "structured_output";
+/**
+ * Whether `output_config.effort` may be sent for this model. Anthropic added
+ * the effort control on the Claude 4.5 line and up (the 5 family); older models
+ * reject it. Parsing major/minor avoids matching a minor "5" in legacy ids
+ * like `claude-3-5-sonnet`.
+ */
+function supportsAnthropicEffort(model) {
+    const match = model.match(/claude-[a-z]+-(\d+)(?:-(\d+))?/);
+    if (!match)
+        return false;
+    const major = Number(match[1]);
+    const minor = match[2] !== undefined ? Number(match[2]) : 0;
+    if (major >= 5)
+        return true;
+    return major === 4 && minor >= 5;
+}
 const STRUCTURED_OUTPUT_NON_PARSE_STOP_REASONS = new Set([
     "refusal",
     "max_tokens",
@@ -1719,7 +1868,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
         this.name = PROVIDER.ANTHROPIC.NAME;
-        this.defaultModel = PROVIDER.ANTHROPIC.MODEL.DEFAULT;
+        this.defaultModel = PROVIDER.ANTHROPIC.DEFAULT;
         // Session-level cache of models observed to reject `temperature` at runtime.
         // Populated by executeRequest on 400 errors so repeat calls skip the param.
         this.runtimeNoTemperatureModels = new Set();
@@ -1859,6 +2008,24 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (request.providerOptions) {
             Object.assign(anthropicRequest, request.providerOptions);
         }
+        // Normalized reasoning effort -> output_config.effort (merged so a format
+        // config above survives). First-class effort wins over providerOptions.
+        if (request.effort &&
+            supportsAnthropicEffort(anthropicRequest.model)) {
+            const mapping = toAnthropicEffort(request.effort);
+            if (mapping.papered) {
+                log$2.debug(paperedEffortMessage({
+                    model: anthropicRequest.model,
+                    provider: this.name,
+                    requested: request.effort,
+                    value: mapping.value,
+                }));
+            }
+            anthropicRequest.output_config = {
+                ...anthropicRequest.output_config,
+                effort: mapping.value,
+            };
+        }
         // First-class temperature takes precedence over providerOptions
         if (request.temperature !== undefined) {
             anthropicRequest.temperature = request.temperature;
@@ -1953,9 +2120,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
      */
     toFallbackStructuredOutputRequest(request) {
         const { output_config, ...rest } = request;
-        if (!output_config)
+        if (!output_config?.format)
             return request;
         const fallbackRequest = { ...rest };
+        // Preserve an effort setting; only the structured-output format falls back.
+        if (output_config.effort) {
+            fallbackRequest.output_config = { effort: output_config.effort };
+        }
         const fakeTool = {
             name: STRUCTURED_OUTPUT_TOOL_NAME$3,
             description: "Output a structured JSON object, " +
@@ -2399,7 +2570,7 @@ class BedrockAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
         this.name = PROVIDER.BEDROCK.NAME;
-        this.defaultModel = PROVIDER.BEDROCK.MODEL.DEFAULT;
+        this.defaultModel = PROVIDER.BEDROCK.DEFAULT;
         this._modelsFallbackToStructuredOutputTool = new Set();
         this._modelsWithoutTemperature = new Set();
     }
@@ -2905,6 +3076,11 @@ const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
 // (including 2.5 thinking) do not support the combo and fall back to the
 // legacy `structured_output` fake-tool emulation.
 const GEMINI_3_PATTERN = /^gemini-3/;
+// Reasoning-effort control differs by generation: Gemini 3.x takes the
+// `thinkingLevel` enum, Gemini 2.5 takes an integer `thinkingBudget`. Sending
+// the wrong one errors, and models outside these families have no thinking
+// control, so effort is only applied when one of these matches.
+const GEMINI_25_PATTERN = /^gemini-2\.5/;
 /**
  * Detect 4xx errors that indicate the model itself does not support the
  * `responseJsonSchema` + tools combo. Triggers the runtime fallback to the
@@ -2951,7 +3127,7 @@ class GoogleAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
         this.name = PROVIDER.GOOGLE.NAME;
-        this.defaultModel = PROVIDER.GOOGLE.MODEL.DEFAULT;
+        this.defaultModel = PROVIDER.GOOGLE.DEFAULT;
         // Session-level cache of Gemini 3 models observed to reject the native
         // `responseJsonSchema` + tools combo. When a model is in this set,
         // buildRequest engages the legacy fake-tool path instead.
@@ -3079,6 +3255,42 @@ class GoogleAdapter extends BaseProviderAdapter {
                 ...request.providerOptions,
             };
         }
+        // Normalized reasoning effort -> thinkingConfig. Gemini 3.x uses the
+        // thinkingLevel enum; 2.5 uses an integer thinkingBudget. Merged so a
+        // providerOptions.thinkingConfig survives; first-class effort wins.
+        if (request.effort) {
+            const model = geminiRequest.model;
+            let thinkingConfig;
+            let papered = false;
+            let value;
+            if (GEMINI_3_PATTERN.test(model)) {
+                const mapping = toGeminiThinkingLevel(request.effort);
+                ({ papered, value } = mapping);
+                thinkingConfig = { thinkingLevel: mapping.value };
+            }
+            else if (GEMINI_25_PATTERN.test(model)) {
+                const mapping = toGeminiThinkingBudget(request.effort);
+                ({ papered, value } = mapping);
+                thinkingConfig = { thinkingBudget: mapping.value };
+            }
+            if (thinkingConfig) {
+                if (papered) {
+                    log$2.debug(paperedEffortMessage({
+                        model,
+                        provider: this.name,
+                        requested: request.effort,
+                        value: value,
+                    }));
+                }
+                geminiRequest.config = {
+                    ...geminiRequest.config,
+                    thinkingConfig: {
+                        ...geminiRequest.config?.thinkingConfig,
+                        ...thinkingConfig,
+                    },
+                };
+            }
+        }
         // First-class temperature takes precedence over providerOptions
         if (request.temperature !== undefined) {
             geminiRequest.config = {
@@ -3998,7 +4210,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
         this.name = PROVIDER.OPENAI.NAME;
-        this.defaultModel = PROVIDER.OPENAI.MODEL.DEFAULT;
+        this.defaultModel = PROVIDER.OPENAI.DEFAULT;
         // Session-level cache of models observed to reject `temperature` at runtime.
         // Populated by executeRequest on 400 errors so repeat calls skip the param.
         this.runtimeNoTemperatureModels = new Set();
@@ -4014,6 +4226,14 @@ class OpenAiAdapter extends BaseProviderAdapter {
             return false;
         return !MODELS_WITHOUT_TEMPERATURE$1.some((pattern) => pattern.test(model));
     }
+    /** Whether `reasoning.effort` may be sent for this model. Overridden by xAI. */
+    supportsReasoningEffort(model) {
+        return isReasoningModel(model);
+    }
+    /** Translate a normalized effort to this provider's `reasoning.effort` value. */
+    mapReasoningEffort(effort, model) {
+        return toOpenAiEffort(effort, { model });
+    }
     //
     // Request Building
     //
@@ -4052,6 +4272,24 @@ class OpenAiAdapter extends BaseProviderAdapter {
         if (request.providerOptions) {
             Object.assign(openaiRequest, request.providerOptions);
         }
+        // Normalized reasoning effort -> reasoning.effort (merged so the
+        // summary:auto above survives). First-class effort wins over providerOptions.
+        if (request.effort && this.supportsReasoningEffort(model)) {
+            const mapping = this.mapReasoningEffort(request.effort, model);
+            if (mapping.papered) {
+                log$2.debug(paperedEffortMessage({
+                    model,
+                    provider: this.name,
+                    requested: request.effort,
+                    value: mapping.value,
+                }));
+            }
+            const existingReasoning = openaiRequest.reasoning ?? {};
+            openaiRequest.reasoning = {
+                ...existingReasoning,
+                effort: mapping.value,
+            };
+        }
         // First-class temperature takes precedence over providerOptions
         if (request.temperature !== undefined) {
             openaiRequest.temperature = request.temperature;
@@ -4646,7 +4884,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
         this.name = PROVIDER.OPENROUTER.NAME;
-        this.defaultModel = PROVIDER.OPENROUTER.MODEL.DEFAULT;
+        this.defaultModel = PROVIDER.OPENROUTER.DEFAULT;
         // Session-level cache of models observed to reject native
         // `response_format: json_schema`. When a model is in this set, buildRequest
         // engages the legacy fake-tool path instead of native structured output.
@@ -4739,6 +4977,15 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         if (request.providerOptions) {
             Object.assign(openRouterRequest, request.providerOptions);
         }
+        // Normalized reasoning effort -> reasoning.effort. OpenRouter accepts the
+        // full ladder and maps to the routed provider's nearest supported level.
+        // First-class effort wins over providerOptions.
+        if (request.effort) {
+            openRouterRequest.reasoning = {
+                ...openRouterRequest.reasoning,
+                effort: toOpenRouterEffort(request.effort).value,
+            };
+        }
         // First-class temperature takes precedence over providerOptions
         if (request.temperature !== undefined) {
             openRouterRequest.temperature =
@@ -5357,8 +5604,21 @@ class XaiAdapter extends OpenAiAdapter {
         super(...arguments);
         // @ts-expect-error Narrowing override: xAI name differs from parent's literal "openai"
         this.name = PROVIDER.XAI.NAME;
-        // @ts-expect-error Narrowing override: xAI default model differs from parent's literal
-        this.defaultModel = PROVIDER.XAI.MODEL.DEFAULT;
+        this.defaultModel = PROVIDER.XAI.DEFAULT;
+    }
+    /**
+     * Grok gates reasoning effort by model, not by the OpenAI `gpt-*`/`o*`
+     * patterns. Only explicit `*-reasoning` models accept `reasoning_effort`;
+     * bare grok-4 reasons implicitly and rejects it, so we stay conservative and
+     * only opt in models whose name advertises reasoning.
+     */
+    supportsReasoningEffort(model) {
+        if (/non-reasoning/.test(model))
+            return false;
+        return /reasoning/.test(model);
+    }
+    mapReasoningEffort(effort) {
+        return toXaiEffort(effort);
     }
     classifyError(error) {
         if (isTransientIngestError(error)) {
@@ -6635,6 +6895,7 @@ class OperateLoop {
                 }
                 // Rebuild request with updated history for next turn
                 request = {
+                    effort: options.effort,
                     format: state.formattedFormat,
                     instructions: options.instructions,
                     messages: state.currentInput,
@@ -6652,6 +6913,11 @@ class OperateLoop {
                 metrics: usageToLlmObsMetrics(response.usage),
                 outputData: response.content,
             });
+            tallyOperate({
+                toolCallNames: state.toolCallNames,
+                turns: state.currentTurn,
+                usage: response.usage,
+            });
             await emitProgress({
                 event: {
                     content: response.content,
@@ -6721,6 +6987,7 @@ class OperateLoop {
             formattedTools,
             maxTurns,
             responseBuilder,
+            toolCallNames: [],
             toolkit,
         };
     }
@@ -6732,6 +6999,7 @@ class OperateLoop {
     }
     buildInitialRequest(state, options) {
         return {
+            effort: options.effort,
             format: state.formattedFormat,
             instructions: options.instructions,
             messages: state.currentInput,
@@ -6889,6 +7157,7 @@ class OperateLoop {
                 this.appendResponseItemsToRequest(currentProviderRequest, responseItems);
                 // Process each tool call
                 for (const toolCall of toolCalls) {
+                    state.toolCallNames.push(toolCall.name);
                     // Resolved once per call; never throws (undefined when tool has no message)
                     const toolMessage = await state.toolkit.resolveMessage({
                         arguments: toolCall.arguments,
@@ -7245,6 +7514,7 @@ class StreamLoop {
                 }
                 // Rebuild request with updated history for next turn
                 request = {
+                    effort: options.effort,
                     format: state.formattedFormat,
                     instructions: options.instructions,
                     messages: state.currentInput,
@@ -7262,6 +7532,11 @@ class StreamLoop {
             }
         }
         // Emit final done chunk with accumulated usage
+        tallyOperate({
+            toolCallNames: state.toolCallNames,
+            turns: state.currentTurn,
+            usage: state.usageItems,
+        });
         yield {
             type: LlmStreamChunkType.Done,
             usage: state.usageItems,
@@ -7302,6 +7577,7 @@ class StreamLoop {
             formattedFormat,
             formattedTools,
             maxTurns,
+            toolCallNames: [],
             toolkit,
             usageItems: [],
         };
@@ -7314,6 +7590,7 @@ class StreamLoop {
     }
     buildInitialRequest(state, options) {
         return {
+            effort: options.effort,
             format: state.formattedFormat,
             instructions: options.instructions,
             messages: state.currentInput,
@@ -7484,6 +7761,7 @@ class StreamLoop {
     async *processToolCalls(toolCalls, state, context) {
         const log = getLogger$6();
         for (const toolCall of toolCalls) {
+            state.toolCallNames.push(toolCall.name);
             // Resolved once per call; never throws (undefined when tool has no message)
             const toolMessage = await state.toolkit.resolveMessage({
                 arguments: toolCall.arguments,
@@ -7876,7 +8154,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
 
 // Main class implementation
 class AnthropicProvider {
-    constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
+    constructor(model = PROVIDER.ANTHROPIC.DEFAULT, { apiKey } = {}) {
         this.log = getLogger$5();
         this.conversationHistory = [];
         this.model = model;
@@ -7984,7 +8262,7 @@ async function initializeClient$4({ region, } = {}) {
 }
 
 class BedrockProvider {
-    constructor(model = PROVIDER.BEDROCK.MODEL.DEFAULT, { region } = {}) {
+    constructor(model = PROVIDER.BEDROCK.DEFAULT, { region } = {}) {
         this.log = getLogger$4();
         this.conversationHistory = [];
         this.model = model;
@@ -8227,7 +8505,7 @@ function prepareMessages$2(message, { data, placeholders } = {}) {
 }
 
 class GoogleProvider {
-    constructor(model = PROVIDER.GOOGLE.MODEL.DEFAULT, { apiKey } = {}) {
+    constructor(model = PROVIDER.GOOGLE.DEFAULT, { apiKey } = {}) {
         this.log = getLogger$3();
         this.conversationHistory = [];
         this.model = model;
@@ -8429,7 +8707,7 @@ async function createTextCompletion(client, { messages, model, }) {
 }
 
 class OpenAiProvider {
-    constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
+    constructor(model = PROVIDER.OPENAI.DEFAULT, { apiKey } = {}) {
         this.log = getLogger$2();
         this.conversationHistory = [];
         this.model = model;
@@ -8660,7 +8938,7 @@ async function initializeClient$1({ apiKey, } = {}) {
 }
 // Get default model from environment or constants
 function getDefaultModel() {
-    return process.env.OPENROUTER_MODEL || PROVIDER.OPENROUTER.MODEL.DEFAULT;
+    return process.env.OPENROUTER_MODEL || PROVIDER.OPENROUTER.DEFAULT;
 }
 function formatSystemMessage(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
     const content = placeholders$1?.system === false
@@ -8812,7 +9090,7 @@ async function initializeClient({ apiKey, } = {}) {
 }
 
 class XaiProvider {
-    constructor(model = PROVIDER.XAI.MODEL.DEFAULT, { apiKey } = {}) {
+    constructor(model = PROVIDER.XAI.DEFAULT, { apiKey } = {}) {
         this.log = getLogger$2();
         this.conversationHistory = [];
         this.model = model;
@@ -8943,23 +9221,25 @@ class Llm {
         const { apiKey, model } = options;
         switch (providerName) {
             case PROVIDER.ANTHROPIC.NAME:
-                return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
+                return new AnthropicProvider(model || PROVIDER.ANTHROPIC.DEFAULT, {
+                    apiKey,
+                });
             case PROVIDER.BEDROCK.NAME:
-                return new BedrockProvider(model || PROVIDER.BEDROCK.MODEL.DEFAULT);
+                return new BedrockProvider(model || PROVIDER.BEDROCK.DEFAULT);
             case PROVIDER.GOOGLE.NAME:
-                return new GoogleProvider(model || PROVIDER.GOOGLE.MODEL.DEFAULT, {
+                return new GoogleProvider(model || PROVIDER.GOOGLE.DEFAULT, {
                     apiKey,
                 });
             case PROVIDER.OPENAI.NAME:
-                return new OpenAiProvider(model || PROVIDER.OPENAI.MODEL.DEFAULT, {
+                return new OpenAiProvider(model || PROVIDER.OPENAI.DEFAULT, {
                     apiKey,
                 });
             case PROVIDER.OPENROUTER.NAME:
-                return new OpenRouterProvider(model || PROVIDER.OPENROUTER.MODEL.DEFAULT, {
+                return new OpenRouterProvider(model || PROVIDER.OPENROUTER.DEFAULT, {
                     apiKey,
                 });
             case PROVIDER.XAI.NAME:
-                return new XaiProvider(model || PROVIDER.XAI.MODEL.DEFAULT, {
+                return new XaiProvider(model || PROVIDER.XAI.DEFAULT, {
                     apiKey,
                 });
             default: