active_genie 0.0.24 → 0.0.25

data/lib/active_genie/battle/basic.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../clients/unified_client'
-
-module ActiveGenie::Battle
-  # The Basic class provides a foundation for evaluating battles between two players
-  # using AI-powered evaluation. It determines a winner based on specified criteria,
-  # analyzing how well each player meets the requirements.
-  #
-  # The battle evaluation process compares two players' content against given criteria
-  # and returns detailed feedback including the winner and reasoning for the decision.
-  #
-  # @example Basic usage with two players and criteria
-  #   Basic.call("Player A content", "Player B content", "Evaluate keyword usage and pattern matching")
-  #
-  class Basic
-    def self.call(...)
-      new(...).call
-    end
-
-    # @param player_1 [String] The content or submission from the first player
-    # @param player_2 [String] The content or submission from the second player
-    # @param criteria [String] The evaluation criteria or rules to assess against
-    # @param config [Hash] Additional configuration options that modify the battle evaluation behavior
-    # @return [Hash] The evaluation result containing the winner and reasoning
-    #   @return [String] :winner The winner, either player_1 or player_2
-    #   @return [String] :reasoning Detailed explanation of why the winner was chosen
-    #   @return [String] :what_could_be_changed_to_avoid_draw A suggestion on how to avoid a draw
-    def initialize(player_1, player_2, criteria, config: {})
-      @player_1 = player_1
-      @player_2 = player_2
-      @criteria = criteria
-      @config = ActiveGenie::Configuration.to_h(config)
-    end
-
-    def call
-      messages = [
-        {  role: 'system', content: PROMPT },
-        {  role: 'user', content: "criteria: #{@criteria}" },
-        {  role: 'user', content: "player_1: #{@player_1}" },
-        {  role: 'user', content: "player_2: #{@player_2}" },
-      ]
-
-      response = ::ActiveGenie::Clients::UnifiedClient.function_calling(
-        messages,
-        FUNCTION,
-        model_tier: 'lower_tier',
-        config: @config
-      )
-
-      ActiveGenie::Logger.debug({
-        code: :battle,
-        player_1: @player_1[0..30],
-        player_2: @player_2[0..30],
-        criteria: @criteria[0..30],
-        winner: response['impartial_judge_winner'],
-        reasoning: response['impartial_judge_winner_reasoning']
-      })
-
-      response_formatted(response)
-    end
-
-    private
-
-    def response_formatted(response)
-      winner = response['impartial_judge_winner']
-      loser = case response['impartial_judge_winner']
-              when 'player_1' then 'player_2'
-              when 'player_2' then 'player_1'
-              end
-
-      { 'winner' => winner, 'loser' => loser, 'reasoning' => response['impartial_judge_winner_reasoning'] }
-    end
-
-    PROMPT = <<~PROMPT
-    Based on two players, player_1 and player_2, they will battle against each other based on criteria. Criteria are vital as they provide a clear metric to compare the players. Follow these criteria strictly.
-
-    # Steps
-    1. player_1 presents their strengths and how they meet the criteria. Max of 100 words.
-    2. player_2 presents their strengths and how they meet the criteria. Max of 100 words.
-    3. player_1 argues why they should be the winner compared to player_2. Max of 100 words.
-    4. player_2 counter-argues why they should be the winner compared to player_1. Max of 100 words.
-    5. The impartial judge chooses the winner.
-
-    # Output Format
-    - The impartial judge chooses this player as the winner.
-
-    # Notes
-    - Avoid resulting in a draw. Use reasoning or make fair assumptions if needed.
-    - Critically assess each player's adherence to the criteria.
-    - Clearly communicate the reasoning behind your decision.
-    PROMPT
-
-    FUNCTION =  {
-      name: 'battle_evaluation',
-      description: 'Evaluate a battle between player_1 and player_2 using predefined criteria and identify the winner.',
-      parameters: {
-        type: "object",
-        properties: {
-          player_1_sell_himself: {
-            type: 'string',
-            description: 'player_1 presents their strengths and how they meet the criteria. Max of 100 words.',
-          },
-          player_2_sell_himself: {
-            type: 'string',
-            description: 'player_2 presents their strengths and how they meet the criteria. Max of 100 words.',
-          },
-          player_1_arguments: {
-            type: 'string',
-            description: 'player_1 arguments for why they should be the winner compared to player_2. Max of 100 words.',
-          },
-          player_2_counter: {
-            type: 'string',
-            description: 'player_2 counter arguments for why they should be the winner compared to player_1. Max of 100 words.',
-          },
-          impartial_judge_winner_reasoning: {
-            type: 'string',
-            description: 'The detailed reasoning about why the impartial judge chose the winner. Max of 100 words.',
-          },
-          impartial_judge_winner: {
-            type: 'string',
-            description: 'Who is the winner based on the impartial judge reasoning?',
-            enum: ['player_1', 'player_2']
-          },
-        }
-      }
-    }
-  end
-end

