smart_prompt 0.4.4 → 0.5.0

data/lib/smart_prompt/anthropic_adapter.rb

@@ -1,298 +1,380 @@
-require "net/http"
-require "json"
+require "anthropic"
+require "base64"
 require "uri"
-
-module SmartPrompt
-  class AnthropicAdapter < LLMAdapter
-    DEFAULT_URL = "https://api.anthropic.com"
-    DEFAULT_VERSION = "2023-06-01"
-    DEFAULT_MAX_TOKENS = 4096
-
-    def initialize(config)
-      super
-      @api_key = resolve_api_key(@config["api_key"]) || ENV["ANTHROPIC_API_KEY"]
-      @url = (@config["url"] || DEFAULT_URL).chomp("/")
-      @anthropic_version = @config["anthropic_version"] || DEFAULT_VERSION
-      @request_timeout = @config["request_timeout"] || 240
-
-      raise LLMAPIError, "Invalid Anthropic configuration: missing api_key" if @api_key.nil? || @api_key.empty?
-
-      @messages_uri = URI("#{@url}/v1/messages")
-      SmartPrompt.logger.info "Successful creation an Anthropic client."
-    rescue URI::InvalidURIError => e
-      SmartPrompt.logger.error "Failed to initialize Anthropic client: #{e.message}"
-      raise LLMAPIError, "Invalid Anthropic configuration: #{e.message}"
-    rescue LLMAPIError
-      raise
-    rescue => e
-      SmartPrompt.logger.error "Failed to initialize Anthropic client: #{e.message}"
-      raise Error, "Unexpected error initializing Anthropic client: #{e.message}"
-    end
-
-    def send_request(messages, model = nil, temperature = 0.7, tools = nil, proc = nil)
-      SmartPrompt.logger.info "AnthropicAdapter: Sending request to Anthropic"
-      temperature = 0.7 if temperature.nil?
-      model_name = model || @config["model"]
-      SmartPrompt.logger.info "AnthropicAdapter: Using model #{model_name}"
-
-      parameters = build_parameters(messages, model_name, temperature, tools, !proc.nil?)
-      SmartPrompt.logger.info "Send parameters is: #{parameters}"
-
-      response = post_messages(parameters, proc)
-      SmartPrompt.logger.info "AnthropicAdapter: Received response from Anthropic"
-
-      return if proc
-
-      @last_response = response
-      extract_content(response)
-    rescue JSON::ParserError
-      SmartPrompt.logger.error "Failed to parse Anthropic API response"
-      raise LLMAPIError, "Failed to parse Anthropic API response"
-    rescue LLMAPIError
-      raise
-    rescue => e
-      SmartPrompt.logger.error "Unexpected error during Anthropic request: #{e.message}"
-      raise Error, "Unexpected error during Anthropic request: #{e.message}"
-    ensure
-      SmartPrompt.logger.info "Successful send a message"
-    end
-
-    private
-
-    def resolve_api_key(api_key)
-      return api_key unless api_key.is_a?(String)
-
-      match = api_key.match(/\AENV\[(["']?)([A-Za-z_][A-Za-z0-9_]*)\1\]\z/)
-      return ENV[match[2]] if match
-
-      api_key
-    end
-
-    def build_parameters(messages, model_name, temperature, tools, stream)
-      anthropic_messages, system = normalize_messages(messages)
-      parameters = {
-        model: model_name,
-        messages: anthropic_messages,
-        max_tokens: @config["max_tokens"] || @config["max_completion_tokens"] || DEFAULT_MAX_TOKENS,
-        temperature: @config["temperature"] || temperature,
-      }
-      parameters[:system] = system unless system.empty?
-      parameters[:tools] = normalize_tools(tools) if tools
-      parameters[:stream] = true if stream
-      parameters
+require "json"
+
+module SmartPrompt
+  class AnthropicAdapter < LLMAdapter
+    def initialize(config)
+      super
+      SmartPrompt.logger.info "Start create the SmartPrompt AnthropicAdapter."
+
+      # Parse API key (support environment variable reference)
+      api_key = @config["api_key"]
+      if api_key.is_a?(String) && api_key.start_with?("ENV[") && api_key.end_with?("]")
+        api_key = eval(api_key)
+      end
+
+      # Determine base_url with priority: config['url'] > ENV['ANTHROPIC_BASE_URL'] > default
+      base_url = @config["url"] || ENV["ANTHROPIC_BASE_URL"]
+
+      begin
+        # Create Anthropic::Client instance
+        client_options = { api_key: api_key }
+        client_options[:base_url] = base_url if base_url
+
+        @client = Anthropic::Client.new(**client_options)
+        SmartPrompt.logger.info "Successful creation an Anthropic client."
+      rescue => e
+        SmartPrompt.logger.error "Failed to initialize Anthropic client: #{e.message}"
+        raise LLMAPIError, "Invalid Anthropic configuration: #{e.message}"
+      end
+    end
+
+    private
+
+    # Extract system message from messages array
+    # @param messages [Array] Array of message hashes
+    # @return [String, nil] System message content or nil if not found
+    def extract_system_message(messages)
+      system_msg = messages.find { |msg| msg[:role] == "system" || msg["role"] == "system" }
+      system_msg ? (system_msg[:content] || system_msg["content"]) : nil
+    end
+
+    # Convert SmartPrompt message format to Anthropic format
+    # @param messages [Array] Array of message hashes in SmartPrompt format
+    # @return [Array] Array of message hashes in Anthropic format
+    def convert_messages_to_anthropic_format(messages)
+      messages.reject { |msg|
+        role = msg[:role] || msg["role"]
+        role == "system"
+      }.map do |msg|
+        role = msg[:role] || msg["role"]
+        content = msg[:content] || msg["content"]
+
+        # Convert content based on its type
+        converted_content = if content.is_a?(String)
+            # String content: convert to hash format
+            { type: "text", text: content }
+          elsif content.is_a?(Array)
+            # Array content: process each item
+            content.map do |item|
+              item_type = item[:type] || item["type"]
+
+              if item_type == "text"
+                # Keep text items as-is
+                item
+              elsif item_type == "image_url"
+                # Convert image_url to Anthropic format
+                image_url = item[:image_url] || item["image_url"]
+                url = image_url.is_a?(Hash) ? (image_url[:url] || image_url["url"]) : image_url
+                prepare_image_content(url)
+              else
+                # Keep other types as-is
+                item
+              end
+            end.compact # Remove nil values from failed image conversions
+          else
+            content
+          end
+
+        { role: role, content: [converted_content] }
+      end
+    end
+
+    # Prepare image content for Anthropic API
+    # @param image_url [String] Image URL (HTTP/HTTPS or data URL)
+    # @return [Hash, nil] Anthropic format image content or nil if invalid
+    def prepare_image_content(image_url)
+      return nil unless image_url.is_a?(String)
+
+      if image_url.start_with?("http://", "https://")
+        # HTTP/HTTPS URL format
+        {
+          type: "image",
+          source: {
+            type: "url",
+            url: image_url,
+          },
+        }
+      elsif image_url.start_with?("data:")
+        # Data URL format: data:image/jpeg;base64,<base64_data>
+        match = image_url.match(/^data:(image\/[^;]+);base64,(.+)$/)
+
+        if match
+          media_type = match[1]
+          base64_data = match[2]
+
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: media_type,
+              data: base64_data,
+            },
+          }
+        else
+          SmartPrompt.logger.warn "Invalid image URL format: #{image_url}"
+          nil
+        end
+      else
+        SmartPrompt.logger.warn "Invalid image URL format: #{image_url}"
+        nil
+      end
+    end
+
+    # Convert OpenAI format tools to Anthropic format
+    # @param tools [Array, nil] Array of tool definitions in OpenAI format
+    # @return [Array, nil] Array of tool definitions in Anthropic format or nil
+    def convert_tools_to_anthropic_format(tools)
+      # Handle nil or empty array
+      return nil if tools.nil? || tools.empty?
+
+      # Convert each tool definition
+      tools.map do |tool|
+        # Extract function field
+        function = tool[:function] || tool["function"]
+        next nil unless function
+
+        # Extract name, description, and parameters
+        name = function[:name] || function["name"]
+        description = function[:description] || function["description"]
+        parameters = function[:parameters] || function["parameters"]
+
+        # Build Anthropic format tool definition
+        {
+          name: name,
+          description: description,
+          input_schema: parameters,
+        }
+      end.compact # Remove nil values from failed conversions
     end
 
-    def normalize_messages(messages)
-      system_messages = []
-      anthropic_messages = []
-
-      messages.each do |message|
-        role = message["role"] || message[:role]
-        content = message["content"] || message[:content]
-
-        case role.to_s
-        when "system"
-          system_messages << content.to_s
-        when "user", "assistant"
-          anthropic_messages << {
-            role: role.to_s,
-            content: normalize_content(content),
-          }
-        when "tool"
-          anthropic_messages << {
-            role: "user",
-            content: normalize_tool_result(message),
-          }
+    def convert_response_to_openai_format(response)
+      begin
+        # Normalize response to a Hash with symbol keys
+        raw_response = if response.respond_to?(:to_h)
+                         response.to_h
+                       elsif response.is_a?(Hash)
+                         response
+                       else
+                         JSON.parse(response.to_json)
+                       end
+
+        response_hash = deep_symbolize(raw_response)
+
+        # Handle content blocks (text, tool_use, etc.)
+        content_blocks = response_hash[:content] || []
+        text_content = ""
+        tool_calls = []
+
+        case content_blocks
+        when String
+          text_content = content_blocks
+        when Array
+          content_blocks.each do |block|
+            block_hash = block.respond_to?(:to_h) ? block.to_h : block
+            block_hash = deep_symbolize(block_hash)
+            next unless block_hash.is_a?(Hash)
+
+            case block_hash[:type]
+            when "text"
+              text_content << block_hash[:text].to_s
+            when "tool_use"
+              tool_calls << {
+                "index" => tool_calls.size,
+                "id" => block_hash[:id] || "tool_call_#{tool_calls.size}",
+                "type" => "function",
+                "function" => {
+                  "name" => block_hash[:name],
+                  "arguments" => JSON.generate(block_hash[:input] || {}),
+                },
+              }
+            end
+          end
         else
-          anthropic_messages << {
-            role: "user",
-            content: normalize_content(content),
-          }
+          text_content = content_blocks.to_s
         end
-      end
-
-      [anthropic_messages, system_messages.join("\n\n")]
-    end
-
-    def normalize_content(content)
-      return content if content.is_a?(Array)
 
-      content.to_s
-    end
-
-    def normalize_tool_result(message)
-      tool_use_id = message["tool_call_id"] || message[:tool_call_id]
-      content = message["content"] || message[:content]
-
-      [{
-        type: "tool_result",
-        tool_use_id: tool_use_id.to_s,
-        content: content.to_s,
-      }]
-    end
-
-    def normalize_tools(tools)
-      tools.map do |tool|
-        function = tool["function"] || tool[:function] || tool
-        {
-          name: function["name"] || function[:name],
-          description: function["description"] || function[:description],
-          input_schema: function["parameters"] || function[:parameters] || {},
+        # Map stop reason to OpenAI finish_reason semantics
+        stop_reason = response_hash[:stop_reason] || response_hash[:finish_reason]
+        finish_reason = case stop_reason
+                        when "tool_use"
+                          "tool_calls"
+                        when "end_turn", nil
+                          "stop"
+                        else
+                          stop_reason
+                        end
+
+        # Map usage information
+        usage = response_hash[:usage] || {}
+        prompt_tokens = usage[:input_tokens]
+        completion_tokens = usage[:output_tokens]
+        cache_read_tokens = usage[:cache_read_input_tokens]
+        cache_creation_tokens = usage[:cache_creation_input_tokens]
+        total_tokens = if prompt_tokens || completion_tokens
+                         [prompt_tokens, completion_tokens].compact.sum
+                       end
+        prompt_cache_hit_tokens = cache_read_tokens
+        prompt_cache_miss_tokens = if prompt_tokens && cache_read_tokens
+                                     prompt_tokens - cache_read_tokens
+                                   end
+        prompt_tokens_details = {}
+        prompt_tokens_details["cached_tokens"] = cache_read_tokens if cache_read_tokens
+
+        usage_hash = {}
+        usage_hash["prompt_tokens"] = prompt_tokens if prompt_tokens
+        usage_hash["completion_tokens"] = completion_tokens if completion_tokens
+        usage_hash["total_tokens"] = total_tokens if total_tokens
+        usage_hash["prompt_tokens_details"] = prompt_tokens_details unless prompt_tokens_details.empty?
+        usage_hash["prompt_cache_hit_tokens"] = prompt_cache_hit_tokens if prompt_cache_hit_tokens
+        usage_hash["prompt_cache_miss_tokens"] = prompt_cache_miss_tokens if prompt_cache_miss_tokens
+
+        created_ts = response_hash[:created_at] || response_hash[:created] || Time.now.to_i
+
+        message_role = response_hash[:role] || "assistant"
+
+        openai_response = {
+          "id" => response_hash[:id],
+          "object" => "chat.completion",
+          "created" => created_ts,
+          "model" => response_hash[:model],
+          "choices" => [
+            {
+              "index" => 0,
+              "message" => {
+                "role" => message_role,
+                "content" => text_content.empty? ? nil : text_content,
+              },
+              "finish_reason" => finish_reason,
+            },
+          ],
         }
-      end
-    end
 
-    def post_messages(parameters, stream_proc)
-      http = Net::HTTP.new(@messages_uri.host, @messages_uri.port)
-      http.use_ssl = @messages_uri.scheme == "https"
-      http.read_timeout = @request_timeout
-      http.open_timeout = @request_timeout
-
-      request = Net::HTTP::Post.new(@messages_uri)
-      request["Content-Type"] = "application/json"
-      request["x-api-key"] = @api_key
-      request["anthropic-version"] = @anthropic_version
-      request.body = JSON.generate(parameters)
-
-      if stream_proc
-        handle_streaming_response(http, request, stream_proc)
-      else
-        handle_response(http.request(request))
-      end
-    rescue SocketError => e
-      SmartPrompt.logger.error "Failed to connect to Anthropic API: #{e.message}"
-      raise LLMAPIError, "Network error: Unable to connect to Anthropic API"
-    rescue Net::OpenTimeout, Net::ReadTimeout
-      SmartPrompt.logger.error "Request to Anthropic API timed out"
-      raise LLMAPIError, "Request to Anthropic API timed out"
-    end
-
-    def handle_response(response)
-      body = JSON.parse(response.body)
-      return body if response.is_a?(Net::HTTPSuccess)
-
-      message = body.dig("error", "message") || response.message
-      SmartPrompt.logger.error "Anthropic API error: #{message}"
-      raise LLMAPIError, "Anthropic API error: #{message}"
-    end
-
-    def handle_streaming_response(http, request, stream_proc)
-      accumulated_response = nil
-
-      http.request(request) do |response|
-        unless response.is_a?(Net::HTTPSuccess)
-          body = response.body.to_s.empty? ? {} : JSON.parse(response.body)
-          message = body.dig("error", "message") || response.message
-          SmartPrompt.logger.error "Anthropic API error: #{message}"
-          raise LLMAPIError, "Anthropic API error: #{message}"
-        end
-
-        response.read_body do |chunk|
-          chunk.each_line do |line|
-            next unless line.start_with?("data:")
-
-            data = line.delete_prefix("data:").strip
-            next if data.empty?
-
-            event = JSON.parse(data)
-            accumulated_response = event if event["type"] == "message_start"
-            stream_proc.call(openai_stream_chunk(event), chunk.bytesize)
-          end
+        unless tool_calls.empty?
+          openai_response["choices"][0]["message"]["tool_calls"] = tool_calls
         end
-      end
 
-      accumulated_response
-    end
+        openai_response["usage"] = usage_hash unless usage_hash.empty?
+        openai_response["system_fingerprint"] = response_hash[:system_fingerprint] if response_hash[:system_fingerprint]
 
-    def openai_stream_chunk(event)
-      case event["type"]
-      when "message_start"
-        message = event["message"] || {}
-        {
-          "id" => message["id"],
-          "object" => "chat.completion.chunk",
-          "created" => Time.now.to_i,
-          "model" => message["model"],
-          "choices" => [{
-            "index" => 0,
-            "delta" => {},
-          }],
-          "usage" => message["usage"],
-        }
-      when "content_block_delta"
-        {
-          "choices" => [{
-            "index" => 0,
-            "delta" => {
-              "content" => event.dig("delta", "text").to_s,
-            },
-          }],
-        }
-      else
-        {
-          "choices" => [{
-            "index" => 0,
-            "delta" => {},
-          }],
-        }
+        @last_response = openai_response
+        openai_response
+      rescue => e
+        SmartPrompt.logger.error "Failed to convert Anthropic response: #{e.message}"
+        raise LLMAPIError, "Failed to convert Anthropic response: #{e.message}"
       end
     end
 
-    def extract_content(response)
-      text_parts = []
-      tool_calls = []
-
-      response.fetch("content", []).each do |block|
-        case block["type"]
-        when "text"
-          text_parts << block["text"].to_s
-        when "tool_use"
-          tool_calls << openai_tool_call(block)
-        else
-          text_parts << block.to_s
+    # Deeply symbolize hash keys for consistent access
+    def deep_symbolize(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(k, v), memo|
+          key = k.is_a?(String) || k.is_a?(Symbol) ? k.to_sym : k
+          memo[key] = deep_symbolize(v)
         end
+      when Array
+        obj.map { |item| deep_symbolize(item) }
+      else
+        obj
       end
-
-      content = text_parts.join
-      return content if tool_calls.empty?
-
-      openai_response(response, content, tool_calls)
-    end
-
-    def openai_response(response, content, tool_calls)
-      {
-        "id" => response["id"],
-        "object" => "chat.completion",
-        "created" => Time.now.to_i,
-        "model" => response["model"],
-        "choices" => [{
-          "index" => 0,
-          "message" => {
-            "role" => "assistant",
-            "content" => content,
-            "tool_calls" => tool_calls,
-          },
-          "finish_reason" => openai_finish_reason(response["stop_reason"]),
-        }],
-        "usage" => response["usage"],
-      }
-    end
-
-    def openai_tool_call(block)
-      {
-        "id" => block["id"],
-        "type" => "function",
-        "function" => {
-          "name" => block["name"],
-          "arguments" => JSON.generate(block["input"] || {}),
-        },
-      }
-    end
-
-    def openai_finish_reason(stop_reason)
-      return "tool_calls" if stop_reason == "tool_use"
-
-      stop_reason
     end
-  end
-end
+
+    public
+
+    # Send request to Anthropic API
+    # @param messages [Array] Array of message hashes
+    # @param model [String, nil] Model name (optional, uses config default if nil)
+    # @param temperature [Float, nil] Temperature value (optional, uses config or 0.7 if nil)
+    # @param tools [Array, nil] Array of tool definitions (optional)
+    # @param proc [Proc, nil] Callback for streaming responses (optional)
+    # @return [Hash, nil] OpenAI-formatted response (nil for streaming mode)
+    def send_request(messages, model = nil, temperature = nil, tools = nil, proc = nil)
+      begin
+        # Determine model name (parameter > config)
+        model_name = model || @config["model"]
+
+        # Determine temperature (config > parameter > default 0.7)
+        temp_value = @config["temperature"] || temperature || 0.7
+
+        # Determine max_tokens (config > default 1024)
+        max_tokens_value = @config["max_tokens"] || 1024
+
+        SmartPrompt.logger.info "AnthropicAdapter: Sending request to Anthropic"
+        SmartPrompt.logger.info "AnthropicAdapter: Using model #{model_name}"
+
+        # Extract system message
+        system_message = extract_system_message(messages)
+
+        # Convert messages to Anthropic format
+        converted_messages = convert_messages_to_anthropic_format(messages)
+
+        # Build request parameters
+        parameters = {
+          model: model_name,
+          messages: converted_messages,
+          max_tokens: max_tokens_value,
+          temperature: temp_value,
+        }
+
+        # Add system message if present
+        parameters[:system] = system_message if system_message
+
+        # Convert and add tools if provided
+        if tools
+          anthropic_tools = convert_tools_to_anthropic_format(tools)
+          parameters[:tools] = anthropic_tools if anthropic_tools
+        end
+
+        SmartPrompt.logger.info "Send parameters is: #{parameters}"
+
+        # Send request to Anthropic API
+        if proc
+          # Streaming mode: use stream method
+          stream = @client.messages.stream(**parameters)
+
+          # Iterate through the stream and call proc for each event
+          stream.each do |event|
+            # Convert event to hash format for compatibility
+            event_hash = {
+              "type" => event.type.to_s,
+            }
+
+            # Add delta information for content_block_delta events
+            if event.type == :content_block_delta && event.delta.type == :text_delta
+              event_hash["delta"] = { "text" => event.delta.text }
+            end
+
+            proc.call(event_hash, 0)
+          end
+
+          SmartPrompt.logger.info "Successful send a message (streaming)"
+          nil
+        else
+          # Non-streaming mode: use create method
+          response = @client.messages.create(**parameters)
+          SmartPrompt.logger.info "Successful send a message"
+          SmartPrompt.logger.info "AnthropicAdapter: Received response from Anthropic"
+
+          # Convert response to openai format
+          convert_response_to_openai_format(response)
+        end
+      rescue => e
+        SmartPrompt.logger.error "Anthropic API error: #{e.message}"
+        SmartPrompt.logger.error "Error class: #{e.class}"
+        SmartPrompt.logger.error "Backtrace: #{e.backtrace.first(5).join("\n")}"
+        raise LLMAPIError, "Failed to send request to Anthropic: #{e.message}"
+      end
+    end
+
+    # Embeddings method (not supported by Anthropic API)
+    # @param text [String] Text to generate embeddings for
+    # @param model [String] Model name
+    # @raise [NotImplementedError] Always raises as Anthropic doesn't support embeddings
+    def embeddings(text, model)
+      raise NotImplementedError, "Anthropic API does not support embeddings. Please use OpenAI or other providers for embedding generation."
+    end
+  end
+end