gpt 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63a792b425c4cbce7e97eea48da74efc7d1fab57bb88f8623c683b19d567a55c
-  data.tar.gz: d359d30ae5e9d184330a7922d39416ab80de88a03871a5f6009d2e9d9c65b562
+  metadata.gz: b725ab7bc465dae82acf06dff54ba12d1199ddd6b21c90d8107839c709da7ba9
+  data.tar.gz: 0b6ef69bac8fcaf22565aedbb3fff199a65957ce08514d7f85aff5fc2f3341ed
 SHA512:
-  metadata.gz: 87a5832356464d22b9e0b10a346e8e441593ca6a54ba81a76f135b48cb94fe01951fe89954bcff891eba3d2bfae5a0755c99a974900b90fb4615dfe0459ae410
-  data.tar.gz: 4ad05661b2149c090d5e2546d3952b9410cd9d6c0332cca32cfed5499b21972a0953a153768ebff59ddc66458b1122cadf2312ce45fff6a292c0d7b5a43a6da6
+  metadata.gz: 9c68b407adf9d726b1bfc215c7523663be86cc0749337618c66d52679b628128a22f7d4ecff9cefd403e023a8b7cd65ad4db849898ff9a367ffe40e28f8a68b0
+  data.tar.gz: 213b43fb66a3ddd8e6d237a01f7aaefdff14a25100332db368c3801bf1967ebf4c3acd6d074fa7762d3326bc062303e831809b49d6065f50b6245c45d8813c66

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.0
+- Suporte e exemplos para GPT-5 (reasoning minimal, text verbosity, custom tools e allowed_tools)
+- Validação de `OPENAI_API_KEY` e ajuste de User-Agent
+- README atualizado para GPT-5
+
+## 0.1.1
+- Adiciona `GPT.ask` para uso simplificado, com suporte a streaming
+- Adiciona `GPT::ResponseExtender` com helpers (`content`, `usage`, `total_tokens`, `to_h`)
+- `Responses#create/get` passam a estender a resposta com os helpers
+
 ## 0.0.1
 - Primeira versão com cliente para API Responses (create/get/delete/cancel/input_items) e streaming SSE.
 

data/README.md

@@ -1,39 +1,93 @@
 # gpt
 
-Cliente Ruby simples para a API Responses.
+Cliente Ruby simples para a Responses API, com foco no GPT-5, com uma API de alto nível inspirada no OpenAIExt.
 
-Instalação
-```
-gem build gpt.gemspec && gem install ./gpt-0.0.1.gem
+## Instalação
+```bash
+gem install gpt
 ```
 
-Uso básico
+## Configuração
+- Defina `OPENAI_API_KEY` ou `OPENAI_ACCESS_TOKEN` no ambiente.
+- Opcional: `OPENAI_ORG_ID` ou `OPENAI_ORGANIZATION_ID`, `OPENAI_PROJECT_ID`.
+- Opcional: `OPENAI_REQUEST_TIMEOUT` (segundos, padrão 120).
+
+## Uso básico (GPT-5)
 ```ruby
 require 'gpt'
 
