groq_ruby 0.1.0

data/lib/groq_ruby/models/embeddings/create_embedding_response.rb

@@ -0,0 +1,11 @@
+module GroqRuby
+  module Models
+    # Full response from `client.embeddings.create`.
+    class CreateEmbeddingResponse < Data.define(:data, :model, :object, :usage)
+      extend ModelFactory
+
+      coerce :data, with: ->(arr) { Array(arr).map { |h| Embedding.from_hash(h) } }
+      coerce :usage, with: ->(h) { EmbeddingUsage.from_hash(h) }
+    end
+  end
+end

data/lib/groq_ruby/models/embeddings/embedding.rb

@@ -0,0 +1,8 @@
+module GroqRuby
+  module Models
+    # A single embedding vector with its position in the request.
+    class Embedding < Data.define(:embedding, :index, :object)
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/models/embeddings/embedding_usage.rb

@@ -0,0 +1,8 @@
+module GroqRuby
+  module Models
+    # Token usage returned with an embedding response.
+    class EmbeddingUsage < Data.define(:prompt_tokens, :total_tokens)
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/models/files/file_deleted.rb

@@ -0,0 +1,8 @@
+module GroqRuby
+  module Models
+    # Acknowledgement for a successful file deletion.
+    class FileDeleted < Data.define(:id, :object, :deleted)
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/models/files/file_list.rb

@@ -0,0 +1,10 @@
+module GroqRuby
+  module Models
+    # Wrapper for a `files.list` response.
+    class FileList < Data.define(:data, :object)
+      extend ModelFactory
+
+      coerce :data, with: ->(arr) { Array(arr).map { |h| FileObject.from_hash(h) } }
+    end
+  end
+end

data/lib/groq_ruby/models/files/file_object.rb

@@ -0,0 +1,8 @@
+module GroqRuby
+  module Models
+    # Metadata for a single file uploaded to Groq.
+    class FileObject < Data.define(:id, :object, :bytes, :created_at, :filename, :purpose)
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/models/model.rb

@@ -0,0 +1,8 @@
+module GroqRuby
+  module Models
+    # Metadata for a single Groq model.
+    class Model < Data.define(:id, :object, :created, :owned_by, :active, :context_window, :public_apps, :max_completion_tokens)
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/models/model_deleted.rb

@@ -0,0 +1,8 @@
+module GroqRuby
+  module Models
+    # Acknowledgement for a successful model deletion.
+    class ModelDeleted < Data.define(:id, :object, :deleted)
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/models/model_factory.rb

@@ -0,0 +1,31 @@
+module GroqRuby
+  module Models
+    # Tiny mixin that gives a Data subclass a `from_hash` constructor.
+    # Walks the Data class's `members` and pulls each key out of the
+    # incoming Hash (string-keyed). Unknown keys are ignored; missing keys
+    # default to `nil`. Per-attribute coercions are declared on the class:
+    #
+    #   class MyModel < Data.define(:choices)
+    #     extend ModelFactory
+    #     coerce :choices, with: ->(arr) { arr.map { |h| Choice.from_hash(h) } }
+    #   end
+    module ModelFactory
+      def coerce(attr, with:)
+        coercions[attr] = with
+      end
+
+      def coercions
+        @coercions ||= {}
+      end
+
+      def from_hash(hash)
+        return nil if hash.nil?
+        attrs = members.each_with_object({}) do |name, acc|
+          raw = hash[name.to_s] || hash[name]
+          acc[name] = coercions.key?(name) ? coercions[name].call(raw) : raw
+        end
+        new(**attrs)
+      end
+    end
+  end
+end

data/lib/groq_ruby/models/model_list.rb

@@ -0,0 +1,10 @@
+module GroqRuby
+  module Models
+    # Wrapper for a `models.list` response.
+    class ModelList < Data.define(:data, :object)
+      extend ModelFactory
+
+      coerce :data, with: ->(arr) { Array(arr).map { |h| Model.from_hash(h) } }
+    end
+  end
+end

data/lib/groq_ruby/models/usage.rb

