Class: Aidp::Harness::ProviderConfig

Inherits:
Object
  • Object
show all
Includes:
ProviderTypeChecker
Defined in:
lib/aidp/harness/provider_config.rb

Overview

Provider-specific configuration management

Instance Method Summary collapse

Methods included from ProviderTypeChecker

#get_provider_type, #get_underlying_service, #has_underlying_service?, #passthrough_provider?, #requires_api_key?, #subscription_provider?, #usage_based_provider?

Constructor Details

#initialize(provider_name, config_manager = nil) ⇒ ProviderConfig

Returns a new instance of ProviderConfig.



12
13
14
15
16
17
18
 
# File 'lib/aidp/harness/provider_config.rb', line 12

def initialize(provider_name, config_manager = nil)
  @provider_name = provider_name.to_s
  @config_manager = config_manager || ConfigManager.new
  @provider_config = nil
  @harness_config = nil
  @cache_timestamp = nil
end

Instance Method Details

#configured?(options = {}) ⇒ Boolean

Check if provider is configured

Returns:

  • (Boolean) 


371
372
373
374
 
# File 'lib/aidp/harness/provider_config.rb', line 371

def configured?(options = {})
  config = get_config(options)
  !config.empty?
end

#enabled?(options = {}) ⇒ Boolean

Check if provider is enabled

Returns:

  • (Boolean) 


377
378
379
380
 
# File 'lib/aidp/harness/provider_config.rb', line 377

def enabled?(options = {})
  harness_config = get_harness_config(options)
  harness_config[:enabled] != false
end

#get_api_key(options = {}) ⇒ Object

Get API key from environment or config



168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/aidp/harness/provider_config.rb', line 168

def get_api_key(options = {})
  auth_config = get_auth_config(options)

  # Try environment variable first
  if auth_config[:api_key_env]
    api_key = ENV[auth_config[:api_key_env]]
    return api_key if api_key && !api_key.empty?
  end

  # Try direct config
  auth_config[:api_key]
end

#get_auth_config(options = {}) ⇒ Object

Get authentication configuration



152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/aidp/harness/provider_config.rb', line 152

def get_auth_config(options = {})
  config = get_config(options)
  auth = config[:auth] || config["auth"] || {}

  {
    api_key_env: auth[:api_key_env] || auth["api_key_env"],
    api_key: auth[:api_key] || auth["api_key"],
    api_key_file: auth[:api_key_file] || auth["api_key_file"],
    username: auth[:username] || auth["username"],
    password: auth[:password] || auth["password"],
    token: auth[:token] || auth["token"],
    credentials_file: auth[:credentials_file] || auth["credentials_file"]
  }
end

#get_cache_config(options = {}) ⇒ Object

Get provider-specific cache configuration



344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/aidp/harness/provider_config.rb', line 344

def get_cache_config(options = {})
  config = get_config(options)
  cache_config = config[:cache] || config["cache"] || {}

  {
    enabled: cache_config[:enabled] != false,
    ttl: cache_config[:ttl] || 3600,
    max_size: cache_config[:max_size] || 100,
    strategy: cache_config[:strategy] || "lru"
  }
end

#get_capabilities(options = {}) ⇒ Object

Get provider capabilities



103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/aidp/harness/provider_config.rb', line 103

def get_capabilities(options = {})
  features = get_features(options)
  capabilities = []

  capabilities << "file_upload" if features[:file_upload]
  capabilities << "code_generation" if features[:code_generation]
  capabilities << "analysis" if features[:analysis]
  capabilities << "vision" if features[:vision]
  capabilities << "streaming" if features[:streaming]
  capabilities << "function_calling" if features[:function_calling]
  capabilities << "tool_use" if features[:tool_use]

  capabilities
end

#get_circuit_breaker_config(options = {}) ⇒ Object

Get circuit breaker configuration



249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/aidp/harness/provider_config.rb', line 249

def get_circuit_breaker_config(options = {})
  config = get_config(options)
  cb_config = config[:circuit_breaker] || config["circuit_breaker"] || {}

  {
    enabled: cb_config[:enabled] != false,
    failure_threshold: cb_config[:failure_threshold] || 5,
    timeout: cb_config[:timeout] || 300,
    half_open_max_calls: cb_config[:half_open_max_calls] || 3,
    success_threshold: cb_config[:success_threshold] || 2
  }
end

#get_cmd_args(options = {}) ⇒ Object

Get provider-specific command line arguments