-client = GPT.client
+res = GPT.ask('Diga olá em uma frase.', model: 'gpt-5')
+puts res.content
+```
+
+## Reasoning mínimo (minimal)
+```ruby
+res = GPT.responses.create({
+  'model' => 'gpt-5',
+  'input' => 'Quanto ouro seria necessário para cobrir a Estátua da Liberdade com 1mm?',
+  'reasoning' => { 'effort' => 'minimal' }
+})
+```
+
+## Verbosidade baixa
+```ruby
+res = GPT.responses.create({
+  'model' => 'gpt-5',
+  'input' => 'Qual é a resposta para a vida, o universo e tudo mais?',
+  'text' => { 'verbosity' => 'low' }
+})
+```
+
+## Ferramentas personalizadas (custom tools)
+```ruby
+res = GPT.responses.create({
+  'model' => 'gpt-5',
+  'input' => 'Use a ferramenta code_exec para calcular a área de um círculo com raio igual ao número de letras r em blueberry',
+  'tools' => [
+    { 'type' => 'custom', 'name' => 'code_exec', 'description' => 'Executa código Python arbitrário' }
+  ]
+})
+```
+
+## Restringindo ferramentas (allowed_tools)
+```ruby
+res = GPT.responses.create({
+  'model' => 'gpt-5',
+  'input' => 'Como está o tempo em São Paulo?',
+  'tools' => [ { 'type' => 'function', 'name' => 'get_weather' } ],
+  'tool_choice' => {
+    'type' => 'allowed_tools',
+    'mode' => 'auto',
+    'tools' => [ { 'type' => 'function', 'name' => 'get_weather' } ]
+  }
+})
+```
 
-res = client.responses.create({
-  'model' => 'gpt-4.1',
-  'input' => 'Diga olá em uma frase.'
+## Passando raciocínio prévio (previous_response_id)
+```ruby
+first = GPT.responses.create({
+  'model' => 'gpt-5',
+  'input' => 'Planeje passos para resolver X.'
 })
 
-puts res['id']
+followup = GPT.responses.create({
+  'model' => 'gpt-5',
+  'input' => 'Agora execute o primeiro passo.',
+  'previous_response_id' => first['id']
+})
 ```
 
-Streaming SSE
+## Streaming SSE
 ```ruby
 require 'gpt'
 
-GPT.responses.stream({
-  'model' => 'gpt-4.1',
-  'input' => 'Conte uma história curta.'
-}) do |chunk|
-  print chunk
-end
+GPT.ask('Conte uma história curta.', model: 'gpt-5', stream: true) { |chunk| print chunk }
+
+# Streaming de texto direto
+GPT.ask('Conte uma história curta.', model: 'gpt-5', text_stream: true) { |text| print text }
 ```
 
-Outras operações
+## Outras operações
 ```ruby
 id = res['id']
 GPT.responses.get(id)
