Module: Legion::Extensions::Llm::Bedrock::Provider::ModelCatalogHelpers

Included in:
Legion::Extensions::Llm::Bedrock::Provider
Defined in:
lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb

Overview

Model catalog, offering construction, and capability derivation helpers.

Instance Method Summary collapse

Instance Method Details

#discover_live_offerings(filters, provider_health, live:) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 81

def discover_live_offerings(filters, provider_health, live:)
  discovery_registry_readiness(provider_health, live:)
  Array(list_models(live:, **filters)).filter_map do |model|
    next unless model_matches_filters?(model, filters)
    next unless model_allowed?(model.id)

    log_model_discovered(model)
    offering_from_model(model, health: provider_health)
  end
end

#discover_offerings(live: false, **filters) ⇒ Object 



62
63
64
65
66
67
68
69
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 62

def discover_offerings(live: false, **filters)
  return static_offerings(**filters) unless live

  provider_health = health(live:)
  @cached_offerings = discover_live_offerings(filters, provider_health, live:)
  log_discover_complete(@cached_offerings)
  @cached_offerings
end

#discovery_registry_readiness(provider_health, live:) ⇒ Object 



71
72
73
74
75
76
77
78
79
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 71

def discovery_registry_readiness(provider_health, live:)
  {
    provider: slug.to_sym,
    configured: configured?,
    ready: provider_health[:ready] == true,
    live: live,
    health: provider_health
  }
end

#health(live: false) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 22

def health(live: false)
  baseline = {
    provider: :bedrock,
    region: region,
    configured: true,
    ready: true,
    live: live,
    credentials: credential_source
  }
  unless live
    log.debug { "bedrock.provider.health: offline check (region=#{region})" }
    return baseline.merge(checked: false)
  end

  log.info { "bedrock.provider.health: live check (region=#{region})" }
  bedrock_client.list_foundation_models
  log.info { 'bedrock.provider.health: live check passed' }
  baseline.merge(checked: true)
rescue StandardError => e
  handle_exception(e, level: :warn, handled: true, operation: 'bedrock.provider.health')
  baseline.merge(checked: true, ready: false, error: e.class.name, message: e.message)
end

#list_models(**filters) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 51

def list_models(**filters)
  request_filters = {}
  request_filters[:by_provider] = filters[:by_provider] if filters[:by_provider]

  log.info { 'bedrock.provider.list_models: fetching live model list' }
  response = bedrock_client.list_foundation_models(**request_filters)
  models = Array(value(response, :model_summaries)).filter_map { |s| model_info_from_summary(s) }
  log.info { "bedrock.provider.list_models: found #{models.size} models" }
  models
end

#log_discover_complete(offerings) ⇒ Object 



99
100
101
102
103
104
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 99

def log_discover_complete(offerings)
  log.info(
    "[#{slug}] instance=#{provider_instance_id} action=discover_complete " \
    "model_count=#{Array(offerings).size}"
  )
end

#log_model_discovered(model) ⇒ Object 



92
93
94
95
96
97
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 92

def log_model_discovered(model)
  log.debug(
    "[#{slug}] instance=#{provider_instance_id} action=model_discovered " \
    "model=#{model.id} family=#{model.family}"
  )
end

#offering_for(model:, model_family: nil, instance_id: nil, **metadata) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 10

def offering_for(model:, model_family: nil, instance_id: nil, **metadata)
  model_id_val = self.class.resolve_model_id(model)
  build_offering(
    model: model_id_val,
    alias_name: alias_for(model_id_val),
    model_family: model_family || model_family_for(model_id_val),
    instance_id: instance_id,
    usage_type: metadata.delete(:usage_type) || usage_type_for(model_id_val),
    metadata: metadata
  )
end

#readiness(live: false) ⇒ Object 



45
46
47
48
49
 
# File 'lib/legion/extensions/llm/bedrock/provider/model_catalog_helpers.rb', line 45

def readiness(live: false)
  log.debug { "bedrock.provider.readiness: checking (live=#{live})" }
  health(live: live).merge(local: false, remote: true, api_base: api_base,
                           endpoints: endpoint_manifest)
end