Class: Legion::Extensions::Llm::Bedrock::Translator

Inherits:
Object
  • Object
show all
Includes:
ChunkParsing, MessageRendering, ReadHelpers, RequestRendering, ResponseParsing, Logging::Helper
Defined in:
lib/legion/extensions/llm/bedrock/translator.rb,
lib/legion/extensions/llm/bedrock/translator/read_helpers.rb,
lib/legion/extensions/llm/bedrock/translator/chunk_parsing.rb,
lib/legion/extensions/llm/bedrock/translator/response_parsing.rb,
lib/legion/extensions/llm/bedrock/translator/message_rendering.rb,
lib/legion/extensions/llm/bedrock/translator/request_rendering.rb

Overview

Canonical provider translator for Bedrock.

Converts between Canonical::Request/Response/Chunk and Bedrock wire formats. Supports two render targets:

- :converse (default) — Bedrock Converse API
- :invoke_model — Bedrock invoke_model with Anthropic Messages payload

Defined Under Namespace

Modules: ChunkParsing, MessageRendering, ReadHelpers, RequestRendering, ResponseParsing

Constant Summary collapse

DEFAULT_MAX_TOKENS = 
4096
STOP_REASON_MAP = 
{
  'end_turn' => :end_turn,
  'tool_use' => :tool_use,
  'max_tokens' => :max_tokens,
  'stop_sequence' => :stop_sequence,
  'content_filter' => :content_filter,
  'guardrail_intervened' => :content_filter,
  'error' => :error
}.freeze
MODEL_PREFIXED_FAMILIES = 
%w[anthropic. meta. mistral. cohere. ai21.].freeze

Instance Method Summary collapse

Constructor Details

#initialize(region: nil, geo_prefix: nil) ⇒ Translator

Returns a new instance of Translator.



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

def initialize(region: nil, geo_prefix: nil)
  @region     = region
  @geo_prefix = geo_prefix
end

Instance Method Details

#capabilities ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 50

def capabilities
  {
    provider: 'bedrock',
    render_targets: %i[converse invoke_model],
    thinking: :budget_tokens,
    streaming: true,
    tool_calls: true,
    cache_control: false,
    stop_reasons: {
      'end_turn' => :end_turn,
      'tool_use' => :tool_use,
      'max_tokens' => :max_tokens,
      'guardrail_intervened' => :content_filter
    }
  }
end

#parse_chunk(raw, _model: nil) ⇒ Canonical::Chunk?

Parameters:

  • raw (Hash) —

    Raw streaming event

Returns:

  • (Canonical::Chunk, nil) 


101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 101

def parse_chunk(raw, _model: nil)
  return nil unless raw.is_a?(Hash) && !raw.empty?

  type = (raw['type'] || raw[:type] || '').to_s
  case type
  when 'text_delta'      then parse_text_delta(raw)
  when 'thinking_delta'  then parse_thinking_delta(raw)
  when 'tool_call_delta' then parse_tool_call_delta(raw)
  when 'done'            then parse_done_chunk(raw)
  when 'error'           then parse_error_chunk(raw)
  else parse_anthropic_event(raw)
  end
end

#parse_response(wire, model: nil) ⇒ Canonical::Response

Parameters:

  • wire (Hash) —

    Raw wire response (String or Symbol keyed)

  • model (String, nil) (defaults to: nil)

Returns:

  • (Canonical::Response) 


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 82

def parse_response(wire, model: nil)
  if wire.nil? || wire.empty?
    return Canonical::Response.build(
      text: '', tool_calls: [], usage: Canonical::Usage.from_hash({}),
      stop_reason: nil, model: model, routing: {}, metadata: {}
    )
  end

  if wire.key?('text') || wire.key?(:text)
    Legion::Extensions::Llm::Canonical::Response.from_hash(wire)
  elsif wire.key?('output') || wire.key?(:output)
    parse_converse_response(wire, model)
  else
    parse_invoke_model_response(wire, model)
  end
end

#render_request(canonical, target: nil) ⇒ Hash

Returns Bedrock wire-format payload.

Parameters:

  • canonical (Canonical::Request)
  • target (Symbol, nil) (defaults to: nil) —

    :converse, :invoke_model, or nil (auto)

Returns:

  • (Hash) —

    Bedrock wire-format payload



70
71
72
73
74
75
76
77
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 70

def render_request(canonical, target: nil)
  target ||= target_for(canonical)
  case target
  when :converse     then render_converse(canonical)
  when :invoke_model then render_invoke_model(canonical)
  else raise ArgumentError, "Unknown render target: #{target.inspect}"
  end
end

#target_for(canonical) ⇒ Symbol

Returns :converse or :invoke_model.

Parameters:

  • canonical (Canonical::Request)

Returns:

  • (Symbol) —

    :converse or :invoke_model



117
118
119
120
121
122
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 117

def target_for(canonical)
  mid       = model_from_request(canonical)
  has_think = canonical.thinking.respond_to?(:enabled?) && canonical.thinking.enabled?
  has_tools = canonical.tools && !canonical.tools.empty?
  anthropic_model?(mid) && (has_think || has_tools) ? :invoke_model : :converse
end