aiexecode 1.0.90 → 1.0.92

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

@@ -0,0 +1,348 @@
+/**
+ * Convert Responses API format to Ollama format
+ */
+
+/**
+ * Convert Responses API request to Ollama format
+ * @param {Object} responsesRequest - Responses API format request
+ * @param {string} baseUrl - Ollama base URL
+ * @returns {Object} { url, request } - Ollama API endpoint and request body
+ */
+export function convertResponsesRequestToOllamaFormat(responsesRequest, baseUrl = 'http://localhost:11434') {
+  const ollamaRequest = {
+    model: responsesRequest.model || 'llama3.2',
+    messages: []
+  };
+
+  // Convert input to messages
+  if (typeof responsesRequest.input === 'string') {
+    // Simple string input
+    ollamaRequest.messages.push({
+      role: 'user',
+      content: responsesRequest.input
+    });
+  } else if (Array.isArray(responsesRequest.input)) {
+    // Array input - could be messages or items
+    const toolCalls = []; // Collect tool calls to add to assistant message
+    const callIdToName = {}; // Map call_id to function name
+
+    for (const item of responsesRequest.input) {
+      if (item.type === 'function_call') {
+        // Store call_id -> name mapping
+        if (item.call_id && item.name) {
+          callIdToName[item.call_id] = item.name;
+        }
+
+        // Function call - convert to Ollama tool_calls format (no id or type fields)
+        toolCalls.push({
+          function: {
+            name: item.name,
+            arguments: JSON.parse(item.arguments) // Ollama expects object, not string
+          }
+        });
+      } else if (item.type === 'function_call_output') {
+        // If we have pending tool calls, add assistant message with tool_calls first
+        if (toolCalls.length > 0) {
+          ollamaRequest.messages.push({
+            role: 'assistant',
+            content: '',
+            tool_calls: [...toolCalls]
+          });
+          toolCalls.length = 0; // Clear the array
+        }
+
+        // Function call output - convert to tool message (Ollama uses tool_name, not tool_call_id)
+        // Look up the function name from the call_id
+        const toolName = callIdToName[item.call_id] || '';
+        ollamaRequest.messages.push({
+          role: 'tool',
+          content: item.output,
+          tool_name: toolName
+        });
+      } else if (item.role && item.content) {
+        // If we have pending tool calls, add assistant message with tool_calls first
+        if (toolCalls.length > 0) {
+          ollamaRequest.messages.push({
+            role: 'assistant',
+            content: '',
+            tool_calls: [...toolCalls]
+          });
+          toolCalls.length = 0; // Clear the array
+        }
+
+        // Message format
+        // 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;
+
+        if (item.role === 'system') {
+          // System message
+          ollamaRequest.messages.push({
+            role: 'system',
+            content: content
+          });
+        } else if (item.role === 'tool') {
+          // Tool result
+          ollamaRequest.messages.push({
+            role: 'tool',
+            content: content
+          });
+        } else if (item.role === 'assistant') {
+          // Assistant message
+          ollamaRequest.messages.push({
+            role: 'assistant',
+            content: content
+          });
+        } else {
+          // User message
+          ollamaRequest.messages.push({
+            role: 'user',
+            content: content
+          });
+        }
+      }
+    }
+
+    // If there are remaining tool calls at the end, add them
+    if (toolCalls.length > 0) {
+      ollamaRequest.messages.push({
+        role: 'assistant',
+        content: '',
+        tool_calls: [...toolCalls]
+      });
+    }
+  }
+
+  // Add system instruction if provided
+  if (responsesRequest.instructions) {
+    // Prepend system message
+    ollamaRequest.messages.unshift({
+      role: 'system',
+      content: responsesRequest.instructions
+    });
+  }
+
+  // Convert tools from Responses API format to Ollama format
+  // Ollama uses OpenAI-compatible tool format
+  if (responsesRequest.tools && Array.isArray(responsesRequest.tools)) {
+    ollamaRequest.tools = responsesRequest.tools.map(tool => {
+      if (tool.type === 'function' && tool.function) {
+        // Chat Completions format (already compatible)
+        return tool;
+      } else if (tool.type === 'custom') {
+        // Responses API format - convert to OpenAI function format
+        return {
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description || `Tool: ${tool.name}`,
+            parameters: tool.input_schema || {
+              type: 'object',
+              properties: {}
+            }
+          }
+        };
+      } else if (tool.type === 'function' && !tool.function) {
+        // Flat function format - convert to nested format for Ollama
+        return {
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description || `Tool: ${tool.name}`,
+            parameters: tool.parameters || {
+              type: 'object',
+              properties: {}
+            }
+          }
+        };
+      }
+      // Pass through
+      return tool;
+    });
+  }
+
+  // Options
+  const options = {};
+
+  // Temperature
+  if (responsesRequest.temperature !== undefined) {
+    options.temperature = responsesRequest.temperature;
+  }
+
+  // Top-p
+  if (responsesRequest.top_p !== undefined) {
+    options.top_p = responsesRequest.top_p;
+  }
+
+  // Max tokens (Ollama uses num_predict)
+  if (responsesRequest.max_output_tokens !== undefined) {
+    options.num_predict = responsesRequest.max_output_tokens;
+  }
+
+  if (Object.keys(options).length > 0) {
+    ollamaRequest.options = options;
+  }
+
+  // Tool choice (Responses API to Ollama)
+  // Ollama uses OpenAI-compatible tool_choice format
+  if (responsesRequest.tool_choice !== undefined) {
+    if (typeof responsesRequest.tool_choice === 'string') {
+      // 'auto', 'required', 'none'
+      ollamaRequest.tool_choice = responsesRequest.tool_choice;
+    } else if (responsesRequest.tool_choice?.type === 'function') {
+      // Specific tool
+      ollamaRequest.tool_choice = responsesRequest.tool_choice;
+    } else if (responsesRequest.tool_choice?.type === 'custom') {
+      // Convert custom to function format for Ollama
+      ollamaRequest.tool_choice = {
+        type: 'function',
+        function: {
+          name: responsesRequest.tool_choice.name
+        }
+      };
+    }
+  }
+
+  // Stream setting (will be overridden by client if streaming)
+  ollamaRequest.stream = false;
+
+  return {
+    url: `${baseUrl}/api/chat`,
+    request: ollamaRequest
+  };
+}
+
+/**
+ * Convert Ollama response to Responses API format
+ * @param {Object} ollamaResponse - Ollama format response
+ * @param {string} model - Model name
+ * @param {Object} originalRequest - Original request for context
+ * @returns {Object} Responses API format response
+ */
+export function convertOllamaResponseToResponsesFormat(ollamaResponse, model, originalRequest = {}) {
+  const output = [];
+  let outputText = '';
+
+  // Process message content
+  if (ollamaResponse.message) {
+    const messageContent = [];
+
+    // Text content
+    if (ollamaResponse.message.content) {
+      messageContent.push({
+        type: 'output_text',
+        text: ollamaResponse.message.content,
+        annotations: []
+      });
+      outputText = ollamaResponse.message.content;
+    }
+
+    // Tool calls
+    if (ollamaResponse.message.tool_calls && Array.isArray(ollamaResponse.message.tool_calls)) {
+      for (const toolCall of ollamaResponse.message.tool_calls) {
+        const callId = toolCall.id || `call_${Date.now()}`;
+        output.push({
+          id: `fc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          type: 'function_call',
+          status: 'completed',
+          arguments: typeof toolCall.function?.arguments === 'string'
+            ? toolCall.function.arguments
+            : JSON.stringify(toolCall.function?.arguments || {}),
+          call_id: callId,
+          name: toolCall.function?.name || ''
+        });
+      }
+    }
+
+    // Add message with text content if any
+    if (messageContent.length > 0) {
+      output.push({
+        id: `msg_${Date.now()}`,
+        type: 'message',
+        status: 'completed',
+        role: 'assistant',
+        content: messageContent
+      });
+    }
+  }
+
+  // If no output items, create empty message
+  if (output.length === 0) {
+    output.push({
+      id: `msg_${Date.now()}`,
+      type: 'message',
+      status: 'completed',
+      role: 'assistant',
+      content: []
+    });
+  }
+
+  // Build Responses API response with ALL required fields
+  // Parse created_at from Ollama's ISO format to Unix timestamp
+  let createdAt = Math.floor(Date.now() / 1000);
+  if (ollamaResponse.created_at) {
+    if (typeof ollamaResponse.created_at === 'string') {
+      createdAt = Math.floor(new Date(ollamaResponse.created_at).getTime() / 1000);
+    } else if (typeof ollamaResponse.created_at === 'number') {
+      createdAt = ollamaResponse.created_at;
+    }
+  }
+
+  const responsesResponse = {
+    id: `resp_${Date.now()}`,
+    object: 'response',
+    created_at: createdAt,
+    status: ollamaResponse.done ? '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 || ollamaResponse.model || 'llama3.2',
+    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: ollamaResponse.prompt_eval_count || 0,
+      input_tokens_details: {
+        cached_tokens: 0
+      },
+      output_tokens: ollamaResponse.eval_count || 0,
+      output_tokens_details: {
+        reasoning_tokens: 0
+      },
+      total_tokens: (ollamaResponse.prompt_eval_count || 0) + (ollamaResponse.eval_count || 0)
+    },
+    user: null,
+    metadata: {},
+    output_text: outputText
+  };
+
+  return responsesResponse;
+}

package/src/LLMClient/errors.js

@@ -0,0 +1,372 @@
+/**
+ * OpenAI-compatible error handling
+ */
+
+/**
+ * OpenAI API Error class
+ * Follows OpenAI Responses API error format
+ */
+export class LLMError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'LLMError';
+
+    // OpenAI error structure
+    this.error = {
+      message: message,
+      type: options.type || 'api_error',
+      param: options.param || null,
+      code: options.code || null
+    };
+
+    // HTTP status code (if applicable)
+    this.status = options.status || 500;
+
+    // Original error (for debugging)
+    this.originalError = options.originalError || null;
+
+    // Provider information
+    this.provider = options.provider || 'unknown';
+
+    // Store original request for response format
+    this.request = options.request || {};
+  }
+
+  /**
+   * Convert to OpenAI Responses API error format
+   */
+  toResponsesFormat() {
+    return {
+      id: `resp_error_${Date.now()}`,
+      object: 'response',
+      created_at: Math.floor(Date.now() / 1000),
+      status: 'failed',
+      background: false,
+      billing: {
+        payer: 'developer'
+      },
+      error: {
+        type: this.error.type,
+        message: this.error.message,
+        code: this.error.code,
+        param: this.error.param
+      },
+      incomplete_details: null,
+      instructions: this.request.instructions || null,
+      max_output_tokens: this.request.max_output_tokens || null,
+      max_tool_calls: null,
+      model: this.request.model || null,
+      output: [],
+      parallel_tool_calls: true,
+      previous_response_id: null,
+      prompt_cache_key: null,
+      prompt_cache_retention: null,
+      reasoning: {
+        effort: this.request.reasoning?.effort || null,
+        summary: this.request.reasoning?.summary || null
+      },
+      safety_identifier: null,
+      service_tier: 'default',
+      store: this.request.store !== undefined ? this.request.store : true,
+      temperature: this.request.temperature !== undefined ? this.request.temperature : 1,
+      text: {
+        format: {
+          type: 'text'
+        },
+        verbosity: 'medium'
+      },
+      tool_choice: this.request.tool_choice || 'auto',
+      tools: this.request.tools || [],
+      top_logprobs: 0,
+      top_p: this.request.top_p !== undefined ? this.request.top_p : 1,
+      truncation: 'disabled',
+      usage: {
+        input_tokens: 0,
+        input_tokens_details: {
+          cached_tokens: 0
+        },
+        output_tokens: 0,
+        output_tokens_details: {
+          reasoning_tokens: 0
+        },
+        total_tokens: 0
+      },
+      user: null,
+      metadata: {},
+      output_text: ''
+    };
+  }
+
+  /**
+   * Convert to JSON (Legacy OpenAI error format)
+   */
+  toJSON() {
+    return {
+      error: this.error
+    };
+  }
+
+  /**
+   * Convert to string
+   */
+  toString() {
+    return `${this.provider} Error [${this.error.type}]: ${this.error.message}`;
+  }
+}
+
+/**
+ * Map HTTP status codes to OpenAI error types
+ */
+const ERROR_TYPE_MAP = {
+  400: 'invalid_request_error',
+  401: 'authentication_error',
+  403: 'permission_error',
+  404: 'not_found_error',
+  429: 'rate_limit_error',
+  500: 'api_error',
+  502: 'api_error',
+  503: 'api_error'
+};
+
+/**
+ * Create LLMError from HTTP response
+ */
+export async function createErrorFromResponse(response, provider) {
+  const status = response.status;
+  let errorData = null;
+
+  try {
+    const text = await response.text();
+    errorData = JSON.parse(text);
+  } catch (e) {
+    // Failed to parse JSON
+    return new LLMError(
+      `HTTP ${status}: ${response.statusText}`,
+      {
+        type: ERROR_TYPE_MAP[status] || 'api_error',
+        status: status,
+        provider: provider
+      }
+    );
+  }
+
+  // Extract error information
+  let message = errorData.error?.message || errorData.message || response.statusText;
+  let type = errorData.error?.type || ERROR_TYPE_MAP[status] || 'api_error';
+  let param = errorData.error?.param || null;
+  let code = errorData.error?.code || null;
+
+  return new LLMError(message, {
+    type: type,
+    param: param,
+    code: code,
+    status: status,
+    provider: provider,
+    originalError: errorData
+  });
+}
+
+/**
+ * Convert provider-specific error to LLMError
+ */
+export function normalizeError(error, provider) {
+  // Already an LLMError
+  if (error instanceof LLMError) {
+    return error;
+  }
+
+  // Anthropic SDK error (check BEFORE OpenAI SDK error, as both have error.status && error.error)
+  if (provider === 'claude' && error.status) {
+    // Parse Claude error from error.error object (Anthropic SDK provides parsed error)
+    let errorType = ERROR_TYPE_MAP[error.status] || 'api_error';
+    let code = null;
+    let message = error.message || 'Claude API error';
+
+    // Anthropic SDK provides error.error object with structure:
+    // { type: 'error', error: { type: 'not_found_error', message: '...' } }
+    if (error.error && error.error.error) {
+      const claudeError = error.error.error;
+
+      if (claudeError.type) {
+        code = claudeError.type;
+
+        // Map Claude error types to OpenAI error types
+        const claudeType = claudeError.type;
+        if (claudeType === 'not_found_error') {
+          errorType = 'not_found_error';
+        } else if (claudeType === 'invalid_request_error') {
+          errorType = 'invalid_request_error';
+        } else if (claudeType === 'authentication_error') {
+          errorType = 'authentication_error';
+        } else if (claudeType === 'permission_error') {
+          errorType = 'permission_error';
+        } else if (claudeType === 'rate_limit_error') {
+          errorType = 'rate_limit_error';
+        } else if (claudeType === 'overloaded_error') {
+          errorType = 'api_error';
+        }
+      }
+
+      // Use the actual error message from Claude
+      if (claudeError.message) {
+        message = claudeError.message;
+      }
+    }
+
+    return new LLMError(
+      message,
+      {
+        type: errorType,
+        param: null,
+        code: code,
+        status: error.status,
+        provider: 'claude',
+        originalError: error
+      }
+    );
+  }
+
+  // OpenAI SDK error
+  if (error.status && error.error) {
+    return new LLMError(
+      error.error.message || error.message,
+      {
+        type: error.error.type || ERROR_TYPE_MAP[error.status] || 'api_error',
+        param: error.error.param || null,
+        code: error.error.code || null,
+        status: error.status,
+        provider: provider,
+        originalError: error
+      }
+    );
+  }
+
+  // Google Generative AI error
+  if (provider === 'gemini') {
+    // Extract status from error message if available
+    let status = 500;
+    const statusMatch = error.message?.match(/\[(\d+)\s+/);
+    if (statusMatch) {
+      status = parseInt(statusMatch[1]);
+    }
+
+    return new LLMError(
+      error.message || 'Gemini API error',
+      {
+        type: ERROR_TYPE_MAP[status] || 'api_error',
+        param: null,
+        code: null,
+        status: status,
+        provider: 'gemini',
+        originalError: error
+      }
+    );
+  }
+
+  // Ollama error
+  if (provider === 'ollama') {
+    return new LLMError(
+      error.message || 'Ollama API error',
+      {
+        type: 'api_error',
+        param: null,
+        code: null,
+        status: error.status || 500,
+        provider: 'ollama',
+        originalError: error
+      }
+    );
+  }
+
+  // Network errors (connection refused, DNS errors, etc)
+  if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND' || error.code === 'ETIMEDOUT') {
+    return new LLMError(
+      error.message || 'Network connection error',
+      {
+        type: 'api_error',
+        param: null,
+        code: error.code,
+        status: 500,
+        provider: provider,
+        originalError: error
+      }
+    );
+  }
+
+  // TypeError (usually from URL parsing or network issues)
+  if (error instanceof TypeError) {
+    return new LLMError(
+      error.message || 'Request error',
+      {
+        type: 'api_error',
+        param: null,
+        code: null,
+        status: 500,
+        provider: provider,
+        originalError: error
+      }
+    );
+  }
+
+  // Generic error
+  return new LLMError(
+    error.message || 'Unknown error',
+    {
+      type: 'api_error',
+      status: 500,
+      provider: provider,
+      originalError: error
+    }
+  );
+}
+
+/**
+ * Specific error types for common cases
+ */
+
+export class AuthenticationError extends LLMError {
+  constructor(message, provider) {
+    super(message, {
+      type: 'authentication_error',
+      code: 'invalid_api_key',
+      status: 401,
+      provider: provider
+    });
+    this.name = 'AuthenticationError';
+  }
+}
+
+export class InvalidRequestError extends LLMError {
+  constructor(message, param, provider) {
+    super(message, {
+      type: 'invalid_request_error',
+      param: param,
+      status: 400,
+      provider: provider
+    });
+    this.name = 'InvalidRequestError';
+  }
+}
+
+export class RateLimitError extends LLMError {
+  constructor(message, provider) {
+    super(message, {
+      type: 'rate_limit_error',
+      code: 'rate_limit_exceeded',
+      status: 429,
+      provider: provider
+    });
+    this.name = 'RateLimitError';
+  }
+}
+
+export class NotFoundError extends LLMError {
+  constructor(message, provider) {
+    super(message, {
+      type: 'not_found_error',
+      status: 404,
+      provider: provider
+    });
+    this.name = 'NotFoundError';
+  }
+}