data/lib/active_genie/clients/anthropic_client.rb

@@ -1,84 +0,0 @@
-require 'json'
-require 'net/http'
-require 'uri'
-require_relative './helpers/retry'
-require_relative './base_client'
-
-module ActiveGenie::Clients
-  # Client for interacting with the Anthropic (Claude) API with json response
-  class AnthropicClient < BaseClient
-    class AnthropicError < ClientError; end
-    class RateLimitError < AnthropicError; end
-
-    ANTHROPIC_VERSION = '2023-06-01'
-    ANTHROPIC_ENDPOINT = '/v1/messages'
-
-    def initialize(config)
-      super(config)
-    end
-
-    # Requests structured JSON output from the Anthropic Claude model based on a schema.
-    #
-    # @param messages [Array<Hash>] A list of messages representing the conversation history.
-    #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
-    #   Claude uses 'user', 'assistant', and 'system' roles.
-    # @param function [Hash] A JSON schema definition describing the desired output format.
-    # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
-    # @param config [Hash] Optional configuration overrides:
-    #   - :api_key [String] Override the default API key.
-    #   - :model [String] Override the model name directly.
-    #   - :max_retries [Integer] Max retries for the request.
-    #   - :retry_delay [Integer] Initial delay for retries.
-    #   - :anthropic_version [String] Override the default Anthropic API version.
-    # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
-    def function_calling(messages, function, model_tier: nil, config: {})
-      model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
-
-      system_message = messages.find { |m| m[:role] == 'system' }&.dig(:content) || ''
-      user_messages = messages.select { |m| m[:role] == 'user' || m[:role] == 'assistant' }
-        .map { |m| { role: m[:role], content: m[:content] } }
-
-      anthropic_function = function.dup
-      anthropic_function[:input_schema] = function[:parameters]
-      anthropic_function.delete(:parameters)
-
-      payload = {
-        model:,
-        system: system_message,
-        messages: user_messages,
-        tools: [anthropic_function],
-        tool_choice: { name: anthropic_function[:name], type: 'tool' },
-        max_tokens: config[:runtime][:max_tokens],
-        temperature: config[:runtime][:temperature] || 0,
-      }
-
-      api_key = config[:runtime][:api_key] || @app_config.api_key
-      headers = {
-        'x-api-key': api_key,
-        'anthropic-version': config[:anthropic_version] || ANTHROPIC_VERSION
-      }.compact
-
-      retry_with_backoff(config:) do
-        start_time = Time.now
-        
-        response = post(ANTHROPIC_ENDPOINT, payload, headers: headers, config: config)
-        
-        content = response.dig('content', 0, 'input')
-        
-        ActiveGenie::Logger.trace({
-          code: :llm_usage,
-          input_tokens: response.dig('usage', 'input_tokens'),
-          output_tokens: response.dig('usage', 'output_tokens'),
-          total_tokens: response.dig('usage', 'input_tokens') + response.dig('usage', 'output_tokens'),
-          model: payload[:model],
-          duration: Time.now - start_time,
-          usage: response.dig('usage')
-        })
-
-        ActiveGenie::Logger.trace({code: :function_calling, payload:, parsed_response: content})
-      
-        content
-      end
-    end
-  end
-end

data/lib/active_genie/clients/google_client.rb

