aiexecode 1.0.90 → 1.0.92

package/src/LLMClient/converters/input-normalizer.js

@@ -0,0 +1,238 @@
+/**
+ * Normalize input to OpenAI Responses API format
+ *
+ * Converts various input formats to the standard Responses API format:
+ * input: [
+ *   { type: 'message', content: 'text' },
+ *   { type: 'function_call', call_id: 'xxx', name: 'tool', arguments: '{}' },
+ *   { type: 'function_call_output', call_id: 'xxx', output: 'result' }
+ * ]
+ */
+
+/**
+ * Convert input to OpenAI Responses API format
+ *
+ * OpenAI Responses API actually accepts:
+ * - String input directly
+ * - Array of messages in Chat Completions format (role-based)
+ *
+ * @param {string|Array} input - Input in various formats
+ * @returns {string|Array} Normalized input (string or role-based array)
+ */
+export function normalizeInput(input) {
+  // Simple string input - return as-is
+  if (typeof input === 'string') {
+    return input;
+  }
+
+  // Array input
+  if (Array.isArray(input) && input.length > 0) {
+    const firstItem = input[0];
+
+    // Already in Chat Completions format (role-based) - return as-is
+    if (firstItem.role) {
+      return input;
+    }
+
+    // Convert from our custom format to Chat Completions format
+    if (firstItem.type === 'message' || firstItem.type === 'function_call' || firstItem.type === 'function_call_output') {
+      return convertResponsesInputToChatCompletions(input);
+    }
+  }
+
+  // Fallback to string
+  return String(input);
+}
+
+/**
+ * Convert our internal format to Chat Completions format
+ * @param {Array} items - Internal format items
+ * @returns {Array} Chat Completions format messages
+ */
+function convertResponsesInputToChatCompletions(items) {
+  const messages = [];
+  const pendingToolCalls = [];
+  let currentAssistantContent = '';
+
+  for (const item of items) {
+    if (item.type === 'message') {
+      // If we have pending tool calls, create assistant message first
+      if (pendingToolCalls.length > 0) {
+        messages.push({
+          role: 'assistant',
+          content: currentAssistantContent || null,
+          tool_calls: [...pendingToolCalls]
+        });
+        pendingToolCalls.length = 0;
+        currentAssistantContent = '';
+      }
+
+      // Regular message
+      messages.push({
+        role: 'user',
+        content: item.content
+      });
+    } else if (item.type === 'function_call') {
+      // Tool call
+      pendingToolCalls.push({
+        id: item.call_id,
+        type: 'function',
+        function: {
+          name: item.name,
+          arguments: item.arguments
+        }
+      });
+    } else if (item.type === 'function_call_output') {
+      // If we have pending tool calls, create assistant message first
+      if (pendingToolCalls.length > 0) {
+        messages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: [...pendingToolCalls]
+        });
+        pendingToolCalls.length = 0;
+      }
+
+      // Tool result
+      messages.push({
+        role: 'tool',
+        tool_call_id: item.call_id,
+        content: item.output
+      });
+    }
+  }
+
+  // Flush any remaining tool calls
+  if (pendingToolCalls.length > 0) {
+    messages.push({
+      role: 'assistant',
+      content: null,
+      tool_calls: [...pendingToolCalls]
+    });
+  }
+
+  return messages;
+}
+
+/**
+ * LEGACY: Convert Chat Completions messages to Responses API input
+ * @param {Array} messages - Chat Completions format messages
+ * @returns {Array} Responses API format input
+ */
+function convertChatCompletionsToResponsesInput(messages) {
+  const result = [];
+
+  for (const msg of messages) {
+    const { role, content } = msg;
+
+    if (role === 'system') {
+      // System messages become regular messages with system content
+      // Note: In real Responses API, system messages go to 'instructions' parameter
+      result.push({
+        type: 'message',
+        content: `[System]: ${content}`
+      });
+    } else if (role === 'user') {
+      result.push({
+        type: 'message',
+        content: content
+      });
+    } else if (role === 'assistant') {
+      // Assistant message with potential tool calls
+      if (Array.isArray(content)) {
+        // Content is array (Responses API style already)
+        for (const item of content) {
+          if (typeof item === 'string') {
+            result.push({ type: 'message', content: item });
+          } else if (item.type === 'text') {
+            result.push({ type: 'message', content: item.text });
+          } else if (item.type === 'function_call') {
+            result.push({
+              type: 'function_call',
+              call_id: item.call_id,
+              name: item.name,
+              arguments: typeof item.input === 'string' ? item.input : JSON.stringify(item.input)
+            });
+          }
+        }
+      } else if (typeof content === 'string') {
+        // Simple text content
+        result.push({ type: 'message', content: content });
+      }
+
+      // Check for tool_calls (Chat Completions format)
+      if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+        for (const toolCall of msg.tool_calls) {
+          result.push({
+            type: 'function_call',
+            call_id: toolCall.id,
+            name: toolCall.function?.name || toolCall.name,
+            arguments: typeof toolCall.function?.arguments === 'string'
+              ? toolCall.function.arguments
+              : JSON.stringify(toolCall.function?.arguments || toolCall.arguments || {})
+          });
+        }
+      }
+    } else if (role === 'tool') {
+      // Tool result
+      result.push({
+        type: 'function_call_output',
+        call_id: msg.tool_call_id || msg.call_id,
+        output: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Convert Responses API output back to Chat Completions messages
+ * Useful for compatibility
+ * @param {Array} output - Responses API output array
+ * @returns {Array} Chat Completions format messages
+ */
+export function convertResponsesOutputToMessages(output) {
+  const messages = [];
+  const toolCalls = [];
+  let textContent = '';
+
+  for (const item of output) {
+    if (item.type === 'message') {
+      // Extract text from message
+      if (item.content && Array.isArray(item.content)) {
+        for (const contentItem of item.content) {
+          if (contentItem.type === 'output_text' && contentItem.text) {
+            textContent += contentItem.text;
+          }
+        }
+      }
+    } else if (item.type === 'function_call') {
+      // Tool call
+      toolCalls.push({
+        id: item.call_id,
+        type: 'function',
+        function: {
+          name: item.name,
+          arguments: typeof item.arguments === 'string'
+            ? item.arguments
+            : JSON.stringify(item.input || item.arguments || {})
+        }
+      });
+    }
+  }
+
+  // Create assistant message
+  const assistantMsg = {
+    role: 'assistant',
+    content: textContent || null
+  };
+
+  if (toolCalls.length > 0) {
+    assistantMsg.tool_calls = toolCalls;
+  }
+
+  messages.push(assistantMsg);
+
+  return messages;
+}

package/src/LLMClient/converters/responses-to-claude.js

@@ -0,0 +1,454 @@
+/**
+ * Convert Responses API format to Claude format
+ */
+
+import { getMaxTokens } from '../../config/ai_models.js';
+
+/**
+ * Convert Responses API request to Claude format
+ * @param {Object} responsesRequest - Responses API format request
+ * @returns {Object} Claude format request
+ */
+export function convertResponsesRequestToClaudeFormat(responsesRequest) {
+  const model = responsesRequest.model;
+  if (!model) {
+    throw new Error('Model name is required');
+  }
+
+  const defaultMaxTokens = getMaxTokens(model);
+
+  const claudeRequest = {
+    model: model,
+    max_tokens: responsesRequest.max_output_tokens || defaultMaxTokens
+  };
+  // console.log(claudeRequest);
+
+  // Convert input to messages
+  // Responses API input can be: string, array of messages, or array of items
+  const messages = [];
+
+  if (typeof responsesRequest.input === 'string') {
+    // Simple string input
+    messages.push({
+      role: 'user',
+      content: responsesRequest.input
+    });
+  } else if (Array.isArray(responsesRequest.input)) {
+    // Array input - could be messages or output items
+    for (const item of responsesRequest.input) {
+      // Handle output items (no role, has type)
+      if (!item.role && item.type) {
+        if (item.type === 'message') {
+          // Message item from output
+          const textBlocks = [];
+          if (item.content && Array.isArray(item.content)) {
+            for (const contentBlock of item.content) {
+              if (contentBlock.type === 'output_text' && contentBlock.text) {
+                textBlocks.push({
+                  type: 'text',
+                  text: contentBlock.text
+                });
+              }
+            }
+          }
+          // Only include messages with actual content (skip empty messages)
+          if (textBlocks.length > 0) {
+            messages.push({
+              role: 'assistant',
+              content: textBlocks
+            });
+          }
+        } else if (item.type === 'function_call') {
+          // Function call from output - convert to assistant message with tool_use
+          messages.push({
+            role: 'assistant',
+            content: [
+              {
+                type: 'tool_use',
+                id: item.call_id || item.id,
+                name: item.name,
+                input: JSON.parse(item.arguments || '{}')
+              }
+            ]
+          });
+        } else if (item.type === 'function_call_output') {
+          // Function call output - convert to tool_result
+          messages.push({
+            role: 'user',
+            content: [
+              {
+                type: 'tool_result',
+                tool_use_id: item.call_id,
+                content: item.output
+              }
+            ]
+          });
+        }
+        // Skip other types like 'reasoning'
+        continue;
+      }
+
+      if (item.role && item.content) {
+        // Already in message format
+
+        if (item.role === 'system') {
+          // System messages go to separate field in Claude
+          const content = Array.isArray(item.content)
+            ? item.content.map(c => c.type === 'input_text' || c.type === 'text' ? c.text : c).filter(Boolean).join('\n')
+            : item.content;
+          claudeRequest.system = content;
+        } else if (item.role === 'tool') {
+          // Tool result
+          messages.push({
+            role: 'user',
+            content: [
+              {
+                type: 'tool_result',
+                tool_use_id: item.tool_call_id || item.id,
+                content: item.content
+              }
+            ]
+          });
+        } else if (item.role === 'assistant' && Array.isArray(item.content)) {
+          // Assistant with output array (might contain function_call items)
+          const textBlocks = [];
+          const toolUseBlocks = [];
+
+          for (const outputItem of item.content) {
+            if (outputItem.type === 'message' && outputItem.content) {
+              // Message item - extract text content
+              for (const contentBlock of outputItem.content) {
+                if (contentBlock.type === 'output_text' && contentBlock.text) {
+                  textBlocks.push({
+                    type: 'text',
+                    text: contentBlock.text
+                  });
+                }
+              }
+            } else if (outputItem.type === 'function_call') {
+              // Function call - convert to Claude tool_use
+              toolUseBlocks.push({
+                type: 'tool_use',
+                id: outputItem.call_id || outputItem.id,
+                name: outputItem.name,
+                input: JSON.parse(outputItem.arguments || '{}')
+              });
+            }
+          }
+
+          // Claude requires text blocks to come before tool_use blocks
+          const claudeContent = [...textBlocks, ...toolUseBlocks];
+
+          // Add message only if there's content
+          if (claudeContent.length > 0) {
+            messages.push({
+              role: 'assistant',
+              content: claudeContent
+            });
+          }
+        } else {
+          // Handle content that might be an array (OpenAI Responses API format)
+          const content = Array.isArray(item.content)
+            ? item.content.map(c => c.type === 'input_text' || c.type === 'text' ? c.text : c).filter(Boolean).join('\n')
+            : item.content;
+
+          messages.push({
+            role: item.role === 'assistant' ? 'assistant' : 'user',
+            content: content
+          });
+        }
+      }
+    }
+  }
+
+  // Merge consecutive messages with the same role (Claude doesn't allow this)
+  const mergedMessages = [];
+  for (let i = 0; i < messages.length; i++) {
+    const currentMsg = messages[i];
+
+    // Check if the next message has the same role
+    if (i < messages.length - 1 && messages[i + 1].role === currentMsg.role) {
+      // Merge content from consecutive same-role messages
+      const mergedContent = Array.isArray(currentMsg.content) ? [...currentMsg.content] : [currentMsg.content];
+
+      // Keep merging while the next message has the same role
+      while (i < messages.length - 1 && messages[i + 1].role === currentMsg.role) {
+        i++;
+        const nextContent = messages[i].content;
+        if (Array.isArray(nextContent)) {
+          mergedContent.push(...nextContent);
+        } else {
+          mergedContent.push(nextContent);
+        }
+      }
+
+      mergedMessages.push({
+        role: currentMsg.role,
+        content: mergedContent
+      });
+    } else {
+      mergedMessages.push(currentMsg);
+    }
+  }
+
+  claudeRequest.messages = mergedMessages;
+
+  // Handle instructions (system message)
+  if (responsesRequest.instructions) {
+    claudeRequest.system = responsesRequest.instructions;
+  }
+
+  // Convert tools from Responses API format to Claude format
+  // Responses API: { type: 'function', name, description, parameters }
+  // Claude: { name, description, input_schema } (NO type field)
+  if (responsesRequest.tools && Array.isArray(responsesRequest.tools)) {
+    claudeRequest.tools = responsesRequest.tools.map(tool => {
+      if (tool.type === 'function') {
+        if (tool.function) {
+          // Chat Completions format (for compatibility)
+          return {
+            name: tool.function.name,
+            description: tool.function.description || `Function: ${tool.function.name}`,
+            input_schema: tool.function.parameters || {
+              type: 'object',
+              properties: {}
+            }
+          };
+        } else {
+          // Responses API format with type: 'function'
+          return {
+            name: tool.name,
+            description: tool.description || `Function: ${tool.name}`,
+            input_schema: tool.parameters || {
+              type: 'object',
+              properties: {}
+            }
+          };
+        }
+      } else if (tool.type === 'custom') {
+        // Responses API custom format
+        return {
+          name: tool.name,
+          description: tool.description || `Tool: ${tool.name}`,
+          input_schema: tool.input_schema || {
+            type: 'object',
+            properties: {}
+          }
+        };
+      }
+      // If already in Claude format (no type field), pass through
+      return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.input_schema
+      };
+    });
+  }
+
+  // Temperature - always set to 0 for Claude
+  claudeRequest.temperature = 0;
+
+  // Top-p - do not set for Claude (removed)
+
+  // Tool choice (Responses API to Claude)
+  if (responsesRequest.tool_choice !== undefined) {
+    if (typeof responsesRequest.tool_choice === 'string') {
+      // 'auto', 'required', 'none' -> Claude format
+      if (responsesRequest.tool_choice === 'auto') {
+        claudeRequest.tool_choice = { type: 'auto' };
+      } else if (responsesRequest.tool_choice === 'required') {
+        claudeRequest.tool_choice = { type: 'any' };
+      }
+      // 'none' is handled by not setting tool_choice
+    } else if (responsesRequest.tool_choice?.type === 'function' || responsesRequest.tool_choice?.type === 'custom') {
+      // Specific tool -> Claude format
+      const toolName = responsesRequest.tool_choice.function?.name || responsesRequest.tool_choice.name;
+      claudeRequest.tool_choice = {
+        type: 'tool',
+        name: toolName
+      };
+    }
+  }
+
+  // Metadata (pass through as-is, Claude doesn't use it but won't error)
+  if (responsesRequest.metadata) {
+    claudeRequest.metadata = responsesRequest.metadata;
+  }
+
+  // Handle json_schema format by converting to tool use
+  // OpenAI Responses API: text.format.type = "json_schema" with schema
+  // Claude: Use a synthetic tool to enforce structured output
+  if (responsesRequest.text?.format?.type === 'json_schema') {
+    const schemaName = responsesRequest.text.format.name || 'output';
+    const schema = responsesRequest.text.format.schema;
+
+    // Create a synthetic tool that represents the JSON schema
+    const syntheticTool = {
+      name: schemaName,
+      description: `Generate structured output matching the ${schemaName} schema`,
+      input_schema: schema
+    };
+
+    // Replace tools array with only the synthetic tool (to ensure structured output)
+    claudeRequest.tools = [syntheticTool];
+
+    // Force tool use with this specific tool (ignore original tool_choice)
+    claudeRequest.tool_choice = {
+      type: 'tool',
+      name: schemaName
+    };
+
+    // Claude requires conversation to end with user message when tool_choice is set
+    // If last message is assistant, add a dummy user message
+    if (claudeRequest.messages.length > 0 && claudeRequest.messages[claudeRequest.messages.length - 1].role === 'assistant') {
+      claudeRequest.messages.push({
+        role: 'user',
+        content: [{ type: 'text', text: 'Please provide the structured output.' }]
+      });
+    }
+  }
+
+  return claudeRequest;
+}
+
+/**
+ * Convert Claude response to Responses API format
+ * @param {Object} claudeResponse - Claude format response
+ * @param {string} model - Model name
+ * @param {Object} originalRequest - Original request for context
+ * @returns {Object} Responses API format response
+ */
+export function convertClaudeResponseToResponsesFormat(claudeResponse, model = 'claude-sonnet-4-5', originalRequest = {}) {
+  const output = [];
+  let outputText = '';
+
+  // Check if this was a json_schema request converted to tool use
+  const wasJsonSchemaRequest = originalRequest.text?.format?.type === 'json_schema';
+  const schemaName = originalRequest.text?.format?.name;
+
+  // Process content blocks
+  if (claudeResponse.content && Array.isArray(claudeResponse.content)) {
+    const messageContent = [];
+
+    for (const block of claudeResponse.content) {
+      if (block.type === 'text') {
+        // Text content
+        messageContent.push({
+          type: 'output_text',
+          text: block.text,
+          annotations: []
+        });
+        outputText += block.text;
+      } else if (block.type === 'tool_use') {
+        // Check if this is a synthetic tool for json_schema
+        if (wasJsonSchemaRequest && block.name === schemaName) {
+          // Convert tool_use back to plain text JSON (for json_schema requests)
+          const jsonOutput = JSON.stringify(block.input);
+          messageContent.push({
+            type: 'output_text',
+            text: jsonOutput,
+            annotations: []
+          });
+          outputText += jsonOutput;
+        } else {
+          // Regular tool call - add as separate function_call item
+          output.push({
+            id: `fc_${block.id}`,
+            type: 'function_call',
+            status: 'completed',
+            arguments: JSON.stringify(block.input),
+            call_id: block.id,
+            name: block.name
+          });
+        }
+      }
+    }
+
+    // Add message with text content if any
+    if (messageContent.length > 0) {
+      output.push({
+        id: `msg_${claudeResponse.id}`,
+        type: 'message',
+        status: 'completed',
+        role: 'assistant',
+        content: messageContent
+      });
+    }
+  }
+
+  // If no output items, create a message with placeholder text
+  // (Claude may return empty response for various reasons)
+  if (output.length === 0) {
+    output.push({
+      id: `msg_${claudeResponse.id}`,
+      type: 'message',
+      status: 'completed',
+      role: 'assistant',
+      content: [
+        {
+          type: 'output_text',
+          text: outputText || ' ',
+          annotations: []
+        }
+      ]
+    });
+  }
+
+  // Build Responses API response with ALL required fields
+  const responsesResponse = {
+    id: `resp_${claudeResponse.id}`,
+    object: 'response',
+    created_at: Math.floor(Date.now() / 1000),
+    status: claudeResponse.stop_reason === 'end_turn' || claudeResponse.stop_reason === 'tool_use' ? 'completed' : 'incomplete',
+    background: false,
+    billing: {
+      payer: 'developer'
+    },
+    error: null,
+    incomplete_details: null,
+    instructions: originalRequest.instructions || null,
+    max_output_tokens: originalRequest.max_output_tokens || null,
+    max_tool_calls: null,
+    model: model,
+    output: output,
+    parallel_tool_calls: true,
+    previous_response_id: null,
+    prompt_cache_key: null,
+    prompt_cache_retention: null,
+    reasoning: {
+      effort: originalRequest.reasoning?.effort || null,
+      summary: originalRequest.reasoning?.summary || null
+    },
+    safety_identifier: null,
+    service_tier: 'default',
+    store: originalRequest.store !== undefined ? originalRequest.store : true,
+    temperature: originalRequest.temperature !== undefined ? originalRequest.temperature : 1,
+    text: {
+      format: {
+        type: 'text'
+      },
+      verbosity: 'medium'
+    },
+    tool_choice: originalRequest.tool_choice || 'auto',
+    tools: originalRequest.tools || [],
+    top_logprobs: 0,
+    top_p: originalRequest.top_p !== undefined ? originalRequest.top_p : 1,
+    truncation: 'disabled',
+    usage: {
+      input_tokens: claudeResponse.usage?.input_tokens || 0,
+      input_tokens_details: {
+        cached_tokens: 0
+      },
+      output_tokens: claudeResponse.usage?.output_tokens || 0,
+      output_tokens_details: {
+        reasoning_tokens: 0
+      },
+      total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0)
+    },
+    user: null,
+    metadata: {},
+    output_text: outputText
+  };
+
+  return responsesResponse;
+}