lynkr 9.0.1 → 9.1.2

package/src/clients/openai-format.js

@@ -60,13 +60,16 @@ function convertOpenAIToAnthropic(openaiRequest) {
           if (part.type === "text") {
             return { type: "text", text: part.text };
           } else if (part.type === "image_url") {
-            return {
-              type: "image",
-              source: {
-                type: "url",
-                url: part.image_url.url
+            const url = part.image_url?.url || "";
+            if (url.startsWith("data:")) {
+              const match = url.match(/^data:(image\/[^;]+);base64,(.+)$/);
+              if (match) {
+                return { type: "image", source: { type: "base64", media_type: match[1], data: match[2] } };
               }
-            };
+            }
+            return { type: "image", source: { type: "url", url } };
+          } else if (part.type === "document" || part.type === "image") {
+            return part;
           }
           return part;
         });
@@ -200,18 +203,37 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
 
   const { id, content, stop_reason, usage } = anthropicResponse;
 
-  // Validate required fields
-  if (!content || !Array.isArray(content)) {
-    throw new Error(`convertAnthropicToOpenAI: invalid content field (got ${typeof content})`);
+  // Tolerant fallback: providers sometimes return reasoning-only responses
+  // (Minimax/DeepSeek), error envelopes, or empty bodies. Treat missing/invalid
+  // content as an empty turn so jcode/Pi/Codex don't crash on the response.
+  const safeContent = Array.isArray(content) ? content : [];
+  if (safeContent.length === 0) {
+    logger.warn({
+      hasContent: content !== undefined,
+      contentType: typeof content,
+      stop_reason,
+      responseKeys: Object.keys(anthropicResponse),
+      hasError: !!anthropicResponse.error,
+      errorMessage: anthropicResponse.error?.message,
+    }, "convertAnthropicToOpenAI: empty/missing content, returning empty assistant message");
   }
 
   // Convert content blocks to OpenAI format
   let messageContent = "";
+  let reasoningContent = "";
   const toolCalls = [];
+  let citations = [];
 
-  for (const block of content) {
+  for (const block of safeContent) {
     if (block.type === "text") {
       messageContent += block.text;
+      if (Array.isArray(block.citations)) {
+        citations.push(...block.citations);
+      }
+    } else if (block.type === "thinking") {
+      // Preserve reasoning text so reasoning-only models (Minimax, DeepSeek-R1)
+      // surface visible output to OpenAI clients that don't render thinking blocks
+      reasoningContent += (block.thinking || "");
     } else if (block.type === "tool_use") {
       toolCalls.push({
         id: block.id,
@@ -224,6 +246,12 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
     }
   }
 
+  // Fallback: if the model returned only reasoning (no visible text and no tools),
+  // promote reasoning into the visible content so jcode/Pi/Codex see something
+  if (!messageContent && !toolCalls.length && reasoningContent) {
+    messageContent = reasoningContent;
+  }
+
   // Build OpenAI response
   // Ensure ID has the chatcmpl- prefix that OpenAI clients expect
   const responseId = id && id.startsWith("chatcmpl-") ? id : `chatcmpl-${Date.now()}`;
@@ -249,6 +277,18 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
     }
   };
 
+  // Add citations if present
+  if (citations.length > 0) {
+    openaiResponse.citations = citations;
+  }
+
+  // Add reasoning_content as a side-channel field so clients that render
+  // thinking (e.g. some jcode / OpenRouter setups) can show it without losing
+  // it from the visible content fallback above
+  if (reasoningContent && reasoningContent !== messageContent) {
+    openaiResponse.choices[0].message.reasoning_content = reasoningContent;
+  }
+
   // Add tool_calls if present
   if (toolCalls.length > 0) {
     openaiResponse.choices[0].message.tool_calls = toolCalls;

package/src/clients/openrouter-utils.js

@@ -89,12 +89,12 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
           tool_calls
         };
 
-        // Only add content if there's actual text, otherwise omit the field entirely
-        // Some providers require content to be present, so use empty string as fallback
+        // Moonshot/Kimi and some OpenAI-compatible APIs require content to
+        // be null (not empty string) when tool_calls are present.
         if (textContent && textContent.trim()) {
           message.content = textContent;
         } else {
-          message.content = '';
+          message.content = null;
         }
 
         converted.push(message);
@@ -146,37 +146,32 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
     }
   }
 
