rcrewai 0.2.0 → 0.3.0

data/lib/rcrewai/llm_clients/anthropic.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
+require 'faraday'
+require 'json'
 require_relative 'base'
+require_relative '../events'
+require_relative '../sse_parser'
+require_relative '../provider_schema'
+require_relative '../pricing'
 
 module RCrewAI
   module LLMClients
@@ -8,101 +14,215 @@ module RCrewAI
       BASE_URL = 'https://api.anthropic.com/v1'
       API_VERSION = '2023-06-01'
 
+      STOP_REASON_MAP = {
+        'tool_use' => :tool_calls,
+        'end_turn' => :stop,
+        'stop_sequence' => :stop,
+        'max_tokens' => :length
+      }.freeze
+
       def initialize(config = RCrewAI.configuration)
         super
         @base_url = BASE_URL
       end
 
-      def chat(messages:, **options)
-        # Convert messages to Anthropic format
+      def chat(messages:, tools: nil, tool_choice: :auto, stream: nil, **options)
         system_message = extract_system_message(messages)
-        formatted_messages = format_messages(messages.reject { |m| m.is_a?(Hash) && m[:role] == 'system' })
+        non_system = messages.reject { |m| m.is_a?(Hash) && m[:role] == 'system' }
 
         payload = {
           model: config.model,
-          messages: formatted_messages,
+          messages: format_messages(non_system),
           max_tokens: options[:max_tokens] || config.max_tokens || 1000,
           temperature: options[:temperature] || config.temperature
-        }
+        }.compact
+
+        if system_message
+          payload[:system] = if options[:cache_system]
+                               [{ type: 'text', text: system_message,
+                                  cache_control: { type: 'ephemeral' } }]
+                             else
+                               system_message
+                             end
+        end
 
-        payload[:system] = system_message if system_message
+        if tools && !tools.empty?
+          payload[:tools] = ProviderSchema.for_many(:anthropic, tools)
+          payload[:tool_choice] = { type: tool_choice.to_s } if tool_choice != :auto && tool_choice.is_a?(Symbol)
+        end
 
-        # Add Anthropic-specific options
         payload[:top_p] = options[:top_p] if options[:top_p]
         payload[:top_k] = options[:top_k] if options[:top_k]
         payload[:stop_sequences] = options[:stop_sequences] if options[:stop_sequences]
 
-        url = "#{@base_url}/messages"
-        log_request(:post, url, payload)
-
-        response = http_client.post(url, payload, build_headers.merge(authorization_header))
-        log_response(response)
+        if stream
+          payload[:stream] = true
+          stream_chat(payload, stream)
+        else
+          plain_chat(payload)
+        end
+      end
 
-        result = handle_response(response)
-        format_response(result)
+      def supports_native_tools?(model: config.model) # rubocop:disable Lint/UnusedMethodArgument
+        true
       end
 
       def models
