rasti-ai 3.0.1 → 3.2.0

data/lib/rasti/ai/provider.rb

@@ -0,0 +1,197 @@
+module Rasti
+  module AI
+    class Provider
+
+      MODULES = {
+        open_ai: 'OpenAI',
+        gemini: 'Gemini',
+        anthropic: 'Anthropic',
+        open_router: 'OpenRouter',
+        huawei_maas: 'HuaweiMaaS'
+      }.freeze
+
+      ALIASES = {
+        openai: :open_ai,
+        openrouter: :open_router,
+        huawei: :huawei_maas
+      }.freeze
+
+      class << self
+
+        def build(name, **options)
+          return name if name.is_a? Provider
+          provider_class(name).new(**options)
+        end
+
+        def names
+          MODULES.keys
+        end
+
+        private
+
+        def provider_class(name)
+          key = normalize name
+          key = ALIASES.fetch key, key
+
+          raise Errors::UnknownProvider.new(name, names) unless MODULES.key? key
+
+          AI.const_get(MODULES[key])::Provider
+        end
+
+        def normalize(name)
+          name.to_s.downcase.to_sym
+        end
+
+      end
+
+      attr_reader :model
+
+      def initialize(model:nil, api_key:nil, usage_tracker:nil, logger:nil,
+                     http_connect_timeout:nil, http_read_timeout:nil, http_max_retries:nil)
+
+        @model = model || default_model
+        @api_key = api_key || default_api_key
+        @usage_tracker = usage_tracker
+        @logger = logger
+        @http_connect_timeout = http_connect_timeout
+        @http_read_timeout = http_read_timeout
+        @http_max_retries = http_max_retries
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
+      def default_model
+        raise NotImplementedError
+      end
+
+      def default_api_key
+        raise NotImplementedError
+      end
+
+      def base_url
+        raise NotImplementedError
+      end
+
+      def parse_usage(response)
+        raise NotImplementedError
+      end
+
+      def build_client
+        client_class.new(
+          provider: self,
+          api_key: api_key,
+          logger: logger,
+          usage_tracker: usage_tracker,
+          http_connect_timeout: http_connect_timeout,
+          http_read_timeout: http_read_timeout,
+          http_max_retries: http_max_retries
+        )
+      end
+
+      def create_assistant(state:nil, system:nil, model:nil, tools:[], mcp_servers:{},
+                           json_schema:nil, thinking:nil, client:nil)
+
+        raise ArgumentError, 'Use state or system, not both' if state && system
+
+        state = AssistantState.new(context: system) if state.nil? && system
+
+        assistant_class.new(
+          provider: self,
+          client: client,
+          model: model || self.model,
+          state: state,
+          tools: tools,
+          mcp_servers: mcp_servers,
+          json_schema: json_schema,
+          thinking: thinking,
+          logger: logger
+        )
+      end
+
+      def generate_text(prompt:nil, messages:nil, system:nil, model:nil,
+                        json_schema:nil, thinking:nil, client:nil)
+
+        raise ArgumentError, 'Use prompt or messages, not both' if prompt && messages
+        raise ArgumentError, 'Undefined prompt or messages' if prompt.nil? && messages.nil?
+
+        system_prompt, conversation = split_system(messages || [{role: Roles::USER, content: prompt}])
+
+        client ||= build_client
+
+        response = request(
+          client: client,
+          messages: conversation.map { |message| encode_message message },
+          system: system || system_prompt,
+          model: model || self.model,
+          json_schema: json_schema,
+          thinking: thinking_config(thinking)
+        )
+
+        Result.new content: parse_content(response),
+                   usage: parse_usage(response),
+                   raw: response
+      end
+
+      private
+
+      attr_reader :api_key, :usage_tracker, :logger,
+                  :http_connect_timeout, :http_read_timeout, :http_max_retries
+
+      def provider_module
+        AI.const_get MODULES.fetch(name)
+      end
+
+      def client_class
+        provider_module::Client
+      end
+
+      def assistant_class
+        provider_module::Assistant
+      end
+
+      def split_system(messages)
+        normalized = messages.map { |message| normalize_message message }
+
+        system_messages, conversation = normalized.partition { |message| message[:role] == Roles::SYSTEM }
+
+        system_prompt = system_messages.map { |message| message[:content] }.join("\n") unless system_messages.empty?
+
+        [system_prompt, conversation]
+      end
+
+      def normalize_message(message)
+        {
+          role: (message[:role] || message['role'] || Roles::USER).to_s,
+          content: message[:content] || message['content']
+        }
+      end
+
+      def thinking_config(level)
+        return nil if level.nil?
+
+        levels = self.class::THINKING_LEVELS
+
+        raise ArgumentError, "Invalid thinking level '#{level}'. Valid: #{levels.keys.join(', ')}" unless levels.key? level
+
+        levels[level]
+      end
+
+      # --- Template methods ---
+
+      def request(client:, messages:, system:, model:, json_schema:, thinking:)
+        raise NotImplementedError
+      end
+
+      def encode_message(message)
+        raise NotImplementedError
+      end
+
+      def parse_content(response)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/rasti/ai/provider_aware.rb