-  // Validate message sequence: tool messages must follow assistant messages with tool_calls
+  // Fix tool_call_id mismatches: ensure every tool message's tool_call_id
+  // matches the id in the preceding assistant's tool_calls array.
+  // IDs can drift when multiple conversion layers (Anthropic↔OpenAI) each
+  // generate their own IDs.
   for (let i = 0; i < converted.length; i++) {
     const msg = converted[i];
-    if (msg.role === 'tool') {
-      // Find the preceding assistant message with tool_calls
-      let foundMatchingToolCall = false;
-      for (let j = i - 1; j >= 0; j--) {
-        const prevMsg = converted[j];
-        if (prevMsg.role === 'assistant' && Array.isArray(prevMsg.tool_calls)) {
-          // Check if this tool result matches any of the tool calls
-          if (prevMsg.tool_calls.some(tc => tc.id === msg.tool_call_id)) {
-            foundMatchingToolCall = true;
-            break;
+    if (msg.role !== 'tool') continue;
+
+    // Find the nearest preceding assistant with tool_calls
+    for (let j = i - 1; j >= 0; j--) {
+      const prev = converted[j];
+      if (prev.role === 'user') break;
+      if (prev.role === 'assistant' && Array.isArray(prev.tool_calls) && prev.tool_calls.length > 0) {
+        if (!prev.tool_calls.some(tc => tc.id === msg.tool_call_id)) {
+          // Mismatch — pick the first unmatched tool_call id
+          const usedIds = new Set();
+          for (let k = j + 1; k < converted.length; k++) {
+            if (converted[k].role === 'tool' && k !== i) usedIds.add(converted[k].tool_call_id);
+          }
+          const available = prev.tool_calls.find(tc => !usedIds.has(tc.id));
+          if (available) {
+            logger.info({ from: msg.tool_call_id, to: available.id }, "Fixed tool_call_id mismatch");
+            msg.tool_call_id = available.id;
           }
         }
-        // Stop if we hit another user message
-        if (prevMsg.role === 'user') break;
-      }
-
-      if (!foundMatchingToolCall) {
-        // Log but DON'T remove - the tool result may be valid but IDs mismatched due to format conversion
-        logger.debug({
-          messageIndex: i,
-          toolCallId: msg.tool_call_id,
-          precedingMessages: converted.slice(Math.max(0, i - 3), i).map(m => ({
-            role: m.role,
-            hasToolCalls: !!m.tool_calls,
-            toolCallIds: m.tool_calls?.map(tc => tc.id)
-          }))
-        }, "Tool message without matching tool_call - keeping for API to validate");
-        // Don't remove - let the API handle validation
+        break;
       }
     }
   }
@@ -242,6 +237,17 @@ function convertOpenRouterResponseToAnthropic(openRouterResponse, requestedModel
   const message = choice.message || {};
   const contentBlocks = [];
 
+  // Extract tool calls embedded as XML/text in content (Minimax, Qwen, GLM, etc.)
+  if (!message.tool_calls?.length && typeof message.content === "string" && message.content.trim()) {
+    const { extractToolCallsFromText } = require("./xml-tool-extractor");
+    const extracted = extractToolCallsFromText(message.content);
+    if (extracted.toolCalls.length > 0) {
+      message.tool_calls = extracted.toolCalls;
+      message.content = extracted.cleanedText;
+      choice.finish_reason = "tool_calls";
+    }
+  }
+
   // Check if there are tool calls present
   const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
 
@@ -262,14 +268,13 @@ function convertOpenRouterResponseToAnthropic(openRouterResponse, requestedModel
             trimmed.includes('"arguments"'));
   };
 
-  // Handle reasoning_content from thinking models (e.g., Kimi, o1)
+  // Emit reasoning_content as a thinking block (not as fallback text)
   let textContent = message.content || "";
-  if (!textContent.trim() && message.reasoning_content) {
-    logger.info({
-      hasReasoningContent: true,
-      reasoningLength: message.reasoning_content.length
-    }, "Using reasoning_content as primary content (thinking model detected)");
-    textContent = message.reasoning_content;
+  if (message.reasoning_content && typeof message.reasoning_content === "string") {
+    contentBlocks.push({ type: "thinking", thinking: message.reasoning_content });
+  }
+  if (!textContent.trim() && !message.reasoning_content) {
+    // No content at all — will be handled below
   }
 
   // Add text content if present, but skip if it's a duplicate/malformed tool call JSON

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

@@ -0,0 +1,140 @@
+/**
+ * Provider-Side Prompt Cache Injection
+ *
+ * Injects `cache_control` breakpoints into requests for providers
+ * that support explicit prompt caching (Anthropic, Bedrock, Vertex/Gemini).
+ *
+ * Strategy: "system_and_3" — places up to 4 breakpoints:
+ *   1. System prompt (stable across turns — highest cache hit rate)
+ *   2-4. Last 3 non-system messages (rolling window)
+ *
+ * Providers with automatic caching (OpenAI, DeepSeek) need no injection.
+ *
+ * @module clients/prompt-cache-injection
+ */
+
+const logger = require('../logger');
+
+const CACHE_MARKER = { type: 'ephemeral' };
+const MAX_BREAKPOINTS = 4;
+
+/**
+ * Inject cache_control breakpoints into an Anthropic-format request body.
+ * Mutates the body in-place for zero-copy performance.
+ *
+ * @param {Object} body - Request body with system and messages
+ * @returns {number} Number of breakpoints injected
+ */
+function injectAnthropicCacheBreakpoints(body) {
+  if (!body) return 0;
+
+  let injected = 0;
+
+  // Breakpoint 1: System prompt
+  if (body.system) {
+    if (typeof body.system === 'string') {
+      // Convert string system to array format for cache_control support
+      body.system = [{
+        type: 'text',
+        text: body.system,
+        cache_control: CACHE_MARKER,
+      }];
+      injected++;
+    } else if (Array.isArray(body.system) && body.system.length > 0) {
+      // Mark the last system block
+      const lastBlock = body.system[body.system.length - 1];
+      if (lastBlock && typeof lastBlock === 'object' && !lastBlock.cache_control) {
+        lastBlock.cache_control = CACHE_MARKER;
+        injected++;
+      }
+    }
+  }
+
+  // Breakpoints 2-4: Last 3 non-system messages
+  if (Array.isArray(body.messages) && body.messages.length > 0) {
+    const remaining = MAX_BREAKPOINTS - injected;
+    const messagesToMark = Math.min(remaining, 3, body.messages.length);
+
+    for (let i = 0; i < messagesToMark; i++) {
+      const msgIdx = body.messages.length - 1 - i;
+      const msg = body.messages[msgIdx];
+      if (!msg) continue;
+
+      if (typeof msg.content === 'string') {
+        // Convert string content to array for cache_control
+        msg.content = [{
+          type: 'text',
+          text: msg.content,
+          cache_control: CACHE_MARKER,
+        }];
+        injected++;
+      } else if (Array.isArray(msg.content) && msg.content.length > 0) {
+        // Mark the last content block in this message
+        const lastBlock = msg.content[msg.content.length - 1];
+        if (lastBlock && typeof lastBlock === 'object' && !lastBlock.cache_control) {
+          lastBlock.cache_control = CACHE_MARKER;
+          injected++;
+        }
+      }
+    }
+  }
+
+  if (injected > 0) {
+    logger.debug({ breakpoints: injected }, '[prompt-cache] Injected cache_control breakpoints');
+  }
+
+  return injected;
+}
+
+/**
+ * Inject cache_control for Gemini/Vertex explicit caching.
+ * Uses the same cache_control format — Gemini accepts it via LiteLLM/OpenRouter.
+ *
+ * @param {Object} body - Request body with system and messages (Anthropic format, pre-conversion)
+ * @returns {number} Number of breakpoints injected
+ */
+function injectGeminiCacheBreakpoints(body) {
+  // Gemini uses the same cache_control format when going through
+  // OpenRouter or LiteLLM. For direct Gemini API, implicit caching
+  // is automatic — no injection needed.
+  // We inject anyway for OpenRouter/proxy paths that forward cache_control.
+  return injectAnthropicCacheBreakpoints(body);
+}
+
+/**
+ * Determine if a provider benefits from cache_control injection.
+ *
+ * @param {string} provider - Provider name
+ * @returns {boolean}
+ */
+function needsCacheInjection(provider) {
+  // These providers support explicit cache_control breakpoints
+  const EXPLICIT_CACHE_PROVIDERS = new Set([
+    'azure-anthropic',
+    'bedrock',
+    'databricks',   // Databricks routes to Claude which supports caching
+    'openrouter',   // OpenRouter forwards cache_control to underlying provider
+  ]);
+
+  return EXPLICIT_CACHE_PROVIDERS.has(provider);
+}
+
+/**
+ * Inject provider-side prompt caching into the request body.
+ * Call this before sending to the provider.
+ *
+ * @param {Object} body - Request body (Anthropic format)
+ * @param {string} provider - Provider name
+ * @returns {number} Number of breakpoints injected
+ */
+function injectPromptCaching(body, provider) {
+  if (!needsCacheInjection(provider)) return 0;
+  return injectAnthropicCacheBreakpoints(body);
+}
+
+module.exports = {
+  injectPromptCaching,
+  injectAnthropicCacheBreakpoints,
+  injectGeminiCacheBreakpoints,
+  needsCacheInjection,
+};

package/src/clients/provider-capabilities.js

@@ -0,0 +1,41 @@
+const config = require("../config");
+
+const NATIVE_THINKING_PROVIDERS = new Set(["azure-anthropic", "databricks"]);
+
+const NATIVE_THINKING_BEDROCK_MODELS = [
+  "anthropic.claude",
+  "claude-3",
+  "claude-4",
+  "claude-sonnet",
+  "claude-opus",
+  "claude-haiku",
+];
+
+const REASONING_CONTENT_PROVIDERS = new Set(["moonshot", "openrouter", "openai", "azure-openai"]);
+
+function supportsNativeThinking(providerType, model) {
+  if (NATIVE_THINKING_PROVIDERS.has(providerType)) return true;
+  if (providerType === "bedrock" && model) {
+    return NATIVE_THINKING_BEDROCK_MODELS.some((prefix) => model.toLowerCase().includes(prefix));
+  }
+  if (providerType === "vertex" && model) {
+    return model.toLowerCase().includes("claude");
+  }
+  return false;
+}
+
+function supportsReasoningContent(providerType) {
+  return REASONING_CONTENT_PROVIDERS.has(providerType);
+}
+
+function getThinkingBehavior(providerType, model) {
+  if (supportsNativeThinking(providerType, model)) return "native";
+  if (supportsReasoningContent(providerType)) return "reasoning_content";
+  return "none";
+}
+
+module.exports = {
+  supportsNativeThinking,
+  supportsReasoningContent,
+  getThinkingBehavior,
+};

package/src/clients/responses-format.js

@@ -19,6 +19,7 @@ const logger = require("../logger");
 function mapClientToolToLynkr(clientToolName) {
   const reverseMapping = {
     // ============== CODEX CLI ==============
+    "shell": "Bash",
     "shell_command": "Bash",
     "read_file": "Read",
     "write_file": "Write",
@@ -140,13 +141,13 @@ function convertResponsesToChat(responsesRequest) {
 
         // Handle function_call (tool calls - convert to assistant with tool_calls)
         if (msg.type === 'function_call') {
-          // Map client tool names back to Lynkr names for model consistency
-          // Supports Codex CLI, Cline, Continue.dev
-          const lynkrToolName = mapClientToolToLynkr(msg.name);
+          // Keep the client's original tool name (e.g., "shell", "read_file")
+          // so it matches the tool definitions injected in the Responses endpoint.
+          // Mapping to Lynkr names here would cause a mismatch with
+          // client-named tool definitions sent to the model.
           logger.debug({
-            originalName: msg.name,
-            mappedName: lynkrToolName
-          }, "Mapping client tool name to Lynkr");
+            toolName: msg.name
+          }, "Preserving client tool name in function_call");
 
           return {
             role: 'assistant',
@@ -155,7 +156,7 @@ function convertResponsesToChat(responsesRequest) {
               id: msg.call_id || msg.id,
               type: 'function',
               function: {
-                name: lynkrToolName,
+                name: msg.name,
                 arguments: typeof msg.arguments === 'string' ? msg.arguments : JSON.stringify(msg.arguments || {})
               }
             }]

package/src/clients/standard-tools.js

@@ -275,7 +275,7 @@ EXAMPLE: User says "explore this project" → Call Task with subagent_type="Expl
           description: "Optional model override. Default is appropriate for each agent type."
         }
       },
-      required: ["description", "prompt", "subagent_type"]
+      required: ["prompt"]
     }
   },
   {