smart_prompt 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67ba5c17240bbbfcf74c5aaabf100f01c1c40c360f77e84b15169ee83033018e
-  data.tar.gz: bc43cc30cabdc5e4ba62e1b07b2851482a3dc472e50efc10a56206d73b842a55
+  metadata.gz: 396c6097973289a34143e86b65f428d55919d0e755916992a5c714e289ebf5a2
+  data.tar.gz: 5d2c2d81b486e1fb05b53f116047ab1f90be77c9536fd6440a96b573bdad00c3
 SHA512:
-  metadata.gz: ebd50d0f9f83dbc8c3315b5edb22bf6fb7920c7bd8ae82d3c8bb90ee78b10deb2ff9945a125d248f453b92894e23b5d61f442b8191621b8a044d95468252e796
-  data.tar.gz: 03f784ba90fcdc629694c88448360faf08c9eede708df7c3ebdfe736917e3acb5dc12ff24c55b89a14b2ce2c9721b70d986e35672ce25c001d69ad883bf8858b
+  metadata.gz: c6880395149678a195ea6efc46a81623d61c14c56534936041a625616a9e6b716597c078ccee0ac0d47c3b2a8e67d272742ee36940fa64321426799db0b26e4d
+  data.tar.gz: 63f0b8ae0f6f62363443731cae6fed3eafe746c463d259c9b88eee8563d6ef0cdcd84e684d6daeedd7329c3dcab84748ab62358fa2935b9d0278ec347df45ffb

data/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.1] - 2026-04-22
+### Fixed
+- Re-release package with `lib/smart_prompt/anthropic_adapter.rb`, which is required by the gem entrypoint.
+
+## [0.4.0] - 2026-04-22
+### Added
+- Anthropic adapter support.
+
 ## [0.3.6] - 2026-04-08
 ### Changed
 - Bumped `ruby-openai` dependency from `8.1.0` to `8.3.0`

data/lib/smart_prompt/anthropic_adapter.rb

@@ -0,0 +1,298 @@
+require "net/http"
+require "json"
+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
+    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),
+          }
+        else
+          anthropic_messages << {
+            role: "user",
+            content: normalize_content(content),
+          }
+        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] || {},
+        }
+      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
+        end
+      end
+
+      accumulated_response
+    end
+
+    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" => {},
+          }],
+        }
+      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
+        end
+      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

data/lib/smart_prompt/version.rb

@@ -1,3 +1,3 @@
 module SmartPrompt
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_prompt
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - zhuang biaowei
@@ -107,6 +107,7 @@ files:
 - README.md
 - Rakefile
 - lib/smart_prompt.rb
+- lib/smart_prompt/anthropic_adapter.rb
 - lib/smart_prompt/api_handler.rb
 - lib/smart_prompt/conversation.rb
 - lib/smart_prompt/db_adapter.rb