lynkr 4.1.0 → 4.2.0

package/README.md

@@ -116,9 +116,9 @@ Lynkr reduces AI costs by **60-80%** through intelligent token optimization:
 
 ### IDE Integration
 - ✅ **Claude Code CLI** - Drop-in replacement for Anthropic backend
-- ✅ **Cursor IDE** - Full OpenAI API compatibility
+- ✅ **Cursor IDE** - Full OpenAI API compatibility (Requires Cursor Pro)
 - ✅ **Continue.dev** - Works with any OpenAI-compatible client
-- ✅ **All Features Work** - Chat, file operations, tool calling, streaming
+- ✅ **Cline +VSCode** - Confgiure it similar to cursor in openai compatible section
 
 ### Advanced Capabilities
 - 🧠 **Long-Term Memory** - Titans-inspired memory system with surprise-based filtering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Self-hosted Claude Code & Cursor proxy with Databricks,AWS BedRock,Azure  adapters, openrouter, Ollama,llamacpp,LM Studio, workspace tooling, and MCP integration.",
   "main": "index.js",
   "bin": {

package/src/api/openai-router.js

@@ -900,6 +900,193 @@ router.post("/embeddings", async (req, res) => {
   }
 });
 
+/**
+ * POST /v1/responses
+ *
+ * OpenAI Responses API endpoint (used by GPT-5-Codex and newer models).
+ * Converts Responses API format to Chat Completions → processes → converts back.
+ */
+router.post("/responses", async (req, res) => {
+  const startTime = Date.now();
+  const sessionId = req.headers["x-session-id"] || req.headers["authorization"]?.split(" ")[1] || "responses-session";
+
+  try {
+    const { convertResponsesToChat, convertChatToResponses } = require("../clients/responses-format");
+
+    // Comprehensive debug logging
+    logger.info({
+      endpoint: "/v1/responses",
+      inputType: typeof req.body.input,
+      inputIsArray: Array.isArray(req.body.input),
+      inputLength: Array.isArray(req.body.input) ? req.body.input.length : req.body.input?.length,
+      inputPreview: typeof req.body.input === 'string'
+        ? req.body.input.substring(0, 100)
+        : Array.isArray(req.body.input)
+          ? req.body.input.map(m => ({role: m?.role, hasContent: !!m?.content, hasTool: !!m?.tool_calls}))
+          : 'unknown',
+      model: req.body.model,
+      hasTools: !!req.body.tools,
+      stream: req.body.stream || false,
+      fullRequestBodyKeys: Object.keys(req.body)
+    }, "=== RESPONSES API REQUEST ===");
+
+    // Convert Responses API to Chat Completions format
+    const chatRequest = convertResponsesToChat(req.body);
+
+    logger.info({
+      chatRequestMessageCount: chatRequest.messages?.length,
+      chatRequestMessages: chatRequest.messages?.map(m => ({
+        role: m.role,
+        hasContent: !!m.content,
+        contentPreview: typeof m.content === 'string' ? m.content.substring(0, 50) : m.content
+      }))
+    }, "After Responses→Chat conversion");
+
+    // Convert to Anthropic format
+    const anthropicRequest = convertOpenAIToAnthropic(chatRequest);
+
+    logger.info({
+      anthropicMessageCount: anthropicRequest.messages?.length,
+      anthropicMessages: anthropicRequest.messages?.map(m => ({
+        role: m.role,
+        hasContent: !!m.content
+      }))
+    }, "After Chat→Anthropic conversion");
+
+    // Get session
+    const session = getSession(sessionId);
+
+    // Handle streaming vs non-streaming
+    if (req.body.stream) {
+      // Set up SSE headers for streaming
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache");
+      res.setHeader("Connection", "keep-alive");
+
+      try {
+        // Force non-streaming from orchestrator
+        anthropicRequest.stream = false;
+
+        const result = await orchestrator.processMessage({
+          payload: anthropicRequest,
+          headers: req.headers,
+          session: session,
+          options: {
+            maxSteps: req.body?.max_steps
+          }
+        });
+
+        // Convert back: Anthropic → OpenAI → Responses
+        const chatResponse = convertAnthropicToOpenAI(result.body, req.body.model);
+        const responsesResponse = convertChatToResponses(chatResponse);
+
+        // Simulate streaming using OpenAI Responses API SSE format
+        const content = responsesResponse.content || "";
+        const words = content.split(" ");
+
+        // Send response.created event
+        const createdEvent = {
+          id: responsesResponse.id,
+          object: "response.created",
+          created: responsesResponse.created,
+          model: req.body.model
+        };
+        res.write(`event: response.created\n`);
+        res.write(`data: ${JSON.stringify(createdEvent)}\n\n`);
+
+        // Send content in word chunks using response.output_text.delta
+        for (let i = 0; i < words.length; i++) {
+          const word = words[i] + (i < words.length - 1 ? " " : "");
+          const deltaEvent = {
+            id: responsesResponse.id,
+            object: "response.output_text.delta",
+            delta: word,
+            created: responsesResponse.created
+          };
+          res.write(`event: response.output_text.delta\n`);
+          res.write(`data: ${JSON.stringify(deltaEvent)}\n\n`);
+        }
+
+        // Send response.completed event
+        const completedEvent = {
+          id: responsesResponse.id,
+          object: "response.completed",
+          created: responsesResponse.created,
+          model: req.body.model,
+          content: content,
+          stop_reason: responsesResponse.stop_reason,
+          usage: responsesResponse.usage
+        };
+        res.write(`event: response.completed\n`);
+        res.write(`data: ${JSON.stringify(completedEvent)}\n\n`);
+
+        // Optional: Send [DONE] marker
+        res.write("data: [DONE]\n\n");
+        res.end();
+
+        logger.info({
+          duration: Date.now() - startTime,
+          mode: "streaming",
+          contentLength: content.length
+        }, "=== RESPONSES API STREAMING COMPLETE ===");
+
+      } catch (streamError) {
+        logger.error({ error: streamError.message, stack: streamError.stack }, "Responses API streaming error");
+
+        // Send error via SSE
+        res.write(`data: ${JSON.stringify({
+          error: {
+            message: streamError.message || "Internal server error",
+            type: "server_error",
+            code: "internal_error"
+          }
+        })}\n\n`);
+        res.end();
+      }
+
+    } else {
+      // Non-streaming response
+      anthropicRequest.stream = false;
+
+      const result = await orchestrator.processMessage({
+        payload: anthropicRequest,
+        headers: req.headers,
+        session: session,
+        options: {
+          maxSteps: req.body?.max_steps
+        }
+      });
+
+      // Convert back: Anthropic → OpenAI → Responses
+      const chatResponse = convertAnthropicToOpenAI(result.body, req.body.model);
+      const responsesResponse = convertChatToResponses(chatResponse);
+
+      logger.info({
+        duration: Date.now() - startTime,
+        contentLength: responsesResponse.content?.length || 0,
+        stopReason: responsesResponse.stop_reason
+      }, "=== RESPONSES API RESPONSE ===");
+
+      res.json(responsesResponse);
+    }
+
+  } catch (error) {
+    logger.error({
+      error: error.message,
+      stack: error.stack,
+      duration: Date.now() - startTime
+    }, "Responses API error");
+
+    res.status(500).json({
+      error: {
+        message: error.message || "Internal server error",
+        type: "server_error",
+        code: "internal_error"
+      }
+    });
+  }
+});
+
 /**
  * GET /v1/health
  *

package/src/api/router.js

@@ -180,17 +180,93 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
         }
       }
 
-      // Fallback: if no stream, wrap buffered response in SSE (old behavior)
-      const eventPayload = {
-        type: "message",
-        message: result.body,
-      };
-      res.write(`event: message\n`);
-      res.write(`data: ${JSON.stringify(eventPayload)}\n\n`);
-      res.write(`event: end\n`);
-      res.write(
-        `data: ${JSON.stringify({ termination: result.terminationReason ?? "completion" })}\n\n`,
-      );
+      // Fallback: if no stream, wrap buffered response in proper Anthropic SSE format
+      // Check if result.body exists
+      if (!result || !result.body) {
+        res.write(`event: error\n`);
+        res.write(`data: ${JSON.stringify({ type: "error", error: { message: "Empty response from provider" } })}\n\n`);
+        res.end();
+        return;
+      }
+
+      const msg = result.body;
+
+      // 1. message_start
+      res.write(`event: message_start\n`);
+      res.write(`data: ${JSON.stringify({
+        type: "message_start",
+        message: {
+          id: msg.id,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model: msg.model,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: msg.usage?.input_tokens || 0, output_tokens: 1 }
+        }
+      })}\n\n`);
+
+      // 2. content_block_start and content_block_delta for each content block
+      const contentBlocks = msg.content || [];
+      for (let i = 0; i < contentBlocks.length; i++) {
+        const block = contentBlocks[i];
+
+        if (block.type === "text") {
+          res.write(`event: content_block_start\n`);
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_start",
+            index: i,
+            content_block: { type: "text", text: "" }
+          })}\n\n`);
+
+          // Send text in chunks
+          const text = block.text || "";
+          const chunkSize = 20;
+          for (let j = 0; j < text.length; j += chunkSize) {
+            const chunk = text.slice(j, j + chunkSize);
+            res.write(`event: content_block_delta\n`);
+            res.write(`data: ${JSON.stringify({
+              type: "content_block_delta",
+              index: i,
+              delta: { type: "text_delta", text: chunk }
+            })}\n\n`);
+          }
+
+          res.write(`event: content_block_stop\n`);
+          res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
+        } else if (block.type === "tool_use") {
+          res.write(`event: content_block_start\n`);
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_start",
+            index: i,
+            content_block: { type: "tool_use", id: block.id, name: block.name, input: {} }
+          })}\n\n`);
+
+          res.write(`event: content_block_delta\n`);
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_delta",
+            index: i,
+            delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input) }
+          })}\n\n`);
+
+          res.write(`event: content_block_stop\n`);
+          res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
+        }
+      }
+
+      // 3. message_delta with stop_reason
+      res.write(`event: message_delta\n`);
+      res.write(`data: ${JSON.stringify({
+        type: "message_delta",
+        delta: { stop_reason: msg.stop_reason || "end_turn", stop_sequence: null },
+        usage: { output_tokens: msg.usage?.output_tokens || 0 }
+      })}\n\n`);
+
+      // 4. message_stop
+      res.write(`event: message_stop\n`);
+      res.write(`data: ${JSON.stringify({ type: "message_stop" })}\n\n`);
+
       metrics.recordResponse(result.status);
       res.end();
       return;
@@ -219,17 +295,91 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
         res.flushHeaders();
       }
 
-      const eventPayload = {
-        type: "message",
-        message: result.body,
-      };
-      res.write(`event: message\n`);
-      res.write(`data: ${JSON.stringify(eventPayload)}\n\n`);
-
-      res.write(`event: end\n`);
-      res.write(
-        `data: ${JSON.stringify({ termination: result.terminationReason ?? "completion" })}\n\n`,
-      );
+      // Check if result.body exists
+      if (!result || !result.body) {
+        res.write(`event: error\n`);
+        res.write(`data: ${JSON.stringify({ type: "error", error: { message: "Empty response from provider" } })}\n\n`);
+        res.end();
+        return;
+      }
+
+      // Use proper Anthropic SSE format
+      const msg = result.body;
+
+      // 1. message_start
+      res.write(`event: message_start\n`);
+      res.write(`data: ${JSON.stringify({
+        type: "message_start",
+        message: {
+          id: msg.id,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model: msg.model,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: msg.usage?.input_tokens || 0, output_tokens: 1 }
+        }
+      })}\n\n`);
+
+      // 2. content_block_start and content_block_delta for each content block
+      const contentBlocks = msg.content || [];
+      for (let i = 0; i < contentBlocks.length; i++) {
+        const block = contentBlocks[i];
+
+        if (block.type === "text") {
+          res.write(`event: content_block_start\n`);
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_start",
+            index: i,
+            content_block: { type: "text", text: "" }
+          })}\n\n`);
+
+          const text = block.text || "";
+          const chunkSize = 20;
+          for (let j = 0; j < text.length; j += chunkSize) {
+            const chunk = text.slice(j, j + chunkSize);
+            res.write(`event: content_block_delta\n`);
+            res.write(`data: ${JSON.stringify({
+              type: "content_block_delta",
+              index: i,
+              delta: { type: "text_delta", text: chunk }
+            })}\n\n`);
+          }
+
+          res.write(`event: content_block_stop\n`);
+          res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
+        } else if (block.type === "tool_use") {
+          res.write(`event: content_block_start\n`);
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_start",
+            index: i,
+            content_block: { type: "tool_use", id: block.id, name: block.name, input: {} }
+          })}\n\n`);
+
+          res.write(`event: content_block_delta\n`);
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_delta",
+            index: i,
+            delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input) }
+          })}\n\n`);
+
+          res.write(`event: content_block_stop\n`);
+          res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
+        }
+      }
+
+      // 3. message_delta with stop_reason
+      res.write(`event: message_delta\n`);
+      res.write(`data: ${JSON.stringify({
+        type: "message_delta",
+        delta: { stop_reason: msg.stop_reason || "end_turn", stop_sequence: null },
+        usage: { output_tokens: msg.usage?.output_tokens || 0 }
+      })}\n\n`);
+
+      // 4. message_stop
+      res.write(`event: message_stop\n`);
+      res.write(`data: ${JSON.stringify({ type: "message_stop" })}\n\n`);
 
       metrics.recordResponse(result.status);
       res.end();

package/src/clients/databricks.js

@@ -225,10 +225,35 @@ async function invokeOllama(body) {
     };
   });
 
+  // FIX: Deduplicate consecutive messages with same role (Ollama may reject this)
+  const deduplicated = [];
+  let lastRole = null;
+  for (const msg of convertedMessages) {
+    if (msg.role === lastRole) {
+      logger.debug({
+        skippedRole: msg.role,
+        contentPreview: msg.content.substring(0, 50)
+      }, 'Ollama: Skipping duplicate consecutive message with same role');
+      continue;
+    }
+    deduplicated.push(msg);
+    lastRole = msg.role;
+  }
+
+  if (deduplicated.length !== convertedMessages.length) {
+    logger.info({
+      originalCount: convertedMessages.length,
+      deduplicatedCount: deduplicated.length,
+      removed: convertedMessages.length - deduplicated.length,
+      messageRoles: convertedMessages.map(m => m.role).join(' → '),
+      deduplicatedRoles: deduplicated.map(m => m.role).join(' → ')
+    }, 'Ollama: Removed consecutive duplicate roles from message sequence');
+  }
+
   const ollamaBody = {
     model: config.ollama.model,
-    messages: convertedMessages,
-    stream: body.stream ?? false,
+    messages: deduplicated,
+    stream: false,  // Force non-streaming for Ollama - streaming format conversion not yet implemented
     options: {
       temperature: body.temperature ?? 0.7,
       num_predict: body.max_tokens ?? 4096,
@@ -240,7 +265,8 @@ async function invokeOllama(body) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  const injectToolsOllama = process.env.INJECT_TOOLS_OLLAMA !== "false";
+  if (injectToolsOllama && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.info({
@@ -248,6 +274,8 @@ async function invokeOllama(body) {
       injectedToolNames: STANDARD_TOOLS.map(t => t.name),
       reason: "Client did not send tools (passthrough mode)"
     }, "=== INJECTING STANDARD TOOLS (Ollama) ===");
+  } else if (!injectToolsOllama) {
+    logger.info({}, "Tool injection disabled for Ollama (INJECT_TOOLS_OLLAMA=false)");
   }
 
   // Add tools if present (for tool-capable models)
@@ -351,10 +379,17 @@ async function invokeAzureOpenAI(body) {
   const format = detectAzureFormat(endpoint);
 
   const headers = {
-    "api-key": config.azureOpenAI.apiKey,  // Azure uses "api-key" not "Authorization"
     "Content-Type": "application/json"
   };
 
+  // Azure AI Foundry (services.ai.azure.com) uses Bearer auth
+  // Standard Azure OpenAI (openai.azure.com) uses api-key header
+  if (endpoint.includes("services.ai.azure.com")) {
+    headers["Authorization"] = `Bearer ${config.azureOpenAI.apiKey}`;
+  } else {
+    headers["api-key"] = config.azureOpenAI.apiKey;
+  }
+
   // Convert messages and handle system message
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
@@ -371,7 +406,7 @@ async function invokeAzureOpenAI(body) {
     temperature: body.temperature ?? 0.3,  // Lower temperature for more deterministic, action-oriented behavior
     max_tokens: Math.min(body.max_tokens ?? 4096, 16384),  // Cap at Azure OpenAI's limit
     top_p: body.top_p ?? 1.0,
-    stream: body.stream ?? false,
+    stream: false,  // Force non-streaming for Azure OpenAI - streaming format conversion not yet implemented
     model: config.azureOpenAI.deployment
   };
 
@@ -536,8 +571,35 @@ async function invokeLlamaCpp(body) {
     messages.unshift({ role: "system", content: body.system });
   }
 
+  // FIX: Deduplicate consecutive messages with same role (llama.cpp rejects this)
+  const deduplicated = [];
+  let lastRole = null;
+  for (const msg of messages) {
+    if (msg.role === lastRole) {
+      logger.debug({
+        skippedRole: msg.role,
+        contentPreview: typeof msg.content === 'string'
+          ? msg.content.substring(0, 50)
+          : JSON.stringify(msg.content).substring(0, 50)
+      }, 'llama.cpp: Skipping duplicate consecutive message with same role');
+      continue;
+    }
+    deduplicated.push(msg);
+    lastRole = msg.role;
+  }
+
+  if (deduplicated.length !== messages.length) {
+    logger.info({
+      originalCount: messages.length,
+      deduplicatedCount: deduplicated.length,
+      removed: messages.length - deduplicated.length,
+      messageRoles: messages.map(m => m.role).join(' → '),
+      deduplicatedRoles: deduplicated.map(m => m.role).join(' → ')
+    }, 'llama.cpp: Removed consecutive duplicate roles from message sequence');
+  }
+
   const llamacppBody = {
-    messages,
+    messages: deduplicated,
     temperature: body.temperature ?? 0.7,
     max_tokens: body.max_tokens ?? 4096,
     top_p: body.top_p ?? 1.0,
@@ -548,7 +610,8 @@ async function invokeLlamaCpp(body) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  const injectToolsLlamacpp = process.env.INJECT_TOOLS_LLAMACPP !== "false";
+  if (injectToolsLlamacpp && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.info({
@@ -556,6 +619,8 @@ async function invokeLlamaCpp(body) {
       injectedToolNames: STANDARD_TOOLS.map(t => t.name),
       reason: "Client did not send tools (passthrough mode)"
     }, "=== INJECTING STANDARD TOOLS (llama.cpp) ===");
+  } else if (!injectToolsLlamacpp) {
+    logger.info({}, "Tool injection disabled for llama.cpp (INJECT_TOOLS_LLAMACPP=false)");
   }
 
   if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
@@ -574,6 +639,16 @@ async function invokeLlamaCpp(body) {
     toolCount: llamacppBody.tools?.length || 0,
     temperature: llamacppBody.temperature,
     max_tokens: llamacppBody.max_tokens,
+    messageCount: llamacppBody.messages?.length || 0,
+    messageRoles: llamacppBody.messages?.map(m => m.role).join(' → '),
+    messages: llamacppBody.messages?.map((m, i) => ({
+      index: i,
+      role: m.role,
+      hasContent: !!m.content,
+      contentPreview: typeof m.content === 'string' ? m.content.substring(0, 100) : JSON.stringify(m.content).substring(0, 100),
+      hasToolCalls: !!m.tool_calls,
+      toolCallCount: m.tool_calls?.length || 0,
+    }))
   }, "=== LLAMA.CPP REQUEST ===");
 
   return performJsonRequest(endpoint, { headers, body: llamacppBody }, "llama.cpp");

package/src/clients/openai-format.js

@@ -124,15 +124,17 @@ function convertOpenAIToAnthropic(openaiRequest) {
   // Convert tools format (OpenAI → Anthropic)
   let anthropicTools = null;
   if (tools && tools.length > 0) {
-    anthropicTools = tools.map(tool => ({
-      name: tool.function.name,
-      description: tool.function.description || "",
-      input_schema: tool.function.parameters || {
-        type: "object",
-        properties: {},
-        required: []
-      }
-    }));
+    anthropicTools = tools
+      .filter(tool => tool && tool.function && tool.function.name) // Filter out invalid tools
+      .map(tool => ({
+        name: tool.function.name,
+        description: tool.function.description || "",
+        input_schema: tool.function.parameters || {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }));
   }
 
   // Build Anthropic request

package/src/clients/openrouter-utils.js

@@ -264,9 +264,19 @@ function convertOpenRouterResponseToAnthropic(openRouterResponse, requestedModel
             trimmed.includes('"arguments"'));
   };
 
+  // Handle reasoning_content from thinking models (e.g., Kimi, o1)
+  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;
+  }
+
   // Add text content if present, but skip if it's a duplicate/malformed tool call JSON
-  if (message.content && message.content.trim()) {
-    const looksLikeToolJson = isToolCallJson(message.content);
+  if (textContent && textContent.trim()) {
+    const looksLikeToolJson = isToolCallJson(textContent);
 
     // Skip content in two cases:
     // 1. We have proper tool_calls AND content duplicates them (original fix)
@@ -276,14 +286,14 @@ function convertOpenRouterResponseToAnthropic(openRouterResponse, requestedModel
       if (hasToolCalls) {
         // Case 1: Duplicate - model provided both content and tool_calls
         logger.debug({
-          contentPreview: message.content.substring(0, 100),
+          contentPreview: textContent.substring(0, 100),
           toolCallCount: message.tool_calls.length
         }, "Skipping text content that duplicates tool_calls (llama.cpp quirk)");
       } else {
         // Case 2: Malformed - model only provided JSON in content, not structured tool_calls
         // This is a model error - it should have used tool_calls, not raw JSON
         logger.warn({
-          contentPreview: message.content.substring(0, 200)
+          contentPreview: textContent.substring(0, 200)
         }, "Model output tool call as JSON text instead of structured tool_calls - filtering out malformed output");
       }
       // Skip this content block in both cases
@@ -291,7 +301,7 @@ function convertOpenRouterResponseToAnthropic(openRouterResponse, requestedModel
       // Normal text content - include it
       contentBlocks.push({
         type: "text",
-        text: message.content
+        text: textContent
       });
     }
   }