omniai-openai 1.3.0 → 1.3.2

data/lib/omniai/openai/thread/message.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Thread
+      # An OpenAI message within a thread.
+      class Message
+        # @!attribute [rw] id
+        #   @return [String, nil]
+        attr_accessor :id
+
+        # @!attribute [rw] assistant_id
+        #   @return [String, nil]
+        attr_accessor :assistant_id
+
+        # @!attribute [rw] thread_id
+        #   @return [String, nil]
+        attr_accessor :thread_id
+
+        # @!attribute [rw] run_id
+        #   @return [String, nil]
+        attr_accessor :run_id
+
+        # @!attribute [rw] role
+        #   @return [String, nil]
+        attr_accessor :role
+
+        # @!attribute [rw] content
+        #   @return [String, Array, nil]
+        attr_accessor :content
+
+        # @!attribute [rw] attachments
+        #   @return [Array, nil]
+        attr_accessor :attachments
+
+        # @!attribute [rw] metadata
+        #   @return [Array, nil]
+        attr_accessor :metadata
+
+        # @!attribute [rw] deleted
+        #   @return [Boolean, nil]
+        attr_accessor :deleted
+
+        # @param id [String, nil] optional
+        # @param assistant_id [String, nil] optional
+        # @param thread_id [String, nil] optional
+        # @param run_id [String, nil] optional
+        # @param role [String, nil] optional
+        # @param content [String, Array, nil] optional
+        # @param attachments [Array, nil] optional
+        # @param metadata [Hash, nil] optional
+        # @param client [OmniAI::OpenAI::Client] optional
+        def initialize(
+          id: nil,
+          assistant_id: nil,
+          thread_id: nil,
+          run_id: nil,
+          role: nil,
+          content: nil,
+          attachments: [],
+          metadata: {},
+          client: Client.new
+        )
+          @id = id
+          @assistant_id = assistant_id
+          @thread_id = thread_id
+          @run_id = run_id
+          @role = role
+          @content = content
+          @attachments = attachments
+          @metadata = metadata
+          @client = client
+        end
+
+        # @return [String]
+        def inspect
+          props = [
+            "id=#{@id.inspect}",
+            ("assistant_id=#{@assistant_id.inspect}" if @assistant_id),
+            ("thread_id=#{@thread_id.inspect}" if @thread_id),
+            ("content=#{@content.inspect}" if @content),
+          ].compact
+
+          "#<#{self.class.name} #{props.join(' ')}>"
+        end
+
+        # @param thread_id [String] required
+        # @param id [String] required
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [OmniAI::OpenAI::Thread::Message]
+        def self.find(thread_id:, id:, client: Client.new)
+          response = client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .get("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{thread_id}/messages/#{id}")
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          parse(data: response.parse)
+        end
+
+        # @param thread_id [String] required
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [Array<OmniAI::OpenAI::Thread::Message>]
+        def self.all(thread_id:, limit: nil, client: Client.new)
+          response = client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .get("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{thread_id}/messages", params: { limit: }.compact)
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          response.parse['data'].map { |data| parse(data:, client:) }
+        end
+
+        # @param thread_id [String] required
+        # @param id [String] required
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [Hash]
+        def self.destroy!(thread_id:, id:, client: Client.new)
+          response = client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .delete("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{thread_id}/messages/#{id}")
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          response.parse
+        end
+
+        # @raise [HTTPError]
+        # @return [OmniAI::OpenAI::Thread]
+        def save!
+          response = @client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .post(path, json: payload)
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          parse(data: response.parse)
+          self
+        end
+
+        # @raise [OmniAI::Error]
+        # @return [OmniAI::OpenAI::Thread]
+        def destroy!
+          raise OmniAI::Error, 'cannot destroy a non-persisted thread' unless @id
+
+          data = self.class.destroy!(thread_id: @thread_id, id: @id, client: @client)
+          @deleted = data['deleted']
+          self
+        end
+
+        private
+
+        class << self
+          private
+
+          # @param data [Hash] required
+          # @param client [OmniAI::OpenAI::Client] required
+          # @return [OmniAI::OpenAI::Thread]
+          def parse(data:, client: Client.new)
+            new(
+              client:,
+              id: data['id'],
+              assistant_id: data['assistant_id'],
+              thread_id: data['thread_id'],
+              run_id: data['run_id'],
+              role: data['role'],
+              content: data['content'],
+              attachments: data['attachments'],
+              metadata: data['metadata']
+            )
+          end
+        end
+
+        # @param data [Hash] required
+        def parse(data:)
+          @id = data['id']
+          @assistant_id = data['assistant_id']
+          @thread_id =  data['thread_id']
+          @run_id =  data['run_id']
+          @role =  data['role']
+          @content = data['content']
+          @attachments = data['attachments']
+          @metadata =  data['metadata']
+        end
+
+        # @return [Hash]
+        def payload
+          {
+            role: @role,
+            content: @content,
+            attachments: @attachments,
+            metadata: @metadata,
+          }.compact
+        end
+
+        # @return [String]
+        def path
+          "/#{OmniAI::OpenAI::Client::VERSION}/threads/#{@thread_id}/messages#{"/#{@id}" if @id}"
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/thread/messages.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Thread
+      # An OpenAI scope for establishing messages.
+      class Messages
+        # @param client [OmniAI::OpenAI::Client] required
+        # @param thread [OmniAI::OpenAI::Thread] required
+        def initialize(client:, thread:)
+          @client = client
+          @thread = thread
+        end
+
+        # @param limit [Integer] optional
+        # @return [Array<OmniAI::Thread::Message>]
+        def all(limit: nil)
+          Message.all(thread_id: @thread.id, limit:, client: @client)
+        end
+
+        # @param id [String] required
+        # @return [OmniAI::OpenAI::Thread::Message]
+        def find(id:)
+          Message.find(id:, thread_id: @thread.id, client: @client)
+        end
+
+        # @param id [String] required
+        # @return [Hash]
+        def destroy!(id:)
+          Message.destroy!(id:, thread_id: @thread.id, client: @client)
+        end
+
+        # @param role [String, nil] optional
+        # @param content [String, Array, nil] optional
+        # @param attachments [Array, nil] optional
+        # @param metadata [Hash, nil] optional
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [OmniAI::OpenAI::Thread::Message]
+        def build(role: nil, content: nil, attachments: [], metadata: {})
+          Message.new(role:, content:, attachments:, metadata:, thread_id: @thread.id, client: @client)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/thread/run.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Thread
+      # An OpenAI run within a thread.
+      class Run
+        module Status
+          CANCELLED = 'cancelled'
+          FAILED = 'failed'
+          COMPLETED = 'completed'
+          EXPIRED = 'expired'
+        end
+
+        TERMINATED_STATUSES = [
+          Status::CANCELLED,
+          Status::FAILED,
+          Status::COMPLETED,
+          Status::EXPIRED,
+        ].freeze
+
+        # @!attribute [rw] id
+        #   @return [String, nil]
+        attr_accessor :id
+
+        # @!attribute [rw] assistant_id
+        #   @return [String, nil]
+        attr_accessor :assistant_id
+
+        # @!attribute [rw] thread_id
+        #   @return [String, nil]
+        attr_accessor :thread_id
+
+        # @!attribute [rw] status
+        #   @return [String, nil]
+        attr_accessor :status
+
+        # @!attribute [rw] model
+        #   @return [String, nil]
+        attr_accessor :model
+
+        # @!attribute [rw] temperature
+        #   @return [Float, nil]
+        attr_accessor :temperature
+
+        # @!attribute [rw] instructions
+        #   @return [String, nil]
+        attr_accessor :instructions
+
+        # @!attribute [rw] tools
+        #   @return [Array<Hash>, nil]
+        attr_accessor :tools
+
+        # @!attribute [rw] metadata
+        #   @return [Hash, nil]
+        attr_accessor :metadata
+
+        # @param id [String, nil] optional
+        # @param assistant_id [String, nil] optional
+        # @param thread_id [String, nil] optional
+        # @param status [String, nil] optional
+        # @param temperature [Decimal, nil] optional
+        # @param instructions [String, nil] optional
+        # @param metadata [Hash, nil] optional
+        # @param tools [Array<Hash>, nil] optional
+        # @param client [OmniAI::OpenAI::Client] optional
+        def initialize(
+          id: nil,
+          assistant_id: nil,
+          thread_id: nil,
+          status: nil,
+          model: nil,
+          temperature: nil,
+          instructions: nil,
+          metadata: {},
+          tools: [],
+          client: Client.new
+        )
+          @id = id
+          @assistant_id = assistant_id
+          @thread_id = thread_id
+          @status = status
+          @model = model
+          @temperature = temperature
+          @instructions = instructions
+          @metadata = metadata
+          @tools = tools
+          @client = client
+        end
+
+        # @return [String]
+        def inspect
+          props = [
+            "id=#{@id.inspect}",
+            ("assistant_id=#{@assistant_id.inspect}" if @assistant_id),
+            ("thread_id=#{@thread_id.inspect}" if @thread_id),
+            ("status=#{@status.inspect}" if @status),
+          ].compact
+          "#<#{self.class.name} #{props.join(' ')}>"
+        end
+
+        # @param thread_id [String] required
+        # @param id [String] required
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [OmniAI::OpenAI::Thread::Run]
+        def self.find(thread_id:, id:, client: Client.new)
+          response = client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .get("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{thread_id}/runs/#{id}")
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          parse(data: response.parse)
+        end
+
+        # @param thread_id [String] required
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [Array<OmniAI::OpenAI::Thread::Run>]
+        def self.all(thread_id:, limit: nil, client: Client.new)
+          response = client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .get("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{thread_id}/runs", params: { limit: }.compact)
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          response.parse['data'].map { |data| parse(data:, client:) }
+        end
+
+        # @param thread_id [String] required
+        # @param id [String] required
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [Hash]
+        def self.cancel!(thread_id:, id:, client: Client.new)
+          response = client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .post("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{thread_id}/runs/#{id}/cancel")
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          response.parse
+        end
+
+        # @raise [HTTPError]
+        # @return [OmniAI::OpenAI::Thread]
+        def save!
+          response = @client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .post(path, json: payload)
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          parse(data: response.parse)
+          self
+        end
+
+        # @raise [HTTPError]
+        # @return [OmniAI::OpenAI::Thread]
+        def reload!
+          raise Error, 'unable to fetch! without an ID' unless @id
+
+          response = @client.connection
+            .accept(:json)
+            .headers(HEADERS)
+            .get(path)
+
+          raise HTTPError, response.flush unless response.status.ok?
+
+          parse(data: response.parse)
+          self
+        end
+
+        # @raise [OmniAI::Error]
+        # @return [OmniAI::OpenAI::Thread]
+        def cancel!
+          raise OmniAI::Error, 'cannot cancel a non-persisted thread' unless @id
+
+          data = self.class.cancel!(thread_id: @thread_id, id: @id, client: @client)
+          @status = data['status']
+          self
+        end
+
+        # @param interval [Integer, Float, nil] optional (seconds)
+        #
+        # @return [OmniAI::OpenAI::Thread::Run]
+        def poll!(delay: 2)
+          loop do
+            reload!
+            break if terminated?
+
+            sleep(delay) if delay
+          end
+        end
+
+        # @return [Boolean]
+        def terminated?
+          TERMINATED_STATUSES.include?(@status)
+        end
+
+        private
+
+        class << self
+          private
+
+          # @param data [Hash] required
+          # @param client [OmniAI::OpenAI::Client] required
+          # @return [OmniAI::OpenAI::Thread]
+          def parse(data:, client: Client.new)
+            new(
+              client:,
+              id: data['id'],
+              assistant_id: data['assistant_id'],
+              thread_id: data['thread_id'],
+              status: data['status'],
+              model: data['model'],
+              temperature: data['temperature'],
+              instructions: data['instructions'],
+              tools: data['tools'],
+              metadata: data['metadata']
+            )
+          end
+        end
+
+        # @param data [Hash] required
+        def parse(data:)
+          @id = data['id']
+          @assistant_id = data['assistant_id']
+          @thread_id = data['thread_id']
+          @run_id = data['run_id']
+          @status = data['status']
+          @model = data['model']
+          @temperature = data['temperature']
+          @instructions = data['instructions']
+          @tools = data['tools']
+          @metadata = data['metadata']
+        end
+
+        # @return [Hash]
+        def payload
+          {
+            assistant_id: @assistant_id,
+            model: @model,
+            temperature: @temperature,
+            instructions: @instructions,
+            tools: @tools,
+            metadata: @metadata,
+          }.compact
+        end
+
+        # @return [String]
+        def path
+          "/#{OmniAI::OpenAI::Client::VERSION}/threads/#{@thread_id}/runs#{"/#{@id}" if @id}"
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/thread/runs.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    class Thread
+      # An OpenAI scope for establishing messages.
+      class Runs
+        # @param client [OmniAI::OpenAI::Client] required
+        # @param thread [OmniAI::OpenAI::Thread] required
+        def initialize(client:, thread:)
+          @client = client
+          @thread = thread
+        end
+
+        # @param limit [Integer] optional
+        # @return [Array<OmniAI::Thread::Message>]
+        def all(limit: nil)
+          Run.all(thread_id: @thread.id, limit:, client: @client)
+        end
+
+        # @param id [String] required
+        # @return [OmniAI::OpenAI::Thread::Message]
+        def find(id:)
+          Run.find(id:, thread_id: @thread.id, client: @client)
+        end
+
+        # @param id [String] required
+        # @return [Hash]
+        def cancel!(id:)
+          Run.cancel!(id:, thread_id: @thread.id, client: @client)
+        end
+
+        # @param assistant_id [String] required
+        # @param model [String] optional
+        # @param temperature [Float] optional
+        # @param instructions [String] optional
+        # @param tools [Array<Hash>, nil] optional
+        # @param metadata [Hash, nil] optional
+        # @param client [OmniAI::OpenAI::Client] optional
+        # @return [OmniAI::OpenAI::Thread::Message]
+        def build(assistant_id:, model: nil, temperature: nil, instructions: nil, tools: nil, metadata: {})
+          Run.new(
+            assistant_id:,
+            thread_id: @thread.id,
+            model:,
+            temperature:,
+            instructions:,
+            tools:,
+            metadata:,
+            client: @client
+          )
+        end
+      end
+    end
+  end
+end