@@ -1,135 +0,0 @@
-require 'json'
-require 'net/http'
-require 'uri'
-require_relative './helpers/retry'
-require_relative './base_client'
-
-module ActiveGenie::Clients
-  # Client for interacting with the Google Generative Language API.
-  class GoogleClient < BaseClient
-    class GoogleError < ClientError; end
-    class RateLimitError < GoogleError; end
-
-    API_VERSION_PATH = '/v1beta/models'.freeze
-
-    def initialize(config)
-      super(config)
-    end
-
-    # Requests structured JSON output from the Google Generative Language model based on a schema.
-    #
-    # @param messages [Array<Hash>] A list of messages representing the conversation history.
-    #   Each hash should have :role ('user' or 'model') and :content (String).
-    #   Google Generative Language uses 'user' and 'model' roles.
-    # @param function [Hash] A JSON schema definition describing the desired output format.
-    # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
-    # @param config [Hash] Optional configuration overrides:
-    #   - :api_key [String] Override the default API key.
-    #   - :model [String] Override the model name directly.
-    #   - :max_retries [Integer] Max retries for the request.
-    #   - :retry_delay [Integer] Initial delay for retries.
-    # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
-    def function_calling(messages, function, model_tier: nil, config: {})
-      model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
-      api_key = config[:runtime][:api_key] || @app_config.api_key
-
-      contents = convert_messages_to_contents(messages, function)
-      contents << output_as_json_schema(function)
-
-      payload = {
-        contents: contents,
-        generationConfig: {
-          response_mime_type: "application/json",
-          temperature: 0.1
-        }
-      }
-
-      endpoint = "#{API_VERSION_PATH}/#{model}:generateContent"
-      params = { key: api_key }
-      headers = DEFAULT_HEADERS
-
-      retry_with_backoff(config:) do
-        start_time = Time.now
-        
-        response = post(endpoint, payload, headers:, params:, config: config)
-        
-        json_string = response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
-        return nil if json_string.nil? || json_string.empty?
-
-        begin
-          parsed_response = JSON.parse(json_string)
-          
-          # Log usage metrics
-          usage_metadata = response['usageMetadata'] || {}
-          prompt_tokens = usage_metadata['promptTokenCount'] || 0
-          candidates_tokens = usage_metadata['candidatesTokenCount'] || 0
-          total_tokens = usage_metadata['totalTokenCount'] || (prompt_tokens + candidates_tokens)
-
-          ActiveGenie::Logger.trace({
-            code: :llm_usage,
-            input_tokens: prompt_tokens,
-            output_tokens: candidates_tokens,
-            total_tokens: total_tokens,
-            model: model,
-            duration: Time.now - start_time,
-            usage: usage_metadata
-          })
-          
-          ActiveGenie::Logger.trace({ code: :function_calling, payload:, parsed_response: })
-          
-          normalize_function_output(parsed_response)
-        rescue JSON::ParserError => e
-          raise GoogleError, "Failed to parse Google API response: #{e.message} - Content: #{json_string}"
-        end
-      end
-    end
-
-    private
-
-    def normalize_function_output(output)
-      output = if output.is_a?(Array)
-        output.dig(0, 'properties') || output.dig(0)
-      else
-        output
-      end
-
-      output.dig('input_schema', 'properties') || output
-    end
-
-    ROLE_TO_GOOGLE_ROLE = {
-      user: 'user',
-      assistant: 'model',
-    }.freeze
-
-    # Converts standard message format to Google's 'contents' format
-    # and injects JSON schema instructions.
-    # @param messages [Array<Hash>] Array of { role: 'user'/'assistant'/'system', content: '...' }
-    # @param function_schema [Hash] The JSON schema for the desired output.
-    # @return [Array<Hash>] Array formatted for Google's 'contents' field.
-    def convert_messages_to_contents(messages, function_schema)
-      messages.map do |message|
-        {
-          role: ROLE_TO_GOOGLE_ROLE[message[:role].to_sym] || 'user',
-          parts: [{ text: message[:content] }]
-        }
-      end
-    end
-
-    def output_as_json_schema(function_schema)
-      json_instruction = <<~PROMPT
-        Generate a JSON object that strictly adheres to the following JSON schema:
-
-        ```json
-        #{JSON.pretty_generate(function_schema[:parameters])}
-        ```
-
-        IMPORTANT: Only output the raw JSON object. Do not include any other text, explanations, or markdown formatting like ```json ... ``` wrappers around the final output.
-      PROMPT
-
-      {
-        role: 'user',
-        parts: [{ text: json_instruction }]
-      }
-    end
-  end
-end

