rasti-ai 3.0.1 → 3.2.0

data/spec/huawei_maas/client_spec.rb

@@ -0,0 +1,60 @@
+require 'minitest_helper'
+
+describe Rasti::AI::HuaweiMaaS::Client do
+
+  let(:api_url) { 'https://api-ap-southeast-1.modelarts-maas.com/v2/chat/completions' }
+
+  let(:question) { 'who is Messi?' }
+
+  let(:answer) { 'Lionel Messi is the best player ever' }
+
+  def user_message(content)
+    {role: Rasti::AI::HuaweiMaaS::Roles::USER, content: content}
+  end
+
+  it 'Basic message with correct base URL and auth header' do
+    stub_request(:post, api_url)
+      .with(
+        headers: {'Authorization' => "Bearer #{Rasti::AI.huawei_maas_api_key}"},
+        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))
+
+    client = Rasti::AI::HuaweiMaaS::Client.new
+
+    response = client.chat_completions messages: [user_message(question)]
+
+    assert_equal answer, response.dig('choices', 0, 'message', 'content')
+  end
+
+  it 'Usage tracking with provider name' do
+    stub_request(:post, api_url)
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    tracked = []
+    tracker = ->(usage) { tracked << usage }
+
+    client = Rasti::AI::HuaweiMaaS::Client.new usage_tracker: tracker
+
+    client.chat_completions messages: [user_message(question)]
+
+    assert_equal 1, tracked.count
+    assert_instance_of Rasti::AI::Usage, tracked[0]
+    assert_equal 'huawei_maas', tracked[0].provider
+  end
+
+  it 'Custom model' do
+    model = SecureRandom.uuid
+
+    stub_request(:post, api_url)
+      .with(body: read_resource('open_ai/basic_request.json', model: model, prompt: question))
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    client = Rasti::AI::HuaweiMaaS::Client.new
+
+    response = client.chat_completions messages: [user_message(question)], model: model
+
+    assert_equal answer, response.dig('choices', 0, 'message', 'content')
+  end
+
+end

data/spec/minitest_helper.rb

@@ -25,6 +25,12 @@ Rasti::AI.configure do |config|
 
   config.anthropic_api_key = 'test_anthropic_api_key'
   config.anthropic_default_model = 'claude-test'
+
+  config.openrouter_api_key = 'test_openrouter_api_key'
+  config.openrouter_default_model = 'openrouter-test'
+
+  config.huawei_maas_api_key = 'test_huawei_maas_api_key'
+  config.huawei_maas_default_model = 'huawei-test'
 end
 
 

data/spec/open_ai/provider_spec.rb

@@ -0,0 +1,101 @@
+require 'minitest_helper'
+
+describe Rasti::AI::OpenAI::Provider do
+
+  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_chat_completions(url, request_body)
+    stub_request(:post, url)
+      .with(body: JSON.dump(request_body))
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+  end
+
+  def basic_body(model)
+    {
+      model: model,
+      messages: [
+        {
+          role: 'user',
+          content: question
+        }
+      ],
+      tools: [],
+      tool_choice: 'none'
+    }
+  end
+
+  it 'Name, model and classes' do
+    provider = Rasti::AI.provider :open_ai
+
+    assert_equal :open_ai, provider.name
+    assert_equal Rasti::AI.openai_default_model, provider.model
+    assert_instance_of Rasti::AI::OpenAI::Client, provider.build_client
+    assert_instance_of Rasti::AI::OpenAI::Assistant, provider.create_assistant
+  end
+
+  it 'Generate text' do
+    stub_chat_completions 'https://api.openai.com/v1/chat/completions', basic_body(Rasti::AI.openai_default_model)
+
+    result = Rasti::AI.provider(:open_ai).generate_text prompt: question
+
+    assert_equal answer, result.content
+    assert_equal 'open_ai', result.usage.provider
+  end
+
+  it 'Generate text with json schema and thinking' do
+    json_schema = {player: 'string'}
+
+    body = basic_body(Rasti::AI.openai_default_model).merge(
+      response_format: {
+        type: 'json_schema',
+        json_schema: json_schema
+      },
+      reasoning_effort: 'low'
+    )
+
+    stub_chat_completions 'https://api.openai.com/v1/chat/completions', body
+
+    result = Rasti::AI.provider(:open_ai).generate_text prompt: question, json_schema: json_schema, thinking: 'low'
+
+    assert_equal answer, result.content
+  end
+
+  describe 'OpenAI compatible providers' do
+
+    it 'OpenRouter' do
+      provider = Rasti::AI.provider :open_router
+
+      assert_equal :open_router, provider.name
+      assert_equal Rasti::AI.openrouter_default_model, provider.model
+      assert_instance_of Rasti::AI::OpenRouter::Client, provider.build_client
+      assert_instance_of Rasti::AI::OpenRouter::Assistant, provider.create_assistant
+
+      stub_chat_completions 'https://openrouter.ai/api/v1/chat/completions', basic_body(Rasti::AI.openrouter_default_model)
+
+      result = provider.generate_text prompt: question
+
+      assert_equal answer, result.content
+      assert_equal 'open_router', result.usage.provider
+    end
+
+    it 'Huawei MaaS' do
+      provider = Rasti::AI.provider :huawei_maas
+
+      assert_equal :huawei_maas, provider.name
+      assert_equal Rasti::AI.huawei_maas_default_model, provider.model
+      assert_instance_of Rasti::AI::HuaweiMaaS::Client, provider.build_client
+      assert_instance_of Rasti::AI::HuaweiMaaS::Assistant, provider.create_assistant
+
+      stub_chat_completions 'https://api-ap-southeast-1.modelarts-maas.com/v2/chat/completions', basic_body(Rasti::AI.huawei_maas_default_model)
+
+      result = provider.generate_text prompt: question
+
+      assert_equal answer, result.content
+      assert_equal 'huawei_maas', result.usage.provider
+    end
+
+  end
+
+end

