@adaptic/lumic-utils 1.0.28 → 1.0.30

package/dist/{index-FqzV71J4.js → index-DlAW691N.js}

@@ -100,9 +100,14 @@ const OPENAI_COMPATIBLE_PROVIDERS = {
  */
 const SUPPORTED_MODELS = {
     // ── OpenAI GPT-5.6 series (current flagship) ─────────────────────────
-    // sol / terra / luna are the 2026 flagship trio (developers.openai.com/
-    // api/docs/models/all). Same GPT-5.x API surface + the temperature
-    // constraint documented below.
+    // sol / terra / luna are the 2026 flagship reasoning trio
+    // (developers.openai.com/api/docs/models/all). They are REASONING models
+    // (isReasoningModel: true) and — like all reasoning models — do not accept a
+    // custom temperature. Critically, OpenAI rejects function tools for them on
+    // Chat Completions ("Function tools with reasoning_effort are not supported
+    // for gpt-5.6-sol in /v1/chat/completions"), so `requiresResponsesApiForTools`
+    // routes tool-bearing calls to the Responses API. Both flags are corrected
+    // here from their initial (registration-time) `false` values.
     'gpt-5.6-sol': {
         provider: 'openai',
         supportsTools: true,
@@ -110,7 +115,8 @@ const SUPPORTED_MODELS = {
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
         supportsTemperature: false,
-        isReasoningModel: false,
+        isReasoningModel: true,
+        requiresResponsesApiForTools: true,
     },
     'gpt-5.6-terra': {
         provider: 'openai',
@@ -119,7 +125,8 @@ const SUPPORTED_MODELS = {
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
         supportsTemperature: false,
-        isReasoningModel: false,
+        isReasoningModel: true,
+        requiresResponsesApiForTools: true,
     },
     'gpt-5.6-luna': {
         provider: 'openai',
@@ -128,7 +135,8 @@ const SUPPORTED_MODELS = {
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
         supportsTemperature: false,
-        isReasoningModel: false,
+        isReasoningModel: true,
+        requiresResponsesApiForTools: true,
     },
     // ── OpenAI GPT-5.5 series ────────────────────────────────────────────
     // GPT-5.x series: OpenAI's 2026 API constraint — only the default
@@ -611,24 +619,33 @@ function getModelProvider(model) {
     return SUPPORTED_MODELS[model].provider;
 }
 /**
- * Default model tiers per provider for use with LLM_MODEL_MINI/NORMAL/ADVANCED env vars
+ * Default model tiers per provider for use with the
+ * LLM_MODEL_MINI/NORMAL/ADVANCED/CRITICAL env vars.
+ *
+ * Four tiers, increasing in capability/cost: `mini` (high-volume, cheap) →
+ * `normal` (default) → `advanced` → `critical` (most-capable). The tier a caller
+ * lands on is resolved in `../utils/config` (see `LLM_MODEL_*`).
  */
 const PROVIDER_DEFAULT_MODELS = {
-    // advanced pins to gpt-5.5, NOT the newer gpt-5.6-sol, deliberately: gpt-5.6-sol is a
-    // reasoning model and OpenAI rejects function tools on /v1/chat/completions for it
-    // ("Function tools with reasoning_effort are not supported for gpt-5.6-sol in
-    // /v1/chat/completions") — it requires the Responses API. Consumers that call
-    // makeOpenAIChatCompletionCall WITH tools (e.g. the engine's decision path) 400 on
-    // every call. gpt-5.6-sol/terra/luna remain REGISTERED in SUPPORTED_MODELS for when a
-    // Responses-API routing path lands; until then the advanced (tool-calling) tier pins
-    // to gpt-5.5 — the newest model compatible with chat-completions + function tools.
-    openai: { mini: 'gpt-5.4-nano', normal: 'gpt-5.4-mini', advanced: 'gpt-5.5' },
-    anthropic: { mini: 'claude-haiku-4-5', normal: 'claude-sonnet-4-6', advanced: 'claude-opus-4-7' },
-    deepseek: { mini: 'deepseek-v4-flash', normal: 'deepseek-v4-flash', advanced: 'deepseek-v4-pro' },
-    kimi: { mini: 'kimi-k2-0905-preview', normal: 'kimi-k2.5', advanced: 'kimi-k2.6' },
-    qwen: { mini: 'qwen3.5-flash', normal: 'qwen3.5-plus', advanced: 'qwen3-max' },
-    xai: { mini: 'grok-4.1-fast', normal: 'grok-4-fast-non-reasoning', advanced: 'grok-4.3' },
-    gemini: { mini: 'gemini-3.1-flash-lite-preview', normal: 'gemini-3-flash-preview', advanced: 'gemini-3.1-pro-preview' },
+    // OpenAI now leads with the GPT-5.6 reasoning trio. The historical blocker
+    // (gpt-5.6-* returning 400 on Chat-Completions + tools) is resolved by the
+    // Responses-API routing (`requiresResponsesApiForTools` +
+    // `makeOpenAIChatCompletionCall`), so the intended canary is live:
+    //   normal   → gpt-5.6-luna  (cheapest of the trio)
+    //   advanced → gpt-5.6-terra (flips off the temporary gpt-5.5 pin)
+    //   critical → gpt-5.6-sol   (most capable; in/out priced like gpt-5.5)
+    // `mini` stays on gpt-5.4-nano — the high-volume summarizer tier where the
+    // trio's reasoning cost is not warranted.
+    openai: { mini: 'gpt-5.4-nano', normal: 'gpt-5.6-luna', advanced: 'gpt-5.6-terra', critical: 'gpt-5.6-sol' },
+    // Non-OpenAI providers: `critical` mirrors `advanced` (each provider's
+    // most-capable model), so the new tier is a no-op for them until a distinct
+    // critical-tier model is chosen.
+    anthropic: { mini: 'claude-haiku-4-5', normal: 'claude-sonnet-4-6', advanced: 'claude-opus-4-7', critical: 'claude-opus-4-7' },
+    deepseek: { mini: 'deepseek-v4-flash', normal: 'deepseek-v4-flash', advanced: 'deepseek-v4-pro', critical: 'deepseek-v4-pro' },
+    kimi: { mini: 'kimi-k2-0905-preview', normal: 'kimi-k2.5', advanced: 'kimi-k2.6', critical: 'kimi-k2.6' },
+    qwen: { mini: 'qwen3.5-flash', normal: 'qwen3.5-plus', advanced: 'qwen3-max', critical: 'qwen3-max' },
+    xai: { mini: 'grok-4.1-fast', normal: 'grok-4-fast-non-reasoning', advanced: 'grok-4.3', critical: 'grok-4.3' },
+    gemini: { mini: 'gemini-3.1-flash-lite-preview', normal: 'gemini-3-flash-preview', advanced: 'gemini-3.1-pro-preview', critical: 'gemini-3.1-pro-preview' },
 };
 
 // Default implementation using console (backward compatible)
@@ -703,9 +720,11 @@ const lumicSecretsSchema = zod.z.object({
         llmMiniProvider: zod.z.string().optional(),
         llmNormalProvider: zod.z.string().optional(),
         llmAdvancedProvider: zod.z.string().optional(),
+        llmCriticalProvider: zod.z.string().optional(),
         llmModelMini: zod.z.string().optional(),
         llmModelNormal: zod.z.string().optional(),
         llmModelAdvanced: zod.z.string().optional(),
+        llmModelCritical: zod.z.string().optional(),
         lumicDebug: zod.z.boolean().default(false),
         allowedUploadPaths: zod.z.string().default('/tmp'),
     }),
@@ -768,9 +787,11 @@ function loadSecrets() {
             llmMiniProvider: process.env.LLM_MINI_PROVIDER,
             llmNormalProvider: process.env.LLM_NORMAL_PROVIDER,
             llmAdvancedProvider: process.env.LLM_ADVANCED_PROVIDER,
+            llmCriticalProvider: process.env.LLM_CRITICAL_PROVIDER,
             llmModelMini: process.env.LLM_MODEL_MINI,
             llmModelNormal: process.env.LLM_MODEL_NORMAL,
             llmModelAdvanced: process.env.LLM_MODEL_ADVANCED,
+            llmModelCritical: process.env.LLM_MODEL_CRITICAL,
             lumicDebug: process.env.LUMIC_DEBUG === 'true' ||
                 process.env.lumic_debug === 'true',
             allowedUploadPaths: process.env.LUMIC_ALLOWED_UPLOAD_PATHS || '/tmp',
@@ -870,6 +891,7 @@ const LLM_DEFAULT_PROVIDER = parseProvider(getSecrets().config.llmDefaultProvide
 const LLM_MINI_PROVIDER = parseProvider(getSecrets().config.llmMiniProvider) || LLM_DEFAULT_PROVIDER;
 const LLM_NORMAL_PROVIDER = parseProvider(getSecrets().config.llmNormalProvider) || LLM_DEFAULT_PROVIDER;
 const LLM_ADVANCED_PROVIDER = parseProvider(getSecrets().config.llmAdvancedProvider) || LLM_DEFAULT_PROVIDER;
+const LLM_CRITICAL_PROVIDER = parseProvider(getSecrets().config.llmCriticalProvider) || LLM_DEFAULT_PROVIDER;
 // Keep backward compat — LLM_PROVIDER is the default provider
 const LLM_PROVIDER = LLM_DEFAULT_PROVIDER;
 /**
@@ -889,13 +911,14 @@ const DEFAULT_MODEL = (() => {
  * Model tier values resolved from env vars.
  *
  * Resolution order per tier:
- *   1. LLM_MODEL_MINI / LLM_MODEL_NORMAL / LLM_MODEL_ADVANCED (explicit model override)
+ *   1. LLM_MODEL_MINI / LLM_MODEL_NORMAL / LLM_MODEL_ADVANCED / LLM_MODEL_CRITICAL (explicit model override)
  *   2. PROVIDER_DEFAULT_MODELS[tier-specific provider][tier] (provider default for tier)
  *
  * The tier-specific provider is:
  *   LLM_MINI_PROVIDER → falls back to LLM_DEFAULT_PROVIDER
  *   LLM_NORMAL_PROVIDER → falls back to LLM_DEFAULT_PROVIDER
  *   LLM_ADVANCED_PROVIDER → falls back to LLM_DEFAULT_PROVIDER
+ *   LLM_CRITICAL_PROVIDER → falls back to LLM_DEFAULT_PROVIDER
  */
 const LLM_MODEL_MINI = (() => {
     const env = getSecrets().config.llmModelMini;
@@ -924,6 +947,21 @@ const LLM_MODEL_ADVANCED = (() => {
     }
     return PROVIDER_DEFAULT_MODELS[LLM_ADVANCED_PROVIDER].advanced;
 })();
+/**
+ * The most-capable ("critical") model tier — reserved for the highest-stakes
+ * calls. Resolves from LLM_MODEL_CRITICAL, else the critical-tier default of the
+ * resolved LLM_CRITICAL_PROVIDER (see PROVIDER_DEFAULT_MODELS). For OpenAI this
+ * is gpt-5.6-sol; for other providers it mirrors their advanced tier.
+ */
+const LLM_MODEL_CRITICAL = (() => {
+    const env = getSecrets().config.llmModelCritical;
+    if (env) {
+        const resolved = resolveModelName(env);
+        if (resolved)
+            return resolved;
+    }
+    return PROVIDER_DEFAULT_MODELS[LLM_CRITICAL_PROVIDER].critical;
+})();
 const PERPLEXITY_MODEL = getSecrets().config.perplexityModel || DEFAULT_PERPLEXITY_MODEL;
 const PERPLEXITY_API_URL = 'https://api.perplexity.ai/chat/completions';
 
@@ -936,15 +974,40 @@ const DEFAULT_DEVELOPER_PROMPT = `
     Respond only with final content (e.g. code, a json or yaml object, a formatted string, or a markdown document) and nothing else. Do not reply with a preamble, introduction, or conclusion.
 `;
 /**
- * Token costs in USD per token. Last updated May 2026.
+ * Token costs in USD per token. Last updated July 2026.
  *
- * `cacheHitCost` reflects OpenAI's cached-input billing rate (~50% of the
- * standard input rate per OpenAI's prompt caching documentation). When set,
- * `calculateCost` splits prompt tokens into cached vs non-cached buckets and
- * applies the discount; when omitted, cached tokens are billed at full input
- * rate (a silent ~50% cost overstatement for cache-friendly workloads).
+ * `cacheHitCost` reflects each model's cached-input billing rate. For most
+ * models this is ~50% of the standard input rate (per OpenAI's prompt-caching
+ * documentation); the GPT-5.6 reasoning trio discounts cached input more
+ * aggressively, to 10% of the input rate. When set, `calculateCost` splits
+ * prompt tokens into cached vs non-cached buckets and applies the discount; when
+ * omitted, cached tokens are billed at the full input rate (a silent cost
+ * overstatement for cache-friendly workloads).
  */
 const openAiModelCosts = {
+    // GPT-5.6 reasoning trio (sol/terra/luna). Tiered per-1M-token pricing,
+    // verified against OpenAI's published price sheet on 2026-07-13:
+    //   sol   — $5.00 in / $0.50 cached / $30.00 out  (in/out identical to gpt-5.5)
+    //   terra — $2.50 in / $0.25 cached / $15.00 out
+    //   luna  — $1.00 in / $0.10 cached /  $6.00 out
+    // Cached input is 10% of the input rate across the trio. Reasoning tokens are
+    // a SUBSET of output tokens and are billed at the output rate inside
+    // `calculateCost`, so callers must not add them on top of the output count.
+    'gpt-5.6-sol': {
+        inputCost: 5 / 1_000_000,
+        cacheHitCost: 0.5 / 1_000_000,
+        outputCost: 30 / 1_000_000,
+    },
+    'gpt-5.6-terra': {
+        inputCost: 2.5 / 1_000_000,
+        cacheHitCost: 0.25 / 1_000_000,
+        outputCost: 15 / 1_000_000,
+    },
+    'gpt-5.6-luna': {
+        inputCost: 1 / 1_000_000,
+        cacheHitCost: 0.1 / 1_000_000,
+        outputCost: 6 / 1_000_000,
+    },
     'gpt-5.5': {
         inputCost: 5 / 1_000_000,
         cacheHitCost: 2.5 / 1_000_000,
@@ -2276,12 +2339,18 @@ class LLMCostTracker {
      * @param provider - The LLM provider ('openai' or 'deepseek')
      * @param model - The model name (e.g., 'gpt-5', 'deepseek-chat')
      * @param inputTokens - Number of input/prompt tokens
-     * @param outputTokens - Number of output/completion tokens
-     * @param reasoningTokens - Number of reasoning tokens (default: 0)
+     * @param outputTokens - Total output/completion tokens, INCLUDING reasoning tokens
+     * @param reasoningTokens - Reasoning tokens, a subset of outputTokens (default: 0). Billed at the output rate, not on top of it.
      * @param cacheHitTokens - Number of cache hit tokens (default: 0)
      */
     trackUsage(provider, model, inputTokens, outputTokens, reasoningTokens = 0, cacheHitTokens = 0) {
-        const cost = calculateCost(provider, model, inputTokens, outputTokens, reasoningTokens, cacheHitTokens);
+        // Reasoning tokens are a SUBSET of output tokens for every provider tracked
+        // here (they are counted within completion/output tokens and billed at the
+        // output rate). calculateCost bills output AND reasoning separately, so cost
+        // the non-reasoning remainder to avoid billing reasoning twice; the stored
+        // record keeps the full outputTokens/reasoningTokens for reporting. For
+        // non-reasoning calls reasoningTokens is 0, so this is a no-op.
+        const cost = calculateCost(provider, model, inputTokens, outputTokens - reasoningTokens, reasoningTokens, cacheHitTokens);
         const record = {
             provider,
             model,
@@ -2598,6 +2667,105 @@ function isReasoningModel(model) {
     }
     return getModelCapabilities(model).isReasoningModel;
 }
+/**
+ * Checks whether a model must use the OpenAI Responses API (`/v1/responses`)
+ * for function-tool calls rather than Chat Completions (`/v1/chat/completions`).
+ *
+ * Driven entirely by the {@link ModelCapabilities.requiresResponsesApiForTools}
+ * flag in the model registry — there are no hardcoded model-name checks here.
+ * Unknown models and models without the flag return `false` (stay on Chat
+ * Completions).
+ *
+ * @param model The model to check.
+ * @returns True when tool-bearing calls for this model must be routed to the
+ *   Responses API, false otherwise.
+ */
+function requiresResponsesApiForTools(model) {
+    if (!isValidModel(model)) {
+        return false;
+    }
+    return getModelCapabilities(model).requiresResponsesApiForTools ?? false;
+}
+/**
+ * OpenAI's `reasoning_effort` ladder, ordered from least to most effort. This is
+ * the full 2026 ladder (developers.openai.com), including `'max'` — the OpenAI
+ * SDK v6 `Shared.ReasoningEffort` type accepts this entire set on the wire.
+ * Mirrors the widened {@link LLMOptions.reasoning_effort} union.
+ */
+const REASONING_EFFORT_LADDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Per-model `reasoning_effort` support window for OpenAI reasoning models,
+ * expressed on {@link REASONING_EFFORT_LADDER}. `min`/`max` are the lowest and
+ * highest effort each model's API accepts; a request below `min` clamps up and
+ * above `max` clamps down, so an over/under-shoot degrades gracefully instead of
+ * returning HTTP 400.
+ *
+ * Reasoning models ABSENT from this table omit `reasoning_effort` entirely —
+ * notably `o1-mini`, which does not accept the parameter at all. The windows
+ * record TRUE API support; the wire value is additionally narrowed to
+ * {@link SdkReasoningEffort} in {@link toSdkReasoningEffort}, so when the SDK
+ * widens only that mapping (not these windows) needs revisiting.
+ */
+const MODEL_REASONING_EFFORT_SUPPORT = {
+    // GPT-5.6 reasoning trio — full ladder (developers.openai.com/api/docs/models).
+    'gpt-5.6-sol': { min: 'minimal', max: 'xhigh' },
+    'gpt-5.6-terra': { min: 'minimal', max: 'xhigh' },
+    'gpt-5.6-luna': { min: 'minimal', max: 'xhigh' },
+    // o-series reasoning models accept low|medium|high (no none/minimal/xhigh).
+    o1: { min: 'low', max: 'high' },
+    o3: { min: 'low', max: 'high' },
+    'o3-mini': { min: 'low', max: 'high' },
+    'o4-mini': { min: 'low', max: 'high' },
+    // o1-mini is intentionally omitted — it rejects reasoning_effort outright.
+};
+/**
+ * Identity pass-through from a full-ladder effort level to an SDK-sendable value.
+ * Under OpenAI SDK v6 the wire type ({@link SdkReasoningEffort}) spans the entire
+ * ladder, so every level is sendable as-is; the per-model
+ * {@link MODEL_REASONING_EFFORT_SUPPORT} window (applied in
+ * {@link clampReasoningEffort}) is what keeps a request within a model's range.
+ * Retained as a named seam so a future SDK narrowing has one obvious place to
+ * re-introduce folding.
+ *
+ * @param level A level on {@link REASONING_EFFORT_LADDER}.
+ * @returns The same level, typed as SDK-sendable.
+ */
+function toSdkReasoningEffort(level) {
+    return level;
+}
+/**
+ * Clamps a requested {@link LLMOptions.reasoning_effort} to a value the target
+ * model — and the installed OpenAI SDK — will accept, degrading gracefully so an
+ * unsupported (too-high or too-low) level never returns HTTP 400.
+ *
+ * Resolution:
+ *   1. Models without an entry in {@link MODEL_REASONING_EFFORT_SUPPORT}
+ *      (non-reasoning models, or reasoning models like `o1-mini` that reject the
+ *      parameter) ⇒ `undefined`, i.e. omit `reasoning_effort` from the request.
+ *   2. Clamp the requested level into the model's `[min, max]` window.
+ *   3. Fold onto the SDK-sendable range via {@link toSdkReasoningEffort}.
+ *
+ * Shared by BOTH OpenAI transports so the Chat and Responses paths clamp
+ * identically.
+ *
+ * @param requested The caller's requested effort (full ladder).
+ * @param model The normalized model name the request targets.
+ * @returns An SDK-safe effort, or `undefined` when the field must be omitted.
+ */
+function clampReasoningEffort(requested, model) {
+    const support = MODEL_REASONING_EFFORT_SUPPORT[model];
+    if (!support) {
+        return undefined;
+    }
+    const requestedIdx = REASONING_EFFORT_LADDER.indexOf(requested);
+    if (requestedIdx < 0) {
+        return undefined;
+    }
+    const minIdx = REASONING_EFFORT_LADDER.indexOf(support.min);
+    const maxIdx = REASONING_EFFORT_LADDER.indexOf(support.max);
+    const clampedIdx = Math.min(Math.max(requestedIdx, minIdx), maxIdx);
+    return toSdkReasoningEffort(REASONING_EFFORT_LADDER[clampedIdx]);
+}
 /**
  * Normalizes the response format option based on model compatibility.
  * @param responseFormat The desired response format.
@@ -2729,6 +2897,18 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     if (options.max_completion_tokens !== undefined) {
         queryOptions.max_completion_tokens = options.max_completion_tokens;
     }
+    // Forward reasoning_effort on the Chat path for reasoning models. Chat
+    // Completions accepts reasoning_effort for reasoning models (only tools +
+    // effort together 400 on GPT-5.6, and those tool-bearing calls are already
+    // routed to the Responses API), so this is safe. The value is clamped per
+    // model so an unsupported level degrades gracefully instead of 400-ing;
+    // clampReasoningEffort returns undefined for models that reject the parameter.
+    if (options.reasoning_effort !== undefined && isReasoningModel(normalizedModel)) {
+        const effort = clampReasoningEffort(options.reasoning_effort, normalizedModel);
+        if (effort !== undefined) {
+            queryOptions.reasoning_effort = effort;
+        }
+    }
     // Only set response_format when it's not the default 'text' type
     // (sending response_format: {type: 'text'} is redundant and may cause issues)
     const responseFormatOption = getResponseFormatOption(responseFormat, normalizedModel);
@@ -2798,12 +2978,18 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     const response = {
         id: completion.id,
         content: completion.choices[0]?.message?.content || '',
-        tool_calls: completion.choices[0]?.message?.tool_calls,
+        // OpenAI SDK v6 widened tool calls into a function/custom union; the engine
+        // only emits + parses function calls, so narrow to the function variant to
+        // preserve the byte-identical `{ id, type, function }` shape.
+        tool_calls: completion.choices[0]?.message?.tool_calls?.filter((tc) => tc.type === 'function'),
         usage: {
             prompt_tokens: completion.usage?.prompt_tokens ?? 0,
             completion_tokens: completion.usage?.completion_tokens ?? 0,
             total_tokens: completion.usage?.total_tokens ?? 0,
             cached_tokens: cachedTokens,
+            // Non-reasoning Chat-Completions models report no reasoning tokens; read
+            // defensively so the field is always present and correct.
+            reasoning_tokens: completion.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
         },
         system_fingerprint: completion.system_fingerprint,
         service_tier: options.service_tier,
@@ -2812,9 +2998,383 @@ async function createCompletion(content, responseFormat, options = DEFAULT_OPTIO
     };
     return response;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Transparent Chat-Completions → Responses API routing (GPT-5.6 reasoning trio)
+//
+// OpenAI's GPT-5.6 reasoning models (sol/terra/luna) return HTTP 400 for
+// function tools on `/v1/chat/completions`
+// ("Function tools with reasoning_effort are not supported for gpt-5.6-sol in
+// /v1/chat/completions"); they require the Responses API (`/v1/responses`).
+// The helpers below convert a Chat-Completions-style request into a Responses
+// request and normalize the Responses result back into the SAME internal
+// {@link CompletionResponse}, so callers of {@link makeOpenAIChatCompletionCall}
+// receive a byte-identical {@link LLMResponse} envelope regardless of which
+// endpoint served the call. The routing decision is data-driven via
+// {@link requiresResponsesApiForTools}.
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Coerces a Chat-Completions message `content` value (string, content-part
+ * array, or null) into a plain string. Mirrors the text-extraction rule used
+ * elsewhere in this module: array parts contribute their `text` field, all
+ * other shapes contribute nothing.
+ *
+ * @param content The message content in any of its Chat-Completions shapes.
+ * @returns The concatenated text, or an empty string when there is none.
+ */
+function coerceMessageText(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => typeof part === 'object' && part !== null && 'text' in part &&
+            typeof part.text === 'string'
+            ? part.text
+            : '')
+            .join('');
+    }
+    return '';
+}
+/**
+ * Converts Chat-Completions user content (string or multi-modal content parts)
+ * into the Responses API content shape. String content passes through
+ * unchanged; content-part arrays map `text` → `input_text` and `image_url` →
+ * `input_image`. Unsupported part kinds (audio/file) are skipped rather than
+ * emitted in an incompatible shape — no tool-calling caller uses them today.
+ *
+ * @param content The Chat-Completions user content.
+ * @returns A string or an array of Responses input-content parts.
+ */
+function chatContentToResponsesContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    const parts = [];
+    for (const part of content) {
+        if (part.type === 'text') {
+            parts.push({ type: 'input_text', text: part.text });
+        }
+        else if (part.type === 'image_url') {
+            parts.push({
+                type: 'input_image',
+                image_url: part.image_url.url,
+                detail: part.image_url.detail ?? 'auto',
+            });
+        }
+    }
+    return parts;
+}
+/**
+ * Converts a single Chat-Completions message into zero or more Responses API
+ * input items. Assistant tool calls become `function_call` items and `tool`
+ * results become `function_call_output` items — both keyed by the SAME id the
+ * chat envelope exposed as `tool_call.id` / `tool_call_id`, so a multi-turn
+ * tool conversation round-trips correctly through the Responses transport.
+ *
+ * @param message The Chat-Completions message to convert.
+ * @returns The equivalent Responses input items (may be empty).
+ */
+function chatMessageToResponsesInput(message) {
+    switch (message.role) {
+        case 'system':
+            return [{ role: 'system', content: coerceMessageText(message.content) }];
+        case 'developer':
+            return [{ role: 'developer', content: coerceMessageText(message.content) }];
+        case 'user':
+            return [{ role: 'user', content: chatContentToResponsesContent(message.content) }];
+        case 'assistant': {
+            const items = [];
+            const text = coerceMessageText(message.content);
+            if (text.length > 0) {
+                items.push({ role: 'assistant', content: text });
+            }
+            if (message.tool_calls) {
+                for (const toolCall of message.tool_calls) {
+                    if (toolCall.type === 'function') {
+                        items.push({
+                            type: 'function_call',
+                            call_id: toolCall.id,
+                            name: toolCall.function.name,
+                            arguments: toolCall.function.arguments,
+                        });
+                    }
+                }
+            }
+            return items;
+        }
+        case 'tool':
+            return [{
+                    type: 'function_call_output',
+                    call_id: message.tool_call_id,
+                    output: coerceMessageText(message.content),
+                }];
+        default:
+            // Deprecated `function`-role messages carry no call_id to correlate; keep
+            // the text so history stays coherent. No current caller emits these.
+            return [{ role: 'assistant', content: coerceMessageText(message.content) }];
+    }
+}
+/**
+ * Converts a Chat-Completions function tool (`{ type:'function', function:{…} }`)
+ * into a Responses API function tool (`{ type:'function', name, parameters,
+ * strict, description }`). `strict` defaults to `false` to preserve Chat
+ * Completions' effective default (non-strict) — the Responses API otherwise
+ * defaults function tools to strict, which would silently change model
+ * behaviour and could reject payloads the Chat path accepted.
+ *
+ * @param tool The Chat-Completions function tool.
+ * @returns The equivalent Responses API function tool.
+ */
+function chatToolToResponsesFunctionTool(tool) {
+    return {
+        type: 'function',
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters ?? {},
+        strict: tool.function.strict ?? false,
+    };
+}
+/**
+ * Maps an {@link OpenAIResponseFormat} onto the Responses API `text.format`
+ * config, applying the same model-capability gates as the Chat path
+ * ({@link getResponseFormatOption}): `'text'` yields `undefined` (omit
+ * `text.format`), `'json'` yields `json_object` only when the model supports
+ * JSON mode, and a `json_schema` request yields the flat Responses
+ * `json_schema` format (name/schema at the top level, unlike Chat's nested
+ * `json_schema` wrapper).
+ *
+ * @param responseFormat The requested response format.
+ * @param normalizedModel The normalized model name.
+ * @returns The `text.format` config, or `undefined` when none should be sent.
+ * @throws Error when a `json_schema` format is requested for an incompatible model.
+ */
+function getResponsesTextFormat(responseFormat, normalizedModel) {
+    if (responseFormat === 'text') {
+        return undefined;
+    }
+    if (responseFormat === 'json') {
+        return supportsJsonMode(normalizedModel) ? { type: 'json_object' } : undefined;
+    }
+    if (typeof responseFormat === 'object' && responseFormat.type === 'json_schema') {
+        if (!isStructuredOutputCompatibleModel(normalizedModel)) {
+            throw new Error(`${normalizedModel} is not compatible with structured outputs / json object.`);
+        }
+        return {
+            type: 'json_schema',
+            name: 'Response',
+            schema: {
+                type: 'object',
+                properties: responseFormat.schema.properties,
+                required: responseFormat.schema.required || [],
+            },
+        };
+    }
+    throw new Error(`Invalid response format: ${String(responseFormat)}`);
+}
+/**
+ * Builds an OpenAI Responses API request body from the exact same arguments a
+ * caller passes to {@link makeOpenAIChatCompletionCall}. This is the request
+ * half of the transparent routing layer.
+ *
+ * The mapping deliberately mirrors {@link createCompletion}'s Chat request
+ * one-for-one so request semantics are preserved across transports:
+ * - `developerPrompt` (+ context messages + user `content`) → `input` items
+ *   (chat `tool_calls`/`tool` messages become `function_call`/
+ *   `function_call_output` items).
+ * - chat `tools` → Responses `tools` (function tools only).
+ * - `temperature` → `temperature`, gated by {@link supportsTemperature} exactly
+ *   as the Chat path (dropped for GPT-5.6/o-series reasoning models).
+ * - `max_completion_tokens` → `max_output_tokens`.
+ * - {@link OpenAIResponseFormat} → `text.format`.
+ * - `reasoning_effort` → `reasoning.effort`, clamped per-model via
+ *   {@link clampReasoningEffort} and gated on {@link isReasoningModel} exactly as
+ *   the Chat path, so the two transports clamp identically. Only set when the
+ *   caller explicitly supplies it — parity is preserved for callers (like the
+ *   engine decision path) that do not.
+ *
+ * Parameters the Chat path does not forward (`top_p`, `parallel_tool_calls`,
+ * `tool_choice`, `metadata`, `store`) are intentionally omitted here too, so the
+ * request semantics stay identical to today's production Chat behaviour.
+ *
+ * @param content The user content (string or multi-modal content parts).
+ * @param responseFormat The desired response format.
+ * @param options The Chat-Completions-style options bag.
+ * @param normalizedModel The normalized model name to target.
+ * @returns A ready-to-send non-streaming Responses API request body.
+ * @throws Error when a `json_schema` format is requested for an incompatible model.
+ */
+function buildResponsesRequestFromChatOptions(content, responseFormat, options, normalizedModel) {
+    const input = [];
+    if (options.developerPrompt && supportsDeveloperPrompt(normalizedModel)) {
+        input.push({ role: 'developer', content: options.developerPrompt });
+    }
+    if (options.context) {
+        for (const message of options.context) {
+            input.push(...chatMessageToResponsesInput(message));
+        }
+    }
+    input.push({ role: 'user', content: chatContentToResponsesContent(content) });
+    const requestBody = {
+        model: normalizedModel,
+        input,
+    };
+    if (options.tools && options.tools.length > 0) {
+        const functionTools = options.tools
+            .filter((tool) => tool.type === 'function')
+            .map(chatToolToResponsesFunctionTool);
+        if (functionTools.length > 0) {
+            requestBody.tools = functionTools;
+        }
+    }
+    if (options.temperature !== undefined && supportsTemperature(normalizedModel)) {
+        requestBody.temperature = options.temperature;
+    }
+    if (options.max_completion_tokens !== undefined) {
+        requestBody.max_output_tokens = options.max_completion_tokens;
+    }
+    const textFormat = getResponsesTextFormat(responseFormat, normalizedModel);
+    if (textFormat) {
+        requestBody.text = { format: textFormat };
+    }
+    if (options.reasoning_effort !== undefined && isReasoningModel(normalizedModel)) {
+        const effort = clampReasoningEffort(options.reasoning_effort, normalizedModel);
+        if (effort !== undefined) {
+            requestBody.reasoning = { effort };
+        }
+    }
+    return requestBody;
+}
+/**
+ * Normalizes an OpenAI Responses API result into the internal
+ * {@link CompletionResponse} shape. This is the response half of the
+ * transparent routing layer and is the single most correctness-critical mapping
+ * in this module: the returned `tool_calls` MUST be byte-identical to what the
+ * Chat path produces so downstream consumers (notably the engine decision path,
+ * which reads `tool_call.function.arguments` as a JSON string) parse it
+ * unchanged.
+ *
+ * Mapping:
+ * - `function_call` output items → `{ id: call_id, type:'function',
+ *   function:{ name, arguments } }` with `arguments` kept as the raw JSON
+ *   string (never pre-parsed) — exactly the Chat `ChatCompletionMessageToolCall`
+ *   shape. `id` is sourced from `call_id` (not the item `id`) so it round-trips
+ *   as the `tool_call_id` in a multi-turn conversation.
+ * - `message` output items → concatenated `output_text` parts (refusals and
+ *   non-text parts contribute nothing, matching the Chat path's null-content →
+ *   empty-string behaviour).
+ * - usage: `input_tokens`→prompt, `output_tokens`→completion,
+ *   `input_tokens_details.cached_tokens`→cached,
+ *   `output_tokens_details.reasoning_tokens`→reasoning.
+ *
+ * `system_fingerprint` is `undefined` — the Responses API does not return one
+ * (the Chat path forwards it; consumers already treat it as optional).
+ *
+ * @param response The raw OpenAI Responses API result.
+ * @param normalizedModel The normalized model name the request targeted.
+ * @param serviceTier The caller's requested service tier, echoed through as on
+ *   the Chat path.
+ * @returns A {@link CompletionResponse} structurally identical to the Chat path's.
+ */
+function normalizeResponsesToCompletion(response, normalizedModel, serviceTier) {
+    const toolCalls = response.output
+        ?.filter((item) => item.type === 'function_call')
+        .map((toolCall) => ({
+        id: toolCall.call_id,
+        type: 'function',
+        function: {
+            name: toolCall.name,
+            arguments: toolCall.arguments,
+        },
+    }));
+    const content = response.output
+        ?.filter((item) => item.type === 'message')
+        .map((item) => item.content
+        .filter((part) => part.type === 'output_text')
+        .map((part) => part.text)
+        .join(''))
+        .join('') || '';
+    return {
+        id: response.id,
+        content,
+        tool_calls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined,
+        usage: {
+            prompt_tokens: response.usage?.input_tokens ?? 0,
+            completion_tokens: response.usage?.output_tokens ?? 0,
+            total_tokens: response.usage?.total_tokens ?? 0,
+            cached_tokens: response.usage?.input_tokens_details?.cached_tokens ?? 0,
+            reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens ?? 0,
+        },
+        system_fingerprint: undefined,
+        service_tier: serviceTier,
+        provider: 'openai',
+        model: normalizedModel,
+    };
+}
+/**
+ * Executes an OpenAI Responses API call for a Chat-Completions-style request and
+ * returns the internal {@link CompletionResponse}. Mirrors {@link createCompletion}'s
+ * transport concerns exactly — API-key resolution, timeout, `AbortSignal`
+ * plumbing, the shared retry policy, and metadata-only failure logging — so the
+ * two producers differ ONLY in the endpoint they hit.
+ *
+ * @param content The user content (string or multi-modal content parts).
+ * @param responseFormat The desired response format.
+ * @param options The Chat-Completions-style options bag.
+ * @returns The normalized completion, identical in shape to the Chat path.
+ * @throws Error when the API key is missing or the API call ultimately fails.
+ */
+async function createResponsesCompletion(content, responseFormat, options = DEFAULT_OPTIONS$1) {
+    const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
+    const apiKey = options.apiKey || getSecrets().openai.apiKey;
+    if (!apiKey) {
+        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
+    }
+    const openai = new OpenAI({
+        apiKey: apiKey,
+        timeout: options.timeout ?? LLM_TIMEOUT_MS,
+    });
+    const requestBody = buildResponsesRequestFromChatOptions(content, responseFormat, options, normalizedModel);
+    let response;
+    try {
+        response = await withRetry(
+        // Same AbortSignal plumbing as the Chat path — a fired signal tears down
+        // the in-flight Responses request and releases its body buffer.
+        () => openai.responses.create(requestBody, options.signal ? { signal: options.signal } : undefined), {
+            maxRetries: 3,
+            baseDelayMs: 2000,
+            maxDelayMs: 30000,
+            retryableErrors: isRetryableLLMError,
+            signal: options.signal,
+        }, `OpenAI-Responses:${normalizedModel}`);
+    }
+    catch (error) {
+        // Metadata-only failure snapshot (no message content, no API key), matching
+        // the Chat path's defensive observability.
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        getLumicLogger().error(`OpenAI Responses call failed for model ${normalizedModel}`, {
+            model: normalizedModel,
+            errorMessage,
+            inputItemCount: Array.isArray(requestBody.input) ? requestBody.input.length : 1,
+            toolCount: requestBody.tools?.length ?? 0,
+            hasTemperature: requestBody.temperature !== undefined && requestBody.temperature !== null,
+            hasTextFormat: requestBody.text?.format !== undefined,
+            hasMaxOutputTokens: requestBody.max_output_tokens !== undefined && requestBody.max_output_tokens !== null,
+            hasReasoningEffort: requestBody.reasoning?.effort !== undefined && requestBody.reasoning?.effort !== null,
+        });
+        throw error;
+    }
+    return normalizeResponsesToCompletion(response, normalizedModel, options.service_tier);
+}
 /**
  * Makes a call to the Lumic LLM interface, either to the default model or to one specified.
  *
+ * Transport is chosen transparently: models flagged
+ * {@link ModelCapabilities.requiresResponsesApiForTools} (the GPT-5.6 reasoning
+ * trio) that are called WITH function tools are routed to the OpenAI Responses
+ * API; every other call stays on Chat Completions. The returned
+ * {@link LLMResponse} envelope — `response`, `tool_calls`, and `usage` — is
+ * byte-identical across both transports, so callers require no changes.
+ *
  * @param content The content to pass to the LLM.
  * @param responseFormat The format of the response. Defaults to 'text'.
  * @param options The options for the LLM call. Defaults to an empty object.
@@ -2825,11 +3385,28 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
         ...DEFAULT_OPTIONS$1,
         ...options,
     };
-    const completion = await createCompletion(content, responseFormat, mergedOptions);
+    // Transparent transport routing. GPT-5.6 reasoning models 400 on
+    // Chat-Completions + function tools, so route tool-bearing calls for such
+    // models to the Responses API. `createResponsesCompletion` returns the SAME
+    // CompletionResponse shape, so all cost-tracking and envelope construction
+    // below is shared and the caller-facing result is identical.
+    const normalizedModel = normalizeModelName(mergedOptions.model || DEFAULT_MODEL);
+    const hasTools = !!(mergedOptions.tools && mergedOptions.tools.length > 0);
+    const completion = requiresResponsesApiForTools(normalizedModel) && hasTools
+        ? await createResponsesCompletion(content, responseFormat, mergedOptions)
+        : await createCompletion(content, responseFormat, mergedOptions);
     // Track cost in the global cost tracker. Pass cached tokens through so the
     // tracker applies the discounted cached-input rate (typically ~50% of the
     // standard input rate) instead of billing every input token at full price.
-    getLLMCostTracker().trackUsage('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens);
+    // reasoning_tokens is 0 on the Chat path and the real count on the Responses
+    // path, so reasoning-heavy models are billed accurately.
+    getLLMCostTracker().trackUsage('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, completion.usage.reasoning_tokens, completion.usage.cached_tokens);
+    // Reasoning tokens are a SUBSET of completion (output) tokens. `calculateCost`
+    // bills output AND reasoning at the output rate, so passing the full
+    // completion_tokens alongside reasoning_tokens would bill reasoning twice.
+    // Cost the non-reasoning remainder here and let calculateCost add reasoning
+    // back once; the reported usage below keeps the full completion_tokens.
+    const nonReasoningOutputTokens = completion.usage.completion_tokens - completion.usage.reasoning_tokens;
     // Handle tool calls differently
     if (completion.tool_calls && completion.tool_calls.length > 0) {
         const toolCallResponse = {
@@ -2844,11 +3421,11 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
             usage: {
                 prompt_tokens: completion.usage.prompt_tokens,
                 completion_tokens: completion.usage.completion_tokens,
-                reasoning_tokens: 0,
+                reasoning_tokens: completion.usage.reasoning_tokens,
                 provider: 'openai',
                 model: completion.model,
                 cached_tokens: completion.usage.cached_tokens,
-                cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
+                cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, nonReasoningOutputTokens, completion.usage.reasoning_tokens, completion.usage.cached_tokens),
             },
             tool_calls: completion.tool_calls,
         };
@@ -2863,11 +3440,11 @@ const makeOpenAIChatCompletionCall = async (content, responseFormat = 'text', op
         usage: {
             prompt_tokens: completion.usage.prompt_tokens,
             completion_tokens: completion.usage.completion_tokens,
-            reasoning_tokens: 0,
+            reasoning_tokens: completion.usage.reasoning_tokens,
             provider: 'openai',
             model: completion.model,
             cached_tokens: completion.usage.cached_tokens,
-            cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, completion.usage.completion_tokens, 0, completion.usage.cached_tokens),
+            cost: calculateCost('openai', completion.model, completion.usage.prompt_tokens, nonReasoningOutputTokens, completion.usage.reasoning_tokens, completion.usage.cached_tokens),
         },
         tool_calls: completion.tool_calls,
     };
@@ -2926,8 +3503,14 @@ const makeResponsesAPICall = async (input, options = {}) => {
     // Responses API exposes cached input tokens under `input_tokens_details.cached_tokens`
     // (the equivalent of Chat Completions' `prompt_tokens_details.cached_tokens`).
     const responsesCachedTokens = response.usage?.input_tokens_details?.cached_tokens || 0;
+    const responsesOutputTokens = response.usage?.output_tokens || 0;
+    const responsesReasoningTokens = response.usage?.output_tokens_details?.reasoning_tokens || 0;
+    // Reasoning tokens are a SUBSET of output tokens; cost the non-reasoning
+    // remainder so calculateCost does not bill reasoning twice (same rationale as
+    // makeOpenAIChatCompletionCall). Reported usage keeps the full output/reasoning counts.
+    const responsesNonReasoningOutputTokens = responsesOutputTokens - responsesReasoningTokens;
     // Track cost in the global cost tracker
-    getLLMCostTracker().trackUsage('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens);
+    getLLMCostTracker().trackUsage('openai', normalizedModel, response.usage?.input_tokens || 0, responsesOutputTokens, responsesReasoningTokens, responsesCachedTokens);
     // Extract tool calls from the output
     const toolCalls = response.output
         ?.filter((item) => item.type === 'function_call')
@@ -2964,12 +3547,12 @@ const makeResponsesAPICall = async (input, options = {}) => {
             response: toolCallResponse,
             usage: {
                 prompt_tokens: response.usage?.input_tokens || 0,
-                completion_tokens: response.usage?.output_tokens || 0,
-                reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
+                completion_tokens: responsesOutputTokens,
+                reasoning_tokens: responsesReasoningTokens,
                 provider: 'openai',
                 model: normalizedModel,
                 cached_tokens: responsesCachedTokens,
-                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens),
+                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, responsesNonReasoningOutputTokens, responsesReasoningTokens, responsesCachedTokens),
             },
             tool_calls: toolCalls,
             ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
@@ -2997,12 +3580,12 @@ const makeResponsesAPICall = async (input, options = {}) => {
         response: parsedResponse,
         usage: {
             prompt_tokens: response.usage?.input_tokens || 0,
-            completion_tokens: response.usage?.output_tokens || 0,
-            reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
+            completion_tokens: responsesOutputTokens,
+            reasoning_tokens: responsesReasoningTokens,
             provider: 'openai',
             model: normalizedModel,
             cached_tokens: responsesCachedTokens,
-            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, responsesCachedTokens),
+            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, responsesNonReasoningOutputTokens, responsesReasoningTokens, responsesCachedTokens),
         },
         tool_calls: toolCalls,
         ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
@@ -8333,7 +8916,12 @@ const isRetryableAnthropicError = (error) => {
  * Anthropic: { name, description, input_schema }
  */
 function translateToolsToAnthropic(tools) {
-    return tools.map((tool) => ({
+    // OpenAI SDK v6 widened `ChatCompletionTool` into a function/custom union.
+    // lumic-utils only supports function tools, so narrow to the function variant
+    // before reading `.function`. Custom tools (which lumic never emits) are skipped.
+    return tools
+        .filter((tool) => tool.type === 'function')
+        .map((tool) => ({
         name: tool.function.name,
         description: tool.function.description || '',
         input_schema: (tool.function.parameters || { type: 'object', properties: {} }),
@@ -8727,8 +9315,11 @@ async function makeOpenAICompatibleCall(content, responseFormat = 'text', option
         const completionTokens = completion.usage?.completion_tokens || 0;
         // Track cost
         getLLMCostTracker().trackUsage(providerConfig.name, model, promptTokens, completionTokens);
-        // Handle tool calls
-        const toolCalls = completion.choices[0]?.message?.tool_calls;
+        // Handle tool calls. OpenAI SDK v6 widened tool calls into a function/custom
+        // union; these OpenAI-compatible providers only return function calls, so
+        // narrow to the function variant to preserve the byte-identical
+        // `function.{name,arguments}` shape the engine parses.
+        const toolCalls = completion.choices[0]?.message?.tool_calls?.filter((tc) => tc.type === 'function');
         if (toolCalls && toolCalls.length > 0) {
             const toolCallResponse = {
                 tool_calls: toolCalls.map((tc) => ({
@@ -9277,7 +9868,13 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         // Handle tool calls similarly to OpenAI
         if (completion.tool_calls && completion.tool_calls.length > 0) {
             const toolCallResponse = {
-                tool_calls: completion.tool_calls.map((tc) => ({
+                // OpenAI SDK v6 widened tool calls into a function/custom union. DeepSeek
+                // (called via the OpenAI-compatible surface) only returns function calls,
+                // so narrow to the function variant to preserve the byte-identical
+                // `function.{name,arguments}` shape.
+                tool_calls: completion.tool_calls
+                    .filter((tc) => tc.type === 'function')
+                    .map((tc) => ({
                     id: tc.id,
                     name: tc.function.name,
                     arguments: JSON.parse(tc.function.arguments),
@@ -23231,11 +23828,11 @@ let poolConfig = DEFAULT_POOL_CONFIG;
 async function loadApolloModules() {
     if (typeof window === "undefined" || process.env.AWS_EXECUTION_ENV) {
         // Server-side (or Lambda): load the CommonJS‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.server-DQPc4Iam.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-DMz8cEcx.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CzTlfziA.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CNrz3Xod.js'); }));
     }
 }
 /**
@@ -80486,11 +81083,93 @@ const tools = [
             }
         }
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "requiresResponsesApiForTools",
+            "description": "Checks whether a model must use the OpenAI Responses API (`/v1/responses`) for function-tool calls rather than Chat Completions (`/v1/chat/completions`). Driven entirely by the {@link ModelCapabilities.requiresResponsesApiForTools} flag in the model registry — there are no hardcoded model-name checks here. Unknown models and models without the flag return `false` (stay on Chat Completions).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "description": "The model to check."
+                    }
+                },
+                "required": [
+                    "model"
+                ]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "buildResponsesRequestFromChatOptions",
+            "description": "Builds an OpenAI Responses API request body from the exact same arguments a caller passes to {@link makeOpenAIChatCompletionCall}. This is the request half of the transparent routing layer. The mapping deliberately mirrors {@link createCompletion}'s Chat request one-for-one so request semantics are preserved across transports: - `developerPrompt` (+ context messages + user `content`) → `input` items (chat `tool_calls`/`tool` messages become `function_call`/ `function_call_output` items). - chat `tools` → Responses `tools` (function tools only). - `temperature` → `temperature`, gated by {@link supportsTemperature} exactly as the Chat path (dropped for GPT-5.6/o-series reasoning models). - `max_completion_tokens` → `max_output_tokens`. - {@link OpenAIResponseFormat} → `text.format`. - `reasoning_effort` → `reasoning.effort`, clamped per-model via {@link clampReasoningEffort} and gated on {@link isReasoningModel} exactly as the Chat path, so the two transports clamp identically. Only set when the caller explicitly supplies it — parity is preserved for callers (like the engine decision path) that do not. Parameters the Chat path does not forward (`top_p`, `parallel_tool_calls`, `tool_choice`, `metadata`, `store`) are intentionally omitted here too, so the request semantics stay identical to today's production Chat behaviour.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "content": {
+                        "type": "string",
+                        "description": "The user content (string or multi-modal content parts)."
+                    },
+                    "responseFormat": {
+                        "type": "string",
+                        "description": "The desired response format."
+                    },
+                    "options": {
+                        "type": "string",
+                        "description": "The Chat-Completions-style options bag."
+                    },
+                    "normalizedModel": {
+                        "type": "string",
+                        "description": "The normalized model name to target."
+                    }
+                },
+                "required": [
+                    "content",
+                    "responseFormat",
+                    "options",
+                    "normalizedModel"
+                ]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "normalizeResponsesToCompletion",
+            "description": "Normalizes an OpenAI Responses API result into the internal {@link CompletionResponse} shape. This is the response half of the transparent routing layer and is the single most correctness-critical mapping in this module: the returned `tool_calls` MUST be byte-identical to what the Chat path produces so downstream consumers (notably the engine decision path, which reads `tool_call.function.arguments` as a JSON string) parse it unchanged. Mapping: - `function_call` output items → `{ id: call_id, type:'function', function:{ name, arguments } }` with `arguments` kept as the raw JSON string (never pre-parsed) — exactly the Chat `ChatCompletionMessageToolCall` shape. `id` is sourced from `call_id` (not the item `id`) so it round-trips as the `tool_call_id` in a multi-turn conversation. - `message` output items → concatenated `output_text` parts (refusals and non-text parts contribute nothing, matching the Chat path's null-content → empty-string behaviour). - usage: `input_tokens`→prompt, `output_tokens`→completion, `input_tokens_details.cached_tokens`→cached, `output_tokens_details.reasoning_tokens`→reasoning. `system_fingerprint` is `undefined` — the Responses API does not return one (the Chat path forwards it; consumers already treat it as optional).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "response": {
+                        "type": "string",
+                        "description": "The raw OpenAI Responses API result."
+                    },
+                    "normalizedModel": {
+                        "type": "string",
+                        "description": "The normalized model name the request targeted."
+                    },
+                    "serviceTier": {
+                        "type": "string",
+                        "description": "The caller's requested service tier, echoed through as on the Chat path."
+                    }
+                },
+                "required": [
+                    "response",
+                    "normalizedModel",
+                    "serviceTier"
+                ]
+            }
+        }
+    },
     {
         "type": "function",
         "function": {
             "name": "makeOpenAIChatCompletionCall",
-            "description": "Makes a call to the Lumic LLM interface, either to the default model or to one specified.",
+            "description": "Makes a call to the Lumic LLM interface, either to the default model or to one specified. Transport is chosen transparently: models flagged {@link ModelCapabilities.requiresResponsesApiForTools} (the GPT-5.6 reasoning trio) that are called WITH function tools are routed to the OpenAI Responses API; every other call stays on Chat Completions. The returned {@link LLMResponse} envelope — `response`, `tool_calls`, and `usage` — is byte-identical across both transports, so callers require no changes.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -81789,9 +82468,11 @@ exports.JsonParseError = JsonParseError;
 exports.LLMCostTracker = LLMCostTracker;
 exports.LLMError = LLMError;
 exports.LLM_ADVANCED_PROVIDER = LLM_ADVANCED_PROVIDER;
+exports.LLM_CRITICAL_PROVIDER = LLM_CRITICAL_PROVIDER;
 exports.LLM_DEFAULT_PROVIDER = LLM_DEFAULT_PROVIDER;
 exports.LLM_MINI_PROVIDER = LLM_MINI_PROVIDER;
 exports.LLM_MODEL_ADVANCED = LLM_MODEL_ADVANCED;
+exports.LLM_MODEL_CRITICAL = LLM_MODEL_CRITICAL;
 exports.LLM_MODEL_MINI = LLM_MODEL_MINI;
 exports.LLM_MODEL_NORMAL = LLM_MODEL_NORMAL;
 exports.LLM_NORMAL_PROVIDER = LLM_NORMAL_PROVIDER;
@@ -81946,4 +82627,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-FqzV71J4.js.map
+//# sourceMappingURL=index-DlAW691N.js.map