rubygpt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 80d7d5153895b17a6dc4bd74f3a55ad90a80e8b1a991256d270dbce2813c46af
+  data.tar.gz: 0aee0ce7e85e9a93f05bd26c114bd5cd536cd0bdf70c07e587e5bd751735d82a
+SHA512:
+  metadata.gz: ec76d8aa68dffa1584357eac6a8ebf8c75fef4238a9413f190abd688cf095a8d4cc9e1cf5588f6c11fb9f333e88c8325f2b26f698311d63232ea9830cb9e58ed
+  data.tar.gz: 8b128b1f7901e72369d3323d521b9c49b00260fa92a2ac1ccca11b36bce72f0f7e78c0f3876bdb2c01d2cc8e491032599cefc2cd7e022749c25040a11b6948d0

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,21 @@
+AllCops:
+  TargetRubyVersion: 3.2.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - 'config/**/*'
+    - 'db/**/*'
+    - 'lib/tasks/**/*'
+    - 'rubygpt.gemspec'

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.2.0

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-03-08
+
+- Created the core of the project
+- Enhanced development environment
+- Chat API integration
+  - JSON mode support

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at feapaydin@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2024 - Furkan Enes Apaydın
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,236 @@
+[![Gem Version](https://badge.fury.io/rb/rubygpt.svg)](https://badge.fury.io/rb/rubygpt)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
+[![Spec](https://github.com/feapaydin/rubygpt/actions/workflows/spec.yml/badge.svg?branch=main)](https://github.com/feapaydin/rubygpt/actions/workflows/spec.yml)
+[![Maintainability](https://api.codeclimate.com/v1/badges/55d19b1c7fbe8c48e9ca/maintainability)](https://codeclimate.com/github/feapaydin/rubygpt/maintainability)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# RubyGPT
+
+This gem aims to provide an easy-to-use Ruby wrapper for all modules of OpenAI's ChatGPT API. It is designed to be simple and easy to use, while also providing a high level of customization. It is also aiming to work efficiently in Ruby on Rails applications.
+
+### Capabilities
+
+- [Chat Completions API](#chat-completions-api)
+  - [JSON Mode Support](#json-mode-messages)
+
+The gem is in the early stages. It's designed to be easily extendable for other modules of the OpenAI APIs and products in the future. See [Contributing](#contributing) section for more details.
+
+## Installation
+
+Install the gem directly via bundler:
+
+```sh
+$ bundle install rubygpt
+```
+
+Or add it to your `Gemfile` for your project:
+
+```ruby
+gem "rubygpt"
+```
+
+And then execute:
+
+```sh
+$ bundle install
+```
+
+##  Configuration
+
+In order to access the OpenAI APIs, you must configure the Rubygpt client with your API key and the preferred ChatGPT model to use. This can be done globally for the entire application, or on a per-request basis.
+
+```ruby
+Rubygpt.configure(api_key: 'YOUR_API_KEY', model: 'gpt-3.5-turbo')
+```
+
+Alternatively, you can provide a block to set the configuration options:
+
+```ruby
+Rubygpt.configure do |config|
+    config.api_key = 'YOUR_API_KEY'
+    config.model = 'gpt-3.5-turbo'
+end
+```
+
+The above examples will create a singleton client that works across the entire application.
+
+If you'd like to use different configurations for different parts of your application, you can manually create  client instances and configure them separately:
+
+```ruby
+# Setup different client objects with different configurations
+client_gpt3 = Rubygpt::Client.new(api_key: 'YOUR_API_KEY', model: 'gpt-3.5-turbo')
+client_gpt4 = Rubygpt::Client.new do |config|
+    config.api_key = 'YOUR_SECOND_API_KEY'
+    config.model = 'gpt-4'
+    config.organization_id = 'OPENAI_ORG_ID'
+end
+
+# Use the client objects to create different requesters
+chat_requester_gpt3 = Rubygpt::Requester::ChatRequester.new(client_gpt3)
+chat_requester_gpt4 = Rubygpt::Requester::ChatRequester.new(client_gpt4)
+```
+
+The following attributes can be configured when initializing the client:
+
+- `api_key` (required): Your OpenAI API key
+- `model` (required): The model to use for the API requests.
+- `api_url`: The base URL for the API requests. The default is `https://api.openai.com/v1`
+- `organization_id`: The organization ID to use for the API requests.
+- `connection_adapter`: The HTTP connection adapter to use for the API requests. The default is `:faraday`
+
+#### Connection Adapters
+
+The Rubygpt client uses [Faraday](https://github.com/lostisland/faraday) to manage HTTP connections. This allows the entire power of Faraday to be used for the API requests, including diverse HTTP adapters and features like streaming.
+
+## Chat Completions API
+
+Chat Completions is a Text Completion feature provided by OpenAI's ChatGPT. It can be used to generate human-like responses to a given prompt. It is one of the core features of the ChatGPT.
+
+See the [OpenAI Chat Completions API documentation](https://platform.openai.com/docs/guides/text-generation/chat-completions-api) and related [Chat API reference](https://platform.openai.com/docs/api-reference/chat/create) for more information.
+
+### Sending Messages
+
+After configuring the Rubygpt client, you can perform requests to the Chat Completions API directly.
+
+```ruby
+# Send a message to GPT
+Rubygpt.chat.create("A system of cells interlinked.") # any message you'd like to send
+
+# Send multiple messages
+Rubygpt.chat.create(["Within cells interlinked", "Within cells interlinked", "Within one stem"])
+```
+
+To use the received responses, refer to the [Using Chat Completion Responses](#using-chat-completion-responses) section.
+
+### Customizing the Messages
+
+By default each message is sent with `system` role and the provided contents in the call.
+
+```ruby
+Rubygpt.chat.create("Test message.") # { role: "system", content: "Test message." }
+```
+
+You can customize the request by providing additional parameters to the `create` method.
+
+A `Message` object consist of following attributes:
+- `role`: The role of the messages author.
+- `content`: The content of the message.
+- `name`: The name of the messages author or function name. (has multiple use cases, see OpenAI docs for details)
+- `tool_calls`: The tool calls generated by the model, such as function calls. (role: assistant only)
+- `tool_call_id`: Tool call that this message is responding to. (role: tool only)
+
+For extended details on the attributes, visit the [OpenAI Chat API reference](https://platform.openai.com/docs/api-reference/chat/create).
+
+```ruby
+Rubygpt.chat.create(role: 'user', content: "What is Ruby?")
+Rubygpt.chat.create(role: 'assistant', name: 'furkan', content: "Ruby is a...")
+```
+It is also possible to send multiple message objects with a single request.
+
+```ruby
+messages = [
+    { role: 'user', content: "foo" },
+    { role: 'assistant', name: 'johndoe', content: "bar" }
+]
+Rubygpt.chat.create(messages) # send the array/hash directly
+Rubygpt.chat.create(messages:) # also works as a keyword argument
+```
+
+### Customizing The Requests
+
+You can send any available request body parameter supported by OpenAI Chat Completion API to the `Rubygpt.chat.create` method. Just send the messages in the `messages:` keyword argument. Any additional parameters you'll provide will be passed-through to the request body directly.
+
+```ruby
+Rubygpt.chat.create(
+    n: 5,
+    messages: ["What time is it?"],
+    model: 'gpt-4-turbo-preview', # overrides your client config when provided explicity here
+    max_tokens: 100,
+    frequency_penalty: 1.0,
+    tempature: 1,
+    user: 'feapaydin',
+    json: true # DO NOT provide response_format for JSON mode, use this flag
+)
+```
+
+### JSON Mode Messages
+
+The JSON Mode is a feature of the Chat Completions API that forces the model to generate a JSON response. 
+
+> A common way to use Chat Completions is to instruct the model to always return a JSON object that makes sense for your use case, by specifying this in the system message. While this does work in some cases, occasionally the models may generate output that does not parse to valid JSON objects.
+
+See [JSON Mode official docs](https://platform.openai.com/docs/guides/text-generation/json-mode) for more details.
+
+To send a message in JSON mode, you can simply send `json: true` option along with your message.
+
+```ruby
+# Single message with JSON mode
+Rubygpt.chat.create(content: "List all programming languages by their creation date.", json: true)
+
+# Multiple messages with JSON mode
+messages = [
+    { role: 'user', content: "List all programming languages by their creation date." },
+    { role: 'user', content: "Also add their creator's name to the objects." }
+]
+Rubygpt.chat.create(messages:, json: true)
+```
+
+### Stream Mode
+
+Streaming mode is a feature of the Chat Completions API that allows the model to generate a continuous stream of messages. This is useful for chat applications where the model is expected to generate multiple or longer responses to a single prompt.
+
+Stream mode is not supported at the moment, but it's planned to be implemented in the future versions.
+
+### Using Chat Completion Responses
+
+Regardless of the amount of messages sent, the response will be an instance of `Response::ChatCompletion` object.
+The object wraps a set of methods to easily access the response data provided by the [OpenAI Chat API: Create](https://platform.openai.com/docs/api-reference/chat/create).
+
+```ruby
+response = Rubygpt.chat.create("What time is it?", "Also tell me the date.")
+response.messages # ["It's 12:00 PM.", "Today is 2032-01-01."]
+response.read # => "It's 12:00 PM. Today is 2032-01-01."
+response.failed? # => true if any message (choice) have finish_reason other than "stop"
+response.cost # => Total cost of the request (usage.total_tokens)
+response.to_h # => Hash representation of the response
+
+# Full attributes:
+# :id, :object, :created, :model, :system_fingerprint, :usage, :choices
+```
+
+Each Choice in the response is an instance of `Response::ChatCompletion::Choice` object.
+
+```ruby
+response = Rubygpt.chat.create("What time is it?", "Also tell me the date.")
+response.choices # => [Response::ChatCompletion::Choice, Response::ChatCompletion::Choice]
+response.choices.first.index # => 0
+response.choices.first.message # => <#Common::Message>
+response.choices.first.content # => "It's 12:00 PM." - delegated from message
+response.choices.first.role # => "system" - delegated from message
+response.choices.first.finish_reason # => "stop"
+response.choices.first.failed? # => false, unless finish_reason is not "stop"
+response.choices.first.to_h # => Hash representation of the choice
+response.choices.first.logprobs # => Log probabilities of the tokens, hash or null
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+The console contains a pre-configured Rubygpt client with a test API key. See [bin/console](bin/console) for more details.
+
+To set the API key for the tests, set the environment variable `OPENAI_API_KEY` to access the APIs.
+
+```sh
+export OPENAI_API_KEY=your_api_key
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/feapaydin/rubygpt. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/feapaydin/rubygpt/blob/main/CODE_OF_CONDUCT.md).
+
+Participations are much welcome in this project as it's still in the early stages of development. You can contribute by addressing the issues flagged as `good first issue` or `help wanted` in the issues section. You can also contribute by opening new issues, suggesting new features, or reporting bugs.
+
+## Code of Conduct
+
+Everyone interacting in the Rubygpt project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/feapaydin/rubygpt/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/SECURITY.md

@@ -0,0 +1,7 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+We're running this project solely on GitHub. Please report any vulnerability issues that you encounter by creating a new issue on GitHub. Please be careful not to cause any possible abuses when sharing details.
+
+For more delicate vulnerabilities, please contact me directly at feapaydin@gmail.com

data/lib/rubygpt/client/configuration.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  class Client
+    # Handles the configuration options when initializing a new Rubygpt::Client object
+    class Configuration
+      # Initializes a new Rubygpt::Client::Configuration object from a hash or another Configuration object
+      def self.from(configuration_input)
+        case configuration_input
+        when Configuration then configuration_input
+        when Hash, nil then Configuration.new(configuration_input || {})
+        else raise InvalidConfigurationError, "Invalid configuration provided for client."
+        end
+      end
+
+      class InvalidConfigurationError < StandardError; end
+
+      # The connection adapter to use for the client
+      # Defaults to :faraday
+      attr_accessor :connection_adapter
+
+      # The API URL to use for the client
+      attr_accessor :api_url
+
+      # The API key to use for the client
+      attr_accessor :api_key
+
+      # The OpenAI OrganizationID that will be sent when making requests (optional)
+      # https://platform.openai.com/docs/api-reference/organization-optional
+      attr_accessor :organization_id
+
+      # The GPT model to use for the client
+      # Sample values: gpt-4, gpt-4-turbo-preview, gpt-3.5-turbo, gpt-3.5-turbo-instruct
+      # Refer to https://platform.openai.com/docs/models
+      attr_accessor :model
+
+      # The base URL for the OpenAI API
+      DEFAULT_API_URL = "https://api.openai.com/v1"
+      DEFAULT_CONNECTION_ADAPTER = :faraday
+
+      # Initializes new Rubygpt::Client::Configuration object
+      #
+      # @param [Hash] options
+      # @option options [String] :api_url required
+      # @option options [String] :api_key
+      # @option options [String] :organization_id
+      # @option options [String] :model required
+      # @option options [String] :connection_adapter
+      def initialize(options = {})
+        @connection_adapter = options[:connection_adapter] || DEFAULT_CONNECTION_ADAPTER
+        @api_key = options[:api_key]
+        @api_url = options[:api_url] || DEFAULT_API_URL
+        @organization_id = options[:organization_id]
+        @model = options[:model]
+      end
+
+      def validate!
+        raise(InvalidConfigurationError, "model is required") unless model
+        raise(InvalidConfigurationError, "api_key is required") unless api_key
+      end
+
+      def to_headers
+        {
+          "Authorization" => "Bearer #{api_key}",
+          "OpenAI-Organization" => organization_id
+        }.compact
+      end
+    end
+  end
+end

data/lib/rubygpt/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  # Main class that issues the connection to OpenAI APIs
+  class Client
+    # The configuration object for the client
+    attr_reader :configuration
+
+    # Initializes new Rubygpt::Client object
+    #
+    # @param [Hash] configuration
+    # @param [Configuration] configuration
+    def initialize(configuration = nil)
+      @configuration = Configuration.from(configuration)
+      yield @configuration if block_given?
+      @configuration.validate!
+    end
+
+    def post(*args)
+      connection.post(*args)
+    end
+
+    private
+
+    def connection
+      @connection ||= Connection.new(configuration)
+    end
+  end
+end

data/lib/rubygpt/common/message.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Common
+  # Represents a Message object that is used in OpenAI Chat API requests
+  # This object is referenced by both ChatRequester and ChatCompletion objects
+  class Message
+    # The role of the author of this message.
+    # One of: user, assistant, system
+    # Default: system
+    attr_reader :role
+
+    # The contents of the message.
+    attr_reader :content
+
+    # Provides the model information to differentiate between participants of the same role.
+    attr_reader :name
+
+    # The tool calls generated by the model, such as function calls. (assistant msg only)
+    attr_reader :tool_calls
+
+    # Tool call that this message is responding to. (tool msg only)
+    attr_reader :tool_call_id
+
+    # Initializes the Message object
+    #
+    # @param [String, Hash] options The message content
+    def initialize(options = {})
+      if options.is_a?(String)
+        @role = "system"
+        @content = options
+      else
+        attributes_from_options(options)
+      end
+      json_content_parse
+    end
+
+    def json?
+      !!@json_content
+    end
+
+    def empty?
+      content.nil? || content.empty?
+    end
+
+    def to_h
+      { role:, content:, name:, tool_calls:, tool_call_id: }.compact
+    end
+
+    private
+
+    def attributes_from_options(options)
+      @role = options[:role] || "system"
+      @content = options[:content]
+      @name = options[:name]
+      @tool_calls = options[:tool_calls]
+      @tool_call_id = options[:tool_call_id]
+    end
+
+    # Parses the content if it is a JSON string
+    # This is used when the request is made with json: true flag
+    # https://platform.openai.com/docs/guides/text-generation/json-mode
+    def json_content_parse
+      return unless @content.is_a?(String) && @content.start_with?("{", "[")
+
+      @content = JSON.parse(@content, symbolize_names: true)
+      @json_content = true
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/rubygpt/connection/faraday.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module Rubygpt
+  module Connection
+    # The HTTP connection adapter derived from Faraday::Connection
+    class Faraday < Faraday::Connection
+      # Initializes a new connection object
+      #
+      # @param [Configuration] configuration
+      # @param [Hash] faraday_options
+      def initialize(configuration, faraday_options = {})
+        options = { url: configuration.api_url, headers: configuration.to_headers }.merge(faraday_options)
+        super(options) do |faraday|
+          faraday.request :json
+          faraday.response :json
+          faraday.response :raise_error
+        end
+      end
+
+      def post(*args)
+        faraday_response = super(*args)
+        Rubygpt::Response::StandardApiResponse.new(
+          adapter_response: faraday_response,
+          **faraday_response.slice(:status, :body, :headers)
+        )
+      end
+    end
+  end
+end

data/lib/rubygpt/connection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  # Moderates available connection adapters
+  module Connection
+    class << self
+      # Find and initialize the connection adapter
+      #
+      # @param [Configuration] configuration
+      # @param [Hash] options
+      def new(configuration, options = {})
+        const_get(configuration.connection_adapter.to_s.capitalize).new(configuration, options)
+      rescue NameError
+        raise Client::Configuration::InvalidConfigurationError, "Invalid adapter provided for connection."
+      end
+    end
+  end
+end

data/lib/rubygpt/requester/chat_requester.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  module Requester
+    # Performs CRUD operations for OpenAI Chat Completion Objects
+    # https://platform.openai.com/docs/api-reference/chat
+    class ChatRequester < BaseRequester
+      # Initializes the ChatRequester
+      #
+      # @param [Client] client The client object
+      def initialize(client)
+        @api_endpoint = "chat/completions"
+        super(client)
+      end
+
+      # Performs a POST request to the API endpoint
+      # https://platform.openai.com/docs/api-reference/chat/create
+      #
+      # @param [String] args The single message to send. Message will be sent with system role
+      # @param [Array] args The array of messages to send. Each message can be a string or a hash
+      # @param [Hash] args The arguments for the request body, including messages
+      # @option args [Array] :messages The messages to send
+      #
+      # @return [Response::ChatCompletion]
+      def create(args = {})
+        # TODO: handle args[:stream] for streaming completions
+        Response::ChatCompletion.new client.post(api_endpoint, create_request_body(args))
+      end
+
+      private
+
+      # Builds the request body for the POST request
+      def create_request_body(args)
+        request_body = { model: client.configuration.model }
+        if args.is_a?(Hash)
+          # Allowing JSON mode for the request
+          # https://platform.openai.com/docs/guides/text-generation/json-mode
+          request_body[:response_format] = { type: "json_object" } if args[:json]
+          request_body[:messages] = messages_from_hash(args)
+          request_body.merge! args.except(:messages, :json)
+        else
+          request_body[:messages] = messages_from_args(args)
+        end
+        request_body.compact
+      end
+
+      # Handles the message data provided as arguments
+      def messages_from_args(args)
+        messages =
+          case args
+          when String then [Common::Message.new(args)]
+          when Array then args.map { |message| Common::Message.new(message) }
+          else raise ArgumentError, "Invalid message data provided"
+          end
+        map_messages(messages)
+      end
+
+      # Handles the message data provided as a hash
+      def messages_from_hash(hash)
+        messages =
+          if hash.key?(:messages)
+            # If it is a hash with a :messages key, then it's a request config with messages provided explicitly
+            # { messages: [{ content: 'foo', role: 'user' }, { content: 'bar', role: 'system' }] }
+            hash[:messages].map { |message| Common::Message.new(message) }
+          else
+            # If it is a hash without a :messages key, then it's a message config itself
+            # { content: 'foo', role: 'user' }
+            [Common::Message.new(hash)]
+          end
+        map_messages(messages)
+      end
+
+      # Maps the messages to a hash
+      # Validates the messages and raises an error if no messages are provided
+      def map_messages(messages)
+        messages.map do |message|
+          raise ArgumentError, "Empty message contents found." if message.empty?
+
+          message.to_h
+        end
+      end
+    end
+  end
+end

data/lib/rubygpt/requester.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  module Requester
+    # Base module for all requester modules
+    class BaseRequester
+      # The client object that will be used to make the request
+      attr_reader :client
+
+      # The API endpoint for the request
+      attr_reader :api_endpoint
+
+      # Initializes new Rubygpt::Requester object
+      #
+      # @param [Client] client
+      def initialize(client)
+        @client = client
+      end
+
+      # Performs a POST request to the API endpoint
+      def create
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rubygpt/response/chat_completion.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  module Response
+    # Represents the ChatCompletion response from the Chat API
+    # https://platform.openai.com/docs/api-reference/chat/object
+    class ChatCompletion < BaseResponse
+      # Represents a Choice object in the ChatCompletion response
+      class Choice
+        # The index of the choice in the list of choices.
+        attr_reader :index
+
+        # A chat completion message generated by the model.
+        # A Message object
+        attr_reader :message
+
+        # Log probability information for the choice.
+        attr_reader :logprobs
+
+        # The reason the model stopped generating tokens.
+        # One of: stop, length, content_filter, tool_calls
+        attr_reader :finish_reason
+
+        # Initializes the Choice object
+        def initialize(index:, message:, logprobs:, finish_reason:)
+          @index = index
+          @message = Common::Message.new(**message.transform_keys(&:to_sym))
+          @logprobs = logprobs
+          @finish_reason = finish_reason
+        end
+
+        # Delegations to the message object
+        def content
+          message.content
+        end
+
+        def role
+          message.role
+        end
+
+        # Returns true if the choice failed to generate a complete message
+        def failed?
+          finish_reason != "stop"
+        end
+
+        def to_h
+          { index:, message: message.to_h, logprobs:, finish_reason: }.compact
+        end
+      end
+
+      # Readers for the standard attributes of the ChatCompletion object
+      attr_reader :id, :object, :created, :model, :system_fingerprint, :usage, :choices
+
+      # Initializes the ChatCompletion object
+      #
+      # @param [StandardApiResponse] api_response The response from the API, standardized by the connection object
+      def initialize(api_response)
+        super
+        @choices = @choices.map { |choice| Choice.new(**choice.transform_keys(&:to_sym)) }.sort_by(&:index) if @choices
+      end
+
+      # The list of message strings generated by the model.
+      #
+      # return [Array<String>]
+      def messages
+        @messages ||= choices.map { |choice| choice.message.content }
+      end
+
+      # Messages combined into a single string, separated by newlines
+      def read(message_separator: "\n")
+        @read ||= messages.join(message_separator)
+      end
+
+      def failed?
+        choices.any?(&:failed?)
+      end
+
+      def cost
+        usage[:total_tokens]
+      end
+
+      def to_h
+        { id:, object:, created:, model:, system_fingerprint:, usage:, choices: choices.map(&:to_h) }.compact
+      end
+    end
+  end
+end

data/lib/rubygpt/response.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  module Response
+    class ConnectionReturnNotStandardizedError < StandardError; end
+
+    # Unifies responses from all connection/adapter objects.
+    #  This is required since a response from Faraday will not be the same as a response from another adapter
+    #  that might be introduced in the future. To solve this,
+    #  we're overriding the post, get, put, delete methods in connection objects to return a StandardApiResponse
+    class StandardApiResponse
+      # The HTTP package contents of the response
+      attr_reader :status, :body, :headers
+
+      # The original, non-standardized response object received from the adapter
+      # This is useful for debugging and for accessing adapter-specific features
+      attr_reader :adapter_response
+
+      # @param [Integer] status The HTTP status code
+      # @param [Hash] body The response body
+      # @param [Hash] headers The response headers
+      # @param [Object] adapter_response The original, non-standardized response object received from the adapter
+      def initialize(status:, body:, headers:, adapter_response: nil)
+        @status = status
+        @body = body
+        @headers = headers
+        @adapter_response = adapter_response
+      end
+    end
+
+    # Base class for all API response objects
+    class BaseResponse
+      # The response from the API, standardized by the connection object
+      attr_reader :api_response
+
+      # @param [StandardApiResponse] api_response The response from the API, standardized by the connection object
+      def initialize(api_response)
+        raise ConnectionReturnNotStandardizedError unless api_response.is_a?(StandardApiResponse)
+
+        @api_response = api_response
+        build_attributes_from_body
+      end
+
+      private
+
+      # Builds instance variables dynamically from the response body
+      def build_attributes_from_body
+        @api_response.body&.each do |key, value|
+          variable_name = key.to_s.downcase
+          instance_variable_set("@#{variable_name}", value)
+          self.class.send(:attr_reader, variable_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubygpt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rubygpt
+  VERSION = "0.1.0"
+end

data/lib/rubygpt.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "rubygpt/version"
+require_relative "rubygpt/connection/faraday"
+require_relative "rubygpt/connection"
+require_relative "rubygpt/client/configuration"
+require_relative "rubygpt/client"
+require_relative "rubygpt/common/message"
+require_relative "rubygpt/response"
+require_relative "rubygpt/response/chat_completion"
+require_relative "rubygpt/requester"
+require_relative "rubygpt/requester/chat_requester"
+
+# The main module for Rubygpt
+# Contains static methods for configuration
+module Rubygpt
+  class << self
+    # The default singleton client for the module
+    # Allows a global configuration to be set across the module
+    #
+    # @return [Client]
+    def configure(configuration = nil, &block)
+      reset_requesters
+      @default_client = Client.new(configuration, &block)
+    end
+
+    # A ChatRequester object, configured by default client
+    # Allows the Rubygpt.chat calls
+    #
+    # @return [Requester::ChatRequester]
+    def chat
+      @chat ||= Requester::ChatRequester.new(@default_client)
+    end
+
+    # Remove memoized requester objects to allow reallocation
+    def reset_requesters
+      @chat = nil
+    end
+  end
+end

data/sig/rubygpt.rbs

@@ -0,0 +1,4 @@
+module Rubygpt
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: rubygpt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Furkan Enes Apaydin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.23.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.23.0
+description: ''
+email:
+- feapaydin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- SECURITY.md
+- lib/rubygpt.rb
+- lib/rubygpt/client.rb
+- lib/rubygpt/client/configuration.rb
+- lib/rubygpt/common/message.rb
+- lib/rubygpt/connection.rb
+- lib/rubygpt/connection/faraday.rb
+- lib/rubygpt/requester.rb
+- lib/rubygpt/requester/chat_requester.rb
+- lib/rubygpt/response.rb
+- lib/rubygpt/response/chat_completion.rb
+- lib/rubygpt/version.rb
+- sig/rubygpt.rbs
+homepage: https://github.com/feapaydin/rubygpt
+licenses: []
+metadata:
+  homepage_uri: https://github.com/feapaydin/rubygpt
+  source_code_uri: https://github.com/feapaydin/rubygpt
+  changelog_uri: https://github.com/feapaydin/rubygpt/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: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Ruby wrapper for OpenAI's ChatGPT APIs.
+test_files: []