feat(executors): Improved UI components for displaying provider limits and usage statistics in the dashboard.

open-sse/translator/helpers/openaiHelper.js

@@ -75,6 +75,53 @@ export function filterToOpenAIFormat(body) {
     delete body.tools;
   }
 
+  // Normalize tools to OpenAI format (from Claude, Gemini, etc.)
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    body.tools = body.tools.map(tool => {
+      // Already OpenAI format
+      if (tool.type === "function" && tool.function) return tool;
+      
+      // Claude format: {name, description, input_schema}
+      if (tool.name && (tool.input_schema || tool.description)) {
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description || "",
+            parameters: tool.input_schema || { type: "object", properties: {} }
+          }
+        };
+      }
+      
+      // Gemini format: {functionDeclarations: [{name, description, parameters}]}
+      if (tool.functionDeclarations && Array.isArray(tool.functionDeclarations)) {
+        return tool.functionDeclarations.map(fn => ({
+          type: "function",
+          function: {
+            name: fn.name,
+            description: fn.description || "",
+            parameters: fn.parameters || { type: "object", properties: {} }
+          }
+        }));
+      }
+      
+      return tool;
+    }).flat();
+  }
+
+  // Normalize tool_choice to OpenAI format
+  if (body.tool_choice && typeof body.tool_choice === "object") {
+    const choice = body.tool_choice;
+    // Claude format: {type: "auto|any|tool", name?: "..."}
+    if (choice.type === "auto") {
+      body.tool_choice = "auto";
+    } else if (choice.type === "any") {
+      body.tool_choice = "required";
+    } else if (choice.type === "tool" && choice.name) {
+      body.tool_choice = { type: "function", function: { name: choice.name } };
+    }
+  }
+
   return body;
 }
 

open-sse/translator/index.js

@@ -71,11 +71,6 @@ export function translateRequest(sourceFormat, targetFormat, model, body, stream
       }
     }
 
-    // Step 1.5: Filter to clean OpenAI format (only when target is OpenAI)
-    if (targetFormat === FORMATS.OPENAI) {
-      result = filterToOpenAIFormat(result);
-    }
-
     // Step 2: openai -> target (if target is not openai)
     if (targetFormat !== FORMATS.OPENAI) {
       const fromOpenAI = requestRegistry.get(`${FORMATS.OPENAI}:${targetFormat}`);
@@ -85,6 +80,12 @@ export function translateRequest(sourceFormat, targetFormat, model, body, stream
     }
   }
 
+  // Always normalize to clean OpenAI format when target is OpenAI
+  // This handles hybrid requests (e.g., OpenAI messages + Claude tools)
+  if (targetFormat === FORMATS.OPENAI) {
+    result = filterToOpenAIFormat(result);
+  }
+
   // Final step: prepare request for Claude format endpoints
   if (targetFormat === FORMATS.CLAUDE) {
     result = prepareClaudeRequest(result, provider);

open-sse/translator/request/openai-to-cursor.js

@@ -6,15 +6,18 @@ import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
 
 /**
- * Convert OpenAI messages to Cursor simple format
+ * Convert OpenAI messages to Cursor format with native tool_results support
  * - system → user with [System Instructions] prefix
- * - tool → user with [Tool Result: name] prefix
- * - assistant with tool_calls → append [Calling tool: name with args: {...}] to content
+ * - tool → accumulate into tool_results array for next user/assistant message
+ * - assistant with tool_calls → keep tool_calls structure (Cursor supports it natively)
  */
 function convertMessages(messages) {
   const result = [];
+  let pendingToolResults = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
 
-  for (const msg of messages) {
     if (msg.role === "system") {
       result.push({
         role: "user",
@@ -36,9 +39,14 @@ function convertMessages(messages) {
       }
       
       const toolName = msg.name || "tool";
-      result.push({
-        role: "user",
-        content: `[Tool Result: ${toolName}]\n${toolContent}`
+      const toolCallId = msg.tool_call_id || "";
+      
+      // Accumulate tool result
+      pendingToolResults.push({
+        tool_call_id: toolCallId,
+        name: toolName,
+        index: pendingToolResults.length,
+        raw_args: toolContent
       });
       continue;
     }
@@ -56,23 +64,34 @@ function convertMessages(messages) {
         }
       }
 
+      // Keep tool_calls structure for assistant messages
       if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+        const assistantMsg = { role: "assistant" };
         if (content) {
-          result.push({ role: "assistant", content });
+          assistantMsg.content = content;
+        }
+        assistantMsg.tool_calls = msg.tool_calls;
+        
+        // Attach pending tool results to assistant message with tool_calls
+        if (pendingToolResults.length > 0) {
+          assistantMsg.tool_results = pendingToolResults;
+          pendingToolResults = [];
         }
         
-        const toolCallsText = msg.tool_calls.map(tc => {
-          const funcName = tc.function?.name || "unknown";
-          const funcArgs = tc.function?.arguments || "{}";
-          return `[Calling tool: ${funcName} with args: ${funcArgs}]`;
-        }).join("\n");
+        result.push(assistantMsg);
+      } else if (content || pendingToolResults.length > 0) {
+        const msgObj = { 
+          role: msg.role, 
+          content: content || ""
+        };
         
-        result.push({
-          role: "assistant",
-          content: toolCallsText
-        });
-      } else if (content) {
-        result.push({ role: msg.role, content });
+        // Attach pending tool results to this message
+        if (pendingToolResults.length > 0) {
+          msgObj.tool_results = pendingToolResults;
+          pendingToolResults = [];
+        }
+        
+        result.push(msgObj);
       }
     }
   }