-        # Anthropic doesn't have a models endpoint, return known models
-        [
-          'claude-3-opus-20240229',
-          'claude-3-sonnet-20240229',
-          'claude-3-haiku-20240307',
-          'claude-2.1',
-          'claude-2.0',
-          'claude-instant-1.2'
+        %w[
+          claude-opus-4-7 claude-sonnet-4-6 claude-haiku-4-5
+          claude-3-5-sonnet-20241022 claude-3-haiku-20240307
         ]
       end
 
       private
 
-      def authorization_header
+      def plain_chat(payload)
+        url = "#{@base_url}/messages"
+        log_request(:post, url, payload)
+        response = http_client.post(url, payload, build_headers.merge(auth_header))
+        log_response(response)
+        body = handle_response(response)
+        normalize_non_streaming(body)
+      end
+
+      def stream_chat(payload, sink) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        url = "#{@base_url}/messages"
+        log_request(:post, url, payload)
+
+        assembled_text = +''
+        # tool_use blocks keyed by content-block index
+        blocks = {}
+        finish_reason = nil
+        prompt_tokens = nil
+        completion_tokens = nil
+
+        parser = SSEParser.new do |sse|
+          data = JSON.parse(sse[:data])
+          case data['type']
+          when 'message_start'
+            prompt_tokens = data.dig('message', 'usage', 'input_tokens')
+          when 'content_block_start'
+            cb = data['content_block'] || {}
+            blocks[data['index']] = { id: cb['id'], name: cb['name'], arguments: +'' } if cb['type'] == 'tool_use'
+          when 'content_block_delta'
+            delta = data['delta'] || {}
+            case delta['type']
+            when 'text_delta'
+              text = delta['text'].to_s
+              assembled_text << text
+              sink.call(Events::TextDelta.new(type: :text_delta, timestamp: Time.now,
+                                              agent: nil, iteration: nil, text: text))
+            when 'input_json_delta'
+              block = blocks[data['index']]
+              block[:arguments] << delta['partial_json'].to_s if block
+            end
+          when 'message_delta'
+            finish_reason ||= STOP_REASON_MAP[data.dig('delta', 'stop_reason')] ||
+                              data.dig('delta', 'stop_reason')&.to_sym
+            completion_tokens = data.dig('usage', 'output_tokens') || completion_tokens
+          end
+        end
+
+        streaming_post(url, payload) { |chunk| parser.feed(chunk) }
+
+        tool_calls = blocks.values.map do |b|
+          {
+            id: b[:id],
+            name: b[:name],
+            arguments: b[:arguments].empty? ? {} : JSON.parse(b[:arguments])
+          }
+        end
+
+        usage = {
+          prompt_tokens: prompt_tokens,
+          completion_tokens: completion_tokens,
+          total_tokens: (prompt_tokens || 0) + (completion_tokens || 0)
+        }
+
+        if prompt_tokens || completion_tokens
+          sink.call(Events::Usage.new(
+                      type: :usage, timestamp: Time.now, agent: nil, iteration: nil,
+                      prompt_tokens: prompt_tokens, completion_tokens: completion_tokens,
+                      total_tokens: usage[:total_tokens],
+                      cost_usd: Pricing.cost_for(config.model,
+                                                 prompt_tokens: prompt_tokens || 0,
+                                                 completion_tokens: completion_tokens || 0)
+                    ))
+        end
+
         {
-          'x-api-key' => config.api_key,
+          content: assembled_text.empty? ? nil : assembled_text,
+          tool_calls: tool_calls,
+          usage: usage,
+          finish_reason: finish_reason || :stop,
+          model: config.model,
+          provider: :anthropic
+        }
+      end
+
+      def streaming_post(url, payload, &on_chunk)
+        conn = Faraday.new do |f|
+          f.request :json
+          f.options.timeout = config.timeout
+          f.adapter Faraday.default_adapter
+        end
+        conn.post(url) do |req|
+          req.headers = build_headers.merge(auth_header)
+          req.body = payload.to_json
+          req.options.on_data = proc { |chunk, _| on_chunk.call(chunk) }
+        end
+      end
+
+      def normalize_non_streaming(body)
+        content_blocks = Array(body['content'])
+        text = content_blocks.select { |b| b['type'] == 'text' }.map { |b| b['text'] }.join
+        tool_calls = content_blocks.select { |b| b['type'] == 'tool_use' }.map do |b|
+          { id: b['id'], name: b['name'], arguments: b['input'] || {} }
+        end
+        prompt_tokens = body.dig('usage', 'input_tokens')
+        completion_tokens = body.dig('usage', 'output_tokens')
+
+        {
+          content: text.empty? ? nil : text,
+          tool_calls: tool_calls,
+          usage: {
+            prompt_tokens: prompt_tokens,
+            completion_tokens: completion_tokens,
+            total_tokens: (prompt_tokens || 0) + (completion_tokens || 0)
+          },
+          finish_reason: STOP_REASON_MAP[body['stop_reason']] || body['stop_reason']&.to_sym || :stop,
+          model: body['model'] || config.model,
+          provider: :anthropic
+        }
+      end
+
+      def auth_header
+        {
+          'x-api-key' => config.anthropic_api_key || config.api_key,
           'anthropic-version' => API_VERSION
         }
       end
 
       def extract_system_message(messages)
         return nil unless messages.is_a?(Array)
-        system_msg = messages.find { |m| m.is_a?(Hash) && m[:role] == 'system' }
-        system_msg&.dig(:content)
+
+        msg = messages.find { |m| m.is_a?(Hash) && m[:role] == 'system' }
+        msg&.dig(:content)
       end
 
       def format_messages(messages)
         messages.map do |msg|
           if msg.is_a?(Hash)
-            {
-              role: msg[:role] == 'assistant' ? 'assistant' : 'user',
-              content: msg[:content]
-            }
+            { role: msg[:role] == 'assistant' ? 'assistant' : 'user', content: msg[:content] }
           else
             { role: 'user', content: msg.to_s }
           end
         end
       end
 
-      def format_response(response)
-        content = response.dig('content', 0, 'text') if response['content']&.any?
-
-        {
-          content: content,
-          role: 'assistant',
-          finish_reason: response['stop_reason'],
-          usage: {
-            'prompt_tokens' => response.dig('usage', 'input_tokens'),
-            'completion_tokens' => response.dig('usage', 'output_tokens'),
-            'total_tokens' => (response.dig('usage', 'input_tokens') || 0) + 
-                             (response.dig('usage', 'output_tokens') || 0)
-          },
-          model: response['model'],
-          provider: :anthropic
-        }
-      end
-
       def validate_config!
-        raise ConfigurationError, "Anthropic API key is required" unless config.anthropic_api_key || config.api_key
-        raise ConfigurationError, "Model is required" unless config.model
+        raise ConfigurationError, 'Anthropic API key is required' unless config.anthropic_api_key || config.api_key
+        raise ConfigurationError, 'Model is required' unless config.model
       end
 
       def handle_response(response)
@@ -110,12 +230,12 @@ module RCrewAI
         when 200..299
           response.body
         when 400
-          error_details = response.body.dig('error', 'message') || response.body
+          error_details = response.body.is_a?(Hash) ? response.body.dig('error', 'message') : response.body
           raise APIError, "Bad request: #{error_details}"
         when 401
-          raise AuthenticationError, "Invalid API key"
+          raise AuthenticationError, 'Invalid API key'
         when 429
-          raise RateLimitError, "Rate limit exceeded"
+          raise RateLimitError, 'Rate limit exceeded'
         when 500..599
           raise APIError, "Server error: #{response.status}"
         else
@@ -124,4 +244,4 @@ module RCrewAI
       end
     end
   end
-end
+end

data/lib/rcrewai/llm_clients/azure.rb

@@ -1,158 +1,53 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'openai'
 
 module RCrewAI
   module LLMClients
-    class Azure < Base
+    # Azure OpenAI: same wire format as OpenAI but routes through a deployment
+    # path with an api-version query param, and authenticates with an api-key
+    # header instead of Authorization: Bearer.
+    class Azure < OpenAI
       def initialize(config = RCrewAI.configuration)
         super
-        @base_url = config.base_url || build_azure_url
         @api_version = config.api_version || '2024-02-01'
         @deployment_name = config.deployment_name || config.model
-      end
-
-      def chat(messages:, **options)
-        payload = {
-          messages: format_messages(messages),
-          temperature: options[:temperature] || config.temperature,
-          max_tokens: options[:max_tokens] || config.max_tokens
-        }
-
-        # Add additional OpenAI-compatible options
-        payload[:top_p] = options[:top_p] if options[:top_p]
-        payload[:frequency_penalty] = options[:frequency_penalty] if options[:frequency_penalty]
-        payload[:presence_penalty] = options[:presence_penalty] if options[:presence_penalty]
-        payload[:stop] = options[:stop] if options[:stop]
-
-        url = "#{@base_url}/openai/deployments/#{@deployment_name}/chat/completions?api-version=#{@api_version}"
-        log_request(:post, url, payload)
-
-        response = http_client.post(url, payload, build_headers.merge(authorization_header))
-        log_response(response)
-
-        result = handle_response(response)
-        format_response(result)
-      end
-
-      def complete(prompt:, **options)
-        # For older models that use completions endpoint
-        payload = {
-          prompt: prompt,
-          temperature: options[:temperature] || config.temperature,
-          max_tokens: options[:max_tokens] || config.max_tokens
-        }
-
-        url = "#{@base_url}/openai/deployments/#{@deployment_name}/completions?api-version=#{@api_version}"
-        log_request(:post, url, payload)
-
-        response = http_client.post(url, payload, build_headers.merge(authorization_header))
-        log_response(response)
-
-        result = handle_response(response)
-        format_completion_response(result)
+        @base_url = build_endpoint_url
       end
 
       def models
-        # Azure OpenAI uses deployments instead of models
         url = "#{@base_url}/openai/deployments?api-version=#{@api_version}"
-        response = http_client.get(url, {}, build_headers.merge(authorization_header))
+        response = http_client.get(url, {}, build_headers.merge(auth_header))
         result = handle_response(response)
-        
-        if result['data']
-          result['data'].map { |deployment| deployment['id'] }
-        else
-          [@deployment_name].compact
-        end
+        Array(result['data']).map { |d| d['id'] }
+      rescue StandardError
+        [@deployment_name].compact
       end
 
       private
 
-      def authorization_header
-        { 'api-key' => config.api_key }
+      def chat_url
+        "#{@base_url}/openai/deployments/#{@deployment_name}/chat/completions?api-version=#{@api_version}"
       end
 
-      def format_messages(messages)
-        messages.map do |msg|
-          if msg.is_a?(Hash)
-            msg
-          else
-            { role: 'user', content: msg.to_s }
-          end
-        end
+      def build_endpoint_url
+        endpoint = config.base_url || ENV['AZURE_OPENAI_ENDPOINT'] || ENV['AZURE_ENDPOINT']
+        endpoint&.chomp('/')
       end
 
-      def format_response(response)
-        choice = response.dig('choices', 0)
-        return nil unless choice
-
-        {
-          content: choice.dig('message', 'content'),
-          role: choice.dig('message', 'role'),
-          finish_reason: choice['finish_reason'],
-          usage: response['usage'],
-          model: @deployment_name,
-          provider: :azure
-        }
+      def provider_name
+        :azure
       end
 
-      def format_completion_response(response)
-        choice = response.dig('choices', 0)
-        return nil unless choice
-
-        {
-          content: choice['text'],
-          finish_reason: choice['finish_reason'],
-          usage: response['usage'],
-          model: @deployment_name,
-          provider: :azure
-        }
+      def auth_header
+        { 'api-key' => config.azure_api_key || config.api_key }
       end
 
       def validate_config!
-        super
-        raise ConfigurationError, "Azure API key is required" unless config.azure_api_key || config.api_key
-        raise ConfigurationError, "Azure base URL or endpoint is required" unless config.base_url || azure_endpoint
-        raise ConfigurationError, "Azure deployment name is required" unless config.deployment_name || config.model
-      end
-
-      def build_azure_url
-        endpoint = azure_endpoint
-        return nil unless endpoint
-        
-        # Remove trailing slash and add proper path
-        endpoint = endpoint.chomp('/')
-        "#{endpoint}"
-      end
-
-      def azure_endpoint
-        # Try multiple environment variable names
-        ENV['AZURE_OPENAI_ENDPOINT'] || 
-        ENV['AZURE_ENDPOINT'] || 
-        config.instance_variable_get(:@azure_endpoint)
-      end
-
-      def handle_response(response)
-        case response.status
-        when 200..299
-          response.body
-        when 400
-          error_details = response.body.dig('error', 'message') || response.body
-          raise APIError, "Bad request: #{error_details}"
-        when 401
-          raise AuthenticationError, "Invalid API key or authentication failed"
-        when 403
-          raise AuthenticationError, "Access denied - check your API key and permissions"
-        when 404
-          raise ModelNotFoundError, "Deployment '#{@deployment_name}' not found"
-        when 429
-          raise RateLimitError, "Rate limit exceeded or quota exhausted"
-        when 500..599
-          raise APIError, "Azure OpenAI service error: #{response.status}"
-        else
-          raise APIError, "Unexpected response: #{response.status}"
-        end
+        raise ConfigurationError, 'Azure API key is required' unless config.azure_api_key || config.api_key
+        raise ConfigurationError, 'Azure endpoint is required' unless config.base_url || ENV['AZURE_OPENAI_ENDPOINT'] || ENV['AZURE_ENDPOINT']
+        raise ConfigurationError, 'Azure deployment name is required' unless config.deployment_name || config.model
       end
     end
   end
-end
+end

data/lib/rcrewai/llm_clients/base.rb

@@ -16,8 +16,12 @@ module RCrewAI
         validate_config!
       end
 
-      def chat(messages:, **options)
-        raise NotImplementedError, "Subclasses must implement #chat method"
+      def chat(messages:, tools: nil, tool_choice: :auto, stream: nil, **options)
+        raise NotImplementedError, 'Subclasses must implement #chat method'
+      end
+
+      def supports_native_tools?(model: config.model) # rubocop:disable Lint/UnusedMethodArgument
+        true
       end
 
       def complete(prompt:, **options)
@@ -27,8 +31,8 @@ module RCrewAI
       protected
 
       def validate_config!
-        raise ConfigurationError, "API key is required" unless config.api_key
-        raise ConfigurationError, "Model is required" unless config.model
+        raise ConfigurationError, 'API key is required' unless config.api_key
+        raise ConfigurationError, 'Model is required' unless config.model
       end
 
       def build_headers
@@ -54,9 +58,9 @@ module RCrewAI
         when 400
           raise APIError, "Bad request: #{response.body}"
         when 401
-          raise AuthenticationError, "Invalid API key"
+          raise AuthenticationError, 'Invalid API key'
         when 429
-          raise RateLimitError, "Rate limit exceeded"
+          raise RateLimitError, 'Rate limit exceeded'
         when 500..599
           raise APIError, "Server error: #{response.status}"
         else
@@ -79,4 +83,4 @@ module RCrewAI
     class RateLimitError < APIError; end
     class ModelNotFoundError < APIError; end
   end
-end
+end