ai-chat 0.4.0 → 0.5.1

data/lib/ai/chat.rb

@@ -11,9 +11,6 @@ require "fileutils"
 require "tty-spinner"
 require "timeout"
 
-require_relative "http"
-include AI::Http
-
 module AI
   # :reek:MissingSafeMethod { exclude: [ generate! ] }
   # :reek:TooManyMethods
@@ -22,21 +19,22 @@ module AI
   # :reek:IrresponsibleModule
   class Chat
     # :reek:Attribute
-    attr_accessor :background, :code_interpreter, :conversation_id, :image_generation, :image_folder, :messages, :model, :proxy, :reasoning_effort, :web_search
-    attr_reader :client, :last_response_id, :schema, :schema_file
+    attr_accessor :background, :code_interpreter, :conversation_id, :image_generation, :image_folder, :messages, :model, :reasoning_effort, :web_search
+    attr_reader :client, :last_response_id, :proxy, :schema, :schema_file
 
-    PROXY_URL = "https://prepend.me/"
+    BASE_PROXY_URL = "https://prepend.me/api.openai.com/v1"
 
     def initialize(api_key: nil, api_key_env_var: "OPENAI_API_KEY")
       @api_key = api_key || ENV.fetch(api_key_env_var)
+      @proxy = false
       @messages = []
       @reasoning_effort = nil
-      @model = "gpt-5.1"
+      @model = "gpt-5.2"
       @client = OpenAI::Client.new(api_key: @api_key)
       @last_response_id = nil
-      @proxy = false
       @image_generation = false
       @image_folder = "./images"
+      @api_key_validated = false
     end
 
     def self.generate_schema!(description, location: "schema.json", api_key: nil, api_key_env_var: "OPENAI_API_KEY", proxy: false)
@@ -44,34 +42,25 @@ module AI
       prompt_path = File.expand_path("../prompts/schema_generator.md", __dir__)
       system_prompt = File.read(prompt_path)
 
-      json = if proxy
-        uri = URI(PROXY_URL + "api.openai.com/v1/responses")
-        parameters = {
-          model: "gpt-5.1",
-          input: [
-            {role: :system, content: system_prompt},
-            {role: :user, content: description}
-          ],
-          text: {format: {type: "json_object"}},
-          reasoning: {effort: "high"}
-        }
+      options = {
+        api_key: api_key,
+        base_url: proxy ? BASE_PROXY_URL : nil
+      }.compact
 
-        send_request(uri, content_type: "json", parameters: parameters, method: "post")
-      else
-        client = OpenAI::Client.new(api_key: api_key)
-        response = client.responses.create(
-          model: "gpt-5.1",
-          input: [
-            {role: :system, content: system_prompt},
-            {role: :user, content: description}
-          ],
-          text: {format: {type: "json_object"}},
-          reasoning: {effort: "high"}
-        )
+      client = OpenAI::Client.new(**options)
+      response = client.responses.create(
+        model: "gpt-5.2",
+        input: [
+          {role: :system, content: system_prompt},
+          {role: :user, content: description}
+        ],
+        text: {format: {type: "json_object"}},
+        reasoning: {effort: "high"}
+      )
+
+      output_text = response.output_text
+      json = JSON.parse(output_text)
 
-        output_text = response.output_text
-        JSON.parse(output_text)
-      end
       content = JSON.pretty_generate(json)
       if location
         path = Pathname.new(location)
@@ -84,15 +73,12 @@ module AI
     # :reek:TooManyStatements
     # :reek:NilCheck
     def add(content, role: "user", response: nil, status: nil, image: nil, images: nil, file: nil, files: nil)
