@stackfactor/agent-utils 1.4.1 → 1.7.0

package/dist/esm/langChain.js

@@ -10,6 +10,7 @@ import logger from "./logger.js";
 import { z } from "zod";
 import { transformJSONSchema } from "@anthropic-ai/sdk/lib/transform-json-schema";
 import { getAbortSignal } from "./runtimeContext.js";
+import { recordUsage } from "./usage.js";
 import { assertTavilyUsable, buildTavilyTools, getTavilyOptions, } from "./tavily.js";
 const JSON_ESCAPE_INSTRUCTION = `
 CRITICAL - Your response must be valid JSON. Escape ALL special characters in string values:
@@ -24,9 +25,10 @@ Do NOT include raw newlines, tabs, or unescaped quotes inside JSON string values
  * Providers for which `getLLMModel` configures native, schema-constrained JSON
  * output (OpenAI `response_format`, Anthropic `output_config.format`, Gemini
  * `responseSchema` + JSON mode). For these the model emits JSON directly, so the
- * prompt-injected schema and the schema-validation retry are skipped. Other
- * providers (DeepSeek/Kimi/GLM via the OpenAI-compatible shim) have no native
- * support here and continue to rely on prompt instructions + validation.
+ * prompt-injected schema and the schema-validation retry are skipped. Every
+ * supported provider is listed here; the check remains so that adding one
+ * without native support falls back to prompt instructions + validation
+ * rather than silently skipping them.
  * @param modelName - The model identifier being routed
  * @returns `true` when native structured output is wired up for the provider
  */
@@ -97,29 +99,36 @@ const checkIfAIProviderConfigured = (config) => {
     }
 };
 /**
- * Reads a per-model rate from the flat cost constants the integration defines
- * in its `config.yaml` (exposed on the config object), e.g.
- * `claude-opus-4-7-input-token-costs`. Returns `0` when the constant is
- * absent or not numeric, which leaves cost contribution zero.
+ * Counts `amount` of `unit` for `modelName`: into the request's usage ledger,
+ * which is reported to the platform, and into the caller's tracker when it
+ * passed one. Nothing is counted for an amount that is not positive.
  */
-const getModelRate = (modelName, config, kind) => {
-    if (!config || !modelName)
-        return 0;
-    const rate = Number(config[`${modelName}-${kind}-costs`]);
-    return Number.isFinite(rate) ? rate : 0;
+const countUsage = (tracker, modelName, unit, amount) => {
+    if (!Number.isFinite(amount) || amount <= 0)
+        return;
+    recordUsage(modelName, unit, amount);
+    if (!tracker)
+        return;
+    const key = `${modelName}_${unit}`;
+    tracker.tokens[key] = (tracker.tokens[key] || 0) + amount;
 };
-/**
- * Adds a single call's usage to the caller-supplied tracker. Initializes
- * `cost` and `tokens` lazily so callers can pass `{}`. No-ops when the
- * tracker is null/undefined.
- */
-const updateUsageTracker = (tracker, modelName, usage, config) => {
-    if (!tracker || !usage || !modelName)
+/** Makes `{}` a tracker. `cost` stays 0: the platform prices what was used. */
+const prepareTracker = (tracker) => {
+    if (!tracker)
         return;
     if (typeof tracker.cost !== "number")
         tracker.cost = 0;
     if (!tracker.tokens || typeof tracker.tokens !== "object")
         tracker.tokens = {};
+};
+/**
+ * Counts a single call's token usage. `config` is no longer read: it carried
+ * the rates, and what usage costs is the platform's to say.
+ */
+const updateUsageTracker = (tracker, modelName, usage, _config) => {
+    if (!usage || !modelName)
+        return;
+    prepareTracker(tracker);
     const inputTokens = usage.input_tokens || 0;
     const visibleOutputTokens = usage.output_tokens || 0;
     const totalTokens = usage.total_tokens || 0;
@@ -128,40 +137,24 @@ const updateUsageTracker = (tracker, modelName, usage, config) => {
     // `total - input - visibleOutput` is the thinking output the caller was still
     // billed for. Providers that already fold reasoning into `output_tokens`
     // (Anthropic, OpenAI) report `total == input + output`, so this adds 0.
-    // Reasoning is charged at the output rate, so we treat it as output for both
-    // the token counters and the cost.
+    // Reasoning is charged at the output rate, so it is counted as output.
     const reasoningTokens = totalTokens > 0
         ? Math.max(0, totalTokens - inputTokens - visibleOutputTokens)
         : 0;
-    const outputTokens = visibleOutputTokens + reasoningTokens;
-    const inputRate = getModelRate(modelName, config, "input-token");
-    const outputRate = getModelRate(modelName, config, "output-token");
-    const addedCost = (inputTokens / 1_000_000) * inputRate +
-        (outputTokens / 1_000_000) * outputRate;
-    if (Number.isFinite(addedCost) && addedCost > 0)
-        tracker.cost += addedCost;
-    const inputKey = `${modelName}_inputTokens`;
-    const outputKey = `${modelName}_outputTokens`;
-    tracker.tokens[inputKey] = (tracker.tokens[inputKey] || 0) + inputTokens;
-    tracker.tokens[outputKey] = (tracker.tokens[outputKey] || 0) + outputTokens;
+    countUsage(tracker, modelName, "inputTokens", inputTokens);
+    countUsage(tracker, modelName, "outputTokens", visibleOutputTokens + reasoningTokens);
 };
 /**
- * Adds a single image-generation call's usage to the caller-supplied tracker.
- * Extracts token counts from provider-specific response shapes: OpenAI returns
- * `response.usage` with `input_tokens_details.{text_tokens,image_tokens}` and
- * `output_tokens`; Google returns `response.usageMetadata` with
- * `promptTokensDetails` (modality-keyed) and `candidatesTokenCount` for the
- * generated image. Reads rates from `<model>-input-token-costs`,
- * `<model>-image-input-token-costs`, and `<model>-image-output-token-costs`.
- * No-ops when the tracker or response usage info is absent.
+ * Counts a single image-generation call's usage. Extracts token counts from
+ * provider-specific response shapes: OpenAI returns `response.usage` with
+ * `input_tokens_details.{text_tokens,image_tokens}` and `output_tokens`;
+ * Google returns `response.usageMetadata` with `promptTokensDetails`
+ * (modality-keyed) and `candidatesTokenCount` for the generated image.
+ * No-ops when the response carries no usage.
  */
-const updateImageUsageTracker = (tracker, modelName, response, config, provider) => {
-    if (!tracker || !modelName || !response)
+const updateImageUsageTracker = (tracker, modelName, response, _config, provider) => {
+    if (!modelName || !response)
         return;
-    if (typeof tracker.cost !== "number")
-        tracker.cost = 0;
-    if (!tracker.tokens || typeof tracker.tokens !== "object")
-        tracker.tokens = {};
     let textInputTokens = 0;
     let imageInputTokens = 0;
     let imageOutputTokens = 0;
@@ -198,85 +191,42 @@ const updateImageUsageTracker = (tracker, modelName, response, config, provider)
         }
         imageOutputTokens = Number(um.candidatesTokenCount) || 0;
     }
-    const textInputRate = getModelRate(modelName, config, "input-token");
-    // Reference-image input tokens are billed at the model's input rate. Configs
-    // that don't define a dedicated `<model>-image-input-token-costs` (the common
-    // case — image models charge all input at one rate and only differ on output)
-    // fall back to the text input rate rather than silently billing image input
-    // at $0.
-    const imageInputRate = getModelRate(modelName, config, "image-input-token") || textInputRate;
-    const imageOutputRate = getModelRate(modelName, config, "image-output-token");
-    const addedCost = (textInputTokens / 1_000_000) * textInputRate +
-        (imageInputTokens / 1_000_000) * imageInputRate +
-        (imageOutputTokens / 1_000_000) * imageOutputRate;
-    if (Number.isFinite(addedCost) && addedCost > 0)
-        tracker.cost += addedCost;
-    if (textInputTokens > 0) {
-        const key = `${modelName}_inputTokens`;
-        tracker.tokens[key] = (tracker.tokens[key] || 0) + textInputTokens;
-    }
-    if (imageInputTokens > 0) {
-        const key = `${modelName}_imageInputTokens`;
-        tracker.tokens[key] = (tracker.tokens[key] || 0) + imageInputTokens;
-    }
-    if (imageOutputTokens > 0) {
-        const key = `${modelName}_imageOutputTokens`;
-        tracker.tokens[key] = (tracker.tokens[key] || 0) + imageOutputTokens;
-    }
+    prepareTracker(tracker);
+    countUsage(tracker, modelName, "inputTokens", textInputTokens);
+    // The platform prices an image a model is given as its other input, unless
+    // the model has a rate of its own for it.
+    countUsage(tracker, modelName, "imageInputTokens", imageInputTokens);
+    countUsage(tracker, modelName, "imageOutputTokens", imageOutputTokens);
 };
 /**
- * Adds character-billed usage (e.g. ElevenLabs TTS) to the caller-supplied
- * tracker. There is no provider response to parse — billing is deterministic
- * from the input character count. Reads the rate from
- * `<model>-character-costs` (USD per million characters) and accumulates
- * under `<model>_characters`. No-ops on missing tracker / model / count.
+ * Counts character-billed usage (e.g. ElevenLabs TTS). There is no provider
+ * response to parse — billing is deterministic from the input character
+ * count. No-ops on a missing model or count.
  */
-const updateUsageTrackerForCharacters = (tracker, modelName, characterCount, config) => {
-    if (!tracker || !modelName || !characterCount)
+const updateUsageTrackerForCharacters = (tracker, modelName, characterCount, _config) => {
+    if (!modelName || !characterCount)
         return;
-    if (typeof tracker.cost !== "number")
-        tracker.cost = 0;
-    if (!tracker.tokens || typeof tracker.tokens !== "object")
-        tracker.tokens = {};
-    const rate = getModelRate(modelName, config, "character");
-    const addedCost = (characterCount / 1_000_000) * rate;
-    if (Number.isFinite(addedCost) && addedCost > 0)
-        tracker.cost += addedCost;
-    const key = `${modelName}_characters`;
-    tracker.tokens[key] = (tracker.tokens[key] || 0) + characterCount;
+    prepareTracker(tracker);
+    countUsage(tracker, modelName, "characters", characterCount);
 };
 /**
- * Adds second-billed usage (video generation) to the caller-supplied tracker.
- *
- * Video is the first output here that providers bill by DURATION rather than by
- * tokens or characters, so the rate constant `<model>-second-costs` is read as
- * USD PER SECOND — not per million, as the `input-token` and `character` rates
- * are. A Veo or Sora second costs cents, and a per-million reading would bill
- * it as effectively free.
+ * Counts second-billed usage (video generation): providers bill video by
+ * DURATION rather than by tokens or characters.
  *
- * The rate is per model, not per model-and-resolution, so a caller that lets a
- * tenant change resolution on a model whose price varies by it (sora-2-pro is
- * $0.30/$0.50/$0.70 at 720p/1024p/1080p) must pin the resolution its constant
- * describes, or it will bill the wrong number.
+ * The platform's rate is per model, not per model-and-resolution, so a caller
+ * that lets a tenant change resolution on a model whose price varies by it
+ * (sora-2-pro is $0.30/$0.50/$0.70 at 720p/1024p/1080p) must pin the
+ * resolution the rate describes, or the wrong number is charged.
  *
- * @param tracker - The accumulator to add to; no-ops when null
- * @param modelName - The video model id, used for both the rate and the counter key
+ * @param tracker - The caller's accumulator, when it passed one
+ * @param modelName - The video model id
  * @param seconds - Billed duration of the generated clip
- * @param config - Integration config carrying `<model>-second-costs`
  */
-const updateVideoUsageTracker = (tracker, modelName, seconds, config) => {
-    if (!tracker || !modelName || !seconds)
+const updateVideoUsageTracker = (tracker, modelName, seconds, _config) => {
+    if (!modelName || !seconds)
         return;
-    if (typeof tracker.cost !== "number")
-        tracker.cost = 0;
-    if (!tracker.tokens || typeof tracker.tokens !== "object")
-        tracker.tokens = {};
-    const rate = getModelRate(modelName, config, "second");
-    const addedCost = seconds * rate;
-    if (Number.isFinite(addedCost) && addedCost > 0)
-        tracker.cost += addedCost;
-    const key = `${modelName}_seconds`;
-    tracker.tokens[key] = (tracker.tokens[key] || 0) + seconds;
+    prepareTracker(tracker);
+    countUsage(tracker, modelName, "seconds", seconds);
 };
 /**
  * Extracts a normalized token-usage object from a single LangChain `invoke()`
@@ -537,36 +487,6 @@ const extractJSONFromResponse = (text) => {
     }
     return null;
 };
-/**
- * Maps a model name prefix to its OpenAI-compatible provider configuration. DeepSeek,
- * Kimi (Moonshot), and GLM (Zhipu) all expose OpenAI-compatible chat completion APIs
- * and can be routed through `ChatOpenAI` with a custom base URL and API key.
- * @param modelName - The model identifier to inspect
- * @param config - Configuration object containing provider-specific API keys
- * @returns An object with `apiKey` and `baseURL` when the model matches a known
- *   OpenAI-compatible provider, or `null` otherwise
- */
-const getOpenAICompatibleProvider = (modelName, config) => {
-    if (modelName.startsWith("deepseek-")) {
-        return {
-            apiKey: config.deepSeekAPIKey,
-            baseURL: "https://api.deepseek.com/v1",
-        };
-    }
-    if (modelName.startsWith("kimi-") || modelName.startsWith("moonshot-")) {
-        return {
-            apiKey: config.kimiAPIKey,
-            baseURL: "https://api.moonshot.ai/v1",
-        };
-    }
-    if (modelName.startsWith("glm-")) {
-        return {
-            apiKey: config.glmAPIKey,
-            baseURL: "https://open.bigmodel.cn/api/paas/v4/",
-        };
-    }
-    return null;
-};
 /**
  * Whether a model accepts the `temperature` sampling parameter at all. Some
  * models reject it with an HTTP 400, so it must be omitted rather than clamped:
@@ -576,7 +496,7 @@ const getOpenAICompatibleProvider = (modelName, config) => {
  *    accept it.
  *  - OpenAI reasoning models (the GPT-5 family and the o-series) reject it;
  *    gpt-4o still accepts it.
- * DeepSeek, Kimi/Moonshot, GLM, and Gemini all accept temperature.
+ * Gemini accepts temperature.
  * @param modelName - the model identifier being routed
  * @returns `true` when the model accepts a `temperature` parameter
  */
@@ -597,18 +517,14 @@ const modelSupportsTemperature = (modelName) => {
 };
 /**
  * Per-provider valid `temperature` range, used to clamp caller-supplied values.
- * Anthropic, Kimi (Moonshot), and GLM (Zhipu) cap at 1.0; OpenAI, Gemini, and
- * DeepSeek accept up to 2.0. Only consulted for models that support temperature
- * at all (see `modelSupportsTemperature`).
+ * Anthropic caps at 1.0; OpenAI and Gemini accept up to 2.0. Only consulted for
+ * models that support temperature at all (see `modelSupportsTemperature`).
  */
 const getTemperatureRange = (modelName) => {
-    if (modelName.startsWith("claude-") ||
-        modelName.startsWith("kimi-") ||
-        modelName.startsWith("moonshot-") ||
-        modelName.startsWith("glm-")) {
+    if (modelName.startsWith("claude-")) {
         return { min: 0, max: 1 };
     }
-    // gpt-, gemini-, deepseek-
+    // gpt-, gemini-
     return { min: 0, max: 2 };
 };
 /**
@@ -637,46 +553,6 @@ const resolveTemperatureSetting = (modelName, config) => {
     }
     return { temperature: clamped };
 };
-/**
- * Gemini's ceiling on `maxOutputTokens`. The API validates the field and
- * rejects the request outright rather than clamping it:
- * "Unable to submit request because it has a maxOutputTokens value of N but the
- * supported range is from 1 (inclusive) to 65537 (exclusive)" (HTTP 400,
- * INVALID_ARGUMENT).
- *
- * Set to 64000 rather than that 65536 validation ceiling: the Pro models report
- * a generation capacity of 64000, so 64000 is the value every model across the
- * Gemini 3 line (3.1 Pro, 3.5/3.7/3.8 Flash) can both accept and actually
- * produce. One safe constant beats a per-model table that would need editing
- * every time Google ships a model — and the 1536 tokens of headroom given up on
- * Flash are far beyond what any caller asks for.
- *
- * Deliberately Gemini-only. Anthropic and OpenAI take the caller's `maxTokens`
- * unchanged, since neither rejects the values configured today.
- */
-const GEMINI_MAX_OUTPUT_TOKENS = 64000;
-/**
- * Resolves `maxOutputTokens` for a Gemini model. Callers share one `maxTokens`
- * setting across every provider, and the other providers tolerate values far
- * above what Gemini accepts, so anything above Gemini's ceiling is clamped here
- * (with a warning) instead of being sent through to a guaranteed HTTP 400. With
- * no caller value the ceiling itself is used, which is what the previous
- * 200000 default was reaching for.
- * @param modelName - The Gemini model identifier being routed
- * @param config - Configuration object; only `maxTokens` is consulted
- * @returns A token count within Gemini's supported range
- */
-const resolveGeminiMaxOutputTokens = (modelName, config) => {
-    const maxTokens = config?.maxTokens;
-    if (typeof maxTokens !== "number" || !Number.isFinite(maxTokens)) {
-        return GEMINI_MAX_OUTPUT_TOKENS;
-    }
-    if (maxTokens > GEMINI_MAX_OUTPUT_TOKENS) {
-        logger.log(null, logger.levels.warn, `maxTokens ${maxTokens} exceeds the ${GEMINI_MAX_OUTPUT_TOKENS}-token output ceiling of "${modelName}"; clamping to ${GEMINI_MAX_OUTPUT_TOKENS}.`);
-        return GEMINI_MAX_OUTPUT_TOKENS;
-    }
-    return maxTokens;
-};
 /**
  * Flattens LangChain message content into plain text. Content is a string for
  * ordinary completions, but providers switch to an array of blocks whenever the
@@ -704,23 +580,22 @@ const extractTextContent = (content) => {
 /**
  * Instantiates and returns the appropriate LangChain chat model based on the model
  * name prefix. `claude-` maps to `ChatAnthropic`, `gemini-` maps to
- * `ChatGoogleGenerativeAI`, and `gpt-` maps to `ChatOpenAI`. DeepSeek (`deepseek-`),
- * Kimi/Moonshot (`kimi-`, `moonshot-`), and GLM/Zhipu (`glm-`) models are routed
- * through `ChatOpenAI` against each provider's OpenAI-compatible endpoint. When a Zod
+ * `ChatGoogleGenerativeAI`, and `gpt-` maps to `ChatOpenAI`. When a Zod
  * `schema` is provided, native structured output is configured per provider: OpenAI
  * via `response_format` with `json_schema`, Anthropic via `output_config.format`, and
  * Gemini via JSON mode (`json: true`) plus `responseSchema`. In every case the model
  * emits JSON as the message text, so the caller's parse/validate pipeline is unchanged.
- * The schema is ignored for the OpenAI-compatible providers (DeepSeek/Kimi/GLM), which
- * have no native structured-output support here. Throws a `BAD_REQUEST` error for
- * unrecognised model names.
+ * Throws a `BAD_REQUEST` error for unrecognised model names.
+ *
+ * Output token limits are not caller-configurable. Anthropic requires
+ * `max_tokens` on every request and @langchain/anthropic defaults it to 4096,
+ * so the Claude branch pins it explicitly; OpenAI and Gemini are sent no limit
+ * and fall back to each provider's own default, which is that model's maximum.
  * @param modelName - The model identifier, e.g. `"gpt-4o"`, `"claude-3-5-sonnet"`,
- *   `"gemini-1.5-pro"`, `"deepseek-chat"`, `"kimi-k2-0905-preview"`, `"glm-4.6"`
+ *   `"gemini-1.5-pro"`
  * @param config - Configuration object containing API keys (`openAIAPIKey`,
- *   `anthropicAPIKey`, `googleAPIKey`, `deepSeekAPIKey`, `kimiAPIKey`, `glmAPIKey`),
- *   optional `maxTokens`, and optional `temperature`
+ *   `anthropicAPIKey`, `googleAPIKey`) and optional `temperature`
  * @param schema - Optional Zod schema used to configure native structured JSON output
- *   for GPT / Claude / Gemini models; ignored for OpenAI-compatible providers
  * @returns A configured LangChain chat model (or bound runnable) instance
  */
 // Exported (but not re-exported from index.ts / the package's public entry
@@ -731,12 +606,17 @@ export const getLLMModel = (modelName, config, schema = null) => {
     const modelSettings = resolveTemperatureSetting(modelName, config);
     // Claude models (Anthropic)
     if (modelName.startsWith("claude-")) {
+        // Anthropic requires `max_tokens` on every request and @langchain/anthropic
+        // defaults it to 4096 when omitted — low enough to truncate agentic turns
+        // mid-tool-call — so it is pinned here rather than left to the library.
+        // 64000 is Anthropic's recommended value for streamed requests and sits
+        // within the 128000-token output limit of every Claude model routed here.
+        //
         // Anthropic's SDK rejects non-streamed requests when max_tokens is large
-        // enough that the operation could exceed 10 minutes (threshold: 21333).
-        // Auto-enable LangChain streaming above that cutoff so `.invoke()` routes
-        // through the streaming endpoint internally — callers see no interface
-        // change, but the guard is bypassed.
-        const maxTokens = config.maxTokens || 16384;
+        // enough that the operation could exceed 10 minutes (threshold: 21333), so
+        // streaming is always on: `.invoke()` routes through the streaming endpoint
+        // internally and callers see no interface change.
+        const maxTokens = 64000;
         // Native structured output: Anthropic's `output_config.format` constrains
         // decoding to the schema while still emitting JSON as the message text, so
         // the downstream streaming + parse/validate pipeline is unchanged.
@@ -757,7 +637,7 @@ export const getLLMModel = (modelName, config, schema = null) => {
             apiKey: config.anthropicAPIKey,
             maxTokens,
             modelName: modelName,
-            streaming: maxTokens > 16384,
+            streaming: true,
             invocationKwargs: { cache_control: { type: "ephemeral" } },
             ...outputConfig,
             ...modelSettings,
@@ -768,7 +648,9 @@ export const getLLMModel = (modelName, config, schema = null) => {
     else if (modelName.startsWith("gemini-")) {
         const model = new ChatGoogleGenerativeAI({
             apiKey: config.googleAPIKey,
-            maxOutputTokens: resolveGeminiMaxOutputTokens(modelName, config),
+            // No `maxOutputTokens`: omitting it leaves Gemini's own default, which is
+            // the model's maximum output. Sending a value meant tracking a per-model
+            // ceiling that the API rejects outright rather than clamps.
             model: modelName,
             // `json: true` forces responseMimeType=application/json, guaranteeing the
             // model returns valid JSON text (never prose) for the parse pipeline.
@@ -790,17 +672,26 @@ export const getLLMModel = (modelName, config, schema = null) => {
     else if (modelName.startsWith("gpt-")) {
         const openAISettings = {
             apiKey: config.openAIAPIKey,
-            max_tokens: config.maxTokens || 200000,
+            // No output limit is sent: OpenAI defaults to the model's maximum. The
+            // snake_case `max_tokens` that used to sit here was never a recognised
+            // ChatOpenAI field and was silently dropped by LangChain.
             modelName: modelName,
             ...modelSettings,
         };
-        // gpt-5.6's /v1/chat/completions endpoint 400s whenever function tools are
-        // bound, because it rejects the model's own server-side default reasoning
-        // effort in that combination ("use /v1/responses or set reasoning_effort
-        // to 'none'"); forcing it to "none" here avoids the collision. Scoped to
-        // exactly gpt-5.6 — sibling gpt-5.x models are not confirmed to share the
-        // bug.
-        const reasoningEffortOverride = modelName === "gpt-5.6" ? { reasoning_effort: "none" } : {};
+        // The gpt-5.6 family's /v1/chat/completions endpoint 400s whenever function
+        // tools are bound, because it rejects the model's own server-side default
+        // reasoning effort in that combination ("use /v1/responses or set
+        // reasoning_effort to 'none'"); forcing it to "none" here avoids the
+        // collision. The restriction belongs to the family, not to one id: the
+        // `gpt-5.6` alias resolves to `gpt-5.6-sol`, and `gpt-5.6-terra` /
+        // `gpt-5.6-luna` are separately addressable ids that hit the same 400, as
+        // do dated snapshots (`gpt-5.6-2026-08-22`). Matching the alias alone left
+        // every one of those unpatched, so match the whole family. Still excludes
+        // sibling releases (gpt-5.5, gpt-5.7): they are not confirmed to share the
+        // bug, and reasoning effort is worth keeping wherever it is accepted.
+        const reasoningEffortOverride = /^gpt-5\.6($|-)/.test(modelName)
+            ? { reasoning_effort: "none" }
+            : {};
         // Use native structured output with a JSON schema. `modelKwargs` is spread
         // verbatim into the Chat Completions request. Merge (not overwrite) with
         // the reasoning-effort override above, since both may apply at once.
@@ -823,17 +714,6 @@ export const getLLMModel = (modelName, config, schema = null) => {
         }
         return new ChatOpenAI(openAISettings);
     }
-    // OpenAI-compatible providers: DeepSeek, Kimi (Moonshot), GLM (Zhipu)
-    const openAICompatible = getOpenAICompatibleProvider(modelName, config);
-    if (openAICompatible) {
-        return new ChatOpenAI({
-            apiKey: openAICompatible.apiKey,
-            maxTokens: config.maxTokens || 200000,
-            modelName: modelName,
-            configuration: { baseURL: openAICompatible.baseURL },
-            ...modelSettings,
-        });
-    }
     throw errorHandlingHelper.create(constants.HTTP_CODES.BAD_REQUEST, constants.ERROR.UNSUPPORTED_MODEL + ": " + modelName);
 };
 /**
@@ -1162,6 +1042,65 @@ const parseAndValidateJSONResponse = (rawContent, schema) => {
  * original base) so that across multiple retries the full failure history
  * accumulates and the model can avoid oscillating between previous broken outputs.
  */
+/**
+ * Whether a response that fails schema validation is retried with the errors
+ * appended (buildValidationRetryMessages), up to MAX_VALIDATION_RETRIES.
+ *
+ * This used to be skipped whenever the model supports native structured
+ * output, on the reasoning that a natively constrained response cannot be
+ * invalid, so a failure had to be a schema bug worth surfacing at once. It
+ * can be invalid, and routinely is: constrained decoding enforces the JSON
+ * *shape*, not the Zod schema. Anthropic's SDK strips `enum` into a
+ * description before sending, Gemini ignores `additionalProperties`, and no
+ * provider runs a refine or a superRefine. Production, 2026-09-23/24: one
+ * agent failed one call in six on extra keys the strict schema refused, and
+ * another was rejected three runs in a row at its last stage on a value off
+ * an enumerated list — every one on a native-schema model, every one reported
+ * straight to the user, and every one restarted from zero by the caller
+ * because the stage that failed was never asked again.
+ *
+ * So the retry now applies whenever a schema is in play. A genuine schema bug
+ * still surfaces: it fails the same way three times and the last error is
+ * thrown as before, at the cost of two extra calls.
+ * @param expectsJsonResponse - Whether the call expects JSON at all
+ * @param schema - The Zod schema the response is validated against, if any
+ * @returns Whether a validation failure is retried
+ */
+const canRetryValidation = (expectsJsonResponse, schema) => !!expectsJsonResponse && !!schema;
+/**
+ * Whether a failure of the JSON stage is one the model can fix if asked again:
+ * a response that failed schema validation, or one that was not JSON at all
+ * (prose, or JSON with a preamble the extractor could not recover). Everything
+ * else — no messages, a provider error, a transport error — is not.
+ * @param error - The failure
+ * @returns Whether a retry with the errors appended makes sense
+ */
+const isRetryableJsonFailure = (error) => error?.code === constants.HTTP_CODES.UNPROCESSABLE_ENTITY ||
+    /non-JSON response when JSON was expected/.test(String(error?.message ?? ""));
+/**
+ * The agentic run takes one user prompt rather than a message list, so a retry
+ * carries the failed output and the errors inside that prompt: the model sees
+ * what it produced and what was wrong with it, the same information
+ * buildValidationRetryMessages gives the non-agentic paths. Previous attempts
+ * accumulate so the model does not oscillate between earlier broken outputs.
+ * @param userPrompt - The prompt of the attempt that failed
+ * @param rawContent - What the model answered
+ * @param error - Why it was refused
+ * @returns The user prompt for the next attempt
+ */
+const buildAgenticRetryPrompt = (userPrompt, rawContent, error) => {
+    const previous = typeof rawContent === "string" ? rawContent : JSON.stringify(rawContent);
+    return `${userPrompt}
+
+---
+Your previous response was rejected:
+${String(error?.message ?? error)}
+
+Your previous response was:
+${previous}
+
+Return a corrected JSON response that fixes ALL of these issues. Respond with the JSON only.`;
+};
 const buildValidationRetryMessages = (priorMessages, rawContent, validationError) => {
     const assistantContent = typeof rawContent === "string" ? rawContent : JSON.stringify(rawContent);
     return [
@@ -1173,6 +1112,58 @@ const buildValidationRetryMessages = (priorMessages, rawContent, validationError
         },
     ];
 };
+/**
+ * The agentic path's JSON stage: the agent's final text as validated JSON.
+ * Direct parse when it looks like JSON, the markdown/preamble extractor
+ * otherwise; a schema failure throws UNPROCESSABLE_ENTITY (validateWithSchema),
+ * anything the extractor cannot recover throws the "non-JSON response" error.
+ * Both are what runPromptWithModel's agentic retry loop asks the model to fix.
+ * @param rawContent - The agent's final message text
+ * @param schema - The Zod schema to validate against, if any
+ * @returns The JSON, re-serialised
+ */
+const parseAgenticJsonResponse = (rawContent, schema) => {
+    if (typeof rawContent === "string") {
+        const trimmed = rawContent.trim();
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (schema) {
+                    validateWithSchema(parsed, schema);
+                }
+                return JSON.stringify(parsed);
+            }
+            catch (parseError) {
+                if (parseError?.code === constants.HTTP_CODES.UNPROCESSABLE_ENTITY) {
+                    throw parseError;
+                }
+            }
+        }
+        // Try to extract JSON from markdown or other wrapping
+        const extracted = extractJSONFromResponse(rawContent);
+        if (extracted) {
+            if (schema) {
+                validateWithSchema(extracted, schema);
+            }
+            return JSON.stringify(extracted);
+        }
+    }
+    let preview = "";
+    if (typeof rawContent === "string") {
+        preview = rawContent.substring(0, 100);
+    }
+    else if (typeof rawContent === "object" && rawContent !== null) {
+        preview = JSON.stringify(rawContent).substring(0, 100);
+    }
+    else if (rawContent !== undefined && rawContent !== null) {
+        preview = String(rawContent).substring(0, 100);
+    }
+    else {
+        preview = "[empty response]";
+    }
+    throw errorHandlingHelper.create(constants.HTTP_CODES.INTERNAL_SERVER_ERROR, `Agent returned non-JSON response when JSON was expected: ${preview}...`);
+};
 /**
  * Sends a prompt to an LLM and returns the response, with support for streaming,
  * agentic execution, progress reporting, JSON extraction, and Zod schema validation.
@@ -1255,65 +1246,43 @@ const runPromptWithModel = async (modelName, config, prompt, onProgressReport, m
         // being reconciled from the response afterwards.
         const agent = createAgent(agentName, modelName, systemPrompt, [...tools], null, // responseFormat
         config, usageTracker);
-        // Run the agent with progress callback
-        const response = await runAgent(agent, userPrompt, config, onProgressReport || null, usageTracker);
-        // Extract content from agent response
-        const messages = response?.messages || [];
-        if (messages.length === 0) {
-            throw errorHandlingHelper.create(constants.HTTP_CODES.INTERNAL_SERVER_ERROR, "Agent returned no messages");
-        }
-        const lastMessage = messages[messages.length - 1];
-        // Flattens the array content blocks that Gemini/Claude agent responses and
-        // any server-tool turn (e.g. web search) return.
-        const rawContent = extractTextContent(lastMessage?.content);
-        // If not expecting JSON, return raw content directly
-        if (!expectsJsonResponse) {
-            return rawContent;
-        }
-        // Process JSON response similar to non-agentic path
-        if (typeof rawContent === "string") {
-            const trimmed = rawContent.trim();
-            if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
-                (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (schema) {
-                        validateWithSchema(parsed, schema);
-                    }
-                    return JSON.stringify(parsed);
-                }
-                catch (parseError) {
-                    if (parseError?.code === constants.HTTP_CODES.UNPROCESSABLE_ENTITY) {
-                        throw parseError;
-                    }
-                }
-            }
-            // Try to extract JSON from markdown or other wrapping
-            const extracted = extractJSONFromResponse(rawContent);
-            if (extracted) {
-                if (schema) {
-                    validateWithSchema(extracted, schema);
-                }
-                return JSON.stringify(extracted);
-            }
-        }
-        if (expectsJsonResponse) {
-            let preview = "";
-            if (typeof rawContent === "string") {
-                preview = rawContent.substring(0, 100);
+        // The JSON stage is retried like the non-agentic paths (canRetryValidation):
+        // the agent is run again with its rejected output and the errors appended
+        // to the user prompt, up to MAX_VALIDATION_RETRIES. Until now this path
+        // had no retry at all, and it is the one every tool-using generation takes.
+        let activeUserPrompt = userPrompt;
+        let attempt = 0;
+        for (;;) {
+            // Run the agent with progress callback
+            const response = await runAgent(agent, activeUserPrompt, config, onProgressReport || null, usageTracker);
+            // Extract content from agent response
+            const messages = response?.messages || [];
+            if (messages.length === 0) {
+                throw errorHandlingHelper.create(constants.HTTP_CODES.INTERNAL_SERVER_ERROR, "Agent returned no messages");
             }
-            else if (typeof rawContent === "object" && rawContent !== null) {
-                preview = JSON.stringify(rawContent).substring(0, 100);
+            const lastMessage = messages[messages.length - 1];
+            // Flattens the array content blocks that Gemini/Claude agent responses and
+            // any server-tool turn (e.g. web search) return.
+            const rawContent = extractTextContent(lastMessage?.content);
+            // If not expecting JSON, return raw content directly
+            if (!expectsJsonResponse) {
+                return rawContent;
             }
-            else if (rawContent !== undefined && rawContent !== null) {
-                preview = String(rawContent).substring(0, 100);
+            try {
+                return parseAgenticJsonResponse(rawContent, schema);
             }
-            else {
-                preview = "[empty response]";
+            catch (err) {
+                if (canRetryValidation(expectsJsonResponse, schema) &&
+                    isRetryableJsonFailure(err) &&
+                    attempt < MAX_VALIDATION_RETRIES) {
+                    attempt++;
+                    logger.log(null, logger.levels.warn, `Schema validation failed for "${modelName}", retrying (${attempt}/${MAX_VALIDATION_RETRIES}): ${err.message}`);
+                    activeUserPrompt = buildAgenticRetryPrompt(activeUserPrompt, rawContent, err);
+                    continue;
+                }
+                throw err;
             }
-            throw errorHandlingHelper.create(constants.HTTP_CODES.INTERNAL_SERVER_ERROR, `Agent returned non-JSON response when JSON was expected: ${preview}...`);
         }
-        return rawContent;
     }
     let messages;
     if (typeof prompt === "string") {
@@ -1358,13 +1327,13 @@ const runPromptWithModel = async (modelName, config, prompt, onProgressReport, m
         else {
             messagesToSend = messages;
         }
-        // Retry once on schema validation failure. The retry is silent to the progress
+        // Retry on schema validation failure. The retry is silent to the progress
         // callback — same "Generating content..." message and the progress curve
         // continues from the original startTime so the bar doesn't visibly reset.
-        // Skipped when OpenAI native response_format is in use (a 422 there is a
-        // server-side schema bug, not a model output issue). Each attempt accumulates
-        // independently into usageTracker so retry usage is still visible.
-        const canRetryOnValidation = expectsJsonResponse && !!schema && !useNativeSchema;
+        // Each attempt accumulates independently into usageTracker so retry usage
+        // is still visible. Native structured output no longer exempts a model:
+        // see canRetryValidation.
+        const canRetryOnValidation = canRetryValidation(expectsJsonResponse, schema);
         const progressReportInterval = 10; // Report every N chunks
         const overallStartTime = Date.now();
         // Use a time-based asymptotic curve: progress approaches maxPercent but never
@@ -1516,9 +1485,9 @@ const runPromptWithModel = async (modelName, config, prompt, onProgressReport, m
         else {
             messagesToSend = messages;
         }
-        // Retry once on schema validation failure (see streaming branch for rationale).
+        // Retry on schema validation failure (see streaming branch for rationale).
         // Each attempt accumulates independently into usageTracker.
-        const canRetryOnValidation = expectsJsonResponse && !!schema && !useNativeSchema;
+        const canRetryOnValidation = canRetryValidation(expectsJsonResponse, schema);
         let activeMessages = messagesToSend;
         let attempt = 0;
         while (true) {
@@ -2027,6 +1996,11 @@ const runPromptWithModelForVideoGeneration = async (modelName, config, prompt, o
     }
 };
 export default {
+    canRetryValidation,
+    isRetryableJsonFailure,
+    buildAgenticRetryPrompt,
+    parseAgenticJsonResponse,
+    supportsNativeSchema,
     checkIfAIProviderConfigured,
     createAgent,
     runAgent,
@@ -2034,6 +2008,9 @@ export default {
     runPromptWithModelForImageGeneration,
     runPromptWithModelForVideoGeneration,
     throwErrorIfNotSuccessful,
+    updateImageUsageTracker,
+    updateUsageTracker,
     updateUsageTrackerForCharacters,
+    updateVideoUsageTracker,
     validateModel,
 };