Class: CompletionKit::ApiConfig

Inherits:
Object
  • Object
show all
Defined in:
app/services/completion_kit/api_config.rb

Constant Summary collapse

PROVIDERS = 
%w[openai anthropic ollama openrouter].freeze

Class Method Summary collapse

Class Method Details

.available_models(provider: nil, scope: :generation) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'app/services/completion_kit/api_config.rb', line 62

def self.available_models(provider: nil, scope: :generation)
  query = case scope
          when :judging then Model.for_judging
          when :generation then Model.for_generation
          else Model.active
          end
  query = query.where(provider: provider) if provider.present?
  models = query.order(:provider, :display_name).map do |m|
    entry = { id: m.model_id, name: m.display_name || m.model_id, provider: m.provider }
    entry[:judging_confirmed] = !m.supports_judging.nil? if scope == :judging
    entry
  end

  return models if models.any?

  configured = ProviderCredential.pluck(:provider)
  providers = provider.present? ? [provider.to_s] : configured
  providers.flat_map do |provider_name|
    next [] unless configured.include?(provider_name)
    client = LlmClient.for_provider(provider_name, for_provider(provider_name))
    client.available_models.map { |model| model.symbolize_keys.merge(provider: provider_name) }
  rescue StandardError
    []
  end.uniq { |model| model[:id] }
end

.errors_for_model(model_name) ⇒ Object 



57
58
59
60
 
# File 'app/services/completion_kit/api_config.rb', line 57

def self.errors_for_model(model_name)
  client = LlmClient.for_model(model_name, for_model(model_name))
  client.configuration_errors
end

.for_model(model_name) ⇒ Object 



5
6
7
8
 
# File 'app/services/completion_kit/api_config.rb', line 5

def self.for_model(model_name)
  provider = provider_for_model(model_name)
  provider ? for_provider(provider) : {}
end

.for_provider(provider_name) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'app/services/completion_kit/api_config.rb', line 10

def self.for_provider(provider_name)
  provider = provider_name.to_s
  stored = ProviderCredential.find_by(provider: provider)&.config_hash || {}

  defaults = if CompletionKit.config.tenant_scope
               PROVIDERS.include?(provider) ? { provider: provider } : {}
             else
               case provider
               when "openai"
                 { provider: "openai", api_key: CompletionKit.config.openai_api_key || ENV["OPENAI_API_KEY"] }
               when "anthropic"
                 { provider: "anthropic", api_key: CompletionKit.config.anthropic_api_key || ENV["ANTHROPIC_API_KEY"] }
               when "ollama"
                 {
                   provider: "ollama",
                   api_key: CompletionKit.config.ollama_api_key || ENV["OLLAMA_API_KEY"],
                   api_endpoint: CompletionKit.config.ollama_api_endpoint || ENV["OLLAMA_API_ENDPOINT"]
                 }
               when "openrouter"
                 { provider: "openrouter", api_key: ENV["OPENROUTER_API_KEY"] }
               else
                 {}
               end
             end

  defaults.merge(stored.compact)
end

.provider_for_model(model_name) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'app/services/completion_kit/api_config.rb', line 38

def self.provider_for_model(model_name)
  available_match = available_models.find { |model| model[:id] == model_name.to_s }
  return available_match[:provider] if available_match

  case model_name.to_s
  when /\Agpt-/
    "openai"
  when /\Aclaude-/
    "anthropic"
  else
    nil
  end
end

.valid_for_model?(model_name) ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
55
 
# File 'app/services/completion_kit/api_config.rb', line 52

def self.valid_for_model?(model_name)
  client = LlmClient.for_model(model_name, for_model(model_name))
  client.configured?
end