raif 1.0.0 → 1.2.0

data/lib/raif.rb

@@ -6,8 +6,14 @@ require "raif/engine"
 require "raif/configuration"
 require "raif/errors"
 require "raif/utils"
-require "raif/default_llms"
+require "raif/llm_registry"
+require "raif/embedding_model_registry"
+require "raif/json_schema_builder"
+require "raif/migration_checker"
+
 require "faraday"
+require "event_stream_parser"
+require "json-schema"
 require "loofah"
 require "pagy"
 require "reverse_markdown"
@@ -16,7 +22,6 @@ require "turbo-rails"
 module Raif
   class << self
     attr_accessor :configuration
-    attr_accessor :llm_registry
 
     attr_writer :logger
   end
@@ -32,34 +37,4 @@ module Raif
   def self.logger
     @logger ||= Rails.logger
   end
-
-  def self.register_llm(llm_class, llm_config)
-    llm = llm_class.new(**llm_config)
-
-    unless llm.valid?
-      raise ArgumentError, "The LLM you tried to register is invalid: #{llm.errors.full_messages.join(", ")}"
-    end
-
-    @llm_registry ||= {}
-    @llm_registry[llm.key] = llm_config.merge(llm_class: llm_class)
-  end
-
-  def self.llm(model_key)
-    llm_config = llm_registry[model_key]
-
-    if llm_config.nil?
-      raise ArgumentError, "No LLM found for model key: #{model_key}. Available models: #{available_llm_keys.join(", ")}"
-    end
-
-    llm_class = llm_config[:llm_class]
-    llm_class.new(**llm_config.except(:llm_class))
-  end
-
-  def self.available_llms
-    llm_registry.values
-  end
-
-  def self.available_llm_keys
-    llm_registry.keys
-  end
 end

data/lib/tasks/raif_tasks.rake

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-# desc "Explaining what the task does"
-# task :raif do
-#   # Task goes here
-# end
+namespace :raif do
+  namespace :install do
+    desc "Copy migrations from Raif to host application"
+    task :migrations do
+      ENV["FROM"] = "raif"
+      Rake::Task["railties:install:migrations"].invoke
+    end
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: raif
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ben Roesch
 - Brian Leslie
 bindir: bin
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-bedrock
+  name: aws-sdk-bedrockruntime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-bedrockruntime
+  name: event_stream_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -157,6 +157,7 @@ files:
 - app/assets/javascript/raif/stream_actions/raif_scroll_to_bottom.js
 - app/assets/stylesheets/raif.scss
 - app/assets/stylesheets/raif/admin/conversation.scss
+- app/assets/stylesheets/raif/admin/stats.scss
 - app/assets/stylesheets/raif/loader.scss
 - app/assets/stylesheets/raif_admin.scss
 - app/controllers/raif/admin/agents_controller.rb
@@ -164,6 +165,8 @@ files:
 - app/controllers/raif/admin/conversations_controller.rb
 - app/controllers/raif/admin/model_completions_controller.rb
 - app/controllers/raif/admin/model_tool_invocations_controller.rb
+- app/controllers/raif/admin/stats/tasks_controller.rb
+- app/controllers/raif/admin/stats_controller.rb
 - app/controllers/raif/admin/tasks_controller.rb
 - app/controllers/raif/application_controller.rb
 - app/controllers/raif/conversation_entries_controller.rb
@@ -182,19 +185,47 @@ files:
 - app/models/raif/concerns/has_llm.rb
 - app/models/raif/concerns/has_requested_language.rb
 - app/models/raif/concerns/invokes_model_tools.rb
+- app/models/raif/concerns/json_schema_definition.rb
 - app/models/raif/concerns/llm_response_parsing.rb
