omniai-llama 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25c0a8a9ba448d407d0f8300d377d0e3a10a0aa1b18343540a0b32f3eb3baeb5
+  data.tar.gz: 67d4173043933e6314df901969eae71b0ab1137dfd8da4365377824eeed167dd
+SHA512:
+  metadata.gz: 2e43f7b12d1dbcbe2b02c9a7bc206ee0c1980c231843cb7fc292774548fed69ebb492a17aa8d451374a106bcc7d24f9ec0af27cce34004459493174b74854243
+  data.tar.gz: b991b560116560bff895708f89cc28d01c20a1f477ab69625fb910249bdc7b853eb91f23666b8d1fedb7caaac5f715bc01c3cfa749ee91a0d4929d9e9ac1f3ec

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "redcarpet"
+gem "rspec"
+gem "rspec_junit_formatter"
+gem "rubocop"
+gem "rubocop-basic"
+gem "rubocop-rake"
+gem "rubocop-rspec"
+gem "simplecov"
+gem "webmock"
+gem "yard"

data/README.md

@@ -0,0 +1,432 @@
+# OmniAI::Llama
+
+[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ksylvest/omniai-llama/blob/main/LICENSE)
+[![RubyGems](https://img.shields.io/gem/v/omniai-llama)](https://rubygems.org/gems/omniai-llama)
+[![GitHub](https://img.shields.io/badge/github-repo-blue.svg)](https://github.com/ksylvest/omniai-llama)
+[![Yard](https://img.shields.io/badge/docs-site-blue.svg)](https://omniai-llama.ksylvest.com)
+[![CircleCI](https://img.shields.io/circleci/build/github/ksylvest/omniai-llama)](https://circleci.com/gh/ksylvest/omniai-llama)
+
+A implementation of the [OmniAI](https://github.com/ksylvest/omniai) for api.llama.com.
+
+## Installation
+
+```sh
+gem install omniai-llama
+```
+
+## Usage
+
+### Client
+
+A client is setup as follows if `ENV['LLAMA_API_KEY']` exists:
+
+```ruby
+client = OmniAI::Llama::Client.new
+```
+
+A client may also be passed the following options:
+
+- `api_key` (required - default is `ENV['LLAMA_API_KEY']`)
+
+### Configuration
+
+Global configuration is supported for the following options:
+
+```ruby
+OmniAI::Llama.configure do |config|
+  config.api_key = 'sk-...' # default: ENV['LLAMA_API_KEY']
+end
+```
+
+### Chat
+
+A chat completion is generated by passing in a simple text prompt:
+
+```ruby
+completion = client.chat('Tell me a joke!')
+completion.content # 'Why did the chicken cross the road? To get to the other side.'
+```
+
+A chat completion may also be generated by using a prompt builder:
+
+```ruby
+completion = client.chat do |prompt|
+  prompt.system('Your are an expert in geography.')
+  prompt.user('What is the capital of Canada?')
+end
+completion.content # 'The capital of Canada is Ottawa.'
+```
+
+#### Model
+
+`model` takes an optional string (default is `gpt-4o`):
+
+```ruby
+completion = client.chat('How fast is a cheetah?', model: OmniAI::Llama::Chat::Model::GPT_3_5_TURBO)
+completion.content # 'A cheetah can reach speeds over 100 km/h.'
+```
+
+[OpenAI API Reference `model`](https://platform.openai.com/docs/api-reference/chat/create#chat-create-model)
+
+#### Temperature
+
+`temperature` takes an optional float between `0.0` and `2.0` (defaults is `0.7`):
+
+```ruby
+completion = client.chat('Pick a number between 1 and 5', temperature: 2.0)
+completion.content # '3'
+```
+
+[OpenAI API Reference `temperature`](https://platform.openai.com/docs/api-reference/chat/create#chat-create-temperature)
+
+#### Stream
+
+`stream` takes an optional a proc to stream responses in real-time chunks instead of waiting for a complete response:
+
+```ruby
+stream = proc do |chunk|
+  print(chunk.content) # 'Better', 'three', 'hours', ...
+end
+client.chat('Be poetic.', stream:)
+```
+
+[OpenAI API Reference `stream`](https://platform.openai.com/docs/api-reference/chat/create#chat-create-stream)
+
+#### Format
+
+`format` takes an optional symbol (`:json`) and that setes the `response_format` to `json_object`:
+
+```ruby
+completion = client.chat(format: :json) do |prompt|
+  prompt.system(OmniAI::Chat::JSON_PROMPT)
+  prompt.user('What is the name of the drummer for the Beatles?')
+end
+JSON.parse(completion.content) # { "name": "Ringo" }
+```
+
+[OpenAI API Reference `response_format`](https://platform.openai.com/docs/api-reference/chat/create#chat-create-stream)
+
+> When using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message.
+
+### Transcribe
+
+A transcription is generated by passing in a path to a file:
+
+```ruby
+transcription = client.transcribe(file.path)
+transcription.text # '...'
+```
+
+#### Prompt
+
+`prompt` is optional and can provide additional context for transcribing:
+
+```ruby
+transcription = client.transcribe(file.path, prompt: '')
+transcription.text # '...'
+```
+
+[OpenAI API Reference `prompt`](https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-prompt)
+
+#### Format
+
+`format` is optional and supports `json`, `text`, `srt` or `vtt`:
+
+```ruby
+transcription = client.transcribe(file.path, format: OmniAI::Transcribe::Format::TEXT)
+transcription.text # '...'
+```
+
+[OpenAI API Reference `response_format`](https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-response_format)
+
+#### Language
+
+`language` is optional and may improve accuracy and latency:
+
+```ruby
+transcription = client.transcribe(file.path, language: OmniAI::Transcribe::Language::SPANISH)
+transcription.text
+```
+
+[OpenAI API Reference `language`](https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-language)
+
+#### Temperature
+
+`temperature` is optional and must be between 0.0 (more deterministic) and 1.0 (less deterministic):
+
+```ruby
+transcription = client.transcribe(file.path, temperature: 0.2)
+transcription.text
+```
+
+[OpenAI API Reference `temperature`](https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-temperature)
+
+### Speak
+
+Speech can be generated by passing text with a block:
+
+```ruby
+File.open('example.ogg', 'wb') do |file|
+  client.speak('How can a clam cram in a clean cream can?') do |chunk|
+    file << chunk
+  end
+end
+```
+
+If a block is not provided then a tempfile is returned:
+
+```ruby
+tempfile = client.speak('Can you can a can as a canner can can a can?')
+tempfile.close
+tempfile.unlink
+```
+
+#### Voice
+
+`voice` is optional and must be one of the supported voices:
+
+```ruby
+client.speak('She sells seashells by the seashore.', voice: OmniAI::Llama::Speak::Voice::SHIMMER)
+```
+
+[OpenAI API Reference `voice`](https://platform.openai.com/docs/api-reference/audio/createSpeech#audio-createspeech-voice)
+
+#### Model
+
+`model` is optional and must be either `tts-1` or `tts-1-hd` (default):
+
+```ruby
+client.speak('I saw a kitten eating chicken in the kitchen.', format: OmniAI::Llama::Speak::Model::TTS_1)
+```
+
+[OpenAI API Refernce `model`](https://platform.openai.com/docs/api-reference/audio/createSpeech#audio-createspeech-model)
+
+#### Speed
+
+`speed` is optional and must be between 0.25 and 0.40:
+
+```ruby
+client.speak('How much wood would a woodchuck chuck if a woodchuck could chuck wood?', speed: 4.0)
+```
+
+[OmniAI API Reference `speed`](https://platform.openai.com/docs/api-reference/audio/createSpeech#audio-createspeech-speed)
+
+#### Format
+
+`format` is optional and supports `MP3` (default), `OPUS`, `AAC`, `FLAC`, `WAV` or `PCM`:
+
+```ruby
+client.speak('A pessemistic pest exists amidst us.', format: OmniAI::Llama::Speak::Format::FLAC)
+```
+
+[OpenAI API Reference `format`](https://platform.openai.com/docs/api-reference/audio/createSpeech#audio-createspeech-response_format)
+
+## Files
+
+### Finding an File
+
+```ruby
+client.files.find(id: 'file_...')
+```
+
+### Listing all Files
+
+```ruby
+client.files.all
+```
+
+### Uploading a File
+
+#### Using a File
+
+```ruby
+file = client.files.build(io: File.open('demo.pdf', 'wb'))
+file.save!
+```
+
+#### Using a Path
+
+```ruby
+file = client.files.build(io: 'demo.pdf'))
+file.save!
+```
+
+### Downloading a File
+
+```ruby
+file = client.files.find(id: 'file_...')
+File.open('...', 'wb') do |file|
+  file.content do |chunk|
+    file << chunk
+  end
+end
+```
+
+### Destroying a File
+
+```ruby
+client.files.destroy!('file_...')
+```
+
+## Assistants
+
+### Finding an Assistant
+
+```ruby
+client.assistants.find(id: 'asst_...')
+```
+
+### Listing all Assistants
+
+```ruby
+client.assistants.all
+```
+
+### Creating an Assistant
+
+```ruby
+assistant = client.assistants.build
+assistant.name = 'Ringo'
+assistant.model = OmniAI::Llama::Chat::Model::GPT_4
+assistant.description = 'The drummer for the Beatles.'
+assistant.save!
+```
+
+### Updating an Assistant
+
+```ruby
+assistant = client.assistants.find(id: 'asst_...')
+assistant.name = 'George'
+assistant.model = OmniAI::Llama::Chat::Model::GPT_4
+assistant.description = 'A guitarist for the Beatles.'
+assistant.save!
+```
+
+### Destroying an Assistant
+
+```ruby
+client.assistants.destroy!('asst_...')
+```
+
+## Threads
+
+### Finding a Thread
+
+```ruby
+client.threads.find(id: 'thread_...')
+```
+
+### Creating a Thread
+
+```ruby
+thread = client.threads.build
+thread.metadata = { user: 'Ringo' }
+thread.save!
+```
+
+### Updating a Thread
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+thread.metadata = { user: 'Ringo' }
+thread.save!
+```
+
+### Destroying a Threads
+
+```ruby
+client.threads.destroy!('thread_...')
+```
+
+### Messages
+
+#### Finding a Message
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+message = thread.messages.find(id: 'msg_...')
+message.save!
+```
+
+#### Listing all Messages
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+thread.messages.all
+```
+
+#### Creating a Message
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+message = thread.messages.build(role: 'user', content: 'Hello?')
+message.save!
+```
+
+#### Updating a Message
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+message = thread.messages.build(role: 'user', content: 'Hello?')
+message.save!
+```
+
+### Runs
+
+#### Finding a Run
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+run = thread.runs.find(id: 'run_...')
+run.save!
+```
+
+#### Listing all Runs
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+thread.runs.all
+```
+
+#### Creating a Run
+
+```ruby
+run = client.runs.find(id: 'thread_...')
+run = thread.runs.build
+run.metadata = { user: 'Ringo' }
+run.save!
+```
+
+#### Updating a Run
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+run = thread.messages.find(id: 'run_...')
+run.metadata = { user: 'Ringo' }
+run.save!
+```
+
+#### Polling a Run
+
+```ruby
+run.terminated? # false
+run.poll!
+run.terminated? # true
+run.status # 'cancelled' / 'failed' / 'completed' / 'expired'
+```
+
+#### Cancelling a Run
+
+```ruby
+thread = client.threads.find(id: 'thread_...')
+run = thread.runs.cancel!(id: 'run_...')
+```
+
+### Embed
+
+Text can be converted into a vector embedding for similarity comparison usage via:
+
+```ruby
+response = client.embed('The quick brown fox jumps over a lazy dog.')
+response.embedding # [0.0, ...]
+```

data/lib/omniai/llama/chat/choice_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    class Chat
+      # Overrides choice serialize / deserialize for the following payload:
+      #
+      #   {
+      #     content: {
+      #       type: "text",
+      #       text: "Hello!",
+      #     },
+      #     role: "assistant",
+      #     stop_reason: "stop",
+      #     tool_calls: [],
+      #   }
+      module ChoiceSerializer
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Response]
+        def self.deserialize(data, context:)
+          message = OmniAI::Chat::Message.deserialize(data, context:)
+          OmniAI::Chat::Choice.new(message:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/llama/chat/message_serializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    class Chat
+      # Overrides choice serialize / deserialize for the following payload:
+      #
+      #   {
+      #     content: {
+      #       type: "text",
+      #       text: "Hello!",
+      #     },
+      #     role: "assistant",
+      #     stop_reason: "stop",
+      #     tool_calls: [],
+      #   }
+      module MessageSerializer
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Message]
+        def self.deserialize(data, context:)
+          role = data["role"]
+          content = OmniAI::Chat::Content.deserialize(data["content"], context:)
+
+          OmniAI::Chat::Message.new(content:, role:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/llama/chat/response_serializer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    class Chat
+      # Overrides response serialize / deserialize for the following payload:
+      #
+      #   {
+      #     completion_message: {
+      #       content: {
+      #         type: "text",
+      #         text: "Hello!",
+      #       },
+      #       role: "assistant",
+      #       stop_reason: "stop",
+      #       tool_calls: [],
+      #     },
+      #     metrics: [
+      #       {
+      #         metric: "num_completion_tokens",
+      #         value: 25,
+      #         unit: "tokens",
+      #       },
+      #       {
+      #         metric: "num_prompt_tokens",
+      #         value: 25,
+      #         unit: "tokens",
+      #       },
+      #       {
+      #         metric: "num_total_tokens",
+      #         value: 50,
+      #         unit: "tokens",
+      #       },
+      #     ],
+      #   }
+      module ResponseSerializer
+        # @param data [Hash]
+        # @param context [OmniAI::Context]
+        #
+        # @return [OmniAI::Chat::Response]
+        def self.deserialize(data, context:)
+          usage = OmniAI::Chat::Usage.deserialize(data["metrics"], context:) if data["metrics"]
+          choice = OmniAI::Chat::Choice.deserialize(data["completion_message"], context:)
+
+          OmniAI::Chat::Response.new(data:, choices: [choice], usage:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/llama/chat/usage_serializer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    class Chat
+      # Overrides response serialize / deserialize for the following payload:
+      #
+      #   [
+      #     {
+      #       metric: "num_completion_tokens",
+      #       value: 25,
+      #       unit: "tokens",
+      #     },
+      #     {
+      #       metric: "num_prompt_tokens",
+      #       value: 25,
+      #       unit: "tokens",
+      #     },
+      #     {
+      #       metric: "num_total_tokens",
+      #       value: 50,
+      #       unit: "tokens",
+      #     },
+      #   ]
+      module UsageSerializer
+        module Metric
+          NUM_PROMPT_TOKENS = "num_prompt_tokens"
+          NUM_COMPLETION_TOKENS = "num_completion_tokens"
+          NUM_TOTAL_TOKENS = "num_total_tokens"
+        end
+
+        # @param data [Hash]
+        #
+        # @return [OmniAI::Chat::Response]
+        def self.deserialize(data, *)
+          prompt = data.find { |metric| metric["metric"] == Metric::NUM_PROMPT_TOKENS }
+          completion = data.find { |metric| metric["metric"] == Metric::NUM_COMPLETION_TOKENS }
+          total = data.find { |metric| metric["metric"] == Metric::NUM_TOTAL_TOKENS }
+
+          input_tokens = prompt ? prompt["value"] : 0
+          output_tokens = completion ? completion["value"] : 0
+          total_tokens = total ? total["value"] : 0
+
+          OmniAI::Chat::Usage.new(input_tokens:, output_tokens:, total_tokens:)
+        end
+      end
+    end
+  end
+end

data/lib/omniai/llama/chat.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    # An OpenAI chat implementation.
+    #
+    # Usage:
+    #
+    #   completion = OmniAI::Llama::Chat.process!(client: client) do |prompt|
+    #     prompt.system('You are an expert in the field of AI.')
+    #     prompt.user('What are the biggest risks of AI?')
+    #   end
+    #   completion.choice.message.content # '...'
+    class Chat < OmniAI::Chat
+      JSON_RESPONSE_FORMAT = { type: "json_object" }.freeze
+      DEFAULT_STREAM_OPTIONS = { include_usage: ENV.fetch("OMNIAI_STREAM_USAGE", "on").eql?("on") }.freeze
+
+      module Model
+        LLAMA_4_SCOUT_17B_16E_INSTRUCT_FP8 = "Llama-4-Scout-17B-16E-Instruct-FP8"
+        LLAMA_4_MAVERICK_17B_128E_INSTRUCT_FP_8 = "Llama-4-Maverick-17B-128E-Instruct-FP8"
+        LLAMA_3_3_70B_INSTRUCT = "Llama-3.3-70B-Instruct"
+        LLAMA_3_3_8B_INSTRUCT = "Llama-3.3-8B-Instruct"
+        LLAMA_4_SCOUT = LLAMA_4_SCOUT_17B_16E_INSTRUCT_FP8
+        LLAMA_4_MAVERICK = LLAMA_4_MAVERICK_17B_128E_INSTRUCT_FP_8
+      end
+
+      DEFAULT_MODEL = Model::LLAMA_4_SCOUT
+
+      # @return [Context]
+      CONTEXT = Context.build do |context|
+        context.deserializers[:response] = ResponseSerializer.method(:deserialize)
+        context.deserializers[:choice] = ChoiceSerializer.method(:deserialize)
+        context.deserializers[:message] = MessageSerializer.method(:deserialize)
+        context.deserializers[:usage] = UsageSerializer.method(:deserialize)
+      end
+
+    protected
+
+      # @return [Context]
+      def context
+        CONTEXT
+      end
+
+      # @return [Hash]
+      def payload
+        OmniAI::Llama.config.chat_options.merge({
+          messages: @prompt.serialize,
+          model: @model,
+          response_format: (JSON_RESPONSE_FORMAT if @format.eql?(:json)),
+          stream: stream? || nil,
+          stream_options: (DEFAULT_STREAM_OPTIONS if stream?),
+          temperature: @temperature,
+          tools: (@tools.map(&:serialize) if @tools&.any?),
+        }).compact
+      end
+
+      # @return [String]
+      def path
+        "/#{OmniAI::Llama::Client::VERSION}/chat/completions"
+      end
+    end
+  end
+end

data/lib/omniai/llama/client.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    # A Llama client implementation. Usage:
+    #
+    # w/ `api_key``:
+    #   client = OmniAI::Llama::Client.new(api_key: '...')
+    #
+    # w/ ENV['LLAMA_API_KEY']:
+    #
+    #   ENV['LLAMA_API_KEY'] = '...'
+    #   client = OmniAI::Llama::Client.new
+    #
+    # w/ config:
+    #
+    #   OmniAI::Llama.configure do |config|
+    #     config.api_key = '...'
+    #   end
+    #
+    #   client = OmniAI::Llama::Client.new
+    class Client < OmniAI::Client
+      VERSION = "v1"
+
+      # @param api_key [String, nil] optional - defaults to `OmniAI::Llama.config.api_key`
+      # @param host [String] optional - defaults to `OmniAI::Llama.config.host`
+      # @param logger [Logger, nil] optional - defaults to `OmniAI::Llama.config.logger`
+      # @param timeout [Integer, nil] optional - defaults to `OmniAI::Llama.config.timeout`
+      def initialize(
+        api_key: OmniAI::Llama.config.api_key,
+        host: OmniAI::Llama.config.host,
+        logger: OmniAI::Llama.config.logger,
+        timeout: OmniAI::Llama.config.timeout
+      )
+        raise(ArgumentError, %(ENV['LLAMA_API_KEY'] must be defined or `api_key` must be passed)) if api_key.nil?
+
+        super
+      end
+
+      # @return [HTTP::Client]
+      def connection
+        @connection ||= begin
+          http = super
+          http = http.auth("Bearer #{@api_key}") if @api_key
+          http
+        end
+      end
+
+      # @raise [OmniAI::Error]
+      #
+      # @param messages [String] optional
+      # @param model [String] optional
+      # @param format [Symbol] optional :text or :json
+      # @param temperature [Float, nil] optional
+      # @param stream [Proc, nil] optional
+      # @param tools [Array<OmniAI::Tool>, nil] optional
+      #
+      # @yield [prompt]
+      # @yieldparam prompt [OmniAI::Chat::Prompt]
+      #
+      # @return [OmniAI::Chat::Completion]
+      def chat(messages = nil, model: Chat::DEFAULT_MODEL, temperature: nil, format: nil, stream: nil, tools: nil, &)
+        Chat.process!(messages, model:, temperature:, format:, stream:, tools:, client: self, &)
+      end
+    end
+  end
+end

data/lib/omniai/llama/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    # Configuration for OpenAI.
+    class Config < OmniAI::Config
+      DEFAULT_HOST = "https://api.llama.com"
+
+      # @param api_key [String, nil] optional - defaults to `ENV['LLAMA_API_KEY']`
+      # @param host [String, nil] optional - defaults to ENV['LLAMA_HOST'] w/ fallback to `DEFAULT_HOST`
+      # @param logger [Logger, nil] optional
+      # @param timeout [Integer, Hash, nil] optional
+      def initialize(
+        api_key: ENV.fetch("LLAMA_API_KEY", nil),
+        host: ENV.fetch("LLAMA_HOST", DEFAULT_HOST),
+        logger: nil,
+        timeout: nil
+      )
+        super
+      end
+    end
+  end
+end

data/lib/omniai/llama/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OmniAI
+  module Llama
+    VERSION = "0.0.1"
+  end
+end

data/lib/omniai/llama.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "event_stream_parser"
+require "omniai"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.push_dir(__dir__, namespace: OmniAI)
+loader.setup
+
+module OmniAI
+  # A namespace for everything Llama.
+  module Llama
+    # @return [OmniAI::Llama::Config]
+    def self.config
+      @config ||= Config.new
+    end
+
+    # @yield [OmniAI::Llama::Config]
+    def self.configure
+      yield config
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: omniai-llama
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kevin Sylvestre
+bindir: exe
+cert_chain: []
+date: 2025-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: event_stream_parser
+  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: omniai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  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'
+description: An implementation of OmniAI for OpenAI
+email:
+- kevin@ksylvest.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/omniai/llama.rb
+- lib/omniai/llama/chat.rb
+- lib/omniai/llama/chat/choice_serializer.rb
+- lib/omniai/llama/chat/message_serializer.rb
+- lib/omniai/llama/chat/response_serializer.rb
+- lib/omniai/llama/chat/usage_serializer.rb
+- lib/omniai/llama/client.rb
+- lib/omniai/llama/config.rb
+- lib/omniai/llama/version.rb
+homepage: https://github.com/ksylvest/omniai-llama
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ksylvest/omniai-llama
+  changelog_uri: https://github.com/ksylvest/omniai-llama/releases
+  rubygems_mfa_required: 'true'
+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.6.6
+specification_version: 4
+summary: A generalized framework for interacting with OpenAI
+test_files: []