roseflow-openai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 022b3ba6d3486eb3a7ed6abce48815272b2e4d5a52502dc814ebcc26c8c44712
+  data.tar.gz: eac633fb4aab864322916a3c5aa4e71cf15fe937d4c34aec84cbf8b444b44778
+SHA512:
+  metadata.gz: 4fb415158051794661293c7ec227c9384ac8edd3882e209a70cb559f95710d99248f01bba3c91633d6398594132cb1fcb9c5780477074a1aec1f86a95ba43555
+  data.tar.gz: c8d660546cbc37cb46e577f32e51ddfc71c5454f0dfc62fa8fbbbdfa90ba3ae0d40018fd71de856755dab4ed4350ddb30592d82185e0f29d6710b2105441f29d

data/.rspec

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

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-04-26
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,7 @@
+# Contributor Code of Conduct
+
+The Roseflow team is committed to fostering a welcoming community.
+
+**Our Code of Conduct can be found here**:
+
+https://roseflow.ai/conduct

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in roseflow-openai.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.5"
+gem "standard", "~> 1.3"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Lauri Jutila
+
+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,47 @@
+# Roseflow OpenAI integration
+
+This gem adds OpenAI support and integration for Roseflow, a framework for interacting with AI in Ruby.
+
+## Prerequisites
+
+To use this gem effectively, you need the [core Roseflow gem](https://github.com/roseflow-ai/roseflow).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add roseflow-openai
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install roseflow-openai
+
+## Usage
+
+See full documentation how to configure and use Roseflow with OpenAI at [docs.roseflow.ai](https://docs.roseflow.ai/openai).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/roseflow-ai/roseflow-openai.
+
+## Community
+
+### Discord
+
+Join us in our [Discord](https://discord.gg/roseflow).
+
+### Twitter
+
+Connect with the core team on Twitter.
+
+<a href="https://twitter.com/ljuti" target="_blank">
+  <img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/ljuti?logo=twitter&style=social">
+</a>
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Roseflow OpenAI project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/roseflow-ai/roseflow-openai/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

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

data/config/openai.yml

@@ -0,0 +1,14 @@
+default: &default
+  organization_id: <YOUR OPENAI ORGANIZATION ID>
+
+development:
+  <<: *default
+  api_key: <YOUR OPENAI API KEY FOR DEVELOPMENT>
+
+test:
+  <<: *default
+  api_key: <YOUR OPENAI API KEY FOR TEST>
+
+production:
+  <<: *default
+  api_key: <YOUR OPENAI API KEY FOR PRODUCTION>

data/lib/roseflow/openai/client.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "roseflow/openai/config"
+require "roseflow/openai/model"
+require "roseflow/openai/response"
+
+FARADAY_RETRY_OPTIONS = {
+  max: 3,
+  interval: 0.05,
+  interval_randomness: 0.5,
+  backoff_factor: 2,
+}
+
+module Roseflow
+  module OpenAI
+    class Client
+      def initialize(config = Config.new, provider = nil)
+        @config = config
+        @provider = provider
+      end
+
+      # Returns the available models from the API.
+      #
+      # @return [Array<OpenAI::Model>] the available models
+      def models
+        response = connection.get("/v1/models")
+        body = JSON.parse(response.body)
+        body.fetch("data", []).map do |model|
+          OpenAI::Model.new(model, self)
+        end
+      end
+
+      # Creates a chat completion.
+      #
+      # @param model [Roseflow::OpenAI::Model] the model to use
+      # @param messages [Array<String>] the messages to use
+      # @param options [Hash] the options to use
+      # @return [OpenAI::TextApiResponse] the API response object
+      def create_chat_completion(model:, messages:, **options)
+        response = connection.post("/v1/chat/completions") do |request|
+          request.body = options.merge({
+            model: model.name,
+            messages: messages
+          })
+        end
+        ChatResponse.new(response)
+      end
+
+      # Creates a chat completion and streams the response.
+      #
+      # @param model [Roseflow::OpenAI::Model] the model to use
+      # @param messages [Array<String>] the messages to use
+      # @param options [Hash] the options to use
+      # @yield [String] the streamed API response
+      # @return [Array<String>] the streamed API response if no block is given
+      def streaming_chat_completion(model:, messages:, **options, &block)
+        streamed = []
+        connection.post("/v1/chat/completions") do |request|
+          request.body = options.merge({
+            model: model.name,
+            messages: messages,
+            stream: true
+          })
+          request.options.on_data = Proc.new do |chunk|
+            yield streaming_chunk(chunk) if block_given?
+            streamed << chunk unless block_given?
+          end
+        end
+        streamed unless block_given?
+      end
+
+      # Creates a text completion for the provided prompt and parameters.
+      #
+      # @param model [Roseflow::OpenAI::Model] the model to use
+      # @param prompt [String] the prompt to use
+      # @param options [Hash] the options to use
+      # @return [OpenAI::TextApiResponse] the API response object
+      def create_completion(model:, prompt:, **options)
+        response = connection.post("/v1/completions") do |request|
+          request.body = options.merge({
+            model: model.name,
+            prompt: prompt
+          })
+        end
+        CompletionResponse.new(response)
+      end
+
+      # Creates a text completion for the provided prompt and parameters and streams the response.
+      #
+      # @param model [Roseflow::OpenAI::Model] the model to use
+      # @param prompt [String] the prompt to use
+      # @param options [Hash] the options to use
+      # @yield [String] the streamed API response
+      # @return [Array<String>] the streamed API response if no block is given
+      def streaming_completion(model:, prompt:, **options, &block)
+        streamed = []
+        connection.post("/v1/completions") do |request|
+          request.body = options.merge({
+            model: model.name,
+            prompt: prompt,
+            stream: true
+          })
+          request.options.on_data = Proc.new do |chunk|
+            yield streaming_chunk(chunk) if block_given?
+            streamed << chunk unless block_given?
+          end
+        end
+        streamed unless block_given?
+      end
+
+      # Given a prompt and an instruction, the model will return an edited version of the prompt.
+      #
+      # @param model [String] the model to use
+      # @param instruction [String] the instruction to use
+      # @param options [Hash] the options to use
+      # @return [OpenAI::TextApiResponse] the API response object
+      def create_edit(model:, instruction:, **options)
+        response = connection.post("/v1/edits") do |request|
+          request.body = options.merge({
+            model: model.name,
+            instruction: instruction
+          })
+        end
+        EditResponse.new(response)
+      end
+
+      def create_image(prompt:, **options)
+        ImageApiResponse.new(
+          connection.post("/v1/images/generations") do |request|
+            request.body = options.merge(prompt: prompt)
+          end
+        )
+      end
+
+      # Creates an embedding vector representing the input text.
+      #
+      # @param model [Roseflow::OpenAI::Model] the model to use
+      # @param input [String] the input text to use
+      # @return [OpenAI::EmbeddingApiResponse] the API response object
+      def create_embedding(model:, input:)
+        EmbeddingApiResponse.new(
+          connection.post("/v1/embeddings") do |request|
+            request.body = {
+              model: model.name,
+              input: input
+            }
+          end
+        )
+      end
+
+      private
+
+      attr_reader :config, :provider
+
+      # The connection object used to make requests to the API.
+      def connection
+        @connection ||= Faraday.new(
+          url: Config::OPENAI_API_URL,
+          headers: {
+            # "Content-Type" => "application/json",
+            "OpenAI-Organization" => config.organization_id
+          }
+        ) do |faraday|
+          faraday.request :authorization, "Bearer", -> { config.api_key }
+          faraday.request :json
+          faraday.request :retry, FARADAY_RETRY_OPTIONS
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      # Parses streaming chunks from the API response.
+      #
+      # @param chunk [String] the chunk to parse
+      # @return [String] the parsed chunk
+      def streaming_chunk(chunk)
+        return chunk unless chunk.match(/{.*}/)
+        chunk.scan(/{.*}/).map do |json|
+          JSON.parse(json).dig("choices", 0, "delta", "content")
+        end.join("")
+      end
+    end # Client
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "anyway_config"
+
+module Roseflow
+  module OpenAI
+    # Configuration class for the OpenAI provider.
+    class Config < Anyway::Config
+      config_name :openai
+
+      attr_config :api_key, :organization_id
+
+      required :api_key
+      required :organization_id
+
+      OPENAI_API_URL        = "https://api.openai.com"
+      CHAT_MODELS           = %w(gpt-4 gpt-4-0314 gpt-4-32k gpt-4-32k-0314 gpt-3.5-turbo gpt-3.5-turbo-0301).freeze
+      COMPLETION_MODELS     = %w(text-davinci-003 text-davinci-002 text-curie-001 text-babbage-001 text-ada-001 davinci curie babbage ada).freeze
+      EDIT_MODELS           = %w(text-davinci-edit-001 code-davinci-edit-001).freeze
+      TRANSCRIPTION_MODELS  = %w(whisper-1).freeze
+      TRANSLATION_MODELS    = %w(whisper-1).freeze
+      FINE_TUNE_MODELS      = %w(davinci curie babbage ada).freeze
+      EMBEDDING_MODELS      = %w(text-embedding-ada-002 text-search-ada-doc-001).freeze
+      MODERATION_MODELS     = %w(text-moderation-stable text-moderation-latest).freeze
+      MAX_TOKENS = {
+        "gpt-4": 8192,
+        "gpt-4-0314": 8192,
+        "gpt-4-32k": 32_768,
+        "gpt-4-32k-0314": 32_768,
+        "gpt-3.5-turbo": 4096,
+        "gpt-3.5-turbo-0301": 4096,
+        "text-davinci-003": 4097,
+        "text-davinci-002": 4097,
+        "code-davinci-002": 8001
+      }
+    end # Config
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/embedding.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "roseflow/types"
+require "roseflow/embeddings/embedding"
+
+module Roseflow
+  module OpenAI
+    class Embedding < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :embedding, Types::Array.of(Types::Float)
+
+      def to_embedding
+        Roseflow::Embeddings::Embedding.new(vector: embedding, length: embedding.length)
+      end
+    end # Embedding
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/model.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+require "roseflow/tokenizer"
+require "active_support/core_ext/module/delegation"
+
+module Types
+  include Dry.Types()
+end
+
+module Roseflow
+  module OpenAI
+    class Model
+      attr_reader :name
+
+      # Initializes a new model instance.
+      #
+      # @param model [Hash] Model data from the API
+      # @param provider [Roseflow::OpenAI::Provider] Provider instance
+      def initialize(model, provider)
+        @model_ = model
+        @provider_ = provider
+        assign_attributes
+      end
+
+      # Tokenizer instance for the model.
+      def tokenizer
+        @tokenizer_ ||= Tokenizer.new(model: name)
+      end
+
+      # Handles the model call.
+      # FIXME: Operations should be rewritten to match the client API.
+      #
+      # @param operation [Symbol] Operation to perform
+      # @param input [String] Input to use
+      def call(operation, input, **options)
+        token_count = tokenizer.count_tokens(transform_chat_messages(input))
+        if token_count < max_tokens
+          case operation
+          when :chat
+            @provider_.create_chat_completion(model: name, messages: transform_chat_messages(input), **options)
+          when :completion
+            @provider_.create_completion(input)
+          when :image
+            @provider_.create_image_completion(input)
+          when :embed
+            @provider_.create_embedding(input)
+          else
+            raise ArgumentError, "Invalid operation: #{operation}"
+          end
+        else
+          raise TokenLimitExceededError, "Token limit for model #{name} exceeded: #{token_count} is more than #{max_tokens}"
+        end
+      end
+
+      # Indicates if the model is chattable.
+      def chattable?
+        OpenAI::Config::CHAT_MODELS.include?(name)
+      end
+
+      # Indicates if the model can do completions.
+      def completionable?
+        OpenAI::Config::COMPLETION_MODELS.include?(name)
+      end
+
+      # Indicates if the model can do image completions.
+      def imageable?
+        OpenAI::Config::IMAGE_MODELS.include?(name)
+      end
+
+      # Indicates if the model can do embeddings.
+      def embeddable?
+        OpenAI::Config::EMBEDDING_MODELS.include?(name)
+      end
+
+      # Indicates if the model is fine-tunable.
+      def finetuneable?
+        @permissions_.fetch("allow_fine_tuning")
+      end
+
+      # Indicates if the model has searchable indices.
+      def searchable_indices?
+        @permissions_.fetch("allow_search_indices")
+      end
+
+      # Indicates if the model can be sampled.
+      def sampleable?
+        @permissions_.fetch("allow_sampling")
+      end
+
+      def blocking?
+        @permissions_.fetch("is_blocking")
+      end
+
+      # Returns the maximum number of tokens for the model.
+      def max_tokens
+        OpenAI::Config::MAX_TOKENS.fetch(name, 2049)
+      end
+
+      private
+
+      def assign_attributes
+        @name = @model_.fetch("id")
+        @created_at = Time.at(@model_.fetch("created"))
+        @permissions_ = @model_.fetch("permission").first
+      end
+
+      def transform_chat_messages(input)
+        input.map(&:to_h)
+      end
+    end # Model
+
+    # Represents a model permission.
+    class ModelPermission < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :id, Types::String
+      attribute :object, Types::String
+      attribute :created, Types::Integer
+      attribute :allow_create_engine, Types::Bool
+      attribute :allow_sampling, Types::Bool
+      attribute :allow_logprobs, Types::Bool
+      attribute :allow_search_indices, Types::Bool
+      attribute :allow_view, Types::Bool
+      attribute :allow_fine_tuning, Types::Bool
+      attribute :organization, Types::String
+      attribute :is_blocking, Types::Bool
+
+      alias_method :finetuneable?, :allow_fine_tuning
+      alias_method :is_blocking?, :is_blocking
+    end # ModelPermission
+
+    # Represents a model configuration.
+    class ModelConfiguration < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :id, Types::String
+      attribute :created, Types::Integer
+      attribute :permission, Types::Array.of(ModelPermission)
+      attribute :root, Types::String
+      attribute :parent, Types::String | Types::Nil
+
+      alias_method :name, :id
+
+      def permissions
+        permission.first
+      end
+
+      delegate :finetuneable?, :is_blocking?, to: :permissions
+    end # ModelConfiguration
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/model_repository.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Roseflow
+  module OpenAI
+    class ModelRepository
+      attr_reader :models
+
+      delegate :each, :all, to: :models
+      
+      def initialize(provider)
+        @provider = provider
+        @models = provider.client.models
+      end
+
+      # Finds a model by name.
+      #
+      # @param name [String] Name of the model
+      def find(name)
+        @models.select{ |model| model.name == name }.first
+      end
+
+      # Returns all models that are chattable.
+      def chattable
+        @models.select(&:chattable?)
+      end
+
+      # Returns all models that are completionable.
+      def completionable
+        @models.select(&:completionable?)
+      end
+
+      # Returns all models that are support edits.
+      def editable
+        @models.select(&:editable?)
+      end
+
+      # Returns all models that are support embeddings.
+      def embeddable
+        @models.select(&:embeddable?)
+      end
+    end # ModelRepository
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/provider.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "roseflow/openai/client"
+require "roseflow/openai/model_repository"
+
+module Roseflow
+  module OpenAI
+    class Provider
+      def initialize(config = Roseflow::OpenAI::Config.new)
+        @config = config
+      end
+
+      # Returns the client for the provider
+      def client
+        @client ||= Client.new(config, self)
+      end
+
+      # Returns the model repository for the provider
+      def models
+        @models ||= ModelRepository.new(self)
+      end
+
+      # Chat with a model
+      #
+      # @param model [Roseflow::OpenAI::Model] The model object to use
+      # @param messages [Array<String>] The messages to send to the model
+      # @param options [Hash] Additional options to pass to the API
+      # @option options [Integer] :max_tokens The maximum number of tokens to generate in the completion.
+      # @option options [Float] :temperature Sampling temperature to use, between 0 and 2
+      # @option options [Float] :top_p The cumulative probability of tokens to use.
+      # @option options [Integer] :n The number of completions to generate.
+      # @option options [Integer] :logprobs Include the log probabilities on the logprobs most likely tokens.
+      # @option options [Boolean] :echo Whether to echo the question as part of the completion.
+      # @option options [String | Array] :stop Up to 4 sequences where the API will stop generating further tokens. The returned text will not contain the stop sequence.
+      # @option options [Float] :presence_penalty Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
+      # @option options [Float] :frequency_penalty Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+      # @option options [Integer] :best_of Generates `best_of` completions server-side and returns the "best" (the one with the lowest log probability per token)
+      # @option options [Integer] :streaming Whether to stream back partial progress
+      # @option options [String] :user A unique identifier representing your end-user
+      # @return [Roseflow::OpenAI::ChatResponse] The response object from the API.
+      def chat(model:, messages:, **options)
+        streaming = options.fetch(:streaming, false)
+
+        if streaming
+          client.streaming_chat_completion(model: model, messages: messages.map(&:to_h), **options)
+        else
+          client.create_chat_completion(model: model, messages: messages.map(&:to_h), **options)
+        end
+      end
+
+      # Create a completion.
+      #
+      # @param model [Roseflow::OpenAI::Model] The model object to use
+      # @param prompt [String] The prompt to use for completion
+      # @param options [Hash] Additional options to pass to the API
+      # @option options [Integer] :max_tokens The maximum number of tokens to generate in the completion.
+      # @option options [Float] :temperature Sampling temperature to use, between 0 and 2
+      # @option options [Float] :top_p The cumulative probability of tokens to use.
+      # @option options [Integer] :n The number of completions to generate.
+      # @option options [Integer] :logprobs Include the log probabilities on the logprobs most likely tokens.
+      # @option options [Boolean] :echo Whether to echo the question as part of the completion.
+      # @option options [String | Array] :stop Up to 4 sequences where the API will stop generating further tokens.
+      # @option options [Float] :presence_penalty Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
+      # @option options [Float] :frequency_penalty Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+      # @option options [Integer] :best_of Generates `best_of` completions server-side and returns the "best" (the one with the lowest log probability per token)
+      # @option options [Integer] :streaming Whether to stream back partial progress
+      # @option options [String] :user A unique identifier representing your end-user
+      # @return [Roseflow::OpenAI::CompletionResponse] The response object from the API.
+      def completion(model:, prompt:, **options)
+        streaming = options.fetch(:streaming, false)
+
+        if streaming
+          client.streaming_completion(model: model, prompt: prompt, **options)
+        else
+          client.create_completion(model: model, prompt: prompt, **options)
+        end
+      end
+
+      # Creates a new edit for the provided input, instruction, and parameters.
+      #
+      # @param model [Roseflow::OpenAI::Model] The model object to use
+      # @param instruction [String] The instruction to use for editing
+      # @param options [Hash] Additional options to pass to the API
+      # @option options [String] :input The input text to use as a starting point for the edit.
+      # @option options [Integer] :n The number of edits to generate.
+      # @option options [Float] :temperature Sampling temperature to use, between 0 and 2
+      # @option options [Float] :top_p The cumulative probability of tokens to use.
+      # @return [Roseflow::OpenAI::EditResponse] The response object from the API.
+      def edit(model:, instruction:, **options)
+        client.create_edit(model: model, instruction: instruction, **options)
+      end
+
+      # Creates an embedding vector representing the input text.
+      #
+      # @param model [Roseflow::OpenAI::Model] The model object to use
+      # @param input [String] The input text to use for embedding
+      # @param options [Hash] Additional options to pass to the API
+      # @option options [String] :user A unique identifier representing your end-user
+      def embedding(model:, input:, **options)
+        client.create_embedding(model: model, input: input, **options).embedding.to_embedding
+      end
+
+      def image(prompt:, **options)
+        client.create_image(prompt: prompt, **options)
+      end
+
+      attr_reader :config
+    end # Provider
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/response.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+require "roseflow/types"
+require "roseflow/openai/embedding"
+
+module Types
+  include Dry.Types()
+  Number = Types::Integer | Types::Float
+end
+
+module Roseflow
+  module OpenAI
+    FailedToCreateEmbeddingError = Class.new(StandardError)
+
+    class ApiResponse
+      def initialize(response)
+        @response = response
+      end
+
+      def success?
+        @response.success?
+      end
+
+      def status
+        @response.status
+      end
+
+      def body
+        raise NotImplementedError, "Subclasses must implement this method."
+      end
+    end # ApiResponse
+
+    class TextApiResponse < ApiResponse
+      def body
+        @body ||= ApiResponseBody.new(JSON.parse(@response.body))
+      end
+
+      def choices
+        body.choices.map { |choice| Choice.new(choice) }
+      end
+    end # TextApiResponse
+
+    class ChatResponse < TextApiResponse
+      def response
+        choices.first
+      end
+    end
+
+    class CompletionResponse < TextApiResponse
+      def response
+        choices.first
+      end
+
+      def responses
+        choices
+      end
+    end
+
+    class EditResponse < TextApiResponse
+      def response
+        choices.first
+      end
+
+      def responses
+        choices
+      end
+    end
+
+    class ImageApiResponse < ApiResponse
+      def body
+        @body ||= ImageApiResponseBody.new(JSON.parse(@response.body))
+      end
+
+      def images
+        body.data.map { |image| Image.new(image) }
+      end
+    end # ImageApiResponse
+
+    class EmbeddingApiResponse < ApiResponse
+      def body
+        @body ||= begin
+            case @response.status
+            when 200
+              EmbeddingApiResponseBody.new(JSON.parse(@response.body))
+            else
+              EmbeddingApiResponseErrorBody.new(JSON.parse(@response.body))
+            end
+          end
+      end
+
+      def embedding
+        case @response.status
+        when 200
+          body.data.map { |embedding| Embedding.new(embedding) }.first
+        else
+          raise FailedToCreateEmbeddingError, body.error.message
+        end
+      end
+    end # EmbeddingApiResponse
+
+    class Image < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :url, Types::String
+    end # Image
+
+    class Choice < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute? :text, Types::String
+      attribute? :message do
+        attribute :role, Types::String
+        attribute :content, Types::String
+      end
+
+      attribute? :finish_reason, Types::String
+      attribute :index, Types::Integer
+
+      def to_s
+        return message.content if message
+        return text if text
+      end
+    end # Choice
+
+    class ApiUsage < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :prompt_tokens, Types::Integer
+      attribute? :completion_tokens, Types::Integer
+      attribute :total_tokens, Types::Integer
+    end # ApiUsage
+
+    class ImageApiResponseBody < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :created, Types::Integer
+      attribute :data, Types::Array(Types::Hash)
+    end # ImageApiResponseBody
+
+    class OpenAIEmbedding < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :object, Types::String.default("embedding")
+      attribute :embedding, Types::Array(Types::Number)
+      attribute :index, Types::Integer
+    end # OpenAIEmbedding
+
+    class EmbeddingApiResponseBody < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :object, Types::String
+      attribute :data, Types::Array(OpenAIEmbedding)
+      attribute :model, Types::String
+      attribute :usage, ApiUsage
+    end # EmbeddingApiResponseBody
+
+    class EmbeddingApiResponseErrorBody < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :error do
+        attribute :message, Types::String
+      end
+    end # EmbeddingApiResponseErrorBody
+
+    class ApiResponseBody < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute? :id, Types::String
+      attribute :object, Types::String
+      attribute :created, Types::Integer
+      attribute? :model, Types::String
+      attribute :usage, ApiUsage
+      attribute :choices, Types::Array
+
+      def success?
+        true
+      end
+    end # ApiResponseBody
+  end # OpenAI
+end # Roseflow

data/lib/roseflow/openai/structs.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+
+module Roseflow
+  module OpenAI
+    # A model instruction struct. Used to pass instructions to the model.
+    # @param instruction [String] The instruction that tells the model how to edit the prompt.
+    # @param input [String] The input text to use as a starting point for the edit.
+    # @param n [Integer] Number of results to be returned by the model.
+    # @param temperature [Float] Sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+    # @param top_p [Float] An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
+    class EditModelInstruction < Dry::Struct
+      attribute :instruction, Types::String
+      attribute :input, Types::String.default("")
+      attribute :n, Types::Integer.default(1)
+      attribute :temperature, Types::Float.default(1)
+      attribute :top_p, Types::Float.default(1)
+    end
+  end
+end

data/lib/roseflow/openai/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module OpenAI
+    def self.gem_version
+      Gem::Version.new VERSION::STRING
+    end
+
+    module VERSION
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      PRE   = nil
+
+      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
+    end
+  end
+end

data/lib/roseflow/openai.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "openai/version"
+
+module Roseflow
+  module OpenAI
+    class Error < StandardError; end
+  end
+end

data/roseflow-openai.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lib/roseflow/openai/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "roseflow-openai"
+  spec.version = Roseflow::OpenAI.gem_version
+  spec.authors = ["Lauri Jutila"]
+  spec.email = ["git@laurijutila.com"]
+
+  spec.summary = "Roseflow meets OpenAI"
+  spec.description = "OpenAI integration and models for Roseflow."
+  spec.homepage = "https://github.com/roseflow-ai/roseflow-openai"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/roseflow-ai/roseflow-openai"
+  spec.metadata["changelog_uri"] = "https://github.com/roseflow-ai/roseflow-openai/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "anyway_config", "~> 2.0"
+  spec.add_dependency "dry-struct"
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday-retry"
+
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "roseflow"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr"
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/roseflow/openai.rbs

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

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: roseflow-openai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lauri Jutila
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: roseflow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: OpenAI integration and models for Roseflow.
+email:
+- git@laurijutila.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/openai.yml
+- lib/roseflow/openai.rb
+- lib/roseflow/openai/client.rb
+- lib/roseflow/openai/config.rb
+- lib/roseflow/openai/embedding.rb
+- lib/roseflow/openai/model.rb
+- lib/roseflow/openai/model_repository.rb
+- lib/roseflow/openai/provider.rb
+- lib/roseflow/openai/response.rb
+- lib/roseflow/openai/structs.rb
+- lib/roseflow/openai/version.rb
+- roseflow-openai.gemspec
+- sig/roseflow/openai.rbs
+homepage: https://github.com/roseflow-ai/roseflow-openai
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/roseflow-ai/roseflow-openai
+  source_code_uri: https://github.com/roseflow-ai/roseflow-openai
+  changelog_uri: https://github.com/roseflow-ai/roseflow-openai/blob/master/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: Roseflow meets OpenAI
+test_files: []