+- app/models/raif/concerns/llm_temperature.rb
+- app/models/raif/concerns/llms/anthropic/message_formatting.rb
+- app/models/raif/concerns/llms/anthropic/tool_formatting.rb
+- app/models/raif/concerns/llms/bedrock/message_formatting.rb
+- app/models/raif/concerns/llms/bedrock/tool_formatting.rb
+- app/models/raif/concerns/llms/message_formatting.rb
+- app/models/raif/concerns/llms/open_ai/json_schema_validation.rb
+- app/models/raif/concerns/llms/open_ai_completions/message_formatting.rb
+- app/models/raif/concerns/llms/open_ai_completions/tool_formatting.rb
+- app/models/raif/concerns/llms/open_ai_responses/message_formatting.rb
+- app/models/raif/concerns/llms/open_ai_responses/tool_formatting.rb
 - app/models/raif/conversation.rb
 - app/models/raif/conversation_entry.rb
+- app/models/raif/embedding_model.rb
+- app/models/raif/embedding_models/bedrock.rb
+- app/models/raif/embedding_models/open_ai.rb
 - app/models/raif/llm.rb
 - app/models/raif/llms/anthropic.rb
-- app/models/raif/llms/bedrock_claude.rb
-- app/models/raif/llms/open_ai.rb
+- app/models/raif/llms/bedrock.rb
+- app/models/raif/llms/open_ai_base.rb
+- app/models/raif/llms/open_ai_completions.rb
+- app/models/raif/llms/open_ai_responses.rb
+- app/models/raif/llms/open_router.rb
 - app/models/raif/model_completion.rb
+- app/models/raif/model_file_input.rb
+- app/models/raif/model_image_input.rb
 - app/models/raif/model_tool.rb
 - app/models/raif/model_tool_invocation.rb
 - app/models/raif/model_tools/agent_final_answer.rb
 - app/models/raif/model_tools/fetch_url.rb
+- app/models/raif/model_tools/provider_managed/base.rb
+- app/models/raif/model_tools/provider_managed/code_execution.rb
+- app/models/raif/model_tools/provider_managed/image_generation.rb
+- app/models/raif/model_tools/provider_managed/web_search.rb
 - app/models/raif/model_tools/wikipedia_search.rb
+- app/models/raif/streaming_responses/anthropic.rb
+- app/models/raif/streaming_responses/bedrock.rb
+- app/models/raif/streaming_responses/open_ai_completions.rb
+- app/models/raif/streaming_responses/open_ai_responses.rb
 - app/models/raif/task.rb
 - app/models/raif/user_tool_invocation.rb
 - app/views/layouts/raif/admin.html.erb
@@ -212,9 +243,12 @@ files:
 - app/views/raif/admin/model_tool_invocations/_model_tool_invocation.html.erb
 - app/views/raif/admin/model_tool_invocations/index.html.erb
 - app/views/raif/admin/model_tool_invocations/show.html.erb
+- app/views/raif/admin/stats/index.html.erb
+- app/views/raif/admin/stats/tasks/index.html.erb
 - app/views/raif/admin/tasks/_task.html.erb
 - app/views/raif/admin/tasks/index.html.erb
 - app/views/raif/admin/tasks/show.html.erb
+- app/views/raif/conversation_entries/_citations.html.erb
 - app/views/raif/conversation_entries/_conversation_entry.html.erb
 - app/views/raif/conversation_entries/_form.html.erb
 - app/views/raif/conversation_entries/_form_with_available_tools.html.erb
@@ -234,9 +268,19 @@ files:
 - config/locales/en.yml
 - config/routes.rb
 - db/migrate/20250224234252_create_raif_tables.rb
+- db/migrate/20250421202149_add_response_format_to_raif_conversations.rb
+- db/migrate/20250424200755_add_cost_columns_to_raif_model_completions.rb
+- db/migrate/20250424232946_add_created_at_indexes.rb
+- db/migrate/20250502155330_add_status_indexes_to_raif_tasks.rb
+- db/migrate/20250507155314_add_retry_count_to_raif_model_completions.rb
+- db/migrate/20250527213016_add_response_id_and_response_array_to_model_completions.rb
+- db/migrate/20250603140622_add_citations_to_raif_model_completions.rb
+- db/migrate/20250603202013_add_stream_response_to_raif_model_completions.rb
 - lib/generators/raif/agent/agent_generator.rb
 - lib/generators/raif/agent/templates/agent.rb.tt