316
317
318
319
320
 
# File 'lib/aidp/harness/provider_config.rb', line 316

def get_cmd_args(options = {})
  config = get_config(options)
  cmd_args = config[:cmd_args] || config["cmd_args"] || []
  cmd_args.map(&:to_s)
end

#get_combined_flags(model_name = nil, options = {}) ⇒ Object

Get combined flags (default + model-specific)



144
145
146
147
148
149
 
# File 'lib/aidp/harness/provider_config.rb', line 144

def get_combined_flags(model_name = nil, options = {})
  default_flags = get_default_flags(options)
  model_flags = model_name ? get_model_flags(model_name, options) : []

  (default_flags + model_flags).uniq
end

#get_config(options = {}) ⇒ Object

Get complete provider configuration



21
22
23
24
25
26
27
28
29
 
# File 'lib/aidp/harness/provider_config.rb', line 21

def get_config(options = {})
  return @provider_config if @provider_config && !options[:force_reload] && cache_valid?

  @provider_config = @config_manager.get_provider_config(@provider_name, options)
  @harness_config = @config_manager.get_harness_config(options)
  @cache_timestamp = Time.now

  @provider_config || {}
end

#get_cost_config(options = {}) ⇒ Object

Get cost configuration



263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/aidp/harness/provider_config.rb', line 263

def get_cost_config(options = {})
  config = get_config(options)
  cost = config[:cost] || config["cost"] || {}

  {
    input_cost_per_token: cost[:input_cost_per_token] || cost["input_cost_per_token"],
    output_cost_per_token: cost[:output_cost_per_token] || cost["output_cost_per_token"],
    fixed_cost_per_request: cost[:fixed_cost_per_request] || cost["fixed_cost_per_request"],
    currency: cost[:currency] || cost["currency"] || "USD"
  }
end

#get_default_endpoint(options = {}) ⇒ Object

Get default endpoint



196
197
198
199
 
# File 'lib/aidp/harness/provider_config.rb', line 196

def get_default_endpoint(options = {})
  endpoints = get_endpoints(options)
  endpoints[:default]
end

#get_default_flags(options = {}) ⇒ Object

Get provider default flags



131
132
133
134
135
 
# File 'lib/aidp/harness/provider_config.rb', line 131

def get_default_flags(options = {})
  config = get_config(options)
  flags = config[:default_flags] || config["default_flags"] || []
  flags.map(&:to_s)
end

#get_default_model(options = {}) ⇒ Object

Get default model



53
54
55
56
 
# File 'lib/aidp/harness/provider_config.rb', line 53

def get_default_model(options = {})
  models = get_models(options)
  models.first
end

#get_endpoints(options = {}) ⇒ Object

Get endpoints configuration



182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/aidp/harness/provider_config.rb', line 182

def get_endpoints(options = {})
  config = get_config(options)
  endpoints = config[:endpoints] || config["endpoints"] || {}

  {
    default: endpoints[:default] || endpoints["default"],
    chat: endpoints[:chat] || endpoints["chat"],
    completion: endpoints[:completion] || endpoints["completion"],
    embedding: endpoints[:embedding] || endpoints["embedding"],
    vision: endpoints[:vision] || endpoints["vision"]
  }
end

#get_env_vars(options = {}) ⇒ Object

Get provider-specific environment variables



307
308
309
310
311
312
313
 
# File 'lib/aidp/harness/provider_config.rb', line 307

def get_env_vars(options = {})
  config = get_config(options)
  env_vars = config[:env_vars] || config["env_vars"] || {}

  # Convert to string keys for environment variable access
  env_vars.transform_keys(&:to_s)
end

#get_features(options = {}) ⇒ Object

Get provider features



81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/aidp/harness/provider_config.rb', line 81

def get_features(options = {})
  config = get_config(options)
  features = config[:features] || config["features"] || {}

  {
    file_upload: features[:file_upload] == true,
    code_generation: features[:code_generation] != false,
    analysis: features[:analysis] != false,
    vision: features[:vision] == true,
    streaming: features[:streaming] != false,
    function_calling: features[:function_calling] == true,
    tool_use: features[:tool_use] == true
  }
end

#get_harness_config(options = {}) ⇒ Object

Get provider-specific harness configuration



276
277
278
279
280
281
282
283
284
285
286
287
288
 
# File 'lib/aidp/harness/provider_config.rb', line 276

