rasti-ai 3.0.1 → 3.2.0

data/lib/rasti/ai/anthropic/provider.rb

@@ -0,0 +1,87 @@
+module Rasti
+  module AI
+    module Anthropic
+      class Provider < Rasti::AI::Provider
+
+        STRUCTURED_OUTPUT_TOOL = 'structured_output'.freeze
+
+        THINKING_LEVELS = {
+          'low' => {type: 'enabled', budget_tokens: 1_024}.freeze,
+          'medium' => {type: 'enabled', budget_tokens: 8_000}.freeze,
+          'high' => {type: 'enabled', budget_tokens: 16_000}.freeze
+        }.freeze
+
+        def name
+          :anthropic
+        end
+
+        def default_model
+          Rasti::AI.anthropic_default_model
+        end
+
+        def default_api_key
+          Rasti::AI.anthropic_api_key
+        end
+
+        def base_url
+          'https://api.anthropic.com/v1'
+        end
+
+        def parse_usage(response)
+          usage = response['usage']
+          return nil unless usage
+
+          Usage.new(
+            provider: name.to_s,
+            model: response['model'],
+            input_tokens: usage['input_tokens'],
+            output_tokens: usage['output_tokens'],
+            cached_tokens: usage['cache_read_input_tokens'] || 0,
+            reasoning_tokens: 0,
+            raw: usage
+          )
+        end
+
+        private
+
+        def request(client:, messages:, system:, model:, json_schema:, thinking:)
+          tools = json_schema ? [structured_output_tool(json_schema)] : []
+          tool_choice = json_schema ? {type: 'tool', name: STRUCTURED_OUTPUT_TOOL} : nil
+
+          client.messages messages: messages,
+                          model: model,
+                          system: system,
+                          tools: tools,
+                          tool_choice: tool_choice,
+                          thinking: thinking
+        end
+
+        def encode_message(message)
+          {role: message[:role], content: message[:content]}
+        end
+
+        def parse_content(response)
+          content = response['content'] || []
+
+          structured = content.find { |block| block['type'] == 'tool_use' && block['name'] == STRUCTURED_OUTPUT_TOOL }
+          return JSON.dump(structured['input']) if structured
+
+          text_block = content.find { |block| block['type'] == 'text' }
+          text_block['text'] if text_block
+        end
+
+        def structured_output_tool(json_schema)
+          {
+            name: STRUCTURED_OUTPUT_TOOL,
+            description: 'Return the structured response',
+            input_schema: {
+              type: 'object',
+              properties: json_schema
+            }
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/assistant.rb

@@ -2,14 +2,17 @@ module Rasti
   module AI
     class Assistant
 
+      include ProviderAware
+
       attr_reader :state, :model, :thinking
 
       VALID_THINKING_LEVELS = %w[low medium high].freeze
 
-      def initialize(client:nil, json_schema:nil, state:nil, model:nil, thinking:nil, tools:[], mcp_servers:{}, logger:nil)
+      def initialize(client:nil, provider:nil, json_schema:nil, state:nil, model:nil, thinking:nil, tools:[], mcp_servers:{}, logger:nil)
         raise ArgumentError, "Invalid thinking level '#{thinking}'. Valid: #{VALID_THINKING_LEVELS.join(', ')}" if thinking && !VALID_THINKING_LEVELS.include?(thinking)
 
-        @client = client || build_default_client
+        @provider = provider
+        @client = client
         @json_schema = json_schema
         @state = state || AssistantState.new
         @model = model
@@ -50,14 +53,16 @@ module Rasti
 
       private
 
-      attr_reader :client, :json_schema, :tools, :serialized_tools, :logger
+      attr_reader :json_schema, :tools, :serialized_tools, :logger
+
+      def client
+        @client ||= provider.build_client
+      end
 
       def messages
         state.messages
       end
 
-      # --- Shared behavior ---
-
       def register_tools(tools)
         tools.each do |tool|
           serialization = wrap_tool_serialization(ToolSerializer.serialize(tool.class))
@@ -99,12 +104,6 @@ module Rasti
         "Error: #{ex.message}"
       end
 
-      # --- Template methods ---
-
-      def build_default_client
-        raise NotImplementedError
-      end
-
       def build_user_message(prompt)
         raise NotImplementedError
       end

data/lib/rasti/ai/client.rb

@@ -2,9 +2,12 @@ module Rasti
   module AI
     class Client
 
+      include ProviderAware
+
       RETRYABLE_STATUS_CODES = [502, 503, 504].freeze
 
-      def initialize(api_key:nil, logger:nil, http_connect_timeout:nil, http_read_timeout:nil, http_max_retries:nil, usage_tracker:nil)
+      def initialize(provider:nil, api_key:nil, logger:nil, http_connect_timeout:nil, http_read_timeout:nil, http_max_retries:nil, usage_tracker:nil)
+        @provider = provider
         @api_key = api_key || default_api_key
         @logger = logger || Rasti::AI.logger
         @http_connect_timeout = http_connect_timeout || Rasti::AI.http_connect_timeout
@@ -17,22 +20,22 @@ module Rasti
 
       attr_reader :api_key, :logger, :http_connect_timeout, :http_read_timeout, :http_max_retries, :usage_tracker
 
-      def track_usage(response)
-        return unless usage_tracker
-        usage = parse_usage response
-        usage_tracker.call usage if usage
+      def default_api_key
+        provider.default_api_key
       end
 
-      def parse_usage(response)
-        raise NotImplementedError
+      def default_model
+        provider.default_model
       end
 
-      def default_api_key
-        raise NotImplementedError
+      def track_usage(response)
+        return unless usage_tracker
+        usage = provider.parse_usage response
+        usage_tracker.call usage if usage
       end
 
       def base_url
-        raise NotImplementedError
+        provider.base_url
       end
 
       def build_url(relative_url)

data/lib/rasti/ai/errors.rb

@@ -34,6 +34,14 @@ module Rasti
 
       end
 
+      class UnknownProvider < StandardError
+
+        def initialize(provider, valid_providers)
+          super "Unknown provider #{provider.inspect}. Valid providers: #{valid_providers.join(', ')}"
+        end
+
+      end
+
     end
   end
 end

data/lib/rasti/ai/gemini/assistant.rb

@@ -5,18 +5,8 @@ module Rasti
 
         ALLOWED_SCHEMA_FIELDS = %w[type description properties required enum items format nullable anyOf].freeze
 
-        THINKING_LEVELS = {
-          'low'    => {thinking_budget: 1_024}.freeze,
-          'medium' => {thinking_budget: 8_192}.freeze,
-          'high'   => {thinking_budget: 24_576}.freeze
-        }.freeze
-
         private
 
-        def build_default_client
-          Client.new
-        end
-
         def build_user_message(prompt)
           {role: Roles::USER, parts: [{text: prompt}]}
         end
@@ -112,7 +102,7 @@ module Rasti
         end
 
         def thinking_config
-          THINKING_LEVELS[thinking]
+          Provider::THINKING_LEVELS[thinking]
         end
 
         def generation_config

data/lib/rasti/ai/gemini/client.rb

@@ -4,7 +4,7 @@ module Rasti
       class Client < Rasti::AI::Client
 
         def generate_content(contents:, model:nil, tools:[], system_instruction:nil, generation_config:nil)
-          model_name = model || Rasti::AI.gemini_default_model
+          model_name = model || default_model
 
           body = {contents: contents}
 
@@ -17,30 +17,8 @@ module Rasti
 
         private
 
-        def parse_usage(response)
-          usage = response['usageMetadata']
-          return unless usage
-          Usage.new(
-            provider: 'gemini',
-            model: response['modelVersion'],
-            input_tokens: usage['promptTokenCount'],
-            output_tokens: usage['candidatesTokenCount'],
-            cached_tokens: usage['cachedContentTokenCount'] || 0,
-            reasoning_tokens: usage['thoughtsTokenCount'] || 0,
-            raw: usage
-          )
-        end
-
-        def default_api_key
-          Rasti::AI.gemini_api_key
-        end
-
-        def base_url
-          'https://generativelanguage.googleapis.com/v1beta'
-        end
-
         def build_url(relative_url)
-          "#{base_url}#{relative_url}?key=#{api_key}"
+          "#{super}?key=#{api_key}"
         end
 
       end

data/lib/rasti/ai/gemini/provider.rb

@@ -0,0 +1,90 @@
+module Rasti
+  module AI
+    module Gemini
+      class Provider < Rasti::AI::Provider
+
+        THINKING_LEVELS = {
+          'low' => {thinking_budget: 1_024}.freeze,
+          'medium' => {thinking_budget: 8_192}.freeze,
+          'high' => {thinking_budget: 24_576}.freeze
+        }.freeze
+
+        def name
+          :gemini
+        end
+
+        def default_model
+          Rasti::AI.gemini_default_model
+        end
+
+        def default_api_key
+          Rasti::AI.gemini_api_key
+        end
+
+        def base_url
+          'https://generativelanguage.googleapis.com/v1beta'
+        end
+
+        def parse_usage(response)
+          usage = response['usageMetadata']
+          return nil unless usage
+
+          Usage.new(
+            provider: name.to_s,
+            model: response['modelVersion'],
+            input_tokens: usage['promptTokenCount'],
+            output_tokens: usage['candidatesTokenCount'],
+            cached_tokens: usage['cachedContentTokenCount'] || 0,
+            reasoning_tokens: usage['thoughtsTokenCount'] || 0,
+            raw: usage
+          )
+        end
+
+        private
+
+        def request(client:, messages:, system:, model:, json_schema:, thinking:)
+          client.generate_content contents: messages,
+                                  model: model,
+                                  system_instruction: system_instruction(system),
+                                  generation_config: generation_config(json_schema, thinking)
+        end
+
+        def encode_message(message)
+          {
+            role: encode_role(message[:role]),
+            parts: [{text: message[:content]}]
+          }
+        end
+
+        def encode_role(role)
+          role == Rasti::AI::Roles::ASSISTANT ? Roles::MODEL : Roles::USER
+        end
+
+        def parse_content(response)
+          parts = response.dig('candidates', 0, 'content', 'parts') || []
+          text_part = parts.find { |part| part.key? 'text' }
+          text_part['text'] if text_part
+        end
+
+        def system_instruction(system)
+          return nil if system.nil?
+          {parts: [{text: system}]}
+        end
+
+        def generation_config(json_schema, thinking)
+          config = {}
+
+          config[:thinking_config] = thinking if thinking
+
+          if json_schema
+            config[:response_mime_type] = 'application/json'
+            config[:response_schema] = json_schema
+          end
+
+          config.empty? ? nil : config
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/huawei_maas/assistant.rb

@@ -0,0 +1,8 @@
+module Rasti
+  module AI
+    module HuaweiMaaS
+      class Assistant < Rasti::AI::OpenAI::Assistant
+      end
+    end
+  end
+end

data/lib/rasti/ai/huawei_maas/client.rb

@@ -0,0 +1,8 @@
+module Rasti
+  module AI
+    module HuaweiMaaS
+      class Client < Rasti::AI::OpenAI::Client
+      end
+    end
+  end
+end

data/lib/rasti/ai/huawei_maas/provider.rb

@@ -0,0 +1,25 @@
+module Rasti
+  module AI
+    module HuaweiMaaS
+      class Provider < Rasti::AI::OpenAI::Provider
+
+        def name
+          :huawei_maas
+        end
+
+        def default_model
+          Rasti::AI.huawei_maas_default_model
+        end
+
+        def default_api_key
+          Rasti::AI.huawei_maas_api_key
+        end
+
+        def base_url
+          'https://api-ap-southeast-1.modelarts-maas.com/v2'
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/huawei_maas/roles.rb

@@ -0,0 +1,7 @@
+module Rasti
+  module AI
+    module HuaweiMaaS
+      Roles = OpenAI::Roles
+    end
+  end
+end

data/lib/rasti/ai/open_ai/assistant.rb

@@ -5,10 +5,6 @@ module Rasti
 
         private
 
-        def build_default_client
-          Client.new
-        end
-
         def build_user_message(prompt)
           {role: Roles::USER, content: prompt}
         end

data/lib/rasti/ai/open_ai/client.rb

@@ -5,42 +5,20 @@ module Rasti
 
         def chat_completions(messages:, model:nil, tools:[], response_format:nil, reasoning_effort:nil)
           body = {
-            model: model || Rasti::AI.openai_default_model,
+            model: model || default_model,
             messages: messages,
             tools: tools,
             tool_choice: tools.empty? ? 'none' : 'auto'
           }
 
-          body[:response_format]   = response_format   unless response_format.nil?
-          body[:reasoning_effort]  = reasoning_effort  if reasoning_effort
+          body[:response_format] = response_format if response_format
+          body[:reasoning_effort] = reasoning_effort if reasoning_effort
 
           post '/chat/completions', body
         end
 
         private
 
-        def parse_usage(response)
-          usage = response['usage']
-          return unless usage
-          Usage.new(
-            provider: 'open_ai',
-            model: response['model'],
-            input_tokens: usage['prompt_tokens'],
-            output_tokens: usage['completion_tokens'],
-            cached_tokens: usage.dig('prompt_tokens_details', 'cached_tokens') || 0,
-            reasoning_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens') || 0,
-            raw: usage
-          )
-        end
-
-        def default_api_key
-          Rasti::AI.openai_api_key
-        end
-
-        def base_url
-          'https://api.openai.com/v1'
-        end
-
         def build_request(uri)
           request = super
           request['Authorization'] = "Bearer #{api_key}"
@@ -50,4 +28,4 @@ module Rasti
       end
     end
   end
-end
+end

data/lib/rasti/ai/open_ai/provider.rb

@@ -0,0 +1,74 @@
+module Rasti
+  module AI
+    module OpenAI
+      class Provider < Rasti::AI::Provider
+
+        THINKING_LEVELS = {
+          'low' => 'low'.freeze,
+          'medium' => 'medium'.freeze,
+          'high' => 'high'.freeze
+        }.freeze
+
+        def name
+          :open_ai
+        end
+
+        def default_model
+          Rasti::AI.openai_default_model
+        end
+
+        def default_api_key
+          Rasti::AI.openai_api_key
+        end
+
+        def base_url
+          'https://api.openai.com/v1'
+        end
+
+        def parse_usage(response)
+          usage = response['usage']
+          return nil unless usage
+
+          Usage.new(
+            provider: name.to_s,
+            model: response['model'],
+            input_tokens: usage['prompt_tokens'],
+            output_tokens: usage['completion_tokens'],
+            cached_tokens: usage.dig('prompt_tokens_details', 'cached_tokens') || 0,
+            reasoning_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens') || 0,
+            raw: usage
+          )
+        end
+
+        private
+
+        def request(client:, messages:, system:, model:, json_schema:, thinking:)
+          all_messages = system ? [{role: Roles::SYSTEM, content: system}] + messages : messages
+
+          client.chat_completions messages: all_messages,
+                                  model: model,
+                                  response_format: response_format(json_schema),
+                                  reasoning_effort: thinking
+        end
+
+        def encode_message(message)
+          {role: message[:role], content: message[:content]}
+        end
+
+        def parse_content(response)
+          response.dig 'choices', 0, 'message', 'content'
+        end
+
+        def response_format(json_schema)
+          return nil if json_schema.nil?
+
+          {
+            type: 'json_schema',
+            json_schema: json_schema
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/open_router/assistant.rb

@@ -0,0 +1,8 @@
+module Rasti
+  module AI
+    module OpenRouter
+      class Assistant < Rasti::AI::OpenAI::Assistant
+      end
+    end
+  end
+end

data/lib/rasti/ai/open_router/client.rb

@@ -0,0 +1,8 @@
+module Rasti
+  module AI
+    module OpenRouter
+      class Client < Rasti::AI::OpenAI::Client
+      end
+    end
+  end
+end

data/lib/rasti/ai/open_router/provider.rb

@@ -0,0 +1,25 @@
+module Rasti
+  module AI
+    module OpenRouter
+      class Provider < Rasti::AI::OpenAI::Provider
+
+        def name
+          :open_router
+        end
+
+        def default_model
+          Rasti::AI.openrouter_default_model
+        end
+
+        def default_api_key
+          Rasti::AI.openrouter_api_key
+        end
+
+        def base_url
+          'https://openrouter.ai/api/v1'
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/open_router/roles.rb

@@ -0,0 +1,7 @@
+module Rasti
+  module AI
+    module OpenRouter
+      Roles = OpenAI::Roles
+    end
+  end
+end