-      if image.nil? && images.nil? && file.nil? && files.nil?
-        message = {
-          role: role,
-          content: content,
-          response: response
-        }
-        message[:content] = content if content
-        message[:status] = status if status
-        messages.push(message)
+      message = if image.nil? && images.nil? && file.nil? && files.nil?
+        msg = Message[role: role]
+        msg[:content] = content if content
+        msg[:response] = response if response
+        msg[:status] = status if status
+        msg
       else
         text_and_files_array = [
           {
@@ -122,14 +108,15 @@ module AI
           text_and_files_array.push(process_file_input(file))
         end
 
-        messages.push(
-          {
-            role: role,
-            content: text_and_files_array,
-            status: status
-          }
-        )
+        Message[
+          role: role,
+          content: text_and_files_array,
+          status: status
+        ]
       end
+
+      messages.push(message)
+      message
     end
 
     def system(message)
@@ -147,7 +134,7 @@ module AI
     # :reek:NilCheck
     # :reek:TooManyStatements
     def generate!
-      validate_api_key
+      validate_api_key unless @api_key_validated
       response = create_response
       parse_response(response)
 
@@ -168,6 +155,19 @@ module AI
       parse_response(response)
     end
 
+    def proxy=(value)
+      @proxy = value
+      if value
+        @client = OpenAI::Client.new(
+          api_key: @api_key,
+          base_url: BASE_PROXY_URL
+        )
+      else
+        @client = OpenAI::Client.new(api_key: @api_key)
+      end
+      value
+    end
+
     def schema=(value)
       if value.is_a?(String)
         parsed = JSON.parse(value, symbolize_names: true)
@@ -189,88 +189,54 @@ module AI
       messages.last
     end
 
-    def items(order: :asc)
+    def get_items(order: :asc)
       raise "No conversation_id set. Call generate! first to create a conversation." unless conversation_id
 
-      if proxy
-        uri = URI(PROXY_URL + "api.openai.com/v1/conversations/#{conversation_id}/items?order=#{order}")
-        response_hash = send_request(uri, content_type: "json", method: "get")
-
-        if response_hash.key?(:data)
-          response_hash.dig(:data).map do |hash|
-            # Transform values to allow expected symbols that non-proxied request returns
-
-            hash.transform_values! do |value|
-              if hash.key(value) == :type
-                value.to_sym
-              else
-                value
-              end
-            end
-          end
-          response_hash
-        end
-        # Convert to Struct to allow same interface as non-proxied request
-        create_deep_struct(response_hash)
-      else
-        client.conversations.items.list(conversation_id, order: order)
-      end
+      raw_items = client.conversations.items.list(conversation_id, order: order)
+
+      Items.new(raw_items, conversation_id: conversation_id)
     end
 
-    def verbose
-      page = items
+    def inspectable_attributes
+      attrs = []
 
-      box_width = 78
-      inner_width = box_width - 4
+      # 1. Model and reasoning (configuration)
+      attrs << [:@model, @model]
+      attrs << [:@reasoning_effort, @reasoning_effort]
 
-      puts
-      puts "┌#{"─" * (box_width - 2)}┐"
-      puts "│ Conversation: #{conversation_id.ljust(inner_width - 14)} │"
-      puts "│ Items: #{page.data.length.to_s.ljust(inner_width - 7)} │"
-      puts "└#{"─" * (box_width - 2)}┘"
-      puts
+      # 2. Conversation state
+      attrs << [:@conversation_id, @conversation_id]
+      attrs << [:@last_response_id, @last_response_id] if @last_response_id
 
-      ap page.data, limit: 10, indent: 2
+      # 3. Messages (the main content, without response details)
+      display_messages = @messages.map { |msg| msg.except(:response) }
+      attrs << [:@messages, display_messages]
+
+      # 4. Optional features (only if enabled/changed from default)
+      attrs << [:@proxy, @proxy] if @proxy != false
+      attrs << [:@image_generation, @image_generation] if @image_generation != false
+      attrs << [:@image_folder, @image_folder] if @image_folder != "./images"
+
+      # 5. Optional state (only if set)
+      attrs << [:@background, @background] if @background
+      attrs << [:@code_interpreter, @code_interpreter] if @code_interpreter
+      attrs << [:@web_search, @web_search] if @web_search
+      attrs << [:@schema, @schema] if @schema
+      attrs << [:@schema_file, @schema_file] if @schema_file
+
+      attrs
     end
 
     def inspect
-      "#<#{self.class.name} @messages=#{messages.inspect} @model=#{@model.inspect} @schema=#{@schema.inspect} @reasoning_effort=#{@reasoning_effort.inspect}>"
+      ai(plain: !$stdout.tty?, multiline: true)
     end
 
-    # Support for Ruby's pp (pretty print)
-    # :reek:TooManyStatements
-    # :reek:NilCheck
-    # :reek:FeatureEnvy
-    # :reek:DuplicateMethodCall
-    # :reek:UncommunicativeParameterName
-    def pretty_print(q)
-      q.group(1, "#<#{self.class}", ">") do
-        q.breakable
-
-        # Show messages with truncation
-        q.text "@messages="
-        truncated_messages = @messages.map do |msg|
-          truncated_msg = msg.dup
-          if msg[:content].is_a?(String) && msg[:content].length > 80
-            truncated_msg[:content] = msg[:content][0..77] + "..."
-          end
-          truncated_msg
-        end
-        q.pp truncated_messages
-
-        # Show other instance variables (except sensitive ones)
-        skip_vars = [:@messages, :@api_key, :@client]
-        instance_variables.sort.each do |var|
-          next if skip_vars.include?(var)
-          value = instance_variable_get(var)
-          unless value.nil?
-            q.text ","
-            q.breakable
-            q.text "#{var}="
-            q.pp value
-          end
-        end
-      end
+    def to_html
+      AI.wrap_html(ai(html: true, multiline: true))
+    end
+
+    def pretty_inspect
+      "#{inspect}\n"
     end
 
     private
@@ -293,14 +259,8 @@ module AI
     end
 
     def create_conversation
-      self.conversation_id = if proxy
-        uri = URI(PROXY_URL + "api.openai.com/v1/conversations")
-        response = send_request(uri, content_type: "json", method: "post")
-        response.dig(:id)
-      else
-        conversation = client.conversations.create
-        conversation.id
-      end
+      conversation = client.conversations.create
+      self.conversation_id = conversation.id
     end
 
     # :reek:TooManyStatements
@@ -312,7 +272,7 @@ module AI
       parameters[:background] = background if background
       parameters[:tools] = tools unless tools.empty?
       parameters[:text] = schema if schema
-      parameters[:reasoning] = {effort: reasoning_effort} if reasoning_effort
+      parameters[:reasoning] = {effort: reasoning_effort, summary: "auto"} if reasoning_effort
 
       create_conversation unless conversation_id
       parameters[:conversation] = conversation_id
@@ -320,50 +280,22 @@ module AI
       messages_to_send = prepare_messages_for_api
       parameters[:input] = strip_responses(messages_to_send) unless messages_to_send.empty?
 
-      if proxy
-        uri = URI(PROXY_URL + "api.openai.com/v1/responses")
-        send_request(uri, content_type: "json", parameters: parameters, method: "post")
-      else
-        client.responses.create(**parameters)
-      end
+      client.responses.create(**parameters)
     end
 
     # :reek:NilCheck
     # :reek:TooManyStatements
     def parse_response(response)
-      if proxy && response.is_a?(Hash)
-        response_messages = response.dig(:output).select do |output|
-          output.dig(:type) == "message"
-        end
-
-        message_contents = response_messages.map do |message|
-          message.dig(:content)
-        end.flatten
+      text_response = response.output_text
+      response_id = response.id
+      response_status = response.status
+      response_model = response.model
+      response_usage = response.usage.to_h.slice(:input_tokens, :output_tokens, :total_tokens)
 
-        output_texts = message_contents.select do |content|
-          content[:type] == "output_text"
-        end
-
-        text_response = output_texts.map { |output| output[:text] }.join
-        response_id = response.dig(:id)
-        response_status = response.dig(:status).to_sym
-        response_model = response.dig(:model)
-        response_usage = response.dig(:usage)&.slice(:input_tokens, :output_tokens, :total_tokens)
-
-        if response.key?(:conversation)
-          self.conversation_id = response.dig(:conversation, :id)
-        end
-      else
-        text_response = response.output_text
-        response_id = response.id
-        response_status = response.status
-        response_model = response.model
-        response_usage = response.usage.to_h.slice(:input_tokens, :output_tokens, :total_tokens)
-
-        if response.conversation
-          self.conversation_id = response.conversation.id
-        end
+      if response.conversation
+        self.conversation_id = response.conversation.id
       end
+
       image_filenames = extract_and_save_images(response) + extract_and_save_files(response)
 
       chat_response = {
@@ -387,12 +319,12 @@ module AI
         message.dig(:response, :id) == response_id
       end
 
-      message = {
+      message = Message[
         role: "assistant",
         content: response_content,
         response: chat_response,
         status: response_status
-      }
+      ]
 
       message.store(:images, image_filenames) unless image_filenames.empty?
 
@@ -400,8 +332,9 @@ module AI
         messages[existing_message_position] = message
       else
         messages.push(message)
-        message
       end
+
+      message
     end
 
     def cancel_request
@@ -591,30 +524,20 @@ module AI
     def extract_and_save_images(response)
       image_filenames = []
 
-      image_outputs = if proxy
-        response.dig(:output).select { |output|
-          output.dig(:type) == "image_generation_call"
-        }
-      else
-        response.output.select { |output|
+      image_outputs = response.output.select { |output|
           output.respond_to?(:type) && output.type == :image_generation_call
         }
-      end
 
       return image_filenames if image_outputs.empty?
 
-      response_id = proxy ? response.dig(:id) : response.id
+      response_id = response.id
       subfolder_path = create_images_folder(response_id)
 
       image_outputs.each_with_index do |output, index|
-        if proxy
-          next unless output.key?(:result) && output.dig(:result)
-        else
-          next unless output.respond_to?(:result) && output.result
-        end
+        next unless output.respond_to?(:result) && output.result
 
         warn_if_file_fails_to_save do
-          result = proxy ? output.dig(:result) : output.result
+          result = output.result
           image_data = Base64.strict_decode64(result)
 
           filename = "#{(index + 1).to_s.rjust(3, "0")}.png"
@@ -646,27 +569,20 @@ module AI
     end
 
     def validate_api_key
-      openai_api_key_used = @api_key.start_with?("sk-proj")
-      proxy_api_key_used = !openai_api_key_used
-      proxy_enabled = proxy
-      proxy_disabled = !proxy
-
-      if openai_api_key_used && proxy_enabled
-        raise WrongAPITokenUsedError, <<~STRING
-          It looks like you're using an official API key from OpenAI with proxying enabled. When proxying is enabled you must use an OpenAI API key from prepend.me. Please disable proxy or update your API key before generating a response.
+      # Simple API call to validate the token
+      client.models.list
+      @api_key_validated = true
+    rescue OpenAI::Errors::AuthenticationError
+      message = if proxy
+         <<~STRING
+          It looks like you're using an invalid API key. Proxying is enabled, so you must use an OpenAI API key from prepend.me. Please disable proxy or update your API key before generating a response.
         STRING
-      elsif proxy_api_key_used && proxy_disabled
-        raise WrongAPITokenUsedError, <<~STRING
-          It looks like you're using an unofficial OpenAI API key from prepend.me. When using an unofficial API key you must enable proxy before generating a response. Proxying is currently disabled, please enable it before generating a response.
-
-          Example:
-
-            chat = AI::Chat.new
-            chat.proxy = true
-            chat.user(...)
-            chat.generate!
+      else
+        <<~STRING
+          It looks like you're using an invalid API key. Check to make sure your API key is valid before generating a response.
         STRING
       end
+      raise WrongAPITokenUsedError, message, cause: nil
     end
 
     # :reek:FeatureEnvy
@@ -676,72 +592,40 @@ module AI
     def extract_and_save_files(response)
       filenames = []
 
-      if proxy
-        message_outputs = response.dig(:output).select do |output|
-          output.dig(:type) == "message"
-        end
+      message_outputs = response.output.select do |output|
+        output.respond_to?(:type) && output.type == :message
+      end
 
-        outputs_with_annotations = message_outputs.map do |message|
-          message.dig(:content).find do |content|
-            content.dig(:annotations).length.positive?
-          end
-        end.compact
-      else
-        message_outputs = response.output.select do |output|
-          output.respond_to?(:type) && output.type == :message
+      outputs_with_annotations = message_outputs.map do |message|
+        message.content.find do |content|
+          content.respond_to?(:annotations) && content.annotations.length.positive?
         end
-
-        outputs_with_annotations = message_outputs.map do |message|
-          message.content.find do |content|
-            content.respond_to?(:annotations) && content.annotations.length.positive?
-          end
-        end.compact
-      end
+      end.compact
 
       return filenames if outputs_with_annotations.empty?
 
-      response_id = proxy ? response.dig(:id) : response.id
+      response_id = response.id
       subfolder_path = create_images_folder(response_id)
 
-      if proxy
-        annotations = outputs_with_annotations.map do |output|
-          output.dig(:annotations).find do |annotation|
-            annotation.key?(:filename)
-          end
-        end.compact
-
-        annotations.each do |annotation|
-          container_id = annotation.dig(:container_id)
-          file_id = annotation.dig(:file_id)
-          filename = annotation.dig(:filename)
-
-          warn_if_file_fails_to_save do
-            file_content = retrieve_file(file_id, container_id: container_id)
-            file_path = File.join(subfolder_path, filename)
-            File.binwrite(file_path, file_content)
-            filenames << file_path
-          end
+      annotations = outputs_with_annotations.map do |output|
+        output.annotations.find do |annotation|
+          annotation.respond_to?(:filename)
         end
-      else
-        annotations = outputs_with_annotations.map do |output|
-          output.annotations.find do |annotation|
-            annotation.respond_to?(:filename)
-          end
-        end.compact
-
-        annotations.each do |annotation|
-          container_id = annotation.container_id
-          file_id = annotation.file_id
-          filename = annotation.filename
-
-          warn_if_file_fails_to_save do
-            file_content = retrieve_file(file_id, container_id: container_id)
-            file_path = File.join(subfolder_path, filename)
-            File.binwrite(file_path, file_content.read)
-            filenames << file_path
-          end
+      end.compact
+
+      annotations.each do |annotation|
+        container_id = annotation.container_id
+        file_id = annotation.file_id
+        filename = annotation.filename
+
+        warn_if_file_fails_to_save do
+          file_content = retrieve_file(file_id, container_id: container_id)
+          file_path = File.join(subfolder_path, filename)
+          File.binwrite(file_path, file_content.read)
+          filenames << file_path
         end
       end
+
       filenames
     end
 
@@ -802,22 +686,12 @@ module AI
     end
 
     def retrieve_response(response_id)
-      if proxy
-        uri = URI(PROXY_URL + "api.openai.com/v1/responses/#{response_id}")
-        send_request(uri, content_type: "json", method: "get")
-      else
-        client.responses.retrieve(response_id)
-      end
+      client.responses.retrieve(response_id)
     end
 
     def retrieve_file(file_id, container_id: nil)
-      if proxy
-        uri = URI(PROXY_URL + "api.openai.com/v1/containers/#{container_id}/files/#{file_id}/content")
-        send_request(uri, method: "get")
-      else
-        container_content = client.containers.files.content
-        container_content.retrieve(file_id, container_id: container_id)
-      end
+      container_content = client.containers.files.content
+      container_content.retrieve(file_id, container_id: container_id)
     end
   end
 end

data/lib/ai/items.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module AI
+  class Items < SimpleDelegator
+    def initialize(response, conversation_id:)
+      super(response)
+      @conversation_id = conversation_id
+    end
+
+    def to_html
+      AI.wrap_html(build_output(html: true))
+    end
+
+    def inspect
+      build_output(html: false, plain: !$stdout.tty?)
+    end
+
+    def pretty_inspect
+      "#{inspect}\n"
+    end
+
+    def pretty_print(q)
+      q.output << inspect
+    end
+
+    private
+
+    def build_output(html: false, plain: false)
+      box = build_box
+      items_output = data.ai(html: html, plain: plain, limit: 100, indent: 2, index: true)
+
+      if html
+        "<pre>#{box}</pre>\n#{items_output}"
+      else
+        "#{box}\n#{items_output}"
+      end
+    end
+
+    def build_box
+      box_width = 78
+      inner_width = box_width - 4
+
+      lines = []
+      lines << "┌#{"─" * (box_width - 2)}┐"
+      lines << "│ Conversation: #{@conversation_id.to_s.ljust(inner_width - 14)} │"
+      lines << "│ Items: #{data.length.to_s.ljust(inner_width - 7)} │"
+      lines << "└#{"─" * (box_width - 2)}┘"
+
+      lines.join("\n")
+    end
+  end
+end

data/lib/ai/message.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AI
+  class Message < Hash
+    def inspect
+      ai(plain: !$stdout.tty?, index: false)
+    end
+
+    def pretty_inspect
+      "#{inspect}\n"
+    end
+
+    # IRB's ColorPrinter calls pretty_print and re-colorizes text,
+    # which escapes our ANSI codes. Write directly to output to bypass.
+    def pretty_print(q)
+      q.output << inspect
+    end
+
+    def to_html
+      AI.wrap_html(ai(html: true, index: false))
+    end
+  end
+end

data/lib/ai-chat.rb

@@ -1,3 +1,14 @@
+module AI
+  HTML_PRE_STYLE = "background-color: #1e1e1e; color: #d4d4d4; padding: 1em; white-space: pre-wrap; word-wrap: break-word;"
+
+  def self.wrap_html(html)
+    html = html.gsub("<pre>", "<pre style=\"#{HTML_PRE_STYLE}\">")
+    html.respond_to?(:html_safe) ? html.html_safe : html
+  end
+end
+
+require_relative "ai/message"
+require_relative "ai/items"
 require_relative "ai/chat"
 
 # Load amazing_print extension if amazing_print is available