def get_harness_config(options = {})
  config = get_config(options)
  harness_config = config[:harness] || config["harness"] || {}

  {
    enabled: harness_config[:enabled] != false,
    auto_switch_on_error: harness_config[:auto_switch_on_error] != false,
    auto_switch_on_rate_limit: harness_config[:auto_switch_on_rate_limit] != false,
    priority: harness_config[:priority] || get_priority(options),
    weight: harness_config[:weight] || 1,
    max_concurrent_requests: harness_config[:max_concurrent_requests] || 5
  }
end

#get_health_check_config(options = {}) ⇒ Object

Get provider health check configuration



291
292
293
294
295
296
297
298
299
300
301
302
303
304
 
# File 'lib/aidp/harness/provider_config.rb', line 291

def get_health_check_config(options = {})
  config = get_config(options)
  health_check = config[:health_check] || config["health_check"] || {}

  {
    enabled: health_check[:enabled] != false,
    interval: health_check[:interval] || 60,
    timeout: health_check[:timeout] || 10,
    failure_threshold: health_check[:failure_threshold] || 3,
    success_threshold: health_check[:success_threshold] || 2,
    check_url: health_check[:check_url] || health_check["check_url"],
    check_prompt: health_check[:check_prompt] || health_check["check_prompt"]
  }
end

#get_log_config(options = {}) ⇒ Object

Get provider-specific log configuration



329
330
331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/aidp/harness/provider_config.rb', line 329

def get_log_config(options = {})
  config = get_config(options)
  log_config = config[:log] || config["log"] || {}

  {
    enabled: log_config[:enabled] != false,
    level: log_config[:level] || "info",
    file: log_config[:file] || log_config["file"],
    max_size: log_config[:max_size] || 10_485_760, # 10MB
    max_files: log_config[:max_files] || 5,
    format: log_config[:format] || "json"
  }
end

#get_max_tokens(options = {}) ⇒ Object

Get provider max tokens



119
120
121
122
 
# File 'lib/aidp/harness/provider_config.rb', line 119

def get_max_tokens(options = {})
  config = get_config(options)
  config[:max_tokens] || config["max_tokens"]
end

#get_model_config(model_name, options = {}) ⇒ Object

Get model configuration



66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/aidp/harness/provider_config.rb', line 66

def get_model_config(model_name, options = {})
  config = get_config(options)
  models_config = config[:models_config] || config["models_config"] || {}
  model_config = models_config[model_name.to_sym] || models_config[model_name.to_s] || {}

  {
    flags: model_config[:flags] || model_config["flags"] || [],
    max_tokens: model_config[:max_tokens] || model_config["max_tokens"],
    timeout: model_config[:timeout] || model_config["timeout"],
    temperature: model_config[:temperature] || model_config["temperature"],
    max_retries: model_config[:max_retries] || model_config["max_retries"]
  }
end

#get_model_flags(model_name, options = {}) ⇒ Object

Get model-specific flags



138
139
140
141
 
# File 'lib/aidp/harness/provider_config.rb', line 138

def get_model_flags(model_name, options = {})
  model_config = get_model_config(model_name, options)
  model_config[:flags] || []
end

#get_model_weights(options = {}) ⇒ Object

Get model weights



59
60
61
62
63
 
# File 'lib/aidp/harness/provider_config.rb', line 59

def get_model_weights(options = {})
  config = get_config(options)
  weights = config[:model_weights] || config["model_weights"] || {}
  weights.transform_values { |weight| [weight.to_i, 1].max }
end

#get_models(options = {}) ⇒ Object

Get provider models



46
47
48
49
50
 
# File 'lib/aidp/harness/provider_config.rb', line 46

def get_models(options = {})
  config = get_config(options)
  models = config[:models] || config["models"] || []
  models.map(&:to_s)
end

#get_monitoring_config(options = {}) ⇒ Object

Get monitoring configuration



202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/aidp/harness/provider_config.rb', line 202

def get_monitoring_config(options = {})
  config = get_config(options)
  monitoring = config[:monitoring] || config["monitoring"] || {}

  {
    enabled: monitoring[:enabled] != false,
    metrics_interval: monitoring[:metrics_interval] || 60,
    health_check_interval: monitoring[:health_check_interval] || 300,
    log_level: monitoring[:log_level] || "info",
    log_requests: monitoring[:log_requests] != false,
    log_responses: monitoring[:log_responses] == true
  }
end

#get_priority(options = {}) ⇒ Object

Get provider priority



40
41
42
43
 
# File 'lib/aidp/harness/provider_config.rb', line 40