@@ -41,3 +95,61 @@ GPT.responses.input_items(id)
 GPT.responses.cancel(id)
 GPT.responses.delete(id)
 ```
+
+## Helpers de resposta
+```ruby
+res = GPT.ask('Qual a capital da França?', model: 'gpt-5')
+res.content
+res.model
+res.total_tokens
+res.to_h
+```
+
+## Function calling
+```ruby
+require 'gpt'
+
+# Passe ferramentas diretamente para GPT.ask
+res = GPT.ask(
+  'Como está o tempo em São Paulo?',
+  model: 'gpt-5',
+  tools: [
+    {
+      'type' => 'function',
+      'name' => 'get_weather',
+      'description' => 'Obter clima atual',
+      'parameters' => {
+        'type' => 'object',
+        'properties' => {
+          'location' => { 'type' => 'string' },
+          'unit' => { 'type' => 'string', 'enum' => ['celsius', 'fahrenheit'] }
+        },
+        'required' => ['location']
+      }
+    }
+  ]
+)
+
+puts res.content
+```
+
+### Executando funções chamadas pelo modelo
+```ruby
+# Se o modelo decidir acionar uma função, você pode inspecionar e executar:
+if res.functions?
+  # Exemplo de contexto com um método compatível com o nome da função
+  class WeatherContext
+    def get_weather(location:, unit: 'celsius')
+      { location: location, unit: unit, temp: 26 }
+    end
+  end
+
+  tool_messages = res.functions_run_all(context: WeatherContext.new)
+
+  # tool_messages é uma lista de hashes com:
+  #   :tool_call_id, :role=>:tool, :name, :content (string/json)
+  # Em Chat Completions, você pode passar estes objetos diretamente em messages.
+  # Na Responses API, converta-os para input items compatíveis (ex.: tool_result).
+  p tool_messages
+end
+```

data/lib/gpt/client.rb

@@ -5,10 +5,10 @@ module GPT
 
     attr_reader :api_key, :base_url, :timeout, :organization, :project
 
-    def initialize(api_key: ENV['OPENAI_API_KEY'], base_url: nil, timeout: nil, organization: ENV['OPENAI_ORG_ID'], project: ENV['OPENAI_PROJECT_ID'])
+    def initialize(api_key: ENV['OPENAI_API_KEY'] || ENV['OPENAI_ACCESS_TOKEN'], base_url: nil, timeout: nil, organization: ENV['OPENAI_ORG_ID'] || ENV['OPENAI_ORGANIZATION_ID'], project: ENV['OPENAI_PROJECT_ID'])
       @api_key = api_key
       @base_url = base_url || DEFAULT_BASE_URL
-      @timeout = (timeout || DEFAULT_TIMEOUT).to_i
+      @timeout = (timeout || ENV['OPENAI_REQUEST_TIMEOUT'] || DEFAULT_TIMEOUT).to_i
       @organization = organization
       @project = project
     end
@@ -86,10 +86,13 @@ module GPT
     end
 
     def apply_headers(req)
+      if !api_key || api_key.empty?
+        raise GPT::Error.new('Defina OPENAI_API_KEY ou OPENAI_ACCESS_TOKEN')
+      end
       req['Authorization'] = "Bearer #{api_key}"
       req['OpenAI-Organization'] = organization if organization && !organization.empty?
       req['OpenAI-Project'] = project if project && !project.empty?
-      req['User-Agent'] = 'gpt-ruby/0.0.1'
+      req['User-Agent'] = "gpt-ruby/#{GPT::VERSION}"
     end
 
     def parse_response(res)
@@ -117,5 +120,3 @@ module GPT
     end
   end
 end
-
-

data/lib/gpt/error.rb

@@ -9,4 +9,4 @@ class GPT::Error < StandardError
   end
 end
 
-
+class GPT::FunctionExecutionError < GPT::Error; end

data/lib/gpt/response_extender.rb

@@ -0,0 +1,104 @@
+module GPT
+  module ResponseExtender
+    def message
+      if self['choices']
+        dig('choices', 0, 'message') || {}
+      else
+        output_message = if self['output'].is_a?(Array)
+          self['output'].find { |i| i['type'] == 'message' } || self['output'].first
+        end
+        output_message || {}
+      end
+    end
+
+    def content
+      if self['choices']
+        dig('choices', 0, 'message', 'content')
+      else
+        msg = message
+        contents = msg && msg['content']
+        if contents.is_a?(Array)
+          text_item = contents.find { |c| c['type'] == 'output_text' || c['type'] == 'text' }
+          return text_item['text'] if text_item && text_item['text'] && !text_item['text'].empty?
+        end
+        if self['output'].is_a?(Array)
+          text_item = self['output'].find { |i| i['type'] == 'output_text' || i['type'] == 'text' }
+          return text_item['text'] if text_item && text_item['text'] && !text_item['text'].empty?
+        end
+        if self['output_text'].is_a?(String) && !self['output_text'].empty?
+          return self['output_text']
+        end
+        if self['content'].is_a?(String) && !self['content'].empty?
+          return self['content']
+        end
+        nil
+      end
+    end
+
+    def content?
+      !content.nil? && !content.empty?
+    end
+
+    def usage
+      self['usage'] || {}
+    end
+
+    def prompt_tokens
+      usage['prompt_tokens'] || 0
+    end
+
+    def completion_tokens
+      usage['completion_tokens'] || 0
+    end
+
+    def total_tokens
+      usage['total_tokens'] || 0
+    end
+
+    def model
+      self['model']
+    end
+
+    def created_at
+      if self['created']
+        Time.at(self['created'])
+      elsif self['created_at']
+        Time.at(self['created_at'])
+      end
+    end
+    
+    def functions
+      return [] unless tool_calls?
+  
+      tool_functions = tool_calls.select { |tool| tool['type'] == 'function' }
+      return [] if tool_functions.empty?
+  
+      tool_functions.map { |function| build_function_object(function) }
+    end
+  
+    def functions?
+      functions.any?
+    end
+  
+    def functions_run_all(context:)
+      raise OpenAIExt::FunctionExecutionError, 'No functions to execute' if functions.empty?
+      raise OpenAIExt::FunctionExecutionError, 'Context cannot be nil' if context.nil?
+  
+      functions.map { |function| function.run(context: context) }
+    end
+
+    def to_h
+      {
+        content: content,
+        role: message['role'],
+        model: model,
+        usage: usage,
+        created_at: created_at
+      }.compact
+    end
+
+    def to_s
+      content || self['output_text'] || '[No content]'
+    end
+  end
+end

data/lib/gpt/responses.rb

@@ -5,16 +5,20 @@ module GPT
     end
 
     def create(payload)
-      @client.json_post('/v1/responses', body: payload)
+      res = @client.json_post('/v1/responses', body: payload)
+      res.extend(GPT::ResponseExtender) if res.is_a?(Hash)
+      res
     end
 
     def get(response_id, include: nil, include_obfuscation: nil, starting_after: nil, stream: nil)
-      query = {}
-      query['include[]'] = include if include
-      query['include_obfuscation'] = include_obfuscation unless include_obfuscation.nil?
-      query['starting_after'] = starting_after if starting_after
-      query['stream'] = stream unless stream.nil?
-      @client.json_get("/v1/responses/#{response_id}", query: query)
+      query = []
+      Array(include).each { |v| query << ['include[]', v] } if include
+      query << ['include_obfuscation', include_obfuscation] unless include_obfuscation.nil?
+      query << ['starting_after', starting_after] if starting_after
+      query << ['stream', stream] unless stream.nil?
+      res = @client.json_get("/v1/responses/#{response_id}", query: query)
+      res.extend(GPT::ResponseExtender) if res.is_a?(Hash)
+      res
     end
 
     def delete(response_id)
@@ -42,6 +46,49 @@ module GPT
         yield chunk if block_given?
       end
     end
+
+    def stream_text(payload)
+      buffer = ''.dup
+      stream(payload) do |chunk|
+        buffer << chunk
+        parts = buffer.split("\n\n", -1)
+        buffer = parts.pop || ''.dup
+        parts.each do |raw_event|
+          lines = raw_event.split("\n")
+          event_name = nil
+          data_lines = []
+          lines.each do |line|
+            if line.start_with?('event:')
+              event_name = line.sub('event:', '').strip
+            elsif line.start_with?('data:')
+              data_lines << line.sub('data:', '').strip
+            end
+          end
+          next if data_lines.empty?
+          data = data_lines.join("\n")
+          next if data == '[DONE]'
+          begin
+            json = Oj.load(data)
+          rescue Oj::ParseError
+            next
+          end
+          case event_name
+          when 'response.output_text.delta'
+            delta = json['delta']
+            yield delta if delta && !delta.empty?
+          when 'response.delta'
+            delta = json.dig('delta', 'content')
+            if delta.is_a?(Array)
+              text_piece = delta.find { |c| c['type'] == 'output_text' || c['type'] == 'text' }
+              yield(text_piece['text']) if text_piece && text_piece['text'] && !text_piece['text'].empty?
+            end
+          else
+            # ignore other events
+          end
+        end
+      end
+      true
+    end
   end
 end
 

data/lib/gpt/version.rb

@@ -0,0 +1,5 @@
+module GPT
+  VERSION = '0.2.0'
+end
+
+

data/lib/gpt.rb

@@ -1,10 +1,14 @@
+module GPT; end
+
 require 'oj'
 require 'net/http'
 require 'uri'
 
+require_relative 'gpt/version'
 require_relative 'gpt/error'
 require_relative 'gpt/client'
 require_relative 'gpt/responses'
+require_relative 'gpt/response_extender'
 
 module GPT
   def self.client
@@ -14,6 +18,284 @@ module GPT
   def self.responses
     @responses ||= Responses.new(client)
   end
+
+  def self.deep_stringify(value)
+    case value
+    when Hash
+      value.each_with_object({}) { |(k, v), acc| acc[k.to_s] = deep_stringify(v) }
+    when Array
+      value.map { |v| deep_stringify(v) }
+    when Symbol
+      value.to_s
+    else
+      value
+    end
+  end
+
+  def self.normalize_tools(tools)
+    return tools unless tools.is_a?(Array)
+    tools.map do |tool|
+      next tool unless tool.is_a?(Hash)
+      t = deep_stringify(tool)
+      if t['type'].to_s == 'function'
+        fn = t['function'] || {}
+        t['name'] = t['name'] || fn['name']
+        t['description'] = t['description'] || fn['description']
+        t['parameters'] = t['parameters'] || fn['parameters']
+        # Remover strict se for nil para evitar problemas
+        if t.key?('strict') || fn.key?('strict')
+          t['strict'] = t.key?('strict') ? t['strict'] : fn['strict']
+        end
+        t.delete('function')
+      end
+      t
+    end
+  end
+
+  def self.ask(prompt, model: 'gpt-5', stream: false, text_stream: false, **opts, &block)
+    internal_tools_context = opts.key?(:tools_context) ? opts.delete(:tools_context) : opts.delete('tools_context')
+    internal_max_iters = opts.key?(:max_tool_iterations) ? opts.delete(:max_tool_iterations) : opts.delete('max_tool_iterations')
+    # Se tools_context foi fornecido, ativa a execução automática de tools
+    internal_auto = !!internal_tools_context
+
+    payload = { 'model' => model, 'input' => prompt }
+    opts.each { |k, v| payload[k.to_s] = v }
+    payload = deep_stringify(payload)
+    if payload['tools']
+      payload['tools'] = normalize_tools(payload['tools'])
+    end
+
+    if internal_auto
+      return ask_with_auto_tools(payload, prompt: prompt, tools_context: internal_tools_context, max_tool_iterations: internal_max_iters)
+    end
+
+    if stream
+      responses.stream(payload) { |chunk| yield chunk if block_given? }
+    elsif text_stream
+      responses.stream_text(payload) { |text| yield text if block_given? }
+    else
+      res = responses.create(payload)
+      res.extend(ResponseExtender)
+      normalize_response_output!(res)
+      wait_for_response_if_needed(res)
+    end
+  end
+
+  def self.ask_with_auto_tools(base_payload, prompt:, tools_context:, max_tool_iterations: 5)
+    raise GPT::Error.new('auto_tools requer tools') unless base_payload['tools']
+    raise GPT::Error.new('auto_tools requer tools_context') unless tools_context
+
+    res = responses.create(base_payload)
+    res.extend(ResponseExtender)
+    normalize_response_output!(res)
+    res = wait_for_response_if_needed(res)
+
+    iterations = 0
+    last_results = []
+    loop do
+      iterations += 1
+      break if iterations > (max_tool_iterations || 5)
+
+      tool_calls = extract_tool_calls(res)
+      break if tool_calls.empty?
+
+      results = tool_calls.map do |c|
+        args = c['arguments'].is_a?(String) ? safe_parse_json(c['arguments']) : c['arguments']
+        args = args.is_a?(Hash) ? symbolize_keys(args) : {}
+        output = execute_tool(tools_context, c['name'], args)
+        build_tool_result(c['id'], c['name'], output)
+      end
+      last_results = results
+
+      # Construir uma mensagem completa com todo o contexto
+      tool_calls_description = tool_calls.map do |tc|
+        args = tc['arguments'].is_a?(String) ? tc['arguments'] : Oj.dump(tc['arguments'])
+        "Chamada de ferramenta: #{tc['name']} com argumentos: #{args}"
+      end.join("\n")
+      
+      tool_results_text = results.map do |r|
+        text = r.dig('content', 0, 'text') || ''
+        "Resultado de #{r['name']}: #{text}"
+      end.join("\n")
+      
+      # Criar um prompt completo com todo o contexto
+      full_context = [
+        "Usuário solicitou: #{prompt}",
+        "",
+        "Você chamou as seguintes ferramentas:",
+        tool_calls_description,
+        "",
+        "As ferramentas retornaram os seguintes resultados:",
+        tool_results_text,
+        "",
+        "Agora, forneça uma resposta completa e útil ao usuário baseada nos resultados das ferramentas executadas."
+      ].join("\n")
+      
+      # Manter as tools definidas para contexto, mas enviar como input simples
+      payload = base_payload.dup
+      payload['input'] = full_context
+      res = responses.create(payload)
+      res.extend(ResponseExtender)
+      normalize_response_output!(res)
+      res = wait_for_response_if_needed(res)
+    end
+
+    if (!res['output_text'] || res['output_text'].empty?) && last_results.is_a?(Array) && last_results.any?
+      texts = last_results.map { |r| r.dig('content', 0, 'text') }.compact.join
+      res['output_text'] = texts unless texts.empty?
+    end
+    res
+  end
+
+  def self.normalize_tool_call(call)
+    return call unless call.is_a?(Hash)
+    if call['type'] == 'function_call'
+      {
+        'id' => call['call_id'] || call['id'],
+        'type' => 'tool_call',
+        'name' => call['name'],
+        'arguments' => call['arguments']
+      }
+    else
+      call
+    end
+  end
+
+  def self.extract_tool_calls(res)
+    if res.is_a?(Hash)
+      output = res['output']
+      if output.is_a?(Array)
+        calls = output.select { |i| i.is_a?(Hash) && (i['type'] == 'tool_call' || i['type'] == 'function_call') }
+        return calls.map { |c| normalize_tool_call(c) } if calls.any?
+      end
+      if res['choices'].is_a?(Array)
+        msg = res.dig('choices', 0, 'message') || {}
+        calls = msg['tool_calls']
+        if calls.is_a?(Array)
+          return calls.map do |c|
+            {
+              'id' => c['id'],
+              'type' => 'tool_call',
+              'name' => c.dig('function', 'name') || c['name'],
+              'arguments' => c.dig('function', 'arguments') || c['arguments']
+            }
+          end
+        end
+      end
+    end
+    []
+  end
+
+  def self.build_tool_result(tool_call_id, name, output)
+    {
+      'type' => 'tool_result',
+      'tool_call_id' => tool_call_id,
+      'name' => name,
+      'content' => [{ 'type' => 'output_text', 'text' => output.to_s }]
+    }
+  end
+
+  def self.safe_parse_json(str)
+    return {} unless str.is_a?(String)
+    Oj.load(str)
+  rescue Oj::ParseError
+    {}
+  end
+
+  def self.symbolize_keys(h)
+    h.each_with_object({}) { |(k, v), acc| acc[(k.to_sym rescue k)] = v }
+  end
+
+  def self.execute_tool(ctx, name, args)
+    if ctx.respond_to?(name)
+      ctx.public_send(name, **args)
+    else
+      raise GPT::Error.new("Ferramenta não encontrada: #{name}")
+    end
+  end
+
+  def self.normalize_response_output!(res)
+    return unless res.is_a?(Hash)
+    return if res['output_text'].is_a?(String) && !res['output_text'].empty?
+    # 1) Responses API: output array
+    if res['output'].is_a?(Array)
+      texts = res['output'].map do |i|
+        if i.is_a?(Hash)
+          if i['type'] == 'output_text' || i['type'] == 'text'
+            i['text']
+          elsif i['type'] == 'message'
+            content = i['content']
+            if content.is_a?(Array)
+              item = content.find { |c| c['type'] == 'output_text' || c['type'] == 'text' }
+              item && item['text']
+            end
+          end
+        end
+      end.compact
+      combined = texts.join
+      res['output_text'] = combined unless combined.empty?
+    end
+    # 2) Chat style: choices[0].message.content can be string or array
+    if (!res['output_text'] || res['output_text'].empty?) && res['choices'].is_a?(Array)
+      msg = res.dig('choices', 0, 'message') || {}
+      if msg['content'].is_a?(String)
+        res['output_text'] = msg['content'] unless msg['content'].empty?
+      elsif msg['content'].is_a?(Array)
+        item = msg['content'].find { |c| c['type'] == 'text' || c['type'] == 'output_text' }
+        res['output_text'] = item['text'] if item && item['text'] && !item['text'].empty?
+      end
+    end
+  end
+
+  def self.wait_for_response_if_needed(res, poll_interval: 0.5, timeout_s: 60)
+    start_time = Time.now
+    loop do
+      if response_has_content_or_calls?(res)
+        return res
+      end
+      id = res['id']
+      break unless id
+      if Time.now - start_time > timeout_s
+        puts "DEBUG wait: Timeout atingido" if ENV['DEBUG_WAIT']
+        break
+      end
+      sleep poll_interval
+      refreshed = responses.get(id, include: ['output'])
+      refreshed.extend(ResponseExtender) if refreshed.is_a?(Hash)
+      normalize_response_output!(refreshed)
+      res = refreshed
+    end
+    res
+  end
+
+  def self.response_has_content_or_calls?(res)
+    return false unless res.is_a?(Hash)
+    ot = res['output_text']
+    return true if ot.is_a?(String) && !ot.empty?
+    out = res['output']
+    if out.is_a?(Array)
+      has_text = out.any? { |i| i.is_a?(Hash) && ((i['type'] == 'output_text' || i['type'] == 'text') && i['text'] && !i['text'].empty?) }
+      return true if has_text
+      has_message_text = out.any? do |i|
+        i.is_a?(Hash) && i['type'] == 'message' && i['content'].is_a?(Array) && i['content'].any? { |c| (c['type'] == 'text' || c['type'] == 'output_text') && c['text'] && !c['text'].empty? }
+      end
+      return true if has_message_text
+      has_calls = out.any? { |i| i.is_a?(Hash) && (i['type'] == 'tool_call' || i['type'] == 'function_call') }
+      return true if has_calls
+    end
+    if res['choices'].is_a?(Array)
+      msg = res.dig('choices', 0, 'message') || {}
+      cont = msg['content']
+      return true if cont.is_a?(String) && !cont.empty?
+      if cont.is_a?(Array)
+        item = cont.find { |c| (c['type'] == 'text' || c['type'] == 'output_text') && c['text'] && !c['text'].empty? }
+        return true if item
+      end
+    end
+    status = res['status']
+    return true if %w[completed failed cancelled error errored].include?(status.to_s)
+    false
+  end
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gpt
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Gedean Dias
@@ -93,8 +93,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: Based on ruby-openai, adds some extra features for working with OpenAI
-  APIs
+description: Cliente Ruby simples para a Responses API com suporte a reasoning, tools
+  (inclui autoexec) e chat.
 email: gedean.dias@gmail.com
 executables: []
 extensions: []
@@ -106,7 +106,9 @@ files:
 - lib/gpt.rb
 - lib/gpt/client.rb
 - lib/gpt/error.rb
+- lib/gpt/response_extender.rb
 - lib/gpt/responses.rb
+- lib/gpt/version.rb
 homepage: https://github.com/gedean/openaiext
 licenses:
 - MIT
@@ -127,5 +129,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.1
 specification_version: 4
-summary: GPT >= 5
+summary: Cliente Ruby para GPT-5 (Responses API)
 test_files: []