ai-chat 0.0.8 → 0.1.1

data/ai-chat.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "ai-chat"
+  spec.version = "0.1.1"
+  spec.authors = ["Raghu Betina"]
+  spec.email = ["raghu@firstdraft.com"]
+  spec.homepage = "https://github.com/firstdraft/ai-chat"
+  spec.summary = "A beginner-friendly Ruby interface for OpenAI's API"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/firstdraft/ai-chat/issues",
+    "changelog_uri" => "https://github.com/firstdraft/ai-chat/blob/main/CHANGELOG.md",
+    "homepage_uri" => "https://github.com/firstdraft/ai-chat",
+    "label" => "AI Chat",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/firstdraft/ai-chat"
+  }
+
+
+  spec.required_ruby_version = "~> 3.2"
+  spec.add_dependency "zeitwerk", "~> 2.7"
+  spec.add_dependency "openai", "~> 0.14"
+  spec.add_runtime_dependency "mime-types", "~> 3.0"
+  spec.add_runtime_dependency "base64", "~> 0.1"  # Works for all Ruby versions
+
+  spec.add_development_dependency "dotenv"
+  spec.add_development_dependency "refinements", "~> 11.1"
+
+  spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
+  spec.files = Dir["*.gemspec", "lib/**/*"]
+end

data/lib/ai/chat.rb

@@ -1,76 +1,43 @@
 # frozen_string_literal: true
 
-# All dependencies are now required in the main ai-chat.rb file
+require "base64"
+require "mime-types"
+require "openai"
+
+require_relative "response"
 
 module AI
+  # Main namespace.
   class Chat
-    attr_accessor :messages, :schema, :model
-    attr_reader :reasoning_effort
+    def self.loader(registry = Zeitwerk::Registry)
+      @loader ||= registry.loaders.each.find { |loader| loader.tag == "ai-chat" }
+    end
 
-    VALID_REASONING_EFFORTS = [:low, :medium, :high].freeze
+    attr_accessor :messages, :schema, :model, :web_search
+    attr_reader :reasoning_effort, :client
 
-    def initialize(api_key: nil)
-      @api_key = api_key || ENV.fetch("OPENAI_API_KEY")
+    VALID_REASONING_EFFORTS = [:low, :medium, :high].freeze
+    
+    def initialize(api_key: nil, api_key_env_var: "OPENAI_API_KEY")
+      @api_key = api_key || ENV.fetch(api_key_env_var)
       @messages = []
-      @model = "gpt-4.1-mini"
       @reasoning_effort = nil
+      @model = "gpt-4.1-nano"
+      @client = OpenAI::Client.new(api_key: @api_key)
     end
-    
-    def reasoning_effort=(value)
-      if value.nil?
-        @reasoning_effort = nil
-      else
-        # Convert string to symbol if needed
-        symbol_value = value.is_a?(String) ? value.to_sym : value
-        
-        if VALID_REASONING_EFFORTS.include?(symbol_value)
-          @reasoning_effort = symbol_value
-        else
-          valid_values = VALID_REASONING_EFFORTS.map { |v| ":#{v} or \"#{v}\"" }.join(", ")
-          raise ArgumentError, "Invalid reasoning_effort value: '#{value}'. Must be one of: #{valid_values}"
-        end
-      end
-    end
-
-    def system(content)
-      messages.push({role: "system", content: content})
-    end
-
-    def user(content, image: nil, images: nil)
-      if content.is_a?(Array)
-        processed_content = content.map do |item|
-          if item.key?("image") || item.key?(:image)
-            image_value = item.fetch("image") { item.fetch(:image) }
-            {
-              type: "input_image",
-              image_url: process_image(image_value)
-            }
-          elsif item.key?("text") || item.key?(:text)
-            text_value = item.fetch("text") { item.fetch(:text) }
-            {
-              type: "input_text",
-              text: text_value
-            }
-          else
-            item
-          end
-        end
 