@@ -0,0 +1,17 @@
+module Rasti
+  module AI
+    module ProviderAware
+
+      private
+
+      def provider
+        @provider ||= provider_module::Provider.new
+      end
+
+      def provider_module
+        Object.const_get self.class.name.split('::')[0..-2].join('::')
+      end
+
+    end
+  end
+end

data/lib/rasti/ai/result.rb

@@ -0,0 +1,11 @@
+module Rasti
+  module AI
+    class Result < Rasti::Model
+
+      attribute :content, Rasti::Types::String
+      attribute :usage
+      attribute :raw
+
+    end
+  end
+end

data/lib/rasti/ai/roles.rb

@@ -0,0 +1,11 @@
+module Rasti
+  module AI
+    module Roles
+
+      ASSISTANT = 'assistant'.freeze
+      SYSTEM = 'system'.freeze
+      USER = 'user'.freeze
+
+    end
+  end
+end

data/lib/rasti/ai/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module AI
-    VERSION = '3.0.1'
+    VERSION = '3.2.0'
   end
 end

data/lib/rasti/ai.rb

@@ -15,12 +15,17 @@ module Rasti
     extend ClassConfig
 
     require_relative 'ai/errors'
+    require_relative 'ai/roles'
     require_relative 'ai/usage'
+    require_relative 'ai/result'
     require_relative 'ai/assistant_state'
     require_relative 'ai/tool'
     require_relative 'ai/tool_serializer'
+    require_relative 'ai/provider_aware'
     require_relative 'ai/client'
     require_relative 'ai/assistant'
+    require_relative 'ai/provider'
+    require_relative_pattern 'ai/open_ai/*'
     require_relative_pattern 'ai/**/*'
 
     attr_config :logger, Logger.new(STDOUT)
@@ -29,6 +34,8 @@ module Rasti
     attr_config :http_read_timeout, 60
     attr_config :http_max_retries, 3
 
+    attr_config :default_provider, ENV['AI_DEFAULT_PROVIDER']
+
     attr_config :openai_api_key, ENV['OPENAI_API_KEY']
     attr_config :openai_default_model, ENV['OPENAI_DEFAULT_MODEL']
 
@@ -38,7 +45,100 @@ module Rasti
     attr_config :anthropic_api_key, ENV['ANTHROPIC_API_KEY']
     attr_config :anthropic_default_model, ENV['ANTHROPIC_DEFAULT_MODEL']
 
+    attr_config :openrouter_api_key, ENV['OPENROUTER_API_KEY']
+    attr_config :openrouter_default_model, ENV['OPENROUTER_DEFAULT_MODEL']
+
+    attr_config :huawei_maas_api_key, ENV['HUAWEI_MAAS_API_KEY']
+    attr_config :huawei_maas_default_model, ENV['HUAWEI_MAAS_DEFAULT_MODEL']
+
     attr_config :usage_tracker, nil
 