+- lib/generators/raif/agent/templates/application_agent.rb.tt
 - lib/generators/raif/conversation/conversation_generator.rb
+- lib/generators/raif/conversation/templates/application_conversation.rb.tt
 - lib/generators/raif/conversation/templates/conversation.rb.tt
 - lib/generators/raif/install/install_generator.rb
 - lib/generators/raif/install/templates/initializer.rb
@@ -248,19 +292,25 @@ files:
 - lib/generators/raif/views_generator.rb
 - lib/raif.rb
 - lib/raif/configuration.rb
-- lib/raif/default_llms.rb
+- lib/raif/embedding_model_registry.rb
 - lib/raif/engine.rb
 - lib/raif/errors.rb
 - lib/raif/errors/action_not_authorized_error.rb
-- lib/raif/errors/anthropic/api_error.rb
 - lib/raif/errors/invalid_config_error.rb
 - lib/raif/errors/invalid_conversation_type_error.rb
+- lib/raif/errors/invalid_model_file_input_error.rb
+- lib/raif/errors/invalid_model_image_input_error.rb
 - lib/raif/errors/invalid_user_tool_type_error.rb
-- lib/raif/errors/open_ai/api_error.rb
 - lib/raif/errors/open_ai/json_schema_error.rb
+- lib/raif/errors/streaming_error.rb
+- lib/raif/errors/unsupported_feature_error.rb
+- lib/raif/json_schema_builder.rb
 - lib/raif/languages.rb
+- lib/raif/llm_registry.rb
+- lib/raif/migration_checker.rb
 - lib/raif/rspec.rb
 - lib/raif/utils.rb
+- lib/raif/utils/html_fragment_processor.rb
 - lib/raif/utils/html_to_markdown_converter.rb
 - lib/raif/utils/readable_content_extractor.rb
 - lib/raif/version.rb
@@ -287,7 +337,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Raif (Ruby AI Framework) is a Rails engine that helps you add AI-powered
   features to your Rails apps, such as tasks, conversations, and agents.

data/app/models/raif/llms/bedrock_claude.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-class Raif::Llms::BedrockClaude < Raif::Llm
-
-  def perform_model_completion!(model_completion)
-    if Raif.config.aws_bedrock_model_name_prefix.present?
-      model_completion.model_api_name = "#{Raif.config.aws_bedrock_model_name_prefix}.#{model_completion.model_api_name}"
-    end
-
-    params = build_api_parameters(model_completion)
-    resp = bedrock_client.converse(params)
-
-    model_completion.raw_response = if model_completion.response_format_json?
-      extract_json_response(resp)
-    else
-      extract_text_response(resp)
-    end
-
-    model_completion.completion_tokens = resp.usage.output_tokens
-    model_completion.prompt_tokens = resp.usage.input_tokens
-    model_completion.total_tokens = resp.usage.total_tokens
-    model_completion.save!
-
-    model_completion
-  end
-
-protected
-
-  def bedrock_client
-    @bedrock_client ||= Aws::BedrockRuntime::Client.new(region: Raif.config.aws_bedrock_region)
-  end
-
-  def format_messages(messages)
-    messages.map(&:symbolize_keys).map do |message|
-      {
-        role: message[:role],
-        content: [{ text: message[:content] }]
-      }
-    end
-  end
-
-  def build_api_parameters(model_completion)
-    params = {
-      model_id: model_completion.model_api_name,
-      inference_config: { max_tokens: model_completion.max_completion_tokens || 8192 },
-      messages: format_messages(model_completion.messages)
-    }
-
-    params[:system] = [{ text: model_completion.system_prompt }] if model_completion.system_prompt.present?
-
-    # Prepare tools configuration if needed
-    tools = []
-
-    # If we're looking for a JSON response, add a tool to the request that the model can use to provide a JSON response
-    if model_completion.response_format_json? && model_completion.json_response_schema.present?
-      tools << {
-        name: "json_response",
-        description: "Generate a structured JSON response based on the provided schema.",
-        input_schema: { json: model_completion.json_response_schema }
-      }
-    end
-
-    # If we support native tool use and have tools available, add them to the request
-    if supports_native_tool_use? && model_completion.available_model_tools.any?
-      model_completion.available_model_tools_map.each do |_tool_name, tool|
-        tools << {
-          name: tool.tool_name,
-          description: tool.tool_description,
-          input_schema: { json: tool.tool_arguments_schema }
-        }
-      end
-    end
-
-    # Add tool configuration if any tools are available
-    if tools.any?
-      params[:tool_config] = {
-        tools: tools.map { |tool| { tool_spec: tool } }
-      }
-    end
-
-    params
-  end
-
-  def extract_text_response(resp)
-    # Get the message from the response object
-    message = resp.output.message
-
-    # Find the first text content block
-    text_block = message.content&.find do |content|
-      content.respond_to?(:text) && content.text.present?
-    end
-
-    text_block&.text
-  end
-
-  def extract_json_response(resp)
-    # Get the message from the response object
-    message = resp.output.message
-
-    return extract_text_response(resp) if message.content.nil?
-
-    # Look for tool_use blocks in the content array
-    tool_response = message.content.find do |content|
-      content.respond_to?(:tool_use) && content.tool_use.present? && content.tool_use.name == "json_response"
-    end
-
-    if tool_response&.tool_use
-      JSON.generate(tool_response.tool_use.input)
-    else
-      extract_text_response(resp)
-    end
-  end
-
-  def extract_response_tool_calls(resp)
-    # Get the message from the response object
-    message = resp.output.message
-    return if message.content.nil?
-
-    # Find any tool_use blocks in the content array
-    tool_uses = message.content.select do |content|
-      content.respond_to?(:tool_use) && content.tool_use.present?
-    end
-
-    return if tool_uses.blank?
-
-    tool_uses.map do |content|
-      {
-        "name" => content.tool_use.name,
-        "arguments" => content.tool_use.input
-      }
-    end
-  end
-
-end