data/lib/active_genie/clients/helpers/retry.rb

@@ -1,29 +0,0 @@
-MAX_RETRIES = 3
-BASE_DELAY = 0.5
-
-def retry_with_backoff(config: {})
-  retries = config[:runtime][:max_retries] || MAX_RETRIES
-
-  begin
-    yield
-  rescue => e
-    if retries > 0
-      ActiveGenie::Logger.warn({ code: :retry_with_backoff, message: "Retrying request after error: #{e.message}. Attempts remaining: #{retries}" })
-
-      retries -= 1
-      backoff_time = calculate_backoff(MAX_RETRIES - retries)
-      sleep(backoff_time)
-      retry
-    else
-      raise
-    end
-  end
-end
-
-def calculate_backoff(retry_count)
-  # Exponential backoff with jitter: 2^retry_count + random jitter
-  # Base delay is 0.5 seconds, doubles each retry, plus up to 0.5 seconds of random jitter
-  # Simplified example: 0.5, 1, 2, 4, 8, 12, 16, 20, 24, 28, 30 seconds
-  jitter = rand * BASE_DELAY
-  [BASE_DELAY * (2 ** retry_count) + jitter, 30].min # Cap at 30 seconds
-end

data/lib/active_genie/clients/openai_client.rb

@@ -1,98 +0,0 @@
-require 'json'
-require 'net/http'
-
-require_relative './helpers/retry'
-require_relative './base_client'
-
-module ActiveGenie::Clients
-  class OpenaiClient < BaseClient
-    class OpenaiError < ClientError; end
-    class RateLimitError < OpenaiError; end
-    class InvalidResponseError < StandardError; end
-
-    def initialize(config)
-      super(config)
-    end
-
-    # Requests structured JSON output from the OpenAI model based on a schema.
-    #
-    # @param messages [Array<Hash>] A list of messages representing the conversation history.
-    #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
-    # @param function [Hash] A JSON schema definition describing the desired output format.
-    # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
-    # @param config [Hash] Optional configuration overrides:
-    #   - :api_key [String] Override the default API key.
-    #   - :model [String] Override the model name directly.
-    #   - :max_retries [Integer] Max retries for the request.
-    #   - :retry_delay [Integer] Initial delay for retries.
-    # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
-    def function_calling(messages, function, model_tier: nil, config: {})
-      model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
-
-      payload = {
-        messages:,
-        tools: [{
-          type: 'function',
-          function: {
-            **function,
-            parameters: {
-              **function[:parameters],
-              additionalProperties: false
-            },
-            strict: true
-          }.compact
-        }],
-        tool_choice: { type: 'function', function: { name: function[:name] } },
-        stream: false,
-        model:,
-      }
-
-      api_key = config[:runtime][:api_key] || @app_config.api_key
-      headers = {
-        'Authorization': "Bearer #{api_key}"
-      }.compact
-
-      retry_with_backoff(config:) do
-        response = request_openai(payload, headers, config:)
-
-        parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
-        parsed_response = parsed_response.dig('message') || parsed_response
-
-        raise InvalidResponseError, "Invalid response: #{parsed_response}" if parsed_response.nil? || parsed_response.keys.size.zero?
-
-        ActiveGenie::Logger.trace({code: :function_calling, payload:, parsed_response: })
-
-        parsed_response
-      end
-    end
-
-
-    private
-
-    # Make a request to the OpenAI API
-    #
-    # @param payload [Hash] The request payload
-    # @param headers [Hash] Additional headers
-    # @param config [Hash] Configuration options
-    # @return [Hash] The parsed response
-    def request_openai(payload, headers, config:)
-      start_time = Time.now
-
-      response = post("/chat/completions", payload, headers: headers, config: config)
-
-      return nil if response.nil?
-
-      ActiveGenie::Logger.trace({
-        code: :llm_usage,
-        input_tokens: response.dig('usage', 'prompt_tokens'),
-        output_tokens: response.dig('usage', 'completion_tokens'),
-        total_tokens: response.dig('usage', 'total_tokens'),
-        model: payload[:model],
-        duration: Time.now - start_time,
-        usage: response.dig('usage')
-      })
-
-      response
-    end
-  end
-end

