lynkr 9.7.2 → 9.9.0

package/src/clients/gpt-utils.js

@@ -1,89 +1,19 @@
 /**
- * GPT-specific utilities for handling tool calls and responses
- * All settings are hardcoded - no env vars required
+ * Detection of semantically-similar tool calls.
  *
- * This module addresses GPT model compatibility issues when using Azure OpenAI
- * through Lynkr proxy with Claude Code:
- * - GPT doesn't interpret "0 files found" as a final answer
- * - GPT retries the same tool expecting different results
- * - GPT needs explicit guidance on tool result interpretation
+ * GPT-family models often retry a tool with slightly different but
+ * functionally equivalent parameters instead of accepting the result;
+ * the orchestrator uses areSimilarToolCalls to treat those retries as
+ * duplicates.
  */
 
 const logger = require("../logger");
 
-// Hardcoded GPT settings - optimized for GPT model behavior
-const GPT_SETTINGS = {
-  toolLoopThreshold: 2,        // Lower than Claude's 3 to catch loops earlier
-  enhancedFormatting: true,    // Always format results explicitly for GPT
-  similarityThreshold: 0.8,    // For detecting similar (not just identical) tool calls
-};
-
-// Provider identifiers that use GPT models
-const GPT_PROVIDERS = ['azure-openai', 'openai'];
-
-/**
- * Check if a provider uses GPT models
- * @param {string} provider - Provider type (e.g., 'azure-openai', 'databricks')
- * @returns {boolean} - True if provider uses GPT models
- */
-function isGPTProvider(provider) {
-  if (!provider) return false;
-  return GPT_PROVIDERS.includes(provider.toLowerCase());
-}
-
-/**
- * Get the tool loop threshold for GPT models
- * @returns {number} - Threshold (2 for GPT, lower than Claude's 3)
- */
-function getGPTToolLoopThreshold() {
-  return GPT_SETTINGS.toolLoopThreshold;
-}
-
-/**
- * Format tool result with explicit structure for GPT models
- * GPT models need clear, unambiguous formatting to understand tool results
- *
- * @param {string} toolName - Name of the tool that was called
- * @param {string} content - The tool result content
- * @param {Object} args - The arguments passed to the tool
- * @returns {string} - Formatted result with explicit status and instructions
- */
-function formatToolResultForGPT(toolName, content, args) {
-  // Handle empty/no results explicitly - add clear messaging to prevent retries
-  const isEmpty = !content ||
-    content.trim() === '' ||
-    content.includes('0 files found') ||
-    content.includes('No matches found') ||
-    content.includes('No results') ||
-    content.includes('Found 0') ||
-    /^Found \d+ files?\.$/.test(content.trim()) && content.includes('Found 0');
-
-  if (isEmpty) {
-    // Only format empty results - add explicit "don't retry" instruction
-    return `Tool "${toolName}" completed with no results found.
-Query: ${JSON.stringify(args)}
-
-This is a FINAL result - do not retry this query. Respond to the user based on this outcome.`;
-  }
-
-  // For successful results, return content as-is (don't add markers that might confuse GPT)
-  return content;
-}
-
-/**
- * Get system prompt addendum for GPT models
- * This teaches GPT how to properly interpret and use tools
- *
- * @returns {string} - System prompt instructions for GPT
- */
-function getGPTSystemPromptAddendum() {
-  return `Use the Bash tool with ls command for listing files. After any tool returns results, respond to the user.`;
-}
+// Jaccard similarity above this counts two search-tool calls as duplicates
+const SIMILARITY_THRESHOLD = 0.8;
 
 /**
  * Calculate string similarity using Jaccard index
- * Used to detect semantically similar tool calls
- *
  * @param {string} s1 - First string
  * @param {string} s2 - Second string
  * @returns {number} - Similarity score between 0 and 1
@@ -110,8 +40,6 @@ function stringSimilarity(s1, s2) {
 
 /**
  * Check if two tool calls are semantically similar
- * GPT often retries with slightly different parameters that are functionally equivalent
- *
  * @param {Object} call1 - First tool call {name, arguments}
  * @param {Object} call2 - Second tool call {name, arguments}
  * @returns {boolean} - True if calls are similar enough to be considered duplicates
@@ -119,34 +47,31 @@ function stringSimilarity(s1, s2) {
 function areSimilarToolCalls(call1, call2) {
   if (!call1 || !call2) return false;
 
-  // Must be the same tool
   const name1 = call1.function?.name ?? call1.name;
   const name2 = call2.function?.name ?? call2.name;
   if (name1 !== name2) return false;
 
-  // Get arguments
   const args1 = call1.function?.arguments ?? call1.arguments ?? call1.input ?? {};
   const args2 = call2.function?.arguments ?? call2.arguments ?? call2.input ?? {};
 
-  // Stringify for comparison
   const argsStr1 = typeof args1 === 'string' ? args1 : JSON.stringify(args1);
   const argsStr2 = typeof args2 === 'string' ? args2 : JSON.stringify(args2);
 
-  // Exact match
   if (argsStr1 === argsStr2) return true;
 
-  // For search-related tools, check semantic similarity
+  // Only search-style tools get fuzzy matching; mutating tools with
+  // near-identical args may be intentional repeats.
   const searchTools = ['grep', 'glob', 'search', 'find', 'read', 'bash', 'shell'];
   const toolName = (name1 || '').toLowerCase();
   const isSearchTool = searchTools.some(t => toolName.includes(t));
 
   if (isSearchTool) {
     const similarity = stringSimilarity(argsStr1, argsStr2);
-    if (similarity >= GPT_SETTINGS.similarityThreshold) {
+    if (similarity >= SIMILARITY_THRESHOLD) {
       logger.debug({
         tool: name1,
         similarity,
-        threshold: GPT_SETTINGS.similarityThreshold,
+        threshold: SIMILARITY_THRESHOLD,
         args1: argsStr1.substring(0, 100),
         args2: argsStr2.substring(0, 100),
       }, "Similar tool call detected");
@@ -157,25 +82,6 @@ function areSimilarToolCalls(call1, call2) {
   return false;
 }
 
-/**
- * Get a signature for a tool call (for tracking in history)
- * @param {Object} call - Tool call object
- * @returns {string} - Unique signature for the call
- */
-function getToolCallSignature(call) {
-  const name = call.function?.name ?? call.name ?? 'unknown';
-  const args = call.function?.arguments ?? call.arguments ?? call.input ?? {};
-  const argsStr = typeof args === 'string' ? args : JSON.stringify(args);
-  return `${name}:${argsStr}`;
-}
-
 module.exports = {
-  GPT_SETTINGS,
-  isGPTProvider,
-  getGPTToolLoopThreshold,
-  formatToolResultForGPT,
-  getGPTSystemPromptAddendum,
-  stringSimilarity,
   areSimilarToolCalls,
-  getToolCallSignature,
 };