data/app/models/raif/llms/open_ai.rb

@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-
-class Raif::Llms::OpenAi < Raif::Llm
-
-  def perform_model_completion!(model_completion)
-    model_completion.temperature ||= default_temperature
-    parameters = build_chat_parameters(model_completion)
-
-    response = connection.post("chat/completions") do |req|
-      req.body = parameters.to_json
-    end
-
-    resp = JSON.parse(response.body)
-
-    # Handle API errors
-    unless response.success?
-      error_message = resp["error"]&.dig("message") || "OpenAI API error: #{response.status}"
-      raise Raif::Errors::OpenAi::ApiError, error_message
-    end
-
-    model_completion.update!(
-      response_tool_calls: extract_response_tool_calls(resp),
-      raw_response: resp.dig("choices", 0, "message", "content"),
-      completion_tokens: resp["usage"]["completion_tokens"],
-      prompt_tokens: resp["usage"]["prompt_tokens"],
-      total_tokens: resp["usage"]["total_tokens"],
-      response_format_parameter: parameters.dig(:response_format, :type)
-    )
-
-    model_completion
-  end
-
-  def connection
-    @connection ||= Faraday.new(url: "https://api.openai.com/v1") do |f|
-      f.headers["Content-Type"] = "application/json"
-      f.headers["Authorization"] = "Bearer #{Raif.config.open_ai_api_key}"
-    end
-  end
-
-  def validate_json_schema!(schema)
-    return if schema.blank?
-
-    errors = []
-
-    # Check if schema is present
-    if schema.blank?
-      errors << "JSON schema must include a 'schema' property"
-    else
-      # Check root object type
-      if schema[:type] != "object" && !schema.key?(:properties)
-        errors << "Root schema must be of type 'object' with 'properties'"
-      end
-
-      # Check all objects in the schema recursively
-      validate_object_properties(schema, errors)
-
-      # Check properties count (max 100 total)
-      validate_properties_count(schema, errors)
-
-      # Check nesting depth (max 5 levels)
-      validate_nesting_depth(schema, errors)
-
-      # Check for unsupported anyOf at root level
-      if schema[:anyOf].present? && schema[:properties].blank?
-        errors << "Root objects cannot be of type 'anyOf'"
-      end
-    end
-
-    # Raise error if any validation issues found
-    if errors.any?
-      error_message = "Invalid JSON schema for OpenAI structured outputs: #{errors.join("; ")}\nSchema was: #{schema.inspect}"
-      raise Raif::Errors::OpenAi::JsonSchemaError, error_message
-    else
-      true
-    end
-  end
-
-private
-
-  def extract_response_tool_calls(resp)
-    return if resp.dig("choices", 0, "message", "tool_calls").blank?
-
-    resp.dig("choices", 0, "message", "tool_calls").map do |tool_call|
-      {
-        "name" => tool_call["function"]["name"],
-        "arguments" => JSON.parse(tool_call["function"]["arguments"])
-      }
-    end
-  end
-
-  def build_chat_parameters(model_completion)
-    formatted_system_prompt = model_completion.system_prompt.to_s.strip
-
-    # If the response format is JSON, we need to include "as json" in the system prompt.
-    # OpenAI requires this and will throw an error if it's not included.
-    if model_completion.response_format_json?
-      # Ensure system prompt ends with a period if not empty
-      if formatted_system_prompt.present? && !formatted_system_prompt.end_with?(".", "?", "!")
-        formatted_system_prompt += "."
-      end
-      formatted_system_prompt += " Return your response as JSON."
-      formatted_system_prompt.strip!
-    end
-
-    messages = model_completion.messages
-    messages_with_system = if !formatted_system_prompt.empty?
-      [{ "role" => "system", "content" => formatted_system_prompt }] + messages
-    else
-      messages
-    end
-
-    parameters = {
-      model: api_name,
-      messages: messages_with_system,
-      temperature: model_completion.temperature.to_f
-    }
-
-    # If the LLM supports native tool use and there are available tools, add them to the parameters
-    if supports_native_tool_use? && model_completion.available_model_tools.any?
-      parameters[:tools] = model_completion.available_model_tools_map.map do |_tool_name, tool|
-        validate_json_schema!(tool.tool_arguments_schema)
-
-        {
-          type: "function",
-          function: {
-            name: tool.tool_name,
-            description: tool.tool_description,
-            parameters: tool.tool_arguments_schema
-          }
-        }
-      end
-    end
-
-    # Add response format if needed
-    response_format = determine_response_format(model_completion)
-    parameters[:response_format] = response_format if response_format
-
-    parameters
-  end
-
-  def determine_response_format(model_completion)
-    # Only configure response format for JSON outputs
-    return unless model_completion.response_format_json?
-
-    if model_completion.json_response_schema.present? && supports_structured_outputs?
-      validate_json_schema!(model_completion.json_response_schema)
-
-      {
-        type: "json_schema",
-        json_schema: {
-          name: "json_response_schema",
-          strict: true,
-          schema: model_completion.json_response_schema
-        }
-      }
-    else
-      # Default JSON mode for OpenAI models that don't support structured outputs or no schema is provided
-      { type: "json_object" }
-    end
-  end
-
-  def supports_structured_outputs?
-    # Not all OpenAI models support structured outputs:
-    # https://platform.openai.com/docs/guides/structured-outputs?api-mode=chat#supported-models
-    provider_settings[:supports_structured_outputs]
-  end
-
-  def validate_object_properties(schema, errors)
-    return unless schema.is_a?(Hash)
-
-    # Check if the current schema is an object and validate additionalProperties and required fields
-    if schema[:type] == "object"
-      if schema[:additionalProperties] != false
-        errors << "All objects must have 'additionalProperties' set to false"
-      end
-
-      # Check that all properties are required
-      if schema[:properties].is_a?(Hash) && schema[:properties].any?
-        property_keys = schema[:properties].keys
-        required_fields = schema[:required] || []
-
-        if required_fields.sort != property_keys.map(&:to_s).sort
-          errors << "All object properties must be listed in the 'required' array"
-        end
-      end
-    end
-
-    # Check if the current schema is an object and validate additionalProperties
-    if schema[:type] == "object"
-      if schema[:additionalProperties] != false
-        errors << "All objects must have 'additionalProperties' set to false"
-      end
-
-      # Check properties of the object recursively
-      if schema[:properties].is_a?(Hash)
-        schema[:properties].each_value do |property|
-          validate_object_properties(property, errors)
-        end
-      end
-    end
-
-    # Check array items
-    if schema[:type] == "array" && schema[:items].is_a?(Hash)
-      validate_object_properties(schema[:items], errors)
-    end
-
-    # Check anyOf
-    if schema[:anyOf].is_a?(Array)
-      schema[:anyOf].each do |option|
-        validate_object_properties(option, errors)
-      end
-    end
-  end
-
-  def validate_properties_count(schema, errors, count = 0)
-    return count unless schema.is_a?(Hash)
-
-    if schema[:properties].is_a?(Hash)
-      count += schema[:properties].size
-
-      if count > 100
-        errors << "Schema exceeds maximum of 100 total object properties"
-        return count
-      end
-
-      # Check nested properties
-      schema[:properties].each_value do |property|
-        count = validate_properties_count(property, errors, count)
-      end
-    end
-
-    # Check array items
-    if schema[:type] == "array" && schema[:items].is_a?(Hash)
-      count = validate_properties_count(schema[:items], errors, count)
-    end
-
-    count
-  end
-
-  def validate_nesting_depth(schema, errors, depth = 1)
-    return unless schema.is_a?(Hash)
-
-    if depth > 5
-      errors << "Schema exceeds maximum nesting depth of 5 levels"
-      return
-    end
-
-    if schema[:properties].is_a?(Hash)
-      schema[:properties].each_value do |property|
-        validate_nesting_depth(property, errors, depth + 1)
-      end
-    end
-
-    # Check array items
-    if schema[:type] == "array" && schema[:items].is_a?(Hash)
-      validate_nesting_depth(schema[:items], errors, depth + 1)
-    end
-  end
-end