data/lib/active_genie/configuration/log_config.rb

@@ -1,14 +0,0 @@
-
-module ActiveGenie::Configuration
-  class LogConfig
-    attr_writer :log_level
-
-    def log_level
-      @log_level ||= :info
-    end
-
-    def to_h(config = {})
-      { log_level: }.merge(config)
-    end
-  end
-end

data/lib/active_genie/configuration/providers/anthropic_config.rb

@@ -1,54 +0,0 @@
-require_relative '../../clients/anthropic_client'
-require_relative './base_config'
-
-module ActiveGenie
-  module Configuration::Providers
-    # Configuration class for the Anthropic API client.
-    # Manages API keys, URLs, model selections, and client instantiation.
-    class AnthropicConfig < BaseConfig
-      NAME = :anthropic
-
-      # Retrieves the API key.
-      # Falls back to the ANTHROPIC_API_KEY environment variable if not set.
-      # @return [String, nil] The API key.
-      def api_key
-        @api_key || ENV['ANTHROPIC_API_KEY']
-      end
-
-      # Retrieves the base API URL for Anthropic API.
-      # Defaults to 'https://api.anthropic.com'.
-      # @return [String] The API base URL.
-      def api_url
-        @api_url || 'https://api.anthropic.com'
-      end
-
-      # Lazily initializes and returns an instance of the AnthropicClient.
-      # Passes itself (the config object) to the client's constructor.
-      # @return [ActiveGenie::Clients::AnthropicClient] The client instance.
-      def client
-        @client ||= ::ActiveGenie::Clients::AnthropicClient.new(self)
-      end
-
-      # Retrieves the model name designated for the lower tier (e.g., cost-effective, faster).
-      # Defaults to 'claude-3-haiku'.
-      # @return [String] The lower tier model name.
-      def lower_tier_model
-        @lower_tier_model || 'claude-3-5-haiku-20241022'
-      end
-
-      # Retrieves the model name designated for the middle tier (e.g., balanced performance).
-      # Defaults to 'claude-3-sonnet'.
-      # @return [String] The middle tier model name.
-      def middle_tier_model
-        @middle_tier_model || 'claude-3-7-sonnet-20250219'
-      end
-
-      # Retrieves the model name designated for the upper tier (e.g., most capable).
-      # Defaults to 'claude-3-opus'.
-      # @return [String] The upper tier model name.
-      def upper_tier_model
-        @upper_tier_model || 'claude-3-opus-20240229'
-      end
-    end
-  end
-end

data/lib/active_genie/configuration/providers/base_config.rb