@@ -0,0 +1,11 @@
+module GroqRuby
+  module Models
+    # Token + timing usage breakdown returned with chat completions.
+    class Usage < Data.define(
+      :prompt_tokens, :completion_tokens, :total_tokens,
+      :prompt_time, :completion_time, :total_time, :queue_time
+    )
+      extend ModelFactory
+    end
+  end
+end

data/lib/groq_ruby/multipart.rb

@@ -0,0 +1,84 @@
+require "securerandom"
+
+module GroqRuby
+  # Encodes a list of fields into a multipart/form-data body. Used by the
+  # file upload endpoints (audio transcription/translation, files.create).
+  # Single-purpose — builds the body and content-type header. Does no IO.
+  #
+  # @example
+  #   parts = [
+  #     Multipart::Part.new("model", "whisper-large-v3"),
+  #     Multipart::Part.file("file", io: file_io, filename: "audio.mp3", content_type: "audio/mpeg")
+  #   ]
+  #   multipart = Multipart.new(parts)
+  #   request_body = multipart.body
+  #   header_value = multipart.content_type
+  class Multipart
+    # A single field inside a multipart payload.
+    Part = Data.define(:name, :value, :filename, :content_type) do
+      # Build a plain text field.
+      # @param name [String]
+      # @param value [#to_s]
+      # @return [Part]
+      def self.text(name, value)
+        new(name: name, value: value.to_s, filename: nil, content_type: nil)
+      end
+
+      # Build a file upload field.
+      # @param name [String]
+      # @param io [#read] readable IO whose `#read` returns the bytes.
+      # @param filename [String]
+      # @param content_type [String]
+      # @return [Part]
+      def self.file(name, io:, filename:, content_type: "application/octet-stream")
+        new(name: name, value: io, filename: filename, content_type: content_type)
+      end
+
+      # @return [Boolean] true if this part is a file upload (has a filename)
+      def file?
+        !filename.nil?
+      end
+    end
+
+    # @return [String] the random boundary string used to separate parts
+    attr_reader :boundary
+
+    # @param parts [Array<Part>] the fields to encode
+    # @param boundary [String] override the auto-generated boundary
+    def initialize(parts, boundary: SecureRandom.hex(16))
+      @parts = parts
+      @boundary = boundary
+    end
+
+    # @return [String] the encoded multipart body, suitable for `Net::HTTP::Post#body=`
+    def body
+      buffer = +""
+      @parts.each { |p| buffer << encode_part(p) }
+      buffer << "--#{@boundary}--\r\n"
+      buffer
+    end
+
+    # @return [String] the value to use for the `Content-Type` header
+    def content_type
+      "multipart/form-data; boundary=#{@boundary}"
+    end
+
+    private
+
+    def encode_part(part)
+      header = "--#{@boundary}\r\n"
+      header << if part.file?
+        %(Content-Disposition: form-data; name="#{part.name}"; filename="#{part.filename}"\r\n) +
+          "Content-Type: #{part.content_type}\r\n\r\n"
+      else
+        %(Content-Disposition: form-data; name="#{part.name}"\r\n\r\n)
+      end
+      header << read_value(part.value)
+      header << "\r\n"
+    end
+
+    def read_value(value)
+      value.respond_to?(:read) ? value.read : value.to_s
+    end
+  end
+end

data/lib/groq_ruby/request.rb

@@ -0,0 +1,13 @@
+module GroqRuby
+  # Value object describing a single HTTP request. Built by resources,
+  # consumed by {Transport}. Immutable.
+  Request = Data.define(:method, :path, :query, :body, :headers, :content_type) do
+    def initialize(method:, path:, query: nil, body: nil, headers: {}, content_type: nil)
+      super
+    end
+
+    def with_headers(extra)
+      with(headers: headers.merge(extra))
+    end
+  end
+end

data/lib/groq_ruby/resources/audio/speech.rb

