gpt 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 840186b5978b9ff54b0aa11256b238bfe03dba6d50020e70ace54dc9ad69e95c
-  data.tar.gz: 63ea299d5a2d5f0c119e99605cde359294bc60de72fe84eadfd704288c03eb06
+  metadata.gz: b725ab7bc465dae82acf06dff54ba12d1199ddd6b21c90d8107839c709da7ba9
+  data.tar.gz: 0b6ef69bac8fcaf22565aedbb3fff199a65957ce08514d7f85aff5fc2f3341ed
 SHA512:
-  metadata.gz: 7aa46b3f49131432ee7e33303d9581a391d7eea15e75b9ff7e5e1ef78ed33a5c720f337cdafb9641d62a8a11bac427b222fcaa8e9d473f4040559cd7c6e8769c
-  data.tar.gz: f8a4865378bd4981362d751e9c4140618bb2451b90c408a92a3ba95ee391138168c3fe26dcbe73211b867d7547b3ac6803f57b5a989d19e4021488e4c5365e74
+  metadata.gz: 9c68b407adf9d726b1bfc215c7523663be86cc0749337618c66d52679b628128a22f7d4ecff9cefd403e023a8b7cd65ad4db849898ff9a367ffe40e28f8a68b0
+  data.tar.gz: 213b43fb66a3ddd8e6d237a01f7aaefdff14a25100332db368c3801bf1967ebf4c3acd6d074fa7762d3326bc062303e831809b49d6065f50b6245c45d8813c66

data/README.md

@@ -3,8 +3,8 @@
 Cliente Ruby simples para a Responses API, com foco no GPT-5, com uma API de alto nível inspirada no OpenAIExt.
 
 ## Instalação
-```
-bash build_and_install.sh
+```bash
+gem install gpt
 ```
 
 ## Configuração
@@ -104,3 +104,52 @@ 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

@@ -120,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

@@ -17,9 +17,21 @@ module GPT
       else
         msg = message
         contents = msg && msg['content']
-        return nil unless contents.is_a?(Array)
-        text_item = contents.find { |c| c['type'] == 'output_text' || c['type'] == 'text' }
-        text_item && text_item['text']
+        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
 
@@ -54,6 +66,26 @@ module GPT
         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
       {
@@ -66,9 +98,7 @@ module GPT
     end
 
     def to_s
-      content || '[No content]'
+      content || self['output_text'] || '[No content]'
     end
   end
 end
-
-

data/lib/gpt/responses.rb

@@ -11,11 +11,11 @@ module GPT
     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?
+      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

data/lib/gpt/version.rb

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

data/lib/gpt.rb

@@ -19,22 +19,282 @@ module GPT
     @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) do |chunk|
-        yield chunk if block_given?
-      end
+      responses.stream(payload) { |chunk| yield chunk if block_given? }
     elsif text_stream
-      responses.stream_text(payload) do |text|
-        yield text if block_given?
-      end
+      responses.stream_text(payload) { |text| yield text if block_given? }
     else
       res = responses.create(payload)
       res.extend(ResponseExtender)
-      res
+      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.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Gedean Dias
@@ -93,8 +93,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: Cliente Ruby simples para a Responses API com suporte aos recursos do
-  GPT-5 (reasoning, verbosity, tools).
+description: Cliente Ruby simples para a Responses API com suporte a reasoning, tools
+  (inclui autoexec) e chat.
 email: gedean.dias@gmail.com
 executables: []
 extensions: []