data/spec/open_router/assistant_spec.rb

@@ -0,0 +1,80 @@
+require 'minitest_helper'
+
+describe Rasti::AI::OpenRouter::Assistant do
+
+  let(:api_url) { 'https://openrouter.ai/api/v1/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.openrouter_default_model, prompt: question))
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    assistant = Rasti::AI::OpenRouter::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::OpenRouter::Roles::USER,
+                          content: question,
+                          tools: [tool],
+                          response: tool_response
+
+      stub_client_request role: Rasti::AI::OpenRouter::Roles::TOOL,
+                          content: tool_result,
+                          tools: [tool],
+                          response: basic_response(answer_with_tool)
+
+      assistant = Rasti::AI::OpenRouter::Assistant.new client: client, tools: [tool]
+
+      response = assistant.call question
+
+      assert_equal answer_with_tool, response
+
+      client.verify
+    end
+
+  end
+
+end

data/spec/open_router/client_spec.rb

@@ -0,0 +1,60 @@
+require 'minitest_helper'
+
+describe Rasti::AI::OpenRouter::Client do
+
+  let(:api_url) { 'https://openrouter.ai/api/v1/chat/completions' }
+
+  let(:question) { 'who is Messi?' }
+
+  let(:answer) { 'Lionel Messi is the best player ever' }
+
+  def user_message(content)
+    {role: Rasti::AI::OpenRouter::Roles::USER, content: content}
+  end
+
+  it 'Basic message with correct base URL and auth header' do
+    stub_request(:post, api_url)
+      .with(
+        headers: {'Authorization' => "Bearer #{Rasti::AI.openrouter_api_key}"},
+        body: read_resource('open_ai/basic_request.json', model: Rasti::AI.openrouter_default_model, prompt: question)
+      )
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    client = Rasti::AI::OpenRouter::Client.new
+
+    response = client.chat_completions messages: [user_message(question)]
+
+    assert_equal answer, response.dig('choices', 0, 'message', 'content')
+  end
+
+  it 'Usage tracking with provider name' do
+    stub_request(:post, api_url)
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    tracked = []
+    tracker = ->(usage) { tracked << usage }
+
+    client = Rasti::AI::OpenRouter::Client.new usage_tracker: tracker
+
+    client.chat_completions messages: [user_message(question)]
+
+    assert_equal 1, tracked.count
+    assert_instance_of Rasti::AI::Usage, tracked[0]
+    assert_equal 'open_router', tracked[0].provider
+  end
+
+  it 'Custom model' do
+    model = SecureRandom.uuid
+
+    stub_request(:post, api_url)
+      .with(body: read_resource('open_ai/basic_request.json', model: model, prompt: question))
+      .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+    client = Rasti::AI::OpenRouter::Client.new
+
+    response = client.chat_completions messages: [user_message(question)], model: model
+
+    assert_equal answer, response.dig('choices', 0, 'message', 'content')
+  end
+
+end

data/spec/rasti_ai_spec.rb

@@ -0,0 +1,322 @@
+require 'minitest_helper'
+
+describe Rasti::AI do
+
+  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_open_ai(model:nil, prompt:nil, content:nil)
+    stub_request(:post, 'https://api.openai.com/v1/chat/completions')
+      .with(body: read_resource('open_ai/basic_request.json', model: model || Rasti::AI.openai_default_model, prompt: prompt || question))
+      .to_return(body: read_resource('open_ai/basic_response.json', content: content || answer))
+  end
+
+  def with_default_provider(provider)
+    previous = Rasti::AI.default_provider
+    Rasti::AI.default_provider = provider
+    yield
+  ensure
+    Rasti::AI.default_provider = previous
+  end
+
+  describe 'Create assistant' do
+
+    it 'Provider' do
+      assistant = Rasti::AI.create_assistant provider: :open_ai
+
+      assert_instance_of Rasti::AI::OpenAI::Assistant, assistant
+    end
+
+    it 'Provider alias' do
+      assistant = Rasti::AI.create_assistant provider: 'openai'
+
+      assert_instance_of Rasti::AI::OpenAI::Assistant, assistant
+    end
+
+    it 'Provider and model' do
+      assistant = Rasti::AI.create_assistant provider: :anthropic, model: 'claude-sonnet-4-5'
+
+      assert_instance_of Rasti::AI::Anthropic::Assistant, assistant
+      assert_equal 'claude-sonnet-4-5', assistant.model
+    end
+
+    it 'Provider and model as single string' do
+      assistant = Rasti::AI.create_assistant model: 'gemini:gemini-2.0-flash'
+
+      assert_instance_of Rasti::AI::Gemini::Assistant, assistant
+      assert_equal 'gemini-2.0-flash', assistant.model
+    end
+
+    it 'Default provider from config' do
+      with_default_provider :anthropic do
+        assistant = Rasti::AI.create_assistant
+
+        assert_instance_of Rasti::AI::Anthropic::Assistant, assistant
+      end
+    end
+
+    it 'Explicit provider takes precedence over config' do
+      with_default_provider :anthropic do
+        assistant = Rasti::AI.create_assistant provider: :gemini
+
+        assert_instance_of Rasti::AI::Gemini::Assistant, assistant
+      end
+    end
+
+    it 'Undefined provider' do
+      with_default_provider nil do
+        error = assert_raises ArgumentError do
+          Rasti::AI.create_assistant
+        end
+
+        assert_match /\AUndefined provider/, error.message
+      end
+    end
+
+    it 'Unknown provider' do
+      assert_raises Rasti::AI::Errors::UnknownProvider do
+        Rasti::AI.create_assistant provider: :invalid
+      end
+    end
+
+    it 'Thinking, tools and json schema' do
+      assistant = Rasti::AI.create_assistant provider: :open_ai,
+                                             thinking: 'high',
+                                             tools: [GoalsByPlayer.new],
+                                             json_schema: {player: 'string'}
+
+      assert_equal 'high', assistant.thinking
+    end
+
+    it 'System' do
+      assistant = Rasti::AI.create_assistant provider: :open_ai, system: 'Act as sports journalist'
+
+      assert_equal 'Act as sports journalist', assistant.state.context
+    end
+
+    it 'State' do
+      state = Rasti::AI::AssistantState.new context: 'Act as sports journalist'
+
+      assistant = Rasti::AI.create_assistant provider: :open_ai, state: state
+
+      assert_same state, assistant.state
+    end
+
+    it 'State and system are mutually exclusive' do
+      error = assert_raises ArgumentError do
+        Rasti::AI.create_assistant provider: :open_ai, state: Rasti::AI::AssistantState.new, system: 'Act as sports journalist'
+      end
+
+      assert_equal 'Use state or system, not both', error.message
+    end
+
+    it 'Custom client' do
+      client = Rasti::AI::OpenAI::Client.new
+
+      assistant = Rasti::AI.create_assistant provider: :open_ai, client: client
+
+      stub_open_ai
+
+      assert_equal answer, assistant.call(question)
+    end
+
+    it 'Client options' do
+      stub_open_ai
+
+      tracked_usage = []
+
+      assistant = Rasti::AI.create_assistant provider: :open_ai,
+                                             api_key: 'custom_api_key',
+                                             usage_tracker: ->(usage) { tracked_usage << usage },
+                                             http_read_timeout: 120,
+                                             http_max_retries: 5
+
+      assistant.call question
+
+      assert_requested :post, 'https://api.openai.com/v1/chat/completions',
+                       headers: {'Authorization' => 'Bearer custom_api_key'}
+
+      assert_equal 1, tracked_usage.count
+      assert_equal 'open_ai', tracked_usage.first.provider
+    end
+
+  end
+
+  describe 'Provider' do
+
+    it 'Build from name' do
+      provider = Rasti::AI.provider :open_ai
+
+      assert_instance_of Rasti::AI::OpenAI::Provider, provider
+      assert_equal :open_ai, provider.name
+      assert_equal Rasti::AI.openai_default_model, provider.model
+    end
+
+    it 'Build from alias' do
+      assert_instance_of Rasti::AI::OpenRouter::Provider, Rasti::AI.provider('openrouter')
+      assert_instance_of Rasti::AI::HuaweiMaaS::Provider, Rasti::AI.provider(:huawei)
+      assert_instance_of Rasti::AI::OpenAI::Provider, Rasti::AI.provider(:OpenAI)
+    end
+
+    it 'Build from provider and model as single string' do
+      provider = Rasti::AI.provider model: 'anthropic:claude-sonnet-4-5'
+
+      assert_instance_of Rasti::AI::Anthropic::Provider, provider
+      assert_equal 'claude-sonnet-4-5', provider.model
+    end
+
+    it 'Names' do
+      assert_equal [:open_ai, :gemini, :anthropic, :open_router, :huawei_maas], Rasti::AI::Provider.names
+    end
+
+    it 'Unknown provider' do
+      error = assert_raises Rasti::AI::Errors::UnknownProvider do
+        Rasti::AI.provider :invalid
+      end
+
+      assert_equal 'Unknown provider :invalid. Valid providers: open_ai, gemini, anthropic, open_router, huawei_maas', error.message
+    end
+
+    it 'Builds client and assistant of its own provider' do
+      provider = Rasti::AI.provider :gemini
+
+      assert_instance_of Rasti::AI::Gemini::Client, provider.build_client
+      assert_instance_of Rasti::AI::Gemini::Assistant, provider.create_assistant
+    end
+
+    it 'Reusable instance' do
+      provider = Rasti::AI.provider :open_ai, api_key: 'tenant_api_key'
+
+      stub_open_ai
+
+      provider.generate_text prompt: question
+
+      assert_requested :post, 'https://api.openai.com/v1/chat/completions',
+                       headers: {'Authorization' => 'Bearer tenant_api_key'}
+
+      assert_instance_of Rasti::AI::OpenAI::Assistant, provider.create_assistant
+    end
+
+    it 'Invalid thinking level' do
+      error = assert_raises ArgumentError do
+        Rasti::AI.provider(:open_ai).generate_text prompt: question, thinking: 'invalid'
+      end
+
+      assert_equal "Invalid thinking level 'invalid'. Valid: low, medium, high", error.message
+    end
+
+  end
+
+  describe 'Generate text' do
+
+    it 'Provider' do
+      stub_open_ai
+
+      result = Rasti::AI.generate_text prompt: question, provider: :open_ai
+
+      assert_instance_of Rasti::AI::Result, result
+      assert_equal answer, result.content
+      assert_equal 'open_ai', result.usage.provider
+      assert_equal 27, result.usage.input_tokens
+      assert_equal 229, result.usage.output_tokens
+      assert_equal 'stop', result.raw['choices'][0]['finish_reason']
+    end
+
+    it 'Provider and model' do
+      stub_open_ai model: 'gpt-4o'
+
+      result = Rasti::AI.generate_text prompt: question, provider: :open_ai, model: 'gpt-4o'
+
+      assert_equal answer, result.content
+    end
+
+    it 'Provider and model as single string' do
+      stub_open_ai model: 'gpt-4o'
+
+      result = Rasti::AI.generate_text prompt: question, model: 'open_ai:gpt-4o'
+
+      assert_equal answer, result.content
+    end
+
+    it 'Default provider from config' do
+      with_default_provider :open_ai do
+        stub_open_ai
+
+        assert_equal answer, Rasti::AI.generate_text(prompt: question).content
+      end
+    end
+
+    it 'Messages with generic roles' do
+      messages = [
+        {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}
+      ]
+
+      stub_request(:post, 'https://api.openai.com/v1/chat/completions')
+        .with(body: read_resource('open_ai/conversation_request.json', model: Rasti::AI.openai_default_model, prompt: question))
+        .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+      result = Rasti::AI.generate_text messages: messages, provider: :open_ai
+
+      assert_equal answer, result.content
+    end
+
+    it 'System message inside messages' do
+      messages = [
+        {role: Rasti::AI::Roles::SYSTEM, content: 'Act as sports journalist'},
+        {role: Rasti::AI::Roles::USER, content: question}
+      ]
+
+      stub_request(:post, 'https://api.openai.com/v1/chat/completions')
+        .with(body: read_resource('open_ai/system_request.json', model: Rasti::AI.openai_default_model, system: 'Act as sports journalist', prompt: question))
+        .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+      assert_equal answer, Rasti::AI.generate_text(messages: messages, provider: :open_ai).content
+    end
+
+    it 'Prompt and messages are mutually exclusive' do
+      error = assert_raises ArgumentError do
+        Rasti::AI.generate_text prompt: question, messages: [], provider: :open_ai
+      end
+
+      assert_equal 'Use prompt or messages, not both', error.message
+    end
+
+    it 'Undefined prompt and messages' do
+      error = assert_raises ArgumentError do
+        Rasti::AI.generate_text provider: :open_ai
+      end
+
+      assert_equal 'Undefined prompt or messages', error.message
+    end
+
+    it 'System' do
+      stub_request(:post, 'https://api.openai.com/v1/chat/completions')
+        .with(body: read_resource('open_ai/system_request.json', model: Rasti::AI.openai_default_model, system: 'Act as sports journalist', prompt: question))
+        .to_return(body: read_resource('open_ai/basic_response.json', content: answer))
+
+      result = Rasti::AI.generate_text prompt: question,
+                                       provider: :open_ai,
+                                       system: 'Act as sports journalist'
+
+      assert_equal answer, result.content
+    end
+
+    it 'Usage tracker' do
+      stub_open_ai
+
+      tracked_usage = []
+
+      result = Rasti::AI.generate_text prompt: question,
+                                       provider: :open_ai,
+                                       usage_tracker: ->(usage) { tracked_usage << usage }
+
+      assert_equal 1, tracked_usage.count
+      assert_equal tracked_usage.first.to_h, result.usage.to_h
+    end
+
+  end
+
+end

data/spec/resources/open_ai/conversation_request.json

@@ -0,0 +1 @@
+{"model":"<%= model %>","messages":[{"role":"user","content":"who is the best player"},{"role":"assistant","content":"Lionel Messi"},{"role":"user","content":"<%= prompt %>"}],"tools":[],"tool_choice":"none"}

data/spec/resources/open_ai/system_request.json

@@ -0,0 +1 @@
+{"model":"<%= model %>","messages":[{"role":"system","content":"<%= system %>"},{"role":"user","content":"<%= prompt %>"}],"tools":[],"tool_choice":"none"}

data/tasks/assistant.rake

@@ -19,9 +19,11 @@ require 'logger'
 WEATHER_MCP_URL = 'https://gateway.pipeworx.io/weather/mcp'.freeze
 
 PROVIDERS = {
-  'openai'    => {key: 'OPENAI_API_KEY',    klass: -> { Rasti::AI::OpenAI::Assistant }},
-  'gemini'    => {key: 'GEMINI_API_KEY',    klass: -> { Rasti::AI::Gemini::Assistant }},
-  'anthropic' => {key: 'ANTHROPIC_API_KEY', klass: -> { Rasti::AI::Anthropic::Assistant }}
+  'openai'     => {key: 'OPENAI_API_KEY',       klass: -> { Rasti::AI::OpenAI::Assistant }},
+  'gemini'     => {key: 'GEMINI_API_KEY',       klass: -> { Rasti::AI::Gemini::Assistant }},
+  'anthropic'  => {key: 'ANTHROPIC_API_KEY',    klass: -> { Rasti::AI::Anthropic::Assistant }},
+  'openrouter' => {key: 'OPENROUTER_API_KEY',   klass: -> { Rasti::AI::OpenRouter::Assistant }},
+  'huawei_maas'=> {key: 'HUAWEI_MAAS_API_KEY',  klass: -> { Rasti::AI::HuaweiMaaS::Assistant }}
 }.freeze
 
 def build_weather_mcp