@@ -0,0 +1,32 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    class Audio
+      # `client.audio.speech.create(...)` — text-to-speech. Returns the
+      # raw audio bytes (caller decides where to write them).
+      class Speech < Base
+        PATH = "/openai/v1/audio/speech".freeze
+
+        SCHEMA = Dry::Schema.define do
+          required(:input).filled(:string)
+          required(:model).filled(:string)
+          required(:voice).filled(:string)
+          optional(:response_format).filled(:string, included_in?: %w[flac mp3 mulaw ogg wav])
+          optional(:sample_rate).filled(:integer, included_in?: [8000, 16000, 22050, 24000, 32000, 44100, 48000])
+          optional(:speed).filled(:float)
+        end
+
+        # @param params [Hash] required: `:input` (text), `:model`, `:voice`.
+        #   Optional: `:response_format` (`"flac"` | `"mp3"` | `"mulaw"` |
+        #   `"ogg"` | `"wav"`), `:sample_rate`, `:speed`.
+        # @return [String] raw audio bytes — write with `File.binwrite`.
+        # @raise [ParameterError] on invalid params.
+        def create(**params)
+          body = validate!(SCHEMA, params)
+          perform(Request.new(method: :post, path: PATH, body: body), accept: :binary)
+        end
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/audio/transcriptions.rb

@@ -0,0 +1,48 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    class Audio
+      # `client.audio.transcriptions.create(...)` — speech to text. Either
+      # an in-memory `file:` IO or a remote `url:` must be supplied.
+      class Transcriptions < Base
+        PATH = "/openai/v1/audio/transcriptions".freeze
+
+        SCHEMA = Dry::Schema.define do
+          required(:model).filled(:string)
+          optional(:language).filled(:string)
+          optional(:prompt).filled(:string)
+          optional(:response_format).filled(:string, included_in?: %w[json text srt verbose_json vtt])
+          optional(:temperature).filled(:float, gteq?: 0.0, lteq?: 1.0)
+          optional(:timestamp_granularities).value(:array)
+        end
+
+        # @param file [IO, nil] readable IO or nil if `url:` is given.
+        # @param filename [String, nil] filename for the multipart upload.
+        # @param url [String, nil] URL the API can fetch instead of an upload.
+        # @param params [Hash] required: `:model`. Optional: `:language`,
+        #   `:prompt`, `:response_format`, `:temperature`,
+        #   `:timestamp_granularities`.
+        # @return [GroqRuby::Models::Transcription]
+        # @raise [ParameterError] when neither `file:` nor `url:` is given,
+        #   or when other params fail validation.
+        def create(file: nil, filename: nil, url: nil, **params)
+          raise ParameterError, {file: ["either file or url is required"]} if file.nil? && url.nil?
+          body = validate!(SCHEMA, params)
+          multipart = build_multipart(file: file, filename: filename, url: url, body: body)
+          request = Request.new(method: :post, path: PATH, body: multipart.body, content_type: multipart.content_type)
+          GroqRuby::Models::Transcription.from_hash(perform(request))
+        end
+
+        private
+
+        def build_multipart(file:, filename:, url:, body:)
+          parts = body.map { |k, v| Multipart::Part.text(k.to_s, v) }
+          parts << Multipart::Part.text("url", url) if url
+          parts << Multipart::Part.file("file", io: file, filename: filename || "audio", content_type: "application/octet-stream") if file
+          Multipart.new(parts)
+        end
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/audio/translations.rb

@@ -0,0 +1,45 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    class Audio
+      # `client.audio.translations.create(...)` — translates speech in any
+      # supported language into English text.
+      class Translations < Base
+        PATH = "/openai/v1/audio/translations".freeze
+
+        SCHEMA = Dry::Schema.define do
+          required(:model).filled(:string)
+          optional(:prompt).filled(:string)
+          optional(:response_format).filled(:string, included_in?: %w[json text srt verbose_json vtt])
+          optional(:temperature).filled(:float, gteq?: 0.0, lteq?: 1.0)
+        end
+
+        # @param file [IO, nil] readable IO or nil if `url:` is given.
+        # @param filename [String, nil] filename for the multipart upload.
+        # @param url [String, nil] URL the API can fetch instead of an upload.
+        # @param params [Hash] required: `:model`. Optional: `:prompt`,
+        #   `:response_format`, `:temperature`.
+        # @return [GroqRuby::Models::Translation]
+        # @raise [ParameterError] when neither `file:` nor `url:` is given,
+        #   or when other params fail validation.
+        def create(file: nil, filename: nil, url: nil, **params)
+          raise ParameterError, {file: ["either file or url is required"]} if file.nil? && url.nil?
+          body = validate!(SCHEMA, params)
+          multipart = build_multipart(file: file, filename: filename, url: url, body: body)
+          request = Request.new(method: :post, path: PATH, body: multipart.body, content_type: multipart.content_type)
+          GroqRuby::Models::Translation.from_hash(perform(request))
+        end
+
+        private
+
+        def build_multipart(file:, filename:, url:, body:)
+          parts = body.map { |k, v| Multipart::Part.text(k.to_s, v) }
+          parts << Multipart::Part.text("url", url) if url
+          parts << Multipart::Part.file("file", io: file, filename: filename || "audio", content_type: "application/octet-stream") if file
+          Multipart.new(parts)
+        end
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/audio.rb