@@ -1,85 +0,0 @@
-module ActiveGenie
-  module Configuration::Providers
-    class BaseConfig
-      NAME = :unknown
-
-      attr_writer :api_key, :organization, :api_url, :client,
-        :lower_tier_model, :middle_tier_model, :upper_tier_model
-
-      # Maps a symbolic tier (:lower_tier, :middle_tier, :upper_tier) to a specific model name.
-      # Falls back to the lower_tier_model if the tier is nil or unrecognized.
-      # @param tier [Symbol, String, nil] The symbolic tier name.
-      # @return [String] The corresponding model name.
-      def tier_to_model(tier)
-        {
-          lower_tier: lower_tier_model,
-          middle_tier: middle_tier_model,
-          upper_tier: upper_tier_model
-        }[tier&.to_sym] || lower_tier_model
-      end
-
-      # Returns a hash representation of the configuration.
-      # @param config [Hash] Additional key-value pairs to merge into the hash.
-      # @return [Hash] The configuration settings as a hash.
-      def to_h(config = {})
-        {
-          name: NAME,
-          api_key:,
-          api_url:,
-          lower_tier_model:,
-          middle_tier_model:,
-          upper_tier_model:,
-          **config
-        }
-      end
-
-      # Validates the configuration.
-      # @return [Boolean] True if the configuration is valid, false otherwise.
-      def valid?
-        api_key && api_url
-      end
-
-      # Retrieves the API key.
-      # Falls back to the OPENAI_API_KEY environment variable if not set.
-      # @return [String, nil] The API key.
-      def api_key
-        raise NotImplementedError, "Subclasses must implement this method"
-      end
-
-      # Retrieves the base API URL for OpenAI API.
-      # Defaults to 'https://api.openai.com/v1'.
-      # @return [String] The API base URL.
-      def api_url
-        raise NotImplementedError, "Subclasses must implement this method"
-      end
-
-      # Lazily initializes and returns an instance of the OpenaiClient.
-      # Passes itself (the config object) to the client's constructor.
-      # @return [ActiveGenie::Clients::OpenaiClient] The client instance.
-      def client
-        raise NotImplementedError, "Subclasses must implement this method"
-      end
-
-      # Retrieves the model name designated for the lower tier (e.g., cost-effective, faster).
-      # Defaults to 'gpt-4o-mini'.
-      # @return [String] The lower tier model name.
-      def lower_tier_model
-        raise NotImplementedError, "Subclasses must implement this method"
-      end
-
-      # Retrieves the model name designated for the middle tier (e.g., balanced performance).
-      # Defaults to 'gpt-4o'.
-      # @return [String] The middle tier model name.
-      def middle_tier_model
-        raise NotImplementedError, "Subclasses must implement this method"
-      end
-
-      # Retrieves the model name designated for the upper tier (e.g., most capable).
-      # Defaults to 'o1-preview'.
-      # @return [String] The upper tier model name.
-      def upper_tier_model
-        raise NotImplementedError, "Subclasses must implement this method"
-      end
-    end
-  end
-end

data/lib/active_genie/configuration/providers/deepseek_config.rb

@@ -1,54 +0,0 @@
-require_relative '../../clients/openai_client'
-require_relative './base_config'
-
-module ActiveGenie
-  module Configuration::Providers
-    # Configuration class for the DeepSeek API client.
-    # Manages API keys, organization IDs, URLs, model selections, and client instantiation.
-    class DeepseekConfig < BaseConfig
-      NAME = :deepseek
-
-      # Retrieves the API key.
-      # Falls back to the DEEPSEEK_API_KEY environment variable if not set.
-      # @return [String, nil] The API key.
-      def api_key
-        @api_key || ENV['DEEPSEEK_API_KEY']
-      end
-
-      # Retrieves the base API URL for DeepSeek API.
-      # Defaults to 'https://api.deepseek.com/v1'.
-      # @return [String] The API base URL.
-      def api_url
-        @api_url || 'https://api.deepseek.com/v1'
-      end
-
-      # Lazily initializes and returns an instance of the OpenaiClient.
-      # Passes itself (the config object) to the client's constructor.
-      # @return [ActiveGenie::Clients::OpenaiClient] The client instance.
-      def client
-        @client ||= ::ActiveGenie::Clients::OpenaiClient.new(self)
-      end
-
-      # Retrieves the model name designated for the lower tier (e.g., cost-effective, faster).
-      # Defaults to 'deepseek-chat'.
-      # @return [String] The lower tier model name.
-      def lower_tier_model
-        @lower_tier_model || 'deepseek-chat'
-      end
-
-      # Retrieves the model name designated for the middle tier (e.g., balanced performance).
-      # Defaults to 'deepseek-chat'.
-      # @return [String] The middle tier model name.
-      def middle_tier_model
-        @middle_tier_model || 'deepseek-chat'
-      end
-
-      # Retrieves the model name designated for the upper tier (e.g., most capable).
-      # Defaults to 'deepseek-reasoner'.
-      # @return [String] The upper tier model name.
-      def upper_tier_model
-        @upper_tier_model || 'deepseek-reasoner'
-      end
-    end
-  end
-end