@adaptic/lumic-utils 1.0.28 → 1.0.30

package/dist/{index-I-0uzUiF.js → index-BZ9x9UfI.js}

@@ -80,9 +80,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,
@@ -90,7 +95,8 @@ const SUPPORTED_MODELS = {
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
         supportsTemperature: false,
-        isReasoningModel: false,
+        isReasoningModel: true,
+        requiresResponsesApiForTools: true,
     },
     'gpt-5.6-terra': {
         provider: 'openai',
@@ -99,7 +105,8 @@ const SUPPORTED_MODELS = {
         supportsStructuredOutput: true,
         supportsDeveloperPrompt: true,
         supportsTemperature: false,
-        isReasoningModel: false,
+        isReasoningModel: true,
+        requiresResponsesApiForTools: true,
     },
     'gpt-5.6-luna': {
         provider: 'openai',
@@ -108,7 +115,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
@@ -591,24 +599,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)
@@ -683,9 +700,11 @@ const lumicSecretsSchema = z.object({
         llmMiniProvider: z.string().optional(),
         llmNormalProvider: z.string().optional(),
         llmAdvancedProvider: z.string().optional(),
+        llmCriticalProvider: z.string().optional(),
         llmModelMini: z.string().optional(),
         llmModelNormal: z.string().optional(),
         llmModelAdvanced: z.string().optional(),
+        llmModelCritical: z.string().optional(),
         lumicDebug: z.boolean().default(false),
         allowedUploadPaths: z.string().default('/tmp'),
     }),
@@ -748,9 +767,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',
@@ -850,6 +871,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;
 /**
@@ -869,13 +891,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;
@@ -904,6 +927,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';
 
@@ -916,15 +954,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,
@@ -2256,12 +2319,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,
@@ -2578,6 +2647,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.
@@ -2709,6 +2877,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);
@@ -2778,12 +2958,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,
@@ -2792,9 +2978,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.
@@ -2805,11 +3365,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 = {
@@ -2824,11 +3401,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,
         };
@@ -2843,11 +3420,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,
     };
@@ -2906,8 +3483,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')
@@ -2944,12 +3527,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 } : {}),
@@ -2977,12 +3560,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 } : {}),
@@ -8313,7 +8896,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: {} }),
@@ -8707,8 +9295,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) => ({
@@ -9257,7 +9848,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),
@@ -23211,11 +23808,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 import('./apollo-client.server-Bv2rQsCw.js'));
+        return (await import('./apollo-client.server-YkSyk6OJ.js'));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await import('./apollo-client.client-KzZx5slz.js'));
+        return (await import('./apollo-client.client-DsFSBlst.js'));
     }
 }
 /**
@@ -80466,11 +81063,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": {
@@ -81738,5 +82417,5 @@ const lumic = {
     }
 };
 
-export { GraphQLInterfaceType as $, print as A, getNamedType as B, isInputType as C, isRequiredArgument as D, isNamedType as E, GraphQLError as F, GraphQLNonNull as G, isOutputType as H, isRequiredInputField as I, isCompositeType as J, Kind as K, getNullableType as L, getEnterLeaveForKind as M, isNode as N, OperationTypeNode as O, didYouMean as P, naturalCompare as Q, suggestionList as R, specifiedScalarTypes as S, keyMap as T, isType as U, isNullableType as V, visit as W, visitInParallel as X, keyValMap as Y, assertObjectType as Z, GraphQLScalarType as _, isListType as a, validateGoogleSheetsRange as a$, GraphQLUnionType as a0, GraphQLInputObjectType as a1, assertNullableType as a2, assertInterfaceType as a3, mapValue as a4, isSpecifiedScalarType as a5, isPrintableAsBlockString as a6, printBlockString as a7, BREAK as a8, GRAPHQL_MAX_INT as a9, printSourceLocation as aA, resolveObjMapThunk as aB, resolveReadonlyArrayThunk as aC, valueFromASTUntyped as aD, version$4 as aE, versionInfo as aF, getAugmentedNamespace as aG, isDigit$1 as aH, isNameStart as aI, dedentBlockStringLines as aJ, isNameContinue as aK, setLumicLogger as aL, getLumicLogger as aM, sanitizeForLog as aN, sanitizeError as aO, sanitizeAWSAuth as aP, sanitizeObject as aQ, getSecrets as aR, resetSecrets as aS, requireSecret as aT, withRetry as aU, CircuitBreaker as aV, CircuitBreakerState as aW, CircuitBreakerOpenError as aX, DEFAULT_CIRCUIT_BREAKER_CONFIG as aY, validateSlackChannel as aZ, validateS3Key as a_, GRAPHQL_MIN_INT as aa, GraphQLFloat as ab, GraphQLInt as ac, Location as ad, Token as ae, assertAbstractType as af, assertCompositeType as ag, assertEnumType as ah, assertEnumValueName as ai, assertInputObjectType as aj, assertInputType as ak, assertLeafType as al, assertListType as am, assertNamedType as an, assertNonNullType as ao, assertOutputType as ap, assertScalarType as aq, assertType as ar, assertUnionType as as, assertWrappingType as at, formatError as au, getLocation as av, getVisitFn as aw, isWrappingType as ax, printError as ay, printLocation as az, isAbstractType as b, PDFError as b$, LLMCostTracker as b0, getLLMCostTracker as b1, setLLMCostTracker as b2, resetLLMCostTracker as b3, setMetricsCollector as b4, getMetricsCollector as b5, resetMetricsCollector as b6, withMetrics as b7, generateCorrelationId as b8, getCorrelationId as b9, openAIChatCompletionSchema as bA, openAIImageResponseSchema as bB, validateOpenAIChatCompletion as bC, safeValidateOpenAIChatCompletion as bD, perplexityResponseSchema as bE, validatePerplexityResponse as bF, safeValidatePerplexityResponse as bG, googleSheetsValueRangeSchema as bH, validateGoogleSheetsResponse as bI, safeValidateGoogleSheetsResponse as bJ, s3ListObjectsSchema as bK, s3GetObjectSchema as bL, lambdaInvokeResponseSchema as bM, validateS3ListObjects as bN, safeValidateS3ListObjects as bO, validateLambdaResponse as bP, safeValidateLambdaResponse as bQ, createValidator as bR, createSafeValidator as bS, LumicError as bT, SlackError as bU, LLMError as bV, AWSLambdaError as bW, AWSS3Error as bX, GoogleSheetsError as bY, PerplexityError as bZ, JsonParseError as b_, getCorrelationContext as ba, withCorrelationId as bb, getCorrelationHeaders as bc, TokenBucketRateLimiter as bd, RATE_LIMIT_PROFILES as be, getRateLimiter as bf, resetAllRateLimiters as bg, withRateLimit as bh, checkIntegrationHealth as bi, SUPPORTED_MODELS as bj, isValidModel as bk, getModelCapabilities as bl, getModelProvider as bm, MODEL_ALIASES as bn, OPENAI_COMPATIBLE_PROVIDERS as bo, PROVIDER_DEFAULT_MODELS as bp, LLM_DEFAULT_PROVIDER as bq, LLM_MINI_PROVIDER as br, LLM_NORMAL_PROVIDER as bs, LLM_ADVANCED_PROVIDER as bt, LLM_PROVIDER as bu, LLM_MODEL_MINI as bv, LLM_MODEL_NORMAL as bw, LLM_MODEL_ADVANCED as bx, makeAnthropicCall as by, makeOpenAICompatibleCall as bz, isInterfaceType as c, ZipError as c0, SLACK_TIMEOUT_MS as c1, PERPLEXITY_TIMEOUT_MS as c2, GOOGLE_SHEETS_TIMEOUT_MS as c3, LLM_TIMEOUT_MS as c4, AWS_LAMBDA_TIMEOUT_MS as c5, AWS_S3_TIMEOUT_MS as c6, OPENWEATHER_TIMEOUT_MS as c7, GENERIC_FETCH_TIMEOUT_MS as c8, isObjectType as d, assertName as e, devAssert as f, isObjectLike as g, defineArguments as h, isNonNullType as i, argsToArgsConfig as j, GraphQLBoolean as k, lumic as l, GraphQLString as m, instanceOf as n, inspect as o, isInputObjectType as p, isLeafType as q, isEnumType as r, GraphQLID as s, toObjMap as t, invariant as u, GraphQLObjectType as v, GraphQLEnumType as w, GraphQLList as x, isScalarType as y, isUnionType as z };
-//# sourceMappingURL=index-I-0uzUiF.js.map
+export { GraphQLInterfaceType as $, print as A, getNamedType as B, isInputType as C, isRequiredArgument as D, isNamedType as E, GraphQLError as F, GraphQLNonNull as G, isOutputType as H, isRequiredInputField as I, isCompositeType as J, Kind as K, getNullableType as L, getEnterLeaveForKind as M, isNode as N, OperationTypeNode as O, didYouMean as P, naturalCompare as Q, suggestionList as R, specifiedScalarTypes as S, keyMap as T, isType as U, isNullableType as V, visit as W, visitInParallel as X, keyValMap as Y, assertObjectType as Z, GraphQLScalarType as _, isListType as a, validateGoogleSheetsRange as a$, GraphQLUnionType as a0, GraphQLInputObjectType as a1, assertNullableType as a2, assertInterfaceType as a3, mapValue as a4, isSpecifiedScalarType as a5, isPrintableAsBlockString as a6, printBlockString as a7, BREAK as a8, GRAPHQL_MAX_INT as a9, printSourceLocation as aA, resolveObjMapThunk as aB, resolveReadonlyArrayThunk as aC, valueFromASTUntyped as aD, version$4 as aE, versionInfo as aF, getAugmentedNamespace as aG, isDigit$1 as aH, isNameStart as aI, dedentBlockStringLines as aJ, isNameContinue as aK, setLumicLogger as aL, getLumicLogger as aM, sanitizeForLog as aN, sanitizeError as aO, sanitizeAWSAuth as aP, sanitizeObject as aQ, getSecrets as aR, resetSecrets as aS, requireSecret as aT, withRetry as aU, CircuitBreaker as aV, CircuitBreakerState as aW, CircuitBreakerOpenError as aX, DEFAULT_CIRCUIT_BREAKER_CONFIG as aY, validateSlackChannel as aZ, validateS3Key as a_, GRAPHQL_MIN_INT as aa, GraphQLFloat as ab, GraphQLInt as ac, Location as ad, Token as ae, assertAbstractType as af, assertCompositeType as ag, assertEnumType as ah, assertEnumValueName as ai, assertInputObjectType as aj, assertInputType as ak, assertLeafType as al, assertListType as am, assertNamedType as an, assertNonNullType as ao, assertOutputType as ap, assertScalarType as aq, assertType as ar, assertUnionType as as, assertWrappingType as at, formatError as au, getLocation as av, getVisitFn as aw, isWrappingType as ax, printError as ay, printLocation as az, isAbstractType as b, PerplexityError as b$, LLMCostTracker as b0, getLLMCostTracker as b1, setLLMCostTracker as b2, resetLLMCostTracker as b3, setMetricsCollector as b4, getMetricsCollector as b5, resetMetricsCollector as b6, withMetrics as b7, generateCorrelationId as b8, getCorrelationId as b9, makeAnthropicCall as bA, makeOpenAICompatibleCall as bB, openAIChatCompletionSchema as bC, openAIImageResponseSchema as bD, validateOpenAIChatCompletion as bE, safeValidateOpenAIChatCompletion as bF, perplexityResponseSchema as bG, validatePerplexityResponse as bH, safeValidatePerplexityResponse as bI, googleSheetsValueRangeSchema as bJ, validateGoogleSheetsResponse as bK, safeValidateGoogleSheetsResponse as bL, s3ListObjectsSchema as bM, s3GetObjectSchema as bN, lambdaInvokeResponseSchema as bO, validateS3ListObjects as bP, safeValidateS3ListObjects as bQ, validateLambdaResponse as bR, safeValidateLambdaResponse as bS, createValidator as bT, createSafeValidator as bU, LumicError as bV, SlackError as bW, LLMError as bX, AWSLambdaError as bY, AWSS3Error as bZ, GoogleSheetsError as b_, getCorrelationContext as ba, withCorrelationId as bb, getCorrelationHeaders as bc, TokenBucketRateLimiter as bd, RATE_LIMIT_PROFILES as be, getRateLimiter as bf, resetAllRateLimiters as bg, withRateLimit as bh, checkIntegrationHealth as bi, SUPPORTED_MODELS as bj, isValidModel as bk, getModelCapabilities as bl, getModelProvider as bm, MODEL_ALIASES as bn, OPENAI_COMPATIBLE_PROVIDERS as bo, PROVIDER_DEFAULT_MODELS as bp, LLM_DEFAULT_PROVIDER as bq, LLM_MINI_PROVIDER as br, LLM_NORMAL_PROVIDER as bs, LLM_ADVANCED_PROVIDER as bt, LLM_CRITICAL_PROVIDER as bu, LLM_PROVIDER as bv, LLM_MODEL_MINI as bw, LLM_MODEL_NORMAL as bx, LLM_MODEL_ADVANCED as by, LLM_MODEL_CRITICAL as bz, isInterfaceType as c, JsonParseError as c0, PDFError as c1, ZipError as c2, SLACK_TIMEOUT_MS as c3, PERPLEXITY_TIMEOUT_MS as c4, GOOGLE_SHEETS_TIMEOUT_MS as c5, LLM_TIMEOUT_MS as c6, AWS_LAMBDA_TIMEOUT_MS as c7, AWS_S3_TIMEOUT_MS as c8, OPENWEATHER_TIMEOUT_MS as c9, GENERIC_FETCH_TIMEOUT_MS as ca, isObjectType as d, assertName as e, devAssert as f, isObjectLike as g, defineArguments as h, isNonNullType as i, argsToArgsConfig as j, GraphQLBoolean as k, lumic as l, GraphQLString as m, instanceOf as n, inspect as o, isInputObjectType as p, isLeafType as q, isEnumType as r, GraphQLID as s, toObjMap as t, invariant as u, GraphQLObjectType as v, GraphQLEnumType as w, GraphQLList as x, isScalarType as y, isUnionType as z };
+//# sourceMappingURL=index-BZ9x9UfI.js.map