@@ -0,0 +1,26 @@
+module GroqRuby
+  module Resources
+    # Namespace for the three audio sub-resources: speech, transcriptions,
+    # and translations.
+    class Audio
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # @return [Audio::Speech]
+      def speech
+        @speech ||= Audio::Speech.new(@transport)
+      end
+
+      # @return [Audio::Transcriptions]
+      def transcriptions
+        @transcriptions ||= Audio::Transcriptions.new(@transport)
+      end
+
+      # @return [Audio::Translations]
+      def translations
+        @translations ||= Audio::Translations.new(@transport)
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/base.rb

@@ -0,0 +1,33 @@
+module GroqRuby
+  module Resources
+    # Common scaffolding shared by every resource: holds the transport and
+    # exposes a small set of helpers for building requests and surfacing
+    # validation/transport errors.
+    class Base
+      def initialize(transport)
+        @transport = transport
+      end
+
+      private
+
+      attr_reader :transport
+
+      # Run a dry-schema against caller params; raise {ParameterError} on
+      # failure so callers get a single, well-typed error to rescue.
+      def validate!(schema, params)
+        result = schema.call(params)
+        raise ParameterError, result.errors.to_h if result.failure?
+        result.to_h
+      end
+
+      # Send a buffered request and surface either the parsed body Hash or
+      # the raw String (for binary endpoints). Re-raises the {APIError}
+      # carried by a Failure result so resources stay raise-on-error.
+      def perform(request, accept: :json)
+        result = @transport.call(request, accept: accept)
+        raise result.failure if result.failure?
+        result.value!.body
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/batches.rb

@@ -0,0 +1,44 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    # `client.batches.*` — async batch processing of chat completions or
+    # embeddings against an uploaded JSONL file.
+    class Batches < Base
+      BASE_PATH = "/openai/v1/batches".freeze
+
+      CREATE_SCHEMA = Dry::Schema.define do
+        required(:input_file_id).filled(:string)
+        required(:endpoint).filled(:string)
+        required(:completion_window).filled(:string)
+        optional(:metadata).value(:hash)
+      end
+
+      # @param params [Hash] required: `:input_file_id`, `:endpoint`,
+      #   `:completion_window` (e.g. `"24h"`). Optional: `:metadata`.
+      # @return [GroqRuby::Models::Batch]
+      # @raise [ParameterError] on invalid params.
+      def create(**params)
+        body = validate!(CREATE_SCHEMA, params)
+        GroqRuby::Models::Batch.from_hash(perform(Request.new(method: :post, path: BASE_PATH, body: body)))
+      end
+
+      # @param batch_id [String]
+      # @return [GroqRuby::Models::Batch]
+      def retrieve(batch_id)
+        GroqRuby::Models::Batch.from_hash(perform(Request.new(method: :get, path: "#{BASE_PATH}/#{batch_id}")))
+      end
+
+      # @return [GroqRuby::Models::BatchList]
+      def list
+        GroqRuby::Models::BatchList.from_hash(perform(Request.new(method: :get, path: BASE_PATH)))
+      end
+
+      # @param batch_id [String]
+      # @return [GroqRuby::Models::Batch] with `status` advanced toward `cancelled`
+      def cancel(batch_id)
+        GroqRuby::Models::Batch.from_hash(perform(Request.new(method: :post, path: "#{BASE_PATH}/#{batch_id}/cancel")))
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/chat/completions.rb

