rasti-ai 3.1.0 → 3.2.0

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/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/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"}