+    class << self
+
+      def provider(name=nil, model:nil, api_key:nil, usage_tracker:nil, logger:nil,
+                        http_connect_timeout:nil, http_read_timeout:nil, http_max_retries:nil)
+
+        build_provider(
+          name, model, api_key, usage_tracker, logger,
+          http_connect_timeout, http_read_timeout, http_max_retries
+        ).first
+      end
+
+      def create_assistant(provider:nil, model:nil, api_key:nil, usage_tracker:nil, logger:nil,
+                                http_connect_timeout:nil, http_read_timeout:nil, http_max_retries:nil,
+                                state:nil, system:nil, tools:[], mcp_servers:{}, json_schema:nil,
+                                thinking:nil, client:nil)
+
+        resolved_provider, resolved_model = build_provider(
+          provider, model, api_key, usage_tracker, logger,
+          http_connect_timeout, http_read_timeout, http_max_retries
+        )
+
+        resolved_provider.create_assistant(
+          model: resolved_model,
+          state: state,
+          system: system,
+          tools: tools,
+          mcp_servers: mcp_servers,
+          json_schema: json_schema,
+          thinking: thinking,
+          client: client
+        )
+      end
+
+      def generate_text(provider:nil, model:nil, api_key:nil, usage_tracker:nil, logger:nil,
+                            http_connect_timeout:nil, http_read_timeout:nil, http_max_retries:nil,
+                            prompt:nil, messages:nil, system:nil, json_schema:nil,
+                            thinking:nil, client:nil)
+
+        resolved_provider, resolved_model = build_provider(
+          provider, model, api_key, usage_tracker, logger,
+          http_connect_timeout, http_read_timeout, http_max_retries
+        )
+
+        resolved_provider.generate_text(
+          model: resolved_model,
+          prompt: prompt,
+          messages: messages,
+          system: system,
+          json_schema: json_schema,
+          thinking: thinking,
+          client: client
+        )
+      end
+
+      private
+
+      def build_provider(name, model, api_key, usage_tracker, logger,
+                         http_connect_timeout, http_read_timeout, http_max_retries)
+
+        name, model = split_provider_and_model name, model
+
+        resolved_provider = Provider.build name,
+                                           model: model,
+                                           api_key: api_key,
+                                           usage_tracker: usage_tracker,
+                                           logger: logger,
+                                           http_connect_timeout: http_connect_timeout,
+                                           http_read_timeout: http_read_timeout,
+                                           http_max_retries: http_max_retries
+
+        [resolved_provider, model]
+      end
+
+      def split_provider_and_model(name, model)
+        if name.nil? && model.to_s.include?(':')
+          name, model = model.split ':', 2
+        end
+
+        name ||= default_provider
+
+        raise ArgumentError, "Undefined provider. Set it with provider: or Rasti::AI.default_provider. Valid providers: #{Provider.names.join(', ')}" if name.nil?
+
+        [name, model]
+      end
+
+    end
+
   end
-end
+end

data/spec/anthropic/provider_spec.rb