@@ -0,0 +1,94 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    class Chat
+      # `client.chat.completions.create(...)` — the workhorse of the API.
+      # Supports both buffered and Server-Sent-Events streaming responses.
+      #
+      # @example Buffered call
+      #   resp = client.chat.completions.create(
+      #     model: "llama-3.3-70b-versatile",
+      #     messages: [{role: "user", content: "Hello"}]
+      #   )
+      #   resp.choices.first.message.content
+      #
+      # @example Streaming call (block form)
+      #   client.chat.completions.create(
+      #     model: "llama-3.3-70b-versatile",
+      #     messages: [{role: "user", content: "Hello"}],
+      #     stream: true
+      #   ) { |chunk| print chunk.choices.first.delta.content }
+      class Completions < Base
+        PATH = "/openai/v1/chat/completions".freeze
+
+        SCHEMA = Dry::Schema.define do
+          required(:model).filled(:string)
+          required(:messages).value(:array, min_size?: 1)
+          optional(:temperature).filled(:float, gteq?: 0.0, lteq?: 2.0)
+          optional(:top_p).filled(:float, gteq?: 0.0, lteq?: 1.0)
+          optional(:n).filled(:integer, gt?: 0)
+          optional(:max_tokens).filled(:integer, gt?: 0)
+          optional(:max_completion_tokens).filled(:integer, gt?: 0)
+          optional(:presence_penalty).filled(:float, gteq?: -2.0, lteq?: 2.0)
+          optional(:frequency_penalty).filled(:float, gteq?: -2.0, lteq?: 2.0)
+          optional(:seed).filled(:integer)
+          optional(:stop)
+          optional(:stream).filled(:bool)
+          optional(:user).maybe(:string)
+          optional(:tools).value(:array)
+          optional(:tool_choice)
+          optional(:response_format).value(:hash)
+          optional(:logprobs).filled(:bool)
+          optional(:top_logprobs).filled(:integer, gteq?: 0, lteq?: 20)
+          optional(:reasoning_effort).filled(:string, included_in?: %w[none default low medium high])
+          optional(:reasoning_format).filled(:string, included_in?: %w[hidden raw parsed])
+          optional(:service_tier).filled(:string, included_in?: %w[auto on_demand flex performance])
+          optional(:parallel_tool_calls).filled(:bool)
+          optional(:logit_bias).value(:hash)
+          optional(:metadata).value(:hash)
+        end
+
+        # @param stream [Boolean] if true, response is streamed via SSE.
+        # @param params [Hash] all chat completion parameters supported by
+        #   the Groq API. Required: `:model`, `:messages`. Many optional:
+        #   `:temperature`, `:top_p`, `:n`, `:max_completion_tokens`, `:stop`,
+        #   `:tools`, `:tool_choice`, `:response_format`, `:reasoning_effort`,
+        #   `:reasoning_format`, `:service_tier`, `:seed`, `:logit_bias`,
+        #   `:metadata`, etc.
+        # @yieldparam chunk [GroqRuby::Models::ChatCompletionChunk]
+        #   yielded for each event when `stream: true`.
+        # @return [GroqRuby::Models::ChatCompletion] when buffered.
+        # @return [GroqRuby::Streaming::ChunkStream] when `stream: true`
+        #   and no block given. Returns nil when streaming with a block.
+        # @raise [ParameterError] when params fail dry-schema validation.
+        # @raise [APIStatusError] subclass on 4xx/5xx response.
+        # @raise [APIConnectionError] on network failure.
+        def create(stream: false, **params, &block)
+          body = validate!(SCHEMA, params.merge(stream: stream))
+          if stream
+            stream_response(body, &block)
+          else
+            buffered_response(body)
+          end
+        end
+
+        private
+
+        def buffered_response(body)
+          payload = perform(Request.new(method: :post, path: PATH, body: body))
+          GroqRuby::Models::ChatCompletion.from_hash(payload)
+        end
+
+        def stream_response(body, &block)
+          chunks = Streaming::ChunkStream.new(
+            transport: transport,
+            request: Request.new(method: :post, path: PATH, body: body, headers: {"Accept" => "text/event-stream"}),
+            chunk_model: GroqRuby::Models::ChatCompletionChunk
+          )
+          block ? chunks.each(&block) : chunks
+        end
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/chat.rb