data/lib/omniai/openai/thread.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module OpenAI
+    # An OpenAI threads implementation.
+    class Thread
+      HEADERS = { 'OpenAI-Beta': 'assistants=v2' }.freeze
+
+      # @!attribute [rw] id
+      #   @return [String, nil]
+      attr_accessor :id
+
+      # @!attribute [rw] metadata
+      #   @return [Hash]
+      attr_accessor :metadata
+
+      # @!attribute [rw] tool_resources
+      #   @return [Hash]
+      attr_accessor :tool_resources
+
+      # @!attribute [rw] deleted
+      #   @return [Boolean, nil]
+      attr_accessor :deleted
+
+      # @param client [OmniAI::OpenAI::Client] optional
+      # @param id [String]
+      # @param metadata [String]
+      def initialize(
+        client: Client.new,
+        id: nil,
+        metadata: {},
+        tool_resources: {}
+      )
+        @client = client
+        @id = id
+        @metadata = metadata
+        @tool_resources = tool_resources
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class.name} id=#{@id.inspect}>"
+      end
+
+      # @param id [String] required
+      # @param client [OmniAI::OpenAI::Client] optional
+      # @return [OmniAI::OpenAI::Thread]
+      def self.find(id:, client: Client.new)
+        response = client.connection
+          .accept(:json)
+          .headers(HEADERS)
+          .get("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{id}")
+
+        raise HTTPError, response.flush unless response.status.ok?
+
+        parse(data: response.parse)
+      end
+
+      # @param id [String] required
+      # @param client [OmniAI::OpenAI::Client] optional
+      # @return [Hash]
+      def self.destroy!(id:, client: Client.new)
+        response = client.connection
+          .accept(:json)
+          .headers(HEADERS)
+          .delete("/#{OmniAI::OpenAI::Client::VERSION}/threads/#{id}")
+
+        raise HTTPError, response.flush unless response.status.ok?
+
+        response.parse
+      end
+
+      # @raise [HTTPError]
+      # @return [OmniAI::OpenAI::Thread]
+      def save!
+        response = @client.connection
+          .accept(:json)
+          .headers(HEADERS)
+          .post("/#{OmniAI::OpenAI::Client::VERSION}/threads#{"/#{@id}" if @id}", json: payload)
+        raise HTTPError, response.flush unless response.status.ok?
+
+        parse(data: response.parse)
+        self
+      end
+
+      # @raise [OmniAI::Error]
+      # @return [OmniAI::OpenAI::Thread]
+      def destroy!
+        raise OmniAI::Error, 'cannot destroy a non-persisted thread' unless @id
+
+        data = self.class.destroy!(id: @id, client: @client)
+        @deleted = data['deleted']
+        self
+      end
+
+      # @return [OmniAI::OpenAI::Thread::Messages]
+      def messages
+        Messages.new(client: @client, thread: self)
+      end
+
+      # @return [OmniAI::OpenAI::Thread::Runs]
+      def runs
+        Runs.new(client: @client, thread: self)
+      end
+
+      private
+
+      class << self
+        private
+
+        # @param data [Hash] required
+        # @param client [OmniAI::OpenAI::Client] required
+        # @return [OmniAI::OpenAI::Thread]
+        def parse(data:, client: Client.new)
+          new(
+            client:,
+            id: data['id'],
+            metadata: data['metadata'],
+            tool_resources: data['tool_resources']
+          )
+        end
+      end
+
+      # @param data [Hash] required
+      # @return [OmniAI::OpenAI::Thread]
+      def parse(data:)
+        @id = data['id']
+        @metadata = data['metadata']
+        @tool_resources = data['tool_resources']
+      end
+
+      # @return [Hash]
+      def payload
+        {
+          metadata: @metadata,
+          tool_resources: @tool_resources,
+        }.compact
+      end
+    end
+  end
+end