@nexus-cortex/core 4.124.44 → 4.124.46

package/dist/orchestrator/APIClient.js

@@ -20,6 +20,8 @@ import { v4 as uuidv4 } from 'uuid';
 import { assertCompletionBody } from './completionBodyGuard.js';
 import { parseHFCompletion, normalizeToolCallArguments } from '../models/hfSpace/normalize.js';
 import { isResponsesInlineRemindersEnabled, inlineRemindersForResponses, isResponsesStopReasonEnabled, isAnthropicHistoryCacheEnabled, applyAnthropicHistoryCache, countAnthropicBreakpoints, } from './transportFixes.js';
+import { isGeminiSystemFixEnabled, isOpenAICacheKeyEnabled, isStreamUsageEnabled, applyAnthropicCacheLevers, streamFinalUsage, } from './transportCacheFixes.js';
+import { isAnthropicEffortEnabled, isGeminiToolsThinkingEnabled, anthropicOutputEffort, anthropicMaxEffortBudget, } from './transportEffortFixes.js';
 import { anthropicCredentialService, CredentialError } from '../config/AnthropicCredentialService.js';
 /**
  * Anthropic families on the adaptive-thinking-only request surface — sending
@@ -359,6 +361,10 @@ export class APIClient {
         if (enableCaching && isAnthropicHistoryCacheEnabled()) {
             anthropicRequest.messages = applyAnthropicHistoryCache(anthropicRequest.messages, countAnthropicBreakpoints({ system: anthropicRequest.system, tools: anthropicRequest.tools })).messages;
         }
+        // R225 (DARK): CORTEX_ANTHROPIC_AUTO_CACHE top-level automatic cache_control (free slot only) +
+        // CORTEX_ANTHROPIC_CACHE_TTL=1h on every marker. Anthropic only; no-op with both flags off.
+        if (enableCaching)
+            applyAnthropicCacheLevers(anthropicRequest);
         // Phase 2.8: Enable extended thinking for Claude 4+ models with reasoning support
         // Requires beta header: anthropic-beta: interleaved-thinking-2025-05-14
         // Skip if disableThinking option is set (used for continuation requests)
@@ -377,6 +383,11 @@ export class APIClient {
                     process.env.DEBUG_THINKING === 'true'
                         ? { type: 'adaptive', display: 'summarized' }
                         : { type: 'adaptive' };
+                // DARK (CORTEX_ANTHROPIC_EFFORT): the action/request effort reaches adaptive families as output_config.effort.
+                const outputEffort = isAnthropicEffortEnabled() ? anthropicOutputEffort(reasoningEffort) : undefined;
+                if (outputEffort) {
+                    anthropicRequest.output_config = { ...(anthropicRequest.output_config || {}), effort: outputEffort };
+                }
             }
             else {
                 const budgetMap = {
@@ -385,7 +396,11 @@ export class APIClient {
                     medium: 10000,
                     high: 50000,
                 };
-                const budgetTokens = reasoningEffort ? (budgetMap[reasoningEffort] || 10000) : 10000;
+                // DARK (CORTEX_ANTHROPIC_EFFORT): 'max' gets a large budget clamped below max_tokens (was the 10000 fallback).
+                const maxBudget = isAnthropicEffortEnabled() && reasoningEffort === 'max'
+                    ? anthropicMaxEffortBudget(anthropicRequest.max_tokens)
+                    : undefined;
+                const budgetTokens = maxBudget ?? (reasoningEffort ? (budgetMap[reasoningEffort] || 10000) : 10000);
                 anthropicRequest.thinking = {
                     type: 'enabled',
                     budget_tokens: budgetTokens
@@ -742,6 +757,8 @@ export class APIClient {
         // deepseek runs (reasoning + tools, no forced choice) are fine — so drop reasoning ONLY when a
         // tool_choice is actually forced. OpenAI's R19b case (tools alone) stays as-is.
         const hasForcedToolChoice = !!request.toolChoice;
+        // R19b STAYS (live probe 2026-10-03): gpt-5.4-nano AND gpt-5.6-luna still 400 "Function tools with reasoning_effort are not
+        // supported … in /v1/chat/completions. To use function tools, use /v1/responses" — CORTEX_OPENAI_TOOLS_REASONING is Responses-only.
         const dropReasoningForToolCompat = (willAttachTools && isChatCompletionsRoute && modelConfig.provider === 'openai') ||
             (hasForcedToolChoice && isChatCompletionsRoute && modelConfig.provider === 'deepseek');
         // Enable reasoning for OpenAI models that support it (GPT-5 family, o-series)
@@ -784,6 +801,16 @@ export class APIClient {
             chatRequest.tools = request.tools;
             this.applyToolChoice(chatRequest, request, 'chat/completions'); // §13-B1 forced tool_choice
         }
+        // R225 (DARK, CORTEX_OPENAI_CACHE_KEY): OpenAI routes same-key requests to the same prompt cache.
+        // OpenAI provider only (other chat/completions providers may reject the unknown field).
+        if (isOpenAICacheKeyEnabled() && modelConfig.provider === 'openai' && request.conversationId) {
+            chatRequest.prompt_cache_key = request.conversationId;
+        }
+        // R224a (DARK, CORTEX_STREAM_USAGE): ask for the final usage chunk on streaming requests (otherwise the
+        // reassembled message reports zeros). Body-level, after the prefix — cache-neutral.
+        if (opts.stream && isStreamUsageEnabled()) {
+            chatRequest.stream_options = { include_usage: true };
+        }
         this.logChatCompletionsPayload(chatRequest, request.modelId, opts.stream);
         return { client, chatRequest };
     }
@@ -1054,6 +1081,10 @@ export class APIClient {
             // opt-in ZDR mode: "DESIGN NOTE — stateless ZDR mode" in
             // ResponsesAPIAdapter.ts (adapters/).
         }
+        // R225 (DARK, CORTEX_OPENAI_CACHE_KEY): the same session-scoped cache routing key for OpenAI Responses.
+        if (isOpenAICacheKeyEnabled() && modelConfig.provider?.toLowerCase() === 'openai' && request.conversationId) {
+            responsesRequest.prompt_cache_key = request.conversationId;
+        }
         // Set system context as instructions (enables provider-side caching).
         // R63: request.systemMessage (the R28 static system prompt) was previously
         // dropped on this path — only <system-reminder> text mined from user
@@ -1165,6 +1196,12 @@ export class APIClient {
         if (request.tools && request.tools.length > 0) {
             return this.sendGenerateContentHTTP(request, modelConfig, apiKey);
         }
+        // R229 (DARK, CORTEX_GEMINI_SYSTEM_FIX): the @google/generative-ai SDK (v0.2.1, v1 endpoint) has no
+        // systemInstruction support, so a request carrying a system prompt goes through the v1beta REST builder,
+        // which sends it as system_instruction.
+        if (isGeminiSystemFixEnabled() && request.systemMessage) {
+            return this.sendGenerateContentHTTP(request, modelConfig, apiKey);
+        }
         // For non-tool requests, use SDK as before
         if (!this.googleClient) {
             this.googleClient = new GoogleGenerativeAI(apiKey);
@@ -1212,6 +1249,11 @@ export class APIClient {
             contents: request.messages,
             generation_config: generationConfig // Use the nested object directly
         };
+        // R229 (DARK, CORTEX_GEMINI_SYSTEM_FIX): deliver the system prompt (the streaming HTTP builder always did;
+        // this non-streaming builder never did). Same snake_case shape as streamGenerateContentHTTP.
+        if (isGeminiSystemFixEnabled() && request.systemMessage) {
+            requestBody.system_instruction = { parts: [{ text: request.systemMessage }] };
+        }
         // Add tools if present
         if (request.tools && request.tools.length > 0) {
             // REST API uses snake_case "function_declarations", not camelCase "functionDeclarations"
@@ -1353,6 +1395,9 @@ export class APIClient {
             if (enableCaching && isAnthropicHistoryCacheEnabled()) {
                 anthropicRequest.messages = applyAnthropicHistoryCache(anthropicRequest.messages, countAnthropicBreakpoints({ system: anthropicRequest.system, tools: anthropicRequest.tools })).messages;
             }
+            // R225 (DARK): automatic cache_control + 1h TTL — mirrors sendAnthropicMessagesAPI.
+            if (enableCaching)
+                applyAnthropicCacheLevers(anthropicRequest);
             // Phase 2.8: Enable extended thinking for Claude 4+ models with reasoning support
             // Requires beta header: anthropic-beta: interleaved-thinking-2025-05-14
             // Skip if disableThinking option is set (used for continuation requests)
@@ -1370,6 +1415,11 @@ export class APIClient {
                         process.env.DEBUG_THINKING === 'true'
                             ? { type: 'adaptive', display: 'summarized' }
                             : { type: 'adaptive' };
+                    // DARK (CORTEX_ANTHROPIC_EFFORT): parity with the non-streaming path.
+                    const outputEffort = isAnthropicEffortEnabled() ? anthropicOutputEffort(reasoningEffort) : undefined;
+                    if (outputEffort) {
+                        anthropicRequest.output_config = { ...(anthropicRequest.output_config || {}), effort: outputEffort };
+                    }
                     if (process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') {
                         console.log(`[DEBUG APIClient] Adaptive thinking for ${modelConfig.id}${process.env.DEBUG_THINKING === 'true' ? ' (display: summarized)' : ''}`);
                     }
@@ -1381,7 +1431,11 @@ export class APIClient {
                         medium: 10000,
                         high: 50000,
                     };
-                    const budgetTokens = reasoningEffort ? (budgetMap[reasoningEffort] || 10000) : 10000;
+                    // DARK (CORTEX_ANTHROPIC_EFFORT): parity with the non-streaming path ('max' → clamped large budget).
+                    const maxBudget = isAnthropicEffortEnabled() && reasoningEffort === 'max'
+                        ? anthropicMaxEffortBudget(anthropicRequest.max_tokens)
+                        : undefined;
+                    const budgetTokens = maxBudget ?? (reasoningEffort ? (budgetMap[reasoningEffort] || 10000) : 10000);
                     anthropicRequest.thinking = {
                         type: 'enabled',
                         budget_tokens: budgetTokens
@@ -1981,6 +2035,9 @@ export class APIClient {
         // R153 (2026-09-16): keep the provider's LAST non-null finish_reason so a `length` cutoff survives reassembly
         // (the empty-response classifier keys `truncated` on it; the old hardcode reported every text turn as `stop`).
         let lastFinishReason = null;
+        // R224a (DARK, CORTEX_STREAM_USAGE): the provider's final usage chunk (choices: []) when requested.
+        const captureStreamUsage = isStreamUsageEnabled();
+        let streamUsage = null;
         // Capture this context before entering generator
         const self = this;
         // Create async generator that both yields chunks AND accumulates final message
@@ -1994,7 +2051,9 @@ export class APIClient {
                 if (!firstChunk)
                     firstChunk = chunk;
                 chunkCount++;
-                const delta = chunk.choices[0]?.delta;
+                if (captureStreamUsage && chunk?.usage)
+                    streamUsage = chunk.usage;
+                const delta = chunk.choices?.[0]?.delta;
                 // Debug: Log first few chunks to see what fields are present
                 if ((process.env.DEBUG === 'true' || process.env.DEBUG_THINKING === 'true') && chunkCount <= 3) {
                     console.log(`[DEBUG APIClient] Chunk ${chunkCount} delta keys:`, delta ? Object.keys(delta) : 'null');
@@ -2045,7 +2104,7 @@ export class APIClient {
                     }
                 }
                 // Check if finish_reason indicates tool_calls completion (or length-truncated tool call)
-                const finishReason = chunk.choices[0]?.finish_reason;
+                const finishReason = chunk.choices?.[0]?.finish_reason;
                 if (finishReason)
                     lastFinishReason = String(finishReason);
                 if ((finishReason === 'tool_calls' || finishReason === 'length') && accumulatedToolCalls.size > 0) {
@@ -2111,11 +2170,7 @@ export class APIClient {
                         // ('length' = output cap hit) instead of a synthetic 'stop'.
                         finish_reason: finalToolCalls.length > 0 ? 'tool_calls' : (lastFinishReason ?? 'stop')
                     }],
-                usage: {
-                    prompt_tokens: 0,
-                    completion_tokens: 0,
-                    total_tokens: 0
-                }
+                usage: streamFinalUsage(streamUsage)
             });
         }();
         return {
@@ -2215,6 +2270,10 @@ export class APIClient {
                     responsesRequest.prompt_cache_key = request.conversationId;
                 }
             }
+            // R225 (DARK, CORTEX_OPENAI_CACHE_KEY): mirrors sendResponsesAPI.
+            if (isOpenAICacheKeyEnabled() && modelConfig.provider?.toLowerCase() === 'openai' && request.conversationId) {
+                responsesRequest.prompt_cache_key = request.conversationId;
+            }
             // Set system context as instructions (enables provider-side caching).
             // R63: merge the R28 static system prompt (previously dropped on this
             // path) ahead of reminders mined from user messages; XAI gets it as a
@@ -2475,6 +2534,11 @@ export class APIClient {
         if (request.tools && request.tools.length > 0) {
             return this.streamGenerateContentHTTP(request, modelConfig, apiKey);
         }
+        // R229 (DARK, CORTEX_GEMINI_SYSTEM_FIX): the old SDK cannot send a system prompt — use the v1beta REST
+        // streaming builder (already sends system_instruction) whenever one is present.
+        if (isGeminiSystemFixEnabled() && request.systemMessage) {
+            return this.streamGenerateContentHTTP(request, modelConfig, apiKey);
+        }
         // For non-tool requests, use SDK streaming
         if (!this.googleClient) {
             this.googleClient = new GoogleGenerativeAI(apiKey);
@@ -2819,12 +2883,22 @@ export class APIClient {
             Object.assign(config, generationConfig);
         }
         // CRITICAL: thinkingConfig and tools CANNOT coexist
+        // (DARK CORTEX_GEMINI_TOOLS_THINKING: a Gemini 2.0-era observation — on, thinking is sent WITH tools.)
         const hasTools = request.tools && request.tools.length > 0;
+        const geminiToolsThinking = isGeminiToolsThinkingEnabled();
         if (_modelConfig.reasoning?.supported && _modelConfig.reasoning?.pattern === 'interleaved' && !disableThinking && !hasTools) {
-            config.thinkingConfig = {
-                includeThoughts: true,
-                thinkingBudget: 10000
-            };
+            config.thinkingConfig = geminiToolsThinking && config.thinkingConfig
+                // effort-mapped thinkingLevel/thinkingBudget from the gateway; keep the thought summaries this path always asked for
+                ? { includeThoughts: true, ...config.thinkingConfig }
+                : {
+                    includeThoughts: true,
+                    thinkingBudget: 10000
+                };
+        }
+        else if (_modelConfig.reasoning?.supported && _modelConfig.reasoning?.pattern === 'interleaved' && !disableThinking && hasTools && geminiToolsThinking) {
+            // Non-streaming: no includeThoughts — this response is converted by the message-level adapter, which would turn
+            // thought-summary parts into visible text. Effort-mapped config from the gateway, else the no-tools default budget.
+            config.thinkingConfig = config.thinkingConfig ?? { thinkingBudget: 10000 };
         }
         // Add tools to config if present
         if (hasTools && request.tools) {
@@ -2843,7 +2917,14 @@ export class APIClient {
             config
         };
         if (request.systemMessage) {
-            sdkRequest.systemInstruction = request.systemMessage;
+            if (isGeminiSystemFixEnabled()) {
+                // R229 (DARK): @google/genai reads the system prompt ONLY from config.systemInstruction
+                // (GenerateContentParameters = {model, contents, config}); a top-level field is dropped.
+                config.systemInstruction = request.systemMessage;
+            }
+            else {
+                sdkRequest.systemInstruction = request.systemMessage;
+            }
         }
         if (process.env.DEBUG === 'true') {
             console.log(`[DEBUG APIClient SDK] Non-streaming request for model: ${modelId}`);
@@ -2904,16 +2985,24 @@ export class APIClient {
         // Following Claude/Grok pattern: Skip if disableThinking flag is set (used for continuation requests)
         // CRITICAL: thinkingConfig and tools CANNOT coexist — Google API returns empty responses when both present
         const hasTools = request.tools && request.tools.length > 0;
-        if (_modelConfig.reasoning?.supported && _modelConfig.reasoning?.pattern === 'interleaved' && !disableThinking && !hasTools) {
-            config.thinkingConfig = {
-                includeThoughts: true, // Enable thought summaries in response
-                // Gemini 2.5 Flash supports thinkingBudget (0-24576)
-                // -1 = dynamic (model decides), or set explicit budget like Claude's 10000
-                // Set to 10000 tokens to encourage verbose reasoning like Claude
-                thinkingBudget: 10000
-            };
+        // DARK (CORTEX_GEMINI_TOOLS_THINKING): on, thinking is sent WITH tools (effort-mapped by the gateway).
+        const geminiToolsThinking = isGeminiToolsThinkingEnabled();
+        if (_modelConfig.reasoning?.supported && _modelConfig.reasoning?.pattern === 'interleaved' && !disableThinking && (!hasTools || geminiToolsThinking)) {
+            if (geminiToolsThinking && config.thinkingConfig) {
+                // effort-mapped thinkingLevel/thinkingBudget from the gateway (+ thought summaries; the stream parser filters part.thought)
+                config.thinkingConfig = { includeThoughts: true, ...config.thinkingConfig };
+            }
+            else {
+                config.thinkingConfig = {
+                    includeThoughts: true, // Enable thought summaries in response
+                    // Gemini 2.5 Flash supports thinkingBudget (0-24576)
+                    // -1 = dynamic (model decides), or set explicit budget like Claude's 10000
+                    // Set to 10000 tokens to encourage verbose reasoning like Claude
+                    thinkingBudget: 10000
+                };
+            }
             if (process.env.DEBUG === 'true') {
-                console.log(`[DEBUG APIClient SDK] Extended thinking enabled for ${modelId} with budget: 10000`);
+                console.log(`[DEBUG APIClient SDK] Extended thinking enabled for ${modelId}: ${JSON.stringify(config.thinkingConfig)}`);
             }
         }
         else if (hasTools && process.env.DEBUG === 'true') {
@@ -2940,9 +3029,15 @@ export class APIClient {
             contents: request.messages,
             config // Config contains both generation params and tools
         };
-        // Add system instruction if present (top level, not in config)
+        // Add system instruction if present. Legacy: top level (the SDK DROPS it — GenerateContentParameters =
+        // {model, contents, config}). R229 (DARK, CORTEX_GEMINI_SYSTEM_FIX): config.systemInstruction.
         if (request.systemMessage) {
-            sdkRequest.systemInstruction = request.systemMessage;
+            if (isGeminiSystemFixEnabled()) {
+                config.systemInstruction = request.systemMessage;
+            }
+            else {
+                sdkRequest.systemInstruction = request.systemMessage;
+            }
         }
         if (process.env.DEBUG === 'true') {
             console.log(`[DEBUG APIClient SDK] Using model: ${modelId}`);