@@ -0,0 +1,16 @@
+module GroqRuby
+  module Resources
+    # Namespace for the chat sub-resources (only `completions` for now).
+    # Mirrors `client.chat.completions.create(...)` from the python SDK.
+    class Chat
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # @return [Chat::Completions]
+      def completions
+        @completions ||= Chat::Completions.new(@transport)
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/embeddings.rb

@@ -0,0 +1,28 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    # `client.embeddings.create(...)` — turns text into vectors.
+    class Embeddings < Base
+      PATH = "/openai/v1/embeddings".freeze
+
+      SCHEMA = Dry::Schema.define do
+        required(:model).filled(:string)
+        required(:input)
+        optional(:encoding_format).filled(:string, included_in?: %w[float base64])
+        optional(:user).maybe(:string)
+      end
+
+      # @param params [Hash] required: `:model`, `:input` (String or Array of Strings).
+      #   Optional: `:encoding_format` (`"float"` | `"base64"`), `:user`.
+      # @return [GroqRuby::Models::CreateEmbeddingResponse]
+      # @raise [ParameterError] when params fail validation.
+      # @raise [APIStatusError] subclass on 4xx/5xx response.
+      def create(**params)
+        body = validate!(SCHEMA, params)
+        payload = perform(Request.new(method: :post, path: PATH, body: body))
+        GroqRuby::Models::CreateEmbeddingResponse.from_hash(payload)
+      end
+    end
+  end
+end

data/lib/groq_ruby/resources/files.rb

@@ -0,0 +1,55 @@
+require "dry/schema"
+
+module GroqRuby
+  module Resources
+    # `client.files.*` — upload, list, fetch, and delete files used by the
+    # batch endpoints.
+    class Files < Base
+      BASE_PATH = "/openai/v1/files".freeze
+
+      CREATE_SCHEMA = Dry::Schema.define do
+        required(:purpose).filled(:string, included_in?: %w[batch])
+      end
+
+      # Upload a JSONL file to be referenced from a batch job.
+      #
+      # @param file [IO, File] readable IO whose `#read` returns the bytes.
+      # @param filename [String] name to send with the multipart upload.
+      # @param purpose [String] currently always `"batch"`.
+      # @return [GroqRuby::Models::FileObject]
+      # @raise [ParameterError] when `purpose` is not `"batch"`.
+      def create(file:, filename:, purpose:)
+        validate!(CREATE_SCHEMA, {purpose: purpose})
+        multipart = Multipart.new([
+          Multipart::Part.text("purpose", purpose),
+          Multipart::Part.file("file", io: file, filename: filename, content_type: "application/jsonl")
+        ])
+        request = Request.new(method: :post, path: BASE_PATH, body: multipart.body, content_type: multipart.content_type)
+        GroqRuby::Models::FileObject.from_hash(perform(request))
+      end
+
+      # @return [GroqRuby::Models::FileList]
+      def list
+        GroqRuby::Models::FileList.from_hash(perform(Request.new(method: :get, path: BASE_PATH)))
+      end
+
+      # @param file_id [String]
+      # @return [GroqRuby::Models::FileObject]
+      def info(file_id)
+        GroqRuby::Models::FileObject.from_hash(perform(Request.new(method: :get, path: "#{BASE_PATH}/#{file_id}")))
+      end
+
+      # @param file_id [String]
+      # @return [String] the raw bytes of the file
+      def content(file_id)
+        perform(Request.new(method: :get, path: "#{BASE_PATH}/#{file_id}/content"), accept: :binary)
+      end
+
+      # @param file_id [String]
+      # @return [GroqRuby::Models::FileDeleted]
+      def delete(file_id)
+        GroqRuby::Models::FileDeleted.from_hash(perform(Request.new(method: :delete, path: "#{BASE_PATH}/#{file_id}")))
+      end
+    end
+  end
+end