+    def add(content, role: "user", response: nil, image: nil, images: nil, file: nil, files: nil)
+      if image.nil? && images.nil? && file.nil? && files.nil?
         messages.push(
           {
-            role: "user",
-            content: processed_content
-          }
-        )
-      elsif image.nil? && images.nil?
-        messages.push(
-          {
-            role: "user",
-            content: content
-          }
+            role: role,
+            content: content,
+            response: response
+          }.compact
         )
+
       else
-        text_and_images_array = [
+        text_and_files_array = [
           {
             type: "input_text",
             text: content
@@ -81,122 +48,133 @@ module AI
           images_array = images.map do |image|
             {
               type: "input_image",
-              image_url: process_image(image)
+              image_url: process_file(image)
             }
           end
 
-          text_and_images_array += images_array
-        else
-          text_and_images_array.push(
+          text_and_files_array += images_array
+        elsif image
+          text_and_files_array.push(
             {
               type: "input_image",
-              image_url: process_image(image)
+              image_url: process_file(image)
             }
           )
+        elsif files && !files.empty?
+          files_array = files.map do |file|
+            {
+              type: "input_file",
+              filename: "test",
+              file_data: process_file(file)
+            }
+          end
+
+          text_and_files_array += files_array
+        else
+          text_and_files_array.push(
+            {
+              type: "input_file",
+              filename: "test",
+              file_data: process_file(file)
+            }
+          )
+
         end
 
         messages.push(
           {
-            role: "user",
-            content: text_and_images_array
+            role: role,
+            content: text_and_files_array
           }
         )
       end
     end
 
-    def assistant(content)
-      messages.push({role: "assistant", content: content})
+    def system(message)
+      add(message, role: "system")
     end
 
-    def assistant!
-      request_headers_hash = {
-        "Authorization" => "Bearer #{@api_key}",
-        "content-type" => "application/json"
-      }
-
-      request_body_hash = {
-        "model" => model,
-        "input" => messages
-      }
-
-      # Add reasoning parameter if specified
-      if !@reasoning_effort.nil?
-        # Convert symbol back to string for the API request
-        request_body_hash["reasoning"] = {
-          "effort" => @reasoning_effort.to_s
-        }
-      end
+    def user(message, image: nil, images: nil, file: nil, files: nil)
+      add(message, role: "user", image: image, images: images, file: file, files: files)
+    end
+    
+    def assistant(message, response: nil)
+      add(message, role: "assistant", response: response)
+    end
 
-      # Handle structured output (JSON schema)
-      if !schema.nil?
-        # Parse the schema and use it with Structured Output (json_schema)
-        schema_obj = JSON.parse(schema)
-        
-        # Extract schema name from the parsed schema, or use a default
-        schema_name = schema_obj["name"] || "output_object"
-        
-        # Responses API uses proper Structured Output with schema
-        request_body_hash["text"] = {
-          "format" => {
-            "type" => "json_schema",
-            "schema" => schema_obj["schema"] || schema_obj,
-            "name" => schema_name,
-            "strict" => true
-          }
-        }
+    def generate!
+      response = create_response
+
+      if web_search
+        message = response.output.last.content.first.text
+        chat_response = Response.new(response)
+        assistant(message, response: chat_response)
+      elsif schema
+        # filtering out refusals...
+        json_response = response.output.flat_map { _1.content }.select { _1.is_a?(OpenAI::Models::Responses::ResponseOutputText)}.first.text
+        chat_response = Response.new(response)
+        message = JSON.parse(json_response, symbolize_names: true)
+        assistant(message, response: chat_response)
+      else
+        message = response.output.last.content.first.text
+        chat_response = Response.new(response)
+        assistant(message, response: chat_response)
       end
 
-      request_body_json = JSON.generate(request_body_hash)
-
-      uri = URI("https://api.openai.com/v1/responses")
-      raw_response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-        request = Net::HTTP::Post.new(uri, request_headers_hash)
-        request.body = request_body_json
-        http.request(request)
-      end
+      message
+    end
 
-      # Handle empty responses or HTTP errors
-      if raw_response.code.to_i >= 400
-        raise "HTTP Error #{raw_response.code}: #{raw_response.message}\n#{raw_response.body}"
-      end
+    def pick_up_from(response_id)
+      response = client.responses.retrieve(response_id)
+      chat_response = Response.new(response)
+      message = response.output.flat_map { _1.content }.select { _1.is_a?(OpenAI::Models::Responses::ResponseOutputText)}.first.text
+      assistant(message, response: chat_response)
+      message
+    end
 
-      if raw_response.body.nil? || raw_response.body.empty?
-        raise "Empty response received from OpenAI API"
-      end
+    def reasoning_effort=(value)
+      if value.nil?
+        @reasoning_effort = nil
+      else
+        # Convert string to symbol if needed
+        symbol_value = value.is_a?(String) ? value.to_sym : value
 
-      parsed_response = JSON.parse(raw_response.body)
-      
-      # Check for API errors
-      if parsed_response.key?("error") && parsed_response["error"].is_a?(Hash)
-        error_message = parsed_response["error"]["message"] || parsed_response["error"].inspect
-        raise "OpenAI API Error: #{error_message}"
-      end
-      
-      # Extract the text content from the response
-      content = ""
-      
-      # Parse response according to the documented structure
-      if parsed_response.key?("output") && parsed_response["output"].is_a?(Array) && !parsed_response["output"].empty?
-        output_item = parsed_response["output"][0]
-        
-        if output_item["type"] == "message" && output_item.key?("content")
-          content_items = output_item["content"]
-          output_text_item = content_items.find { |item| item["type"] == "output_text" }
-          
-          if output_text_item && output_text_item.key?("text")
-            content = output_text_item["text"]
-          end
+        if VALID_REASONING_EFFORTS.include?(symbol_value)
+          @reasoning_effort = symbol_value
+        else
+          valid_values = VALID_REASONING_EFFORTS.map { |v| ":#{v} or \"#{v}\"" }.join(", ")
+          raise ArgumentError, "Invalid reasoning_effort value: '#{value}'. Must be one of: #{valid_values}"
         end
       end
-      
-      # If no content is found, throw an error
-      if content.empty?
-        raise "Failed to extract content from response: #{parsed_response.inspect}"
+    end
+  
+    def schema=(value)
+      if value.is_a?(String)
+        @schema = JSON.parse(value, symbolize_names: true)
+        unless @schema.key?(:format) || @schema.key?("format")
+          @schema = { format: @schema }
+        end
+      elsif value.is_a?(Hash)
+        if value.key?(:format) || value.key?("format")
+          @schema = value
+        else
+          @schema = { format: value }
+        end
+      else
+        raise ArgumentError, "Invalid schema value: '#{value}'. Must be a String containing JSON or a Hash."
       end
+    end
 
-      messages.push({role: "assistant", content: content})
+    def last
+      messages.last
+    end
+
+    def last_response
+      last[:response]
+    end
 
-      schema.nil? ? content : JSON.parse(content)
+    def last_response_id
+      last_response&.id
     end
 
     def inspect
@@ -208,6 +186,20 @@ module AI
     # Custom exception class for input classification errors.
     class InputClassificationError < StandardError; end
 
+    def create_response
+      parameters = {
+        model: model,
+        input: strip_responses(messages),
+        tools: tools,
+        text: schema,
+        reasoning: {
+          effort: reasoning_effort
+        }.compact
+      }.compact
+      parameters = parameters.delete_if { |k, v| v.empty? }
+      client.responses.create(**parameters)
+    end
+
     def classify_obj(obj)
       if obj.is_a?(String)
         # Attempt to parse as a URL.
@@ -236,7 +228,7 @@ module AI
       end
     end
 
-    def process_image(obj)
+    def process_file(obj)
       case classify_obj(obj)
       when :url
         obj
@@ -262,13 +254,31 @@ module AI
         mime_type = MIME::Types.type_for(filename).first.to_s
         mime_type = "image/jpeg" if mime_type.empty?
 
-        image_data = obj.read
+        file_data = obj.read
         obj.rewind if obj.respond_to?(:rewind)
 
-        base64_string = Base64.strict_encode64(image_data)
+        base64_string = Base64.strict_encode64(file_data)
 
         "data:#{mime_type};base64,#{base64_string}"
       end
     end
+
+    def strip_responses(messages)
+      messages.each do |message|
+        message.delete(:response) if message.key?(:response)
+        message[:content] = JSON.generate(message[:content]) if message[:content].is_a?(Hash)
+      end
+    end
+
+    def tools
+      tools_list = []
+      if web_search
+        tools_list << { type: "web_search_preview" } 
+      end
+    end
+
+    def extract_message(response)
+      response.output.flat_map { _1.content }.select { _1.is_a?(OpenAI::Models::Responses::ResponseOutputText)}.first.text
+    end
   end
 end

data/lib/ai/response.rb

@@ -0,0 +1,12 @@
+module AI
+  class Response
+    attr_reader :id, :model, :usage, :total_tokens
+
+    def initialize(response)
+      @id = response.id
+      @model = response.model
+      @usage = response.usage.to_h.slice(:input_tokens, :output_tokens, :total_tokens)
+      @total_tokens = @usage[:total_tokens]
+    end
+  end
+end

data/lib/ai-chat.rb

@@ -1,11 +1 @@
-# All gem dependencies
-require "mime/types"
-require "base64"
-require "json"
-require "net/http"
-require "pathname"
-require "uri"
-
-# Internal gem files
-require "ai/chat/version"
-require "ai/chat"
+require_relative "ai/chat"

data/lib/ai_chat.rb

@@ -0,0 +1,6 @@
+  require "zeitwerk"
+  loader = Zeitwerk::Loader.for_gem
+  loader.inflector.inflect("ai" => "AI")
+  loader.setup
+
+  require_relative "ai/chat"

metadata

@@ -1,175 +1,142 @@
 --- !ruby/object:Gem::Specification
 name: ai-chat
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.1
 platform: ruby
 authors:
 - Raghu Betina
-- Jelani Woods
-bindir: exe
+autorequire:
+bindir: bin
 cert_chain: []
-date: 2025-04-26 00:00:00.000000000 Z
+date: 2025-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: mime-types
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
-  name: base64
+  name: openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '0.14'
 - !ruby/object:Gem::Dependency
-  name: factory_bot
+  name: mime-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.2'
-  type: :development
+        version: '3.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.2'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
-  type: :development
+        version: '0.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: vcr
+  name: dotenv
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: standard
+  name: refinements
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.32'
+        version: '11.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.32'
-description: This gem provides a class called `AI::Chat` that is intended to make
-  it as easy as possible to use OpenAI's Responses API. Supports Structured Output
-  and Image Processing.
+        version: '11.1'
+description:
 email:
 - raghu@firstdraft.com
-- jelani@firstdraft.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- LICENSE
 files:
-- ".config/rubocop/config.yml"
-- ".reek.yml"
-- ".ruby-version"
-- CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
-- Rakefile
-- ai_chat.gemspec
+- ai-chat.gemspec
 - lib/ai-chat.rb
 - lib/ai/chat.rb
-- lib/ai/chat/version.rb
-- test_program/Gemfile
-- test_program/test_ai_chat.rb
+- lib/ai/response.rb
+- lib/ai_chat.rb
 homepage: https://github.com/firstdraft/ai-chat
 licenses:
 - MIT
 metadata:
+  bug_tracker_uri: https://github.com/firstdraft/ai-chat/issues
+  changelog_uri: https://github.com/firstdraft/ai-chat/blob/main/CHANGELOG.md
   homepage_uri: https://github.com/firstdraft/ai-chat
+  label: AI Chat
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/firstdraft/ai-chat
-  changelog_uri: https://github.com/firstdraft/ai-chat/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.5.23
+signing_key:
 specification_version: 4
-summary: This gem provides a class called `AI::Chat` that is intended to make it as
-  easy as possible to use OpenAI's Responses API.
+summary: A beginner-friendly Ruby interface for OpenAI's API
 test_files: []

data/.config/rubocop/config.yml

@@ -1,2 +0,0 @@
-inherit_gem:
-  caliber: config/all.yml