@@ -0,0 +1,106 @@
+require 'minitest_helper'
+
+describe Rasti::AI::Anthropic::Provider do
+
+  let(:provider) { Rasti::AI.provider :anthropic }
+
+  let(:question) { 'How many goals has Messi scored for Barca?' }
+
+  let(:answer) { 'Lionel Messi scored 672 goals in 778 official matches for FC Barcelona.' }
+
+  def stub_messages(request_body, response_body=nil)
+    stub_request(:post, 'https://api.anthropic.com/v1/messages')
+      .with(headers: {'x-api-key' => Rasti::AI.anthropic_api_key}, body: JSON.dump(request_body))
+      .to_return(body: response_body || read_resource('anthropic/basic_response.json', content: answer))
+  end
+
+  it 'Name, model and classes' do
+    assert_equal :anthropic, provider.name
+    assert_equal Rasti::AI.anthropic_default_model, provider.model
+    assert_instance_of Rasti::AI::Anthropic::Client, provider.build_client
+    assert_instance_of Rasti::AI::Anthropic::Assistant, provider.create_assistant
+  end
+
+  it 'Generate text' do
+    stub_messages model: Rasti::AI.anthropic_default_model,
+                  max_tokens: 4096,
+                  messages: [
+                    {
+                      role: 'user',
+                      content: question
+                    }
+                  ]
+
+    result = provider.generate_text prompt: question
+
+    assert_equal answer, result.content
+    assert_equal 'anthropic', result.usage.provider
+    assert_equal 'end_turn', result.raw['stop_reason']
+  end
+
+  it 'Generate text with system, thinking and model override' do
+    stub_messages model: 'claude-sonnet-4-5',
+                  max_tokens: 4096,
+                  messages: [
+                    {
+                      role: 'user',
+                      content: question
+                    }
+                  ],
+                  thinking: {type: 'enabled', budget_tokens: 16_000},
+                  system: 'Act as sports journalist'
+
+    result = provider.generate_text prompt: question,
+                                    model: 'claude-sonnet-4-5',
+                                    system: 'Act as sports journalist',
+                                    thinking: 'high'
+
+    assert_equal answer, result.content
+  end
+
+  it 'Generate text with json schema' do
+    json_schema = {player: 'string'}
+
+    structured_response = {
+      'content' => [
+        {
+          'type' => 'tool_use',
+          'id' => 'toolu_1',
+          'name' => 'structured_output',
+          'input' => {'player' => 'Lionel Messi'}
+        }
+      ],
+      'stop_reason' => 'tool_use'
+    }
+
+    stub_messages(
+      {
+        model: Rasti::AI.anthropic_default_model,
+        max_tokens: 4096,
+        messages: [
+          {
+            role: 'user',
+            content: question
+          }
+        ],
+        tools: [
+          {
+            name: 'structured_output',
+            description: 'Return the structured response',
+            input_schema: {
+              type: 'object',
+              properties: json_schema
+            }
+          }
+        ],
+        tool_choice: {type: 'tool', name: 'structured_output'}
+      },
+      JSON.dump(structured_response)
+    )
+
+    result = provider.generate_text prompt: question, json_schema: json_schema
+
+    assert_equal '{"player":"Lionel Messi"}', result.content
+  end
+
+end

data/spec/gemini/provider_spec.rb

@@ -0,0 +1,90 @@
+require 'minitest_helper'
+
+describe Rasti::AI::Gemini::Provider do
+
+  let(:provider) { Rasti::AI.provider :gemini }
+
+  let(:question) { 'How many goals has Messi scored for Barca?' }
+
+  let(:answer) { 'Lionel Messi scored 672 goals in 778 official matches for FC Barcelona.' }
+
+  def api_url(model:nil)
+    "https://generativelanguage.googleapis.com/v1beta/models/#{model || Rasti::AI.gemini_default_model}:generateContent?key=#{Rasti::AI.gemini_api_key}"
+  end
+
+  def stub_generate_content(request_body)
+    stub_request(:post, api_url)
+      .with(body: JSON.dump(request_body))
+      .to_return(body: read_resource('gemini/basic_response.json', content: answer))
+  end
+
+  it 'Name, model and classes' do
+    assert_equal :gemini, provider.name
+    assert_equal Rasti::AI.gemini_default_model, provider.model
+    assert_instance_of Rasti::AI::Gemini::Client, provider.build_client
+    assert_instance_of Rasti::AI::Gemini::Assistant, provider.create_assistant
+  end
+
+  it 'Generate text' do
+    stub_generate_content contents: [
+      {
+        role: 'user',
+        parts: [{text: question}]
+      }
+    ]
+
+    result = provider.generate_text prompt: question
+
+    assert_equal answer, result.content
+    assert_equal 'gemini', result.usage.provider
+    assert_equal 'gemini-test', result.raw['modelVersion']
+  end
+
+  it 'Generate text with generic roles and system' do
+    stub_generate_content contents: [
+                            {
+                              role: 'user',
+                              parts: [{text: 'who is the best player'}]
+                            },
+                            {
+                              role: 'model',
+                              parts: [{text: 'Lionel Messi'}]
+                            },
+                            {
+                              role: 'user',
+                              parts: [{text: question}]
+                            }
+                          ],
+                          system_instruction: {
+                            parts: [{text: 'Act as sports journalist'}]
+                          }
+
+    messages = [
+      {role: Rasti::AI::Roles::SYSTEM, content: 'Act as sports journalist'},
+      {role: Rasti::AI::Roles::USER, content: 'who is the best player'},
+      {role: Rasti::AI::Roles::ASSISTANT, content: 'Lionel Messi'},
+      {role: Rasti::AI::Roles::USER, content: question}
+    ]
+
+    assert_equal answer, provider.generate_text(messages: messages).content
+  end
+
+  it 'Generate text with json schema and thinking' do
+    json_schema = {type: 'object', properties: {player: {type: 'string'}}}
+
+    stub_generate_content contents: [
+                            {
+                              role: 'user',
+                              parts: [{text: question}]
+                            }
+                          ],
+                          generation_config: {
+                            thinking_config: {thinking_budget: 8_192},
+                            response_mime_type: 'application/json',
+                            response_schema: json_schema
+                          }
+
+    assert_equal answer, provider.generate_text(prompt: question, json_schema: json_schema, thinking: 'medium').content
+  end
+
+end