data/lib/raif/default_llms.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Raif
-  def self.default_llms
-    {
-      Raif::Llms::OpenAi => [
-        {
-          key: :open_ai_gpt_4o_mini,
-          api_name: "gpt-4o-mini",
-          model_provider_settings: { supports_structured_outputs: true }
-        },
-        {
-          key: :open_ai_gpt_4o,
-          api_name: "gpt-4o",
-          model_provider_settings: { supports_structured_outputs: true }
-        },
-        {
-          key: :open_ai_gpt_3_5_turbo,
-          api_name: "gpt-3.5-turbo",
-          model_provider_settings: { supports_structured_outputs: false }
-        },
-      ],
-      Raif::Llms::Anthropic => [
-        { key: :anthropic_claude_3_7_sonnet, api_name: "claude-3-7-sonnet-latest", max_completion_tokens: 8192 },
-        { key: :anthropic_claude_3_5_sonnet, api_name: "claude-3-5-sonnet-latest", max_completion_tokens: 8192 },
-        { key: :anthropic_claude_3_5_haiku, api_name: "claude-3-5-haiku-latest", max_completion_tokens: 8192 },
-        { key: :anthropic_claude_3_opus, api_name: "claude-3-opus-latest", max_completion_tokens: 4096 },
-      ],
-      Raif::Llms::BedrockClaude => [
-        { key: :bedrock_claude_3_5_sonnet, api_name: "anthropic.claude-3-5-sonnet-20241022-v2:0", max_completion_tokens: 8192 },
-        { key: :bedrock_claude_3_7_sonnet, api_name: "anthropic.claude-3-7-sonnet-20250219-v1:0", max_completion_tokens: 8192 },
-        { key: :bedrock_claude_3_5_haiku, api_name: "anthropic.claude-3-5-haiku-20241022-v1:0", max_completion_tokens: 8192 },
-        { key: :bedrock_claude_3_opus, api_name: "anthropic.claude-3-opus-20240229-v1:0", max_completion_tokens: 4096 },
-      ]
-    }
-  end
-end