Module: Intelligence::OpenAi::ChatResponseMethods

Defined in:
lib/intelligence/adapters/open_ai/chat_response_methods.rb

Instance Method Summary collapse

Instance Method Details

#chat_result_attributes(response) ⇒ Object 



5
6
7
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/intelligence/adapters/open_ai/chat_response_methods.rb', line 5

def chat_result_attributes( response )
  return nil unless response.success?
  response_json = JSON.parse( response.body, symbolize_names: true ) rescue nil
  return nil \
    if response_json.nil? || response_json[ :choices ].nil?
  
  result = {}
  result[ :choices ] = []

  ( response_json[ :choices ] || [] ).each do | json_choice |
    json_message = json_choice[ :message ]
    result_message = nil
    if ( json_message )
      result_message = { role: json_message[ :role ] }
      if json_message[ :content ] 
        result_message[ :contents ] = [ { type: :text, text: json_message[ :content ] } ]
      end
      if json_message[ :tool_calls ] && !json_message[ :tool_calls ].empty?
        result_message[ :contents ] ||= []
        json_message[ :tool_calls ].each do | json_message_tool_call |
          result_message_tool_call_parameters = 
            JSON.parse( json_message_tool_call[ :function ][ :arguments ], symbolize_names: true ) \
              rescue json_message_tool_call[ :function ][ :arguments ]
          result_message[ :contents ] << {
            type: :tool_call, 
            tool_call_id: json_message_tool_call[ :id ],
            tool_name: json_message_tool_call[ :function ][ :name ],
            tool_parameters: result_message_tool_call_parameters
          }
        end 
      end
    end 
    result[ :choices ].push( { 
      end_reason: translate_end_result( json_choice[ :finish_reason ] ), 
      message: result_message 
    } )
  end

  metrics_json = response_json[ :usage ]
  unless metrics_json.nil?

    metrics = {}
    metrics[ :input_tokens ] = metrics_json[ :prompt_tokens ] 
    metrics[ :output_tokens ] = metrics_json[ :completion_tokens ]
    metrics = metrics.compact

    result[ :metrics ] = metrics unless metrics.empty?

  end

  result
end

#chat_result_error_attributes(response) ⇒ Object Also known as: stream_result_error_attributes 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/intelligence/adapters/open_ai/chat_response_methods.rb', line 58

def chat_result_error_attributes( response )
  error_type, error_description = translate_error_response_status( response.status )
  result = {
    error_type: error_type.to_s,
    error_description: error_description
  }

  parsed_body = JSON.parse( response.body, symbolize_names: true ) rescue nil 
  if parsed_body && parsed_body.respond_to?( :include? ) && parsed_body.include?( :error )
    result = {
      error_type: error_type.to_s,
      error: parsed_body[ :error ][ :code ] || error_type.to_s,
      error_description: parsed_body[ :error ][ :message ] || error_description
    }
  end
  
  result
end

#stream_result_attributes(context) ⇒ Object 



170
171
172
173
174
175
176
177
178
179
 
# File 'lib/intelligence/adapters/open_ai/chat_response_methods.rb', line 170

def stream_result_attributes( context )
  choices = context[ :choices ]
  metrics = context[ :metrics ]

  choices = choices.map do | choice |
    { end_reason: choice[ :end_reason ] }
  end

  { choices: choices, metrics: context[ :metrics ] }
end

#stream_result_chunk_attributes(context, chunk) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/intelligence/adapters/open_ai/chat_response_methods.rb', line 77

def stream_result_chunk_attributes( context, chunk )
  context ||= {}
  buffer = context[ :buffer ] || ''
  metrics = context[ :metrics ] || {
    input_tokens: 0,
    output_tokens:  0
  }
  choices = context[ :choices ] || Array.new( 1 , { message: {} } )

  choices.each do | choice |
    choice[ :message ][ :contents ] = choice[ :message ][ :contents ]&.map do | content |
      { type: content[ :type ] }
    end
  end

  buffer += chunk
  while ( eol_index = buffer.index( "\n" ) )
    line = buffer.slice!( 0..eol_index )        
    line = line.strip 
    next if line.empty? || !line.start_with?( 'data:' )
    line = line[ 6..-1 ]

    next if line.end_with?( '[DONE]' )
    data = JSON.parse( line ) rescue nil

    if data.is_a?( Hash )
      data[ 'choices' ]&.each do | data_choice |

        data_choice_index = data_choice[ 'index' ]
        data_choice_delta = data_choice[ 'delta' ]
        data_choice_finish_reason = data_choice[ 'finish_reason' ]
        
        choices.fill( { message: {} }, choices.size, data_choice_index + 1 ) \
          if choices.size <= data_choice_index 
        contents = choices[ data_choice_index ][ :message ][ :contents ] || []

        text_content = contents.first&.[]( :type ) == :text ? contents.first : nil 
        if data_choice_content = data_choice_delta[ 'content' ]
          if text_content.nil?  
            contents.unshift( text_content = { type: :text, text: data_choice_content } )
          else
            text_content[ :text ] = ( text_content[ :text ] || '' ) + data_choice_content
          end
        end 
        if data_choice_tool_calls = data_choice_delta[ 'tool_calls' ]
          data_choice_tool_calls.each do | data_choice_tool_call |
            if data_choice_tool_call_function = data_choice_tool_call[ 'function' ]
              data_choice_tool_index = data_choice_tool_call[ 'index' ]
              data_choice_tool_id = data_choice_tool_call[ 'id' ]
              data_choice_tool_name = data_choice_tool_call_function[ 'name' ]
              data_choice_tool_parameters = data_choice_tool_call_function[ 'arguments' ]
              
              tool_call_content_index = ( text_content.nil? ? 0 : 1 ) + data_choice_tool_index 
              if tool_call_content_index >= contents.length 
                contents.push( { 
                  type: :tool_call, 
                  tool_call_id: data_choice_tool_id,
                  tool_name: data_choice_tool_name,
                  tool_parameters: data_choice_tool_parameters
                } )
              else 
                tool_call = contents[ tool_call_content_index ]
                tool_call[ :tool_call_id ] = ( tool_call[ :tool_call_id ] || '' ) + data_choice_tool_id \
                  if data_choice_tool_id 
                tool_call[ :tool_name ] = ( tool_call[ :tool_name ] || '' ) + data_choice_tool_name \
                  if data_choice_tool_name 
                tool_call[ :tool_parameters ] = ( tool_call[ :tool_parameters ] || '' ) + data_choice_tool_parameters \
                  if data_choice_tool_parameters
              end 
            end 
          end 
        end
        choices[ data_choice_index ][ :message ][ :contents ] = contents
        choices[ data_choice_index ][ :end_reason ] ||= 
          translate_end_result( data_choice_finish_reason )
      end
  
      if usage = data[ 'usage' ]
        metrics[ :input_tokens ] += usage[ 'prompt_tokens' ]
        metrics[ :output_tokens ] += usage[ 'completion_tokens' ]
      end 

    end

  end

  context[ :buffer ] = buffer 
  context[ :metrics ] = metrics
  context[ :choices ] = choices
  
  [ context, choices.empty? ? nil : { choices: choices.dup } ]
end