data/spec/huawei_maas/assistant_spec.rb

@@ -0,0 +1,80 @@
+require 'minitest_helper'
+
+describe Rasti::AI::HuaweiMaaS::Assistant do
+
+  let(:api_url) { 'https://api-ap-southeast-1.modelarts-maas.com/v2/chat/completions' }
+
+  let(:question) { 'How many goals has Messi scored for Barca?' }
+
+  let(:answer) { 'Lionel Messi scored 672 goals in 778 official matches for FC Barcelona.' }
+
+  it 'Default' do
+    stub_request(:post, api_url)
+      .with(body: read_resource('open_ai/basic_request.json', model: Rasti::AI.huawei_maas_default_model, prompt: question))
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    assistant = Rasti::AI::HuaweiMaaS::Assistant.new
+
+    response = assistant.call question
+
+    assert_equal answer, response
+  end
+
+  describe 'Tools' do
+
+    let(:client) { Minitest::Mock.new }
+
+    let(:tool_response) do
+      read_json_resource(
+        'open_ai/tool_response.json',
+        name: 'goals_by_player',
+        arguments: {player: 'Lionel Messi', team: 'Barcelona'}
+      )
+    end
+
+    let(:tool_result) { '672' }
+
+    let(:answer_with_tool) { 'Lionel Messi scored 672 goals for FC Barcelona.' }
+
+    def basic_response(content)
+      read_json_resource('open_ai/basic_response.json', content: content)
+    end
+
+    def stub_client_request(role:, content:, response:, tools:[])
+      serialized_tools = tools.map do |tool|
+        {type: 'function', function: Rasti::AI::ToolSerializer.serialize(tool.class)}
+      end
+
+      client.expect :chat_completions, response do |params|
+        last_message = params[:messages].last
+        last_message[:role] == role &&
+          last_message[:content] == content &&
+          params[:tools] == serialized_tools
+      end
+    end
+
+    it 'Call tool' do
+      tool = GoalsByPlayer.new
+
+      stub_client_request role: Rasti::AI::HuaweiMaaS::Roles::USER,
+                          content: question,
+                          tools: [tool],
+                          response: tool_response
+
+      stub_client_request role: Rasti::AI::HuaweiMaaS::Roles::TOOL,
+                          content: tool_result,
+                          tools: [tool],
+                          response: basic_response(answer_with_tool)
+
+      assistant = Rasti::AI::HuaweiMaaS::Assistant.new client: client, tools: [tool]
+
+      response = assistant.call question
+
+      assert_equal answer_with_tool, response
+
+      client.verify
+    end
+
+  end
+
+end