def get_priority(options = {})
  config = get_config(options)
  config[:priority] || config["priority"] || 1
end

#get_rate_limit_config(options = {}) ⇒ Object

Get rate limiting configuration



217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/aidp/harness/provider_config.rb', line 217

def get_rate_limit_config(options = {})
  config = get_config(options)
  rate_limit = config[:rate_limit] || config["rate_limit"] || {}

  {
    enabled: rate_limit[:enabled] != false,
    requests_per_minute: rate_limit[:requests_per_minute] || 60,
    requests_per_hour: rate_limit[:requests_per_hour] || 1000,
    tokens_per_minute: rate_limit[:tokens_per_minute],
    tokens_per_hour: rate_limit[:tokens_per_hour],
    burst_limit: rate_limit[:burst_limit] || 10,
    reset_time: rate_limit[:reset_time] || 3600
  }
end

#get_retry_config(options = {}) ⇒ Object

Get retry configuration



233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/aidp/harness/provider_config.rb', line 233

def get_retry_config(options = {})
  config = get_config(options)
  retry_config = config[:retry] || config["retry"] || {}

  {
    enabled: retry_config[:enabled] != false,
    max_attempts: retry_config[:max_attempts] || 3,
    base_delay: retry_config[:base_delay] || 1.0,
    max_delay: retry_config[:max_delay] || 60.0,
    exponential_base: retry_config[:exponential_base] || 2.0,
    jitter: retry_config[:jitter] != false,
    retry_on_rate_limit: retry_config[:retry_on_rate_limit] == true
  }
end

#get_security_config(options = {}) ⇒ Object

Get provider-specific security configuration



357
358
359
360
361
362
363
364
365
366
367
368
 
# File 'lib/aidp/harness/provider_config.rb', line 357

def get_security_config(options = {})
  config = get_config(options)
  security = config[:security] || config["security"] || {}

  {
    ssl_verify: security[:ssl_verify] != false,
    allowed_hosts: security[:allowed_hosts] || security["allowed_hosts"] || [],
    blocked_hosts: security[:blocked_hosts] || security["blocked_hosts"] || [],
    timeout: security[:timeout] || 30,
    max_redirects: security[:max_redirects] || 5
  }
end

#get_status(options = {}) ⇒ Object

Get provider status



383
384
385
386
387
388
 
# File 'lib/aidp/harness/provider_config.rb', line 383

def get_status(options = {})
  return :not_configured unless configured?(options)
  return :disabled unless enabled?(options)

  :enabled
end

#get_summary(options = {}) ⇒ Object

Get provider summary



391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
 
# File 'lib/aidp/harness/provider_config.rb', line 391

def get_summary(options = {})
  config = get_config(options)
  return {} if config.empty?

  {
    name: @provider_name,
    type: get_type(options),
    priority: get_priority(options),
    models: get_models(options),
    features: get_capabilities(options),
    status: get_status(options),
    configured: configured?(options),
    enabled: enabled?(options)
  }
end

#get_timeout(options = {}) ⇒ Object

Get provider timeout



125
126
127
128
 
# File 'lib/aidp/harness/provider_config.rb', line 125

def get_timeout(options = {})
  config = get_config(options)
  config[:timeout] || config["timeout"] || 300
end

#get_type(options = {}) ⇒ Object

Get provider type (usage_based, subscription)



32
33
34
35
 
# File 'lib/aidp/harness/provider_config.rb', line 32

def get_type(options = {})
  config = get_config(options)
  config[:type] || config["type"] || "subscription"
end

#get_working_directory(options = {}) ⇒ Object

Get provider-specific working directory



323
324
325
326
 
# File 'lib/aidp/harness/provider_config.rb', line 323

def get_working_directory(options = {})
  config = get_config(options)
  config[:working_directory] || config["working_directory"] || Dir.pwd
end

#reload_config ⇒ Object

Reload configuration



408
409
410
411
412
413
 
# File 'lib/aidp/harness/provider_config.rb', line 408

def reload_config
  @provider_config = nil
  @harness_config = nil
  @cache_timestamp = nil
  @config_manager.reload_config
end

#supports_feature?(feature, options = {}) ⇒ Boolean

Check if provider supports feature

Returns:

  • (Boolean) 


97
98
99
100
 
# File 'lib/aidp/harness/provider_config.rb', line 97

def supports_feature?(feature, options = {})
  features = get_features(options)
  features[feature.to_sym] == true
end