package/src/clients/openai-format.js

@@ -46,9 +46,16 @@ function convertOpenAIToAnthropic(openaiRequest) {
   const anthropicMessages = [];
 
   for (const msg of messageArray) {
-    if (msg.role === "system") {
-      // Anthropic uses a separate system field
-      system = msg.content;
+    if (msg.role === "system" || msg.role === "developer") {
+      // Anthropic uses a separate system field. OpenAI's `developer` role
+      // (Codex sends its sandbox/permissions rules this way) is system-level
+      // content — append rather than overwrite when both are present.
+      const sysText = typeof msg.content === "string"
+        ? msg.content
+        : Array.isArray(msg.content)
+          ? msg.content.filter((p) => p?.type === "text" || typeof p?.text === "string").map((p) => p.text || "").join("\n")
+          : "";
+      system = system ? `${system}\n\n${sysText}` : sysText;
     } else if (msg.role === "user" || msg.role === "assistant") {
       // Convert content format
       let content;

package/src/clients/openrouter-utils.js

@@ -26,18 +26,25 @@ function convertAnthropicToolsToOpenRouter(anthropicTools) {
     return [];
   }
 
-  return anthropicTools.map(tool => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description || "",
-      parameters: tool.input_schema || {
-        type: "object",
-        properties: {},
-        required: []
+  return anthropicTools.map(tool => {
+    // Shape-detect: already OpenAI-format tools pass through untouched —
+    // the orchestrator's build step may have normalised for a different
+    // provider before routing picked this one, and re-wrapping strips the
+    // name ({type:"function", function:{name:undefined}}).
+    if (tool?.type === "function" && tool.function) return tool;
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description || "",
+        parameters: tool.input_schema || {
+          type: "object",
+          properties: {},
+          required: []
+        }
       }
-    }
-  }));
+    };
+  });
 }
 
 /**
@@ -62,6 +69,13 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
       const textBlocks = content.filter(block => block.type === 'text');
       const toolUseBlocks = content.filter(block => block.type === 'tool_use');
       const toolResultBlocks = content.filter(block => block.type === 'tool_result');
+      // Thinking models (Kimi, MiniMax) require prior reasoning passed back
+      // as reasoning_content on replayed assistant turns — dropping it
+      // severs the model's chain across a tool loop.
+      const thinkingText = content
+        .filter(block => block.type === 'thinking' && typeof block.thinking === 'string')
+        .map(block => block.thinking)
+        .join('\n');
 
       logger.debug({
         role: msg.role,
@@ -98,20 +112,18 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
           message.content = null;
         }
 
+        if (thinkingText) {
+          message.reasoning_content = thinkingText;
+        }
+
         converted.push(message);
       }
-      // User message with tool results
+      // User message with tool results. ORDER MATTERS: tool messages must
+      // directly follow the assistant message carrying their tool_calls —
+      // a user-text message in between orphans the results, and strict
+      // providers 400 the unpaired function_call.
       else if (msg.role === 'user' && toolResultBlocks.length > 0) {
-        // Add text content as user message first if present
-        const textContent = textBlocks.map(block => block.text || '').join('\n');
-        if (textContent) {
-          converted.push({
-            role: 'user',
-            content: textContent
-          });
-        }
-
-        // Add each tool result as a separate tool message
+        // Tool results first — adjacent to their assistant tool_calls.
         for (const toolResult of toolResultBlocks) {
           converted.push({
             role: 'tool',
@@ -121,14 +133,27 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
               : JSON.stringify(toolResult.content || {})
           });
         }
+
+        // Then any user-authored/injected text as a user message.
+        const textContent = textBlocks.map(block => block.text || '').join('\n');
+        if (textContent) {
+          converted.push({
+            role: 'user',
+            content: textContent
+          });
+        }
       }
       // Regular message with just text
       else {
         const textContent = textBlocks.map(block => block.text || '').join('\n');
-        converted.push({
+        const message = {
           role: msg.role,
           content: textContent || ''
-        });
+        };
+        if (msg.role === 'assistant' && thinkingText) {
+          message.reasoning_content = thinkingText;
+        }
+        converted.push(message);
       }
     }
     // Simple string content

package/src/clients/prompt-cache-injection.js

@@ -114,6 +114,7 @@ function needsCacheInjection(provider) {
     'bedrock',
     'databricks',   // Databricks routes to Claude which supports caching
     'openrouter',   // OpenRouter forwards cache_control to underlying provider
+    'edenai',       // Eden AI forwards cache_control to underlying provider
   ]);
 
   return EXPLICIT_CACHE_PROVIDERS.has(provider);

package/src/clients/provider-capabilities.js

@@ -11,7 +11,7 @@ const NATIVE_THINKING_BEDROCK_MODELS = [
   "claude-haiku",
 ];
 
-const REASONING_CONTENT_PROVIDERS = new Set(["moonshot", "openrouter", "openai", "azure-openai"]);
+const REASONING_CONTENT_PROVIDERS = new Set(["moonshot", "openrouter", "edenai", "openai", "azure-openai"]);
 
 function supportsNativeThinking(providerType, model) {
   if (NATIVE_THINKING_PROVIDERS.has(providerType)) return true;

package/src/clients/responses-format.js

@@ -71,7 +71,7 @@ function mapClientToolToLynkr(clientToolName) {
  * @returns {Object} Chat Completions format request
  */
 function convertResponsesToChat(responsesRequest) {
-  const { input, model, max_tokens, temperature, top_p, tools, tool_choice, stream } = responsesRequest;
+  const { input, instructions, model, max_tokens, temperature, top_p, tools, tool_choice, stream } = responsesRequest;
 
   logger.info({
     inputType: typeof input,
@@ -173,7 +173,9 @@ function convertResponsesToChat(responsesRequest) {
         if (Array.isArray(content)) {
           // Extract text from array of content parts
           const textParts = content
-            .filter(part => part && (part.type === 'text' || part.type === 'input_text'))
+            // output_text is how prior ASSISTANT replies arrive in input[] —
+            // dropping it made the model re-answer every previous turn.
+            .filter(part => part && (part.type === 'text' || part.type === 'input_text' || part.type === 'output_text'))
             .map(part => part.text || part.input_text || '')
             .filter(text => text.length > 0);
 
@@ -249,13 +251,42 @@ function convertResponsesToChat(responsesRequest) {
     messages = [{ role: "user", content: String(input || "") }];
   }
 
+  // Responses API carries the system prompt in `instructions`, not as an
+  // input message — Codex's entire harness prompt lives here. Dropping it
+  // leaves the model with no tool-usage conventions.
+  if (typeof instructions === "string" && instructions.trim()) {
+    messages = [{ role: "system", content: instructions }, ...messages];
+  }
+
+  // Responses API declares function tools with a top-level name/parameters;
+  // downstream converters expect Chat Completions shape ({function:{name}})
+  // and silently drop anything else. Convert function tools; exotic types
+  // (custom/namespace/tool_search/web_search/image_generation) have no
+  // Chat/Anthropic equivalent and are dropped.
+  let chatTools;
+  if (Array.isArray(tools)) {
+    chatTools = tools
+      .map((t) => {
+        if (t?.type === "function" && t.function) return t; // already Chat-shaped
+        if (t?.type === "function" && t.name && t.parameters) {
+          return {
+            type: "function",
+            function: { name: t.name, description: t.description || "", parameters: t.parameters },
+          };
+        }
+        return null;
+      })
+      .filter(Boolean);
+    if (chatTools.length === 0) chatTools = undefined;
+  }
+
   const result = {
     model: model || "gpt-4o",
     messages: messages,
     max_tokens: max_tokens || 4096,
     temperature: temperature,
     top_p: top_p,
-    tools: tools,
+    tools: chatTools,
     tool_choice: tool_choice,
     stream: stream || false
   };

package/src/clients/routing.js

@@ -11,10 +11,25 @@
  */
 
 const smartRouting = require('../routing');
+const config = require('../config');
+
+// Synchronous version for benchmarking/tests
+// (when tiers are disabled, routing is purely static)
+function determineProviderSync(payload) {
+  const primaryProvider = config.modelProvider?.type || 'databricks';
+  const defaultModel = config.modelProvider?.defaultModel || 'databricks-claude-sonnet-4-5';
+
+  return {
+    provider: primaryProvider,
+    model: defaultModel,
+    reason: 'static_provider'
+  };
+}
 
 // Re-export all functions from smart routing
 module.exports = {
   determineProviderSmart: smartRouting.determineProviderSmart,
+  determineProviderSync,
   isFallbackEnabled: smartRouting.isFallbackEnabled,
   getFallbackProvider: smartRouting.getFallbackProvider,
   getRoutingHeaders: smartRouting.getRoutingHeaders,

package/src/config/index.js

@@ -62,7 +62,7 @@ function resolveConfigPath(targetPath) {
   return path.resolve(normalised);
 }
 
-const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "azure-openai", "openai", "llamacpp", "lmstudio", "bedrock", "zai", "vertex", "moonshot"]);
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "edenai", "azure-openai", "openai", "llamacpp", "lmstudio", "bedrock", "zai", "vertex", "moonshot"]);
 const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
 
 // Validate MODEL_PROVIDER early with a clear error message
@@ -97,6 +97,12 @@ const openRouterModel = process.env.OPENROUTER_MODEL ?? "openai/gpt-4o-mini";
 const openRouterEmbeddingsModel = process.env.OPENROUTER_EMBEDDINGS_MODEL ?? "openai/text-embedding-ada-002";
 const openRouterEndpoint = process.env.OPENROUTER_ENDPOINT ?? "https://openrouter.ai/api/v1/chat/completions";
 
+// Eden AI configuration (OpenAI-compatible v3 gateway — provider/model naming, EU/GDPR)
+const edenAIApiKey = process.env.EDENAI_API_KEY ?? null;
+const edenAIModel = process.env.EDENAI_MODEL ?? "openai/gpt-4o-mini";
+const edenAIEmbeddingsModel = process.env.EDENAI_EMBEDDINGS_MODEL ?? "openai/text-embedding-ada-002";
+const edenAIEndpoint = process.env.EDENAI_ENDPOINT ?? "https://api.edenai.run/v3/chat/completions";
+
 // Azure OpenAI configuration
 const azureOpenAIEndpoint = process.env.AZURE_OPENAI_ENDPOINT?.trim() || null;
 const azureOpenAIApiKey = process.env.AZURE_OPENAI_API_KEY?.trim() || null;
@@ -219,6 +225,13 @@ const toonMinBytes = Number.parseInt(process.env.TOON_MIN_BYTES ?? "4096", 10);
 const toonFailOpen = process.env.TOON_FAIL_OPEN !== "false"; // default true
 const toonLogStats = process.env.TOON_LOG_STATS !== "false"; // default true
 
+// GCF payload compression (opt-in; drop-in alternative to TOON)
+const gcfEnabled = process.env.GCF_ENABLED === "true"; // default false
+const gcfMinBytes = Number.parseInt(process.env.GCF_MIN_BYTES ?? "4096", 10);
+const gcfFailOpen = process.env.GCF_FAIL_OPEN !== "false"; // default true
+const gcfLogStats = process.env.GCF_LOG_STATS !== "false"; // default true
+const gcfVerify = process.env.GCF_VERIFY !== "false"; // default true (round-trip check)
+
 // Smart tool selection configuration (always enabled)
 const smartToolSelectionMode = (process.env.SMART_TOOL_SELECTION_MODE ?? "heuristic").toLowerCase();
 const smartToolSelectionTokenBudget = Number.parseInt(
@@ -336,7 +349,7 @@ const tiersConfigured = !!(
 if (fallbackEnabled && tiersConfigured) {
   const localProviders = ["ollama", "llamacpp", "lmstudio"];
   if (localProviders.includes(fallbackProvider)) {
-    throw new Error(`FALLBACK_PROVIDER cannot be '${fallbackProvider}' (local providers should not be fallbacks). Use cloud providers: databricks, azure-anthropic, azure-openai, openrouter, openai, bedrock`);
+    throw new Error(`FALLBACK_PROVIDER cannot be '${fallbackProvider}' (local providers should not be fallbacks). Use cloud providers: databricks, azure-anthropic, azure-openai, openrouter, edenai, openai, bedrock`);
   }
   let fallbackMisconfigured = false;
   if (fallbackProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
@@ -585,6 +598,12 @@ var config = {
     embeddingsModel: openRouterEmbeddingsModel,
     endpoint: openRouterEndpoint,
   },
+  edenai: {
+    apiKey: edenAIApiKey,
+    model: edenAIModel,
+    embeddingsModel: edenAIEmbeddingsModel,
+    endpoint: edenAIEndpoint,
+  },
   azureOpenAI: {
     endpoint: azureOpenAIEndpoint,
     apiKey: azureOpenAIApiKey,
@@ -855,6 +874,13 @@ var config = {
     failOpen: toonFailOpen,
     logStats: toonLogStats,
   },
+  gcf: {
+    enabled: gcfEnabled,
+    minBytes: Number.isNaN(gcfMinBytes) ? 4096 : gcfMinBytes,
+    failOpen: gcfFailOpen,
+    logStats: gcfLogStats,
+    verify: gcfVerify,
+  },
   smartToolSelection: {
     enabled: true,  // HARDCODED - always enabled
     mode: smartToolSelectionMode,
@@ -1013,6 +1039,8 @@ function reloadConfig() {
   config.ollama.model = process.env.OLLAMA_MODEL ?? "qwen2.5-coder:7b";
   config.openrouter.apiKey = process.env.OPENROUTER_API_KEY ?? null;
   config.openrouter.model = process.env.OPENROUTER_MODEL ?? "openai/gpt-4o-mini";
+  config.edenai.apiKey = process.env.EDENAI_API_KEY ?? null;
+  config.edenai.model = process.env.EDENAI_MODEL ?? "openai/gpt-4o-mini";
   config.azureOpenAI.apiKey = process.env.AZURE_OPENAI_API_KEY?.trim() || null;
   config.openai.apiKey = process.env.OPENAI_API_KEY?.trim() || null;
   config.bedrock.apiKey = process.env.AWS_BEDROCK_API_KEY?.trim() || null;
@@ -1041,6 +1069,12 @@ function reloadConfig() {
   config.toon.minBytes = Number.isNaN(newToonMinBytes) ? 4096 : newToonMinBytes;
   config.toon.failOpen = process.env.TOON_FAIL_OPEN !== "false";
   config.toon.logStats = process.env.TOON_LOG_STATS !== "false";
+  config.gcf.enabled = process.env.GCF_ENABLED === "true";
+  const newGcfMinBytes = Number.parseInt(process.env.GCF_MIN_BYTES ?? "4096", 10);
+  config.gcf.minBytes = Number.isNaN(newGcfMinBytes) ? 4096 : newGcfMinBytes;
+  config.gcf.failOpen = process.env.GCF_FAIL_OPEN !== "false";
+  config.gcf.logStats = process.env.GCF_LOG_STATS !== "false";
+  config.gcf.verify = process.env.GCF_VERIFY !== "false";
 
   // Tier routing (critical for fixing model name issues without restart)
   config.modelTiers.SIMPLE = process.env.TIER_SIMPLE?.trim() || null;