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

STOP_REASON_MAP =

Wire spelling table (13 §3 edge): the Converse API spells the content-filter stop reason 'content_filtered'; Anthropic event streams spell it 'content_filter'. Both map to the canonical :content_filter (Canonical::Response::STOP_REASONS).

{
  'end_turn' => :end_turn,
  'tool_use' => :tool_use,
  'max_tokens' => :max_tokens,
  'stop_sequence' => :stop_sequence,
  'content_filter' => :content_filter,
  'content_filtered' => :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.



49
50
51
52
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 49

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

Instance Method Details

#capabilities ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 54

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) 


106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 106

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) 


87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 87

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



74
75
76
77
78
79
80
81
82
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 74

def render_request(canonical, target: nil)
  reject_system_messages!(canonical)
  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

B1: the dialect predicate has one owner — ThinkingModes, shared with the Provider dispatch path.

Parameters:

  • canonical (Canonical::Request)

Returns:

  • (Symbol) —

    :converse or :invoke_model



124
125
126
127
128
129
130
131
 
# File 'lib/legion/extensions/llm/bedrock/translator.rb', line 124

def target_for(canonical)
  mid = model_from_request(canonical)
  if ThinkingModes.invoke_model_target?(model_id: mid, thinking: canonical.thinking, tools: canonical.tools)
    :invoke